1/************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28#include "util/ralloc.h" 29#include "util/u_inlines.h" 30#include "util/u_memory.h" 31#include "util/simple_list.h" 32#include "util/u_framebuffer.h" 33 34#include "pipe/p_format.h" 35#include "pipe/p_screen.h" 36 37#include "tr_dump.h" 38#include "tr_dump_defines.h" 39#include "tr_dump_state.h" 40#include "tr_public.h" 41#include "tr_screen.h" 42#include "tr_texture.h" 43#include "tr_context.h" 44 45 46struct trace_query 47{ 48 struct threaded_query base; 49 unsigned type; 50 51 struct pipe_query *query; 52}; 53 54 55static inline struct trace_query * 56trace_query(struct pipe_query *query) 57{ 58 return (struct trace_query *)query; 59} 60 61 62static inline struct pipe_query * 63trace_query_unwrap(struct pipe_query *query) 64{ 65 if (query) { 66 return trace_query(query)->query; 67 } else { 68 return NULL; 69 } 70} 71 72 73static inline struct pipe_surface * 74trace_surface_unwrap(struct trace_context *tr_ctx, 75 struct pipe_surface *surface) 76{ 77 struct trace_surface *tr_surf; 78 79 if (!surface) 80 return NULL; 81 82 assert(surface->texture); 83 if (!surface->texture) 84 return surface; 85 86 tr_surf = trace_surface(surface); 87 88 assert(tr_surf->surface); 89 return tr_surf->surface; 90} 91 92static void 93dump_fb_state(struct trace_context *tr_ctx, 94 const char *method, 95 bool deep) 96{ 97 struct pipe_context *pipe = tr_ctx->pipe; 98 99 trace_dump_call_begin("pipe_context", method); 100 101 trace_dump_arg(ptr, pipe); 102 if (deep) 103 trace_dump_arg(framebuffer_state_deep, &tr_ctx->unwrapped_state); 104 else 105 trace_dump_arg(framebuffer_state, &tr_ctx->unwrapped_state); 106 trace_dump_call_end(); 107 108 tr_ctx->seen_fb_state = true; 109} 110 111static void 112trace_context_draw_vbo(struct pipe_context *_pipe, 113 const struct pipe_draw_info *info, 114 unsigned drawid_offset, 115 const struct pipe_draw_indirect_info *indirect, 116 const struct pipe_draw_start_count_bias *draws, 117 unsigned num_draws) 118{ 119 struct trace_context *tr_ctx = trace_context(_pipe); 120 struct pipe_context *pipe = tr_ctx->pipe; 121 122 if (!tr_ctx->seen_fb_state && trace_dump_is_triggered()) 123 dump_fb_state(tr_ctx, "current_framebuffer_state", true); 124 125 trace_dump_call_begin("pipe_context", "draw_vbo"); 126 127 trace_dump_arg(ptr, pipe); 128 trace_dump_arg(draw_info, info); 129 trace_dump_arg(int, drawid_offset); 130 trace_dump_arg(draw_indirect_info, indirect); 131 trace_dump_arg_begin("draws"); 132 trace_dump_struct_array(draw_start_count, draws, num_draws); 133 trace_dump_arg_end(); 134 trace_dump_arg(uint, num_draws); 135 136 trace_dump_trace_flush(); 137 138 pipe->draw_vbo(pipe, info, drawid_offset, indirect, draws, num_draws); 139 140 trace_dump_call_end(); 141} 142 143 144static void 145trace_context_draw_vertex_state(struct pipe_context *_pipe, 146 struct pipe_vertex_state *state, 147 uint32_t partial_velem_mask, 148 struct pipe_draw_vertex_state_info info, 149 const struct pipe_draw_start_count_bias *draws, 150 unsigned num_draws) 151{ 152 struct trace_context *tr_ctx = trace_context(_pipe); 153 struct pipe_context *pipe = tr_ctx->pipe; 154 155 if (!tr_ctx->seen_fb_state && trace_dump_is_triggered()) 156 dump_fb_state(tr_ctx, "current_framebuffer_state", true); 157 158 trace_dump_call_begin("pipe_context", "draw_vertex_state"); 159 160 trace_dump_arg(ptr, pipe); 161 trace_dump_arg(ptr, state); 162 trace_dump_arg(uint, partial_velem_mask); 163 trace_dump_arg(draw_vertex_state_info, info); 164 trace_dump_arg_begin("draws"); 165 trace_dump_struct_array(draw_start_count, draws, num_draws); 166 trace_dump_arg_end(); 167 trace_dump_arg(uint, num_draws); 168 169 trace_dump_trace_flush(); 170 171 pipe->draw_vertex_state(pipe, state, partial_velem_mask, info, draws, 172 num_draws); 173 trace_dump_call_end(); 174} 175 176 177static struct pipe_query * 178trace_context_create_query(struct pipe_context *_pipe, 179 unsigned query_type, 180 unsigned index) 181{ 182 struct trace_context *tr_ctx = trace_context(_pipe); 183 struct pipe_context *pipe = tr_ctx->pipe; 184 struct pipe_query *query; 185 186 trace_dump_call_begin("pipe_context", "create_query"); 187 188 trace_dump_arg(ptr, pipe); 189 trace_dump_arg(query_type, query_type); 190 trace_dump_arg(int, index); 191 192 query = pipe->create_query(pipe, query_type, index); 193 194 trace_dump_ret(ptr, query); 195 196 trace_dump_call_end(); 197 198 /* Wrap query object. */ 199 if (query) { 200 struct trace_query *tr_query = CALLOC_STRUCT(trace_query); 201 if (tr_query) { 202 tr_query->type = query_type; 203 tr_query->query = query; 204 query = (struct pipe_query *)tr_query; 205 } else { 206 pipe->destroy_query(pipe, query); 207 query = NULL; 208 } 209 } 210 211 return query; 212} 213 214 215static void 216trace_context_destroy_query(struct pipe_context *_pipe, 217 struct pipe_query *_query) 218{ 219 struct trace_context *tr_ctx = trace_context(_pipe); 220 struct pipe_context *pipe = tr_ctx->pipe; 221 struct trace_query *tr_query = trace_query(_query); 222 struct pipe_query *query = tr_query->query; 223 224 FREE(tr_query); 225 226 trace_dump_call_begin("pipe_context", "destroy_query"); 227 228 trace_dump_arg(ptr, pipe); 229 trace_dump_arg(ptr, query); 230 231 pipe->destroy_query(pipe, query); 232 233 trace_dump_call_end(); 234} 235 236 237static bool 238trace_context_begin_query(struct pipe_context *_pipe, 239 struct pipe_query *query) 240{ 241 struct trace_context *tr_ctx = trace_context(_pipe); 242 struct pipe_context *pipe = tr_ctx->pipe; 243 bool ret; 244 245 query = trace_query_unwrap(query); 246 247 trace_dump_call_begin("pipe_context", "begin_query"); 248 249 trace_dump_arg(ptr, pipe); 250 trace_dump_arg(ptr, query); 251 252 ret = pipe->begin_query(pipe, query); 253 254 trace_dump_call_end(); 255 return ret; 256} 257 258 259static bool 260trace_context_end_query(struct pipe_context *_pipe, 261 struct pipe_query *_query) 262{ 263 struct trace_context *tr_ctx = trace_context(_pipe); 264 struct pipe_context *pipe = tr_ctx->pipe; 265 bool ret; 266 267 struct pipe_query *query = trace_query_unwrap(_query); 268 269 trace_dump_call_begin("pipe_context", "end_query"); 270 271 trace_dump_arg(ptr, pipe); 272 trace_dump_arg(ptr, query); 273 274 if (tr_ctx->threaded) 275 threaded_query(query)->flushed = trace_query(_query)->base.flushed; 276 ret = pipe->end_query(pipe, query); 277 278 trace_dump_call_end(); 279 return ret; 280} 281 282 283static bool 284trace_context_get_query_result(struct pipe_context *_pipe, 285 struct pipe_query *_query, 286 bool wait, 287 union pipe_query_result *result) 288{ 289 struct trace_context *tr_ctx = trace_context(_pipe); 290 struct pipe_context *pipe = tr_ctx->pipe; 291 struct trace_query *tr_query = trace_query(_query); 292 struct pipe_query *query = tr_query->query; 293 bool ret; 294 295 trace_dump_call_begin("pipe_context", "get_query_result"); 296 297 trace_dump_arg(ptr, pipe); 298 trace_dump_arg(ptr, query); 299 trace_dump_arg(bool, wait); 300 301 if (tr_ctx->threaded) 302 threaded_query(query)->flushed = trace_query(_query)->base.flushed; 303 304 ret = pipe->get_query_result(pipe, query, wait, result); 305 306 trace_dump_arg_begin("result"); 307 if (ret) { 308 trace_dump_query_result(tr_query->type, result); 309 } else { 310 trace_dump_null(); 311 } 312 trace_dump_arg_end(); 313 314 trace_dump_ret(bool, ret); 315 316 trace_dump_call_end(); 317 318 return ret; 319} 320 321 322static void 323trace_context_set_active_query_state(struct pipe_context *_pipe, 324 bool enable) 325{ 326 struct trace_context *tr_ctx = trace_context(_pipe); 327 struct pipe_context *pipe = tr_ctx->pipe; 328 329 trace_dump_call_begin("pipe_context", "set_active_query_state"); 330 331 trace_dump_arg(ptr, pipe); 332 trace_dump_arg(bool, enable); 333 334 pipe->set_active_query_state(pipe, enable); 335 336 trace_dump_call_end(); 337} 338 339 340static void * 341trace_context_create_blend_state(struct pipe_context *_pipe, 342 const struct pipe_blend_state *state) 343{ 344 struct trace_context *tr_ctx = trace_context(_pipe); 345 struct pipe_context *pipe = tr_ctx->pipe; 346 void * result; 347 348 trace_dump_call_begin("pipe_context", "create_blend_state"); 349 350 trace_dump_arg(ptr, pipe); 351 trace_dump_arg(blend_state, state); 352 353 result = pipe->create_blend_state(pipe, state); 354 355 trace_dump_ret(ptr, result); 356 357 trace_dump_call_end(); 358 359 struct pipe_blend_state *blend = ralloc(tr_ctx, struct pipe_blend_state); 360 if (blend) { 361 memcpy(blend, state, sizeof(struct pipe_blend_state)); 362 _mesa_hash_table_insert(&tr_ctx->blend_states, result, blend); 363 } 364 365 return result; 366} 367 368 369static void 370trace_context_bind_blend_state(struct pipe_context *_pipe, 371 void *state) 372{ 373 struct trace_context *tr_ctx = trace_context(_pipe); 374 struct pipe_context *pipe = tr_ctx->pipe; 375 376 trace_dump_call_begin("pipe_context", "bind_blend_state"); 377 378 trace_dump_arg(ptr, pipe); 379 if (state && trace_dump_is_triggered()) { 380 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->blend_states, state); 381 if (he) 382 trace_dump_arg(blend_state, he->data); 383 else 384 trace_dump_arg(blend_state, NULL); 385 } else 386 trace_dump_arg(ptr, state); 387 388 pipe->bind_blend_state(pipe, state); 389 390 trace_dump_call_end(); 391} 392 393 394static void 395trace_context_delete_blend_state(struct pipe_context *_pipe, 396 void *state) 397{ 398 struct trace_context *tr_ctx = trace_context(_pipe); 399 struct pipe_context *pipe = tr_ctx->pipe; 400 401 trace_dump_call_begin("pipe_context", "delete_blend_state"); 402 403 trace_dump_arg(ptr, pipe); 404 trace_dump_arg(ptr, state); 405 406 pipe->delete_blend_state(pipe, state); 407 408 if (state) { 409 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->blend_states, state); 410 if (he) { 411 ralloc_free(he->data); 412 _mesa_hash_table_remove(&tr_ctx->blend_states, he); 413 } 414 } 415 416 trace_dump_call_end(); 417} 418 419 420static void * 421trace_context_create_sampler_state(struct pipe_context *_pipe, 422 const struct pipe_sampler_state *state) 423{ 424 struct trace_context *tr_ctx = trace_context(_pipe); 425 struct pipe_context *pipe = tr_ctx->pipe; 426 void * result; 427 428 trace_dump_call_begin("pipe_context", "create_sampler_state"); 429 430 trace_dump_arg(ptr, pipe); 431 trace_dump_arg(sampler_state, state); 432 433 result = pipe->create_sampler_state(pipe, state); 434 435 trace_dump_ret(ptr, result); 436 437 trace_dump_call_end(); 438 439 return result; 440} 441 442 443static void 444trace_context_bind_sampler_states(struct pipe_context *_pipe, 445 enum pipe_shader_type shader, 446 unsigned start, 447 unsigned num_states, 448 void **states) 449{ 450 struct trace_context *tr_ctx = trace_context(_pipe); 451 struct pipe_context *pipe = tr_ctx->pipe; 452 453 /* remove this when we have pipe->bind_sampler_states(..., start, ...) */ 454 assert(start == 0); 455 456 trace_dump_call_begin("pipe_context", "bind_sampler_states"); 457 458 trace_dump_arg(ptr, pipe); 459 trace_dump_arg(uint, shader); 460 trace_dump_arg(uint, start); 461 trace_dump_arg(uint, num_states); 462 trace_dump_arg_array(ptr, states, num_states); 463 464 pipe->bind_sampler_states(pipe, shader, start, num_states, states); 465 466 trace_dump_call_end(); 467} 468 469 470static void 471trace_context_delete_sampler_state(struct pipe_context *_pipe, 472 void *state) 473{ 474 struct trace_context *tr_ctx = trace_context(_pipe); 475 struct pipe_context *pipe = tr_ctx->pipe; 476 477 trace_dump_call_begin("pipe_context", "delete_sampler_state"); 478 479 trace_dump_arg(ptr, pipe); 480 trace_dump_arg(ptr, state); 481 482 pipe->delete_sampler_state(pipe, state); 483 484 trace_dump_call_end(); 485} 486 487 488static void * 489trace_context_create_rasterizer_state(struct pipe_context *_pipe, 490 const struct pipe_rasterizer_state *state) 491{ 492 struct trace_context *tr_ctx = trace_context(_pipe); 493 struct pipe_context *pipe = tr_ctx->pipe; 494 void * result; 495 496 trace_dump_call_begin("pipe_context", "create_rasterizer_state"); 497 498 trace_dump_arg(ptr, pipe); 499 trace_dump_arg(rasterizer_state, state); 500 501 result = pipe->create_rasterizer_state(pipe, state); 502 503 trace_dump_ret(ptr, result); 504 505 trace_dump_call_end(); 506 507 struct pipe_rasterizer_state *rasterizer = ralloc(tr_ctx, struct pipe_rasterizer_state); 508 if (rasterizer) { 509 memcpy(rasterizer, state, sizeof(struct pipe_rasterizer_state)); 510 _mesa_hash_table_insert(&tr_ctx->rasterizer_states, result, rasterizer); 511 } 512 513 return result; 514} 515 516 517static void 518trace_context_bind_rasterizer_state(struct pipe_context *_pipe, 519 void *state) 520{ 521 struct trace_context *tr_ctx = trace_context(_pipe); 522 struct pipe_context *pipe = tr_ctx->pipe; 523 524 trace_dump_call_begin("pipe_context", "bind_rasterizer_state"); 525 526 trace_dump_arg(ptr, pipe); 527 if (state && trace_dump_is_triggered()) { 528 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->rasterizer_states, state); 529 if (he) 530 trace_dump_arg(rasterizer_state, he->data); 531 else 532 trace_dump_arg(rasterizer_state, NULL); 533 } else 534 trace_dump_arg(ptr, state); 535 536 pipe->bind_rasterizer_state(pipe, state); 537 538 trace_dump_call_end(); 539} 540 541 542static void 543trace_context_delete_rasterizer_state(struct pipe_context *_pipe, 544 void *state) 545{ 546 struct trace_context *tr_ctx = trace_context(_pipe); 547 struct pipe_context *pipe = tr_ctx->pipe; 548 549 trace_dump_call_begin("pipe_context", "delete_rasterizer_state"); 550 551 trace_dump_arg(ptr, pipe); 552 trace_dump_arg(ptr, state); 553 554 pipe->delete_rasterizer_state(pipe, state); 555 556 trace_dump_call_end(); 557 558 if (state) { 559 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->rasterizer_states, state); 560 if (he) { 561 ralloc_free(he->data); 562 _mesa_hash_table_remove(&tr_ctx->rasterizer_states, he); 563 } 564 } 565} 566 567 568static void * 569trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe, 570 const struct pipe_depth_stencil_alpha_state *state) 571{ 572 struct trace_context *tr_ctx = trace_context(_pipe); 573 struct pipe_context *pipe = tr_ctx->pipe; 574 void * result; 575 576 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state"); 577 578 result = pipe->create_depth_stencil_alpha_state(pipe, state); 579 580 trace_dump_arg(ptr, pipe); 581 trace_dump_arg(depth_stencil_alpha_state, state); 582 583 trace_dump_ret(ptr, result); 584 585 trace_dump_call_end(); 586 587 struct pipe_depth_stencil_alpha_state *depth_stencil_alpha = ralloc(tr_ctx, struct pipe_depth_stencil_alpha_state); 588 if (depth_stencil_alpha) { 589 memcpy(depth_stencil_alpha, state, sizeof(struct pipe_depth_stencil_alpha_state)); 590 _mesa_hash_table_insert(&tr_ctx->depth_stencil_alpha_states, result, depth_stencil_alpha); 591 } 592 593 return result; 594} 595 596 597static void 598trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, 599 void *state) 600{ 601 struct trace_context *tr_ctx = trace_context(_pipe); 602 struct pipe_context *pipe = tr_ctx->pipe; 603 604 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state"); 605 606 trace_dump_arg(ptr, pipe); 607 if (state && trace_dump_is_triggered()) { 608 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->depth_stencil_alpha_states, state); 609 if (he) 610 trace_dump_arg(depth_stencil_alpha_state, he->data); 611 else 612 trace_dump_arg(depth_stencil_alpha_state, NULL); 613 } else 614 trace_dump_arg(ptr, state); 615 616 pipe->bind_depth_stencil_alpha_state(pipe, state); 617 618 trace_dump_call_end(); 619} 620 621 622static void 623trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, 624 void *state) 625{ 626 struct trace_context *tr_ctx = trace_context(_pipe); 627 struct pipe_context *pipe = tr_ctx->pipe; 628 629 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state"); 630 631 trace_dump_arg(ptr, pipe); 632 trace_dump_arg(ptr, state); 633 634 pipe->delete_depth_stencil_alpha_state(pipe, state); 635 636 trace_dump_call_end(); 637 638 if (state) { 639 struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->depth_stencil_alpha_states, state); 640 if (he) { 641 ralloc_free(he->data); 642 _mesa_hash_table_remove(&tr_ctx->depth_stencil_alpha_states, he); 643 } 644 } 645} 646 647 648#define TRACE_SHADER_STATE(shader_type) \ 649 static void * \ 650 trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \ 651 const struct pipe_shader_state *state) \ 652 { \ 653 struct trace_context *tr_ctx = trace_context(_pipe); \ 654 struct pipe_context *pipe = tr_ctx->pipe; \ 655 void * result; \ 656 trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \ 657 trace_dump_arg(ptr, pipe); \ 658 trace_dump_arg(shader_state, state); \ 659 result = pipe->create_##shader_type##_state(pipe, state); \ 660 trace_dump_ret(ptr, result); \ 661 trace_dump_call_end(); \ 662 return result; \ 663 } \ 664 \ 665 static void \ 666 trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \ 667 void *state) \ 668 { \ 669 struct trace_context *tr_ctx = trace_context(_pipe); \ 670 struct pipe_context *pipe = tr_ctx->pipe; \ 671 trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \ 672 trace_dump_arg(ptr, pipe); \ 673 trace_dump_arg(ptr, state); \ 674 pipe->bind_##shader_type##_state(pipe, state); \ 675 trace_dump_call_end(); \ 676 } \ 677 \ 678 static void \ 679 trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \ 680 void *state) \ 681 { \ 682 struct trace_context *tr_ctx = trace_context(_pipe); \ 683 struct pipe_context *pipe = tr_ctx->pipe; \ 684 trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \ 685 trace_dump_arg(ptr, pipe); \ 686 trace_dump_arg(ptr, state); \ 687 pipe->delete_##shader_type##_state(pipe, state); \ 688 trace_dump_call_end(); \ 689 } 690 691TRACE_SHADER_STATE(fs) 692TRACE_SHADER_STATE(vs) 693TRACE_SHADER_STATE(gs) 694TRACE_SHADER_STATE(tcs) 695TRACE_SHADER_STATE(tes) 696 697#undef TRACE_SHADER_STATE 698 699 700static inline void * 701trace_context_create_compute_state(struct pipe_context *_pipe, 702 const struct pipe_compute_state *state) 703{ 704 struct trace_context *tr_ctx = trace_context(_pipe); 705 struct pipe_context *pipe = tr_ctx->pipe; 706 void * result; 707 708 trace_dump_call_begin("pipe_context", "create_compute_state"); 709 trace_dump_arg(ptr, pipe); 710 trace_dump_arg(compute_state, state); 711 result = pipe->create_compute_state(pipe, state); 712 trace_dump_ret(ptr, result); 713 trace_dump_call_end(); 714 return result; 715} 716 717static inline void 718trace_context_bind_compute_state(struct pipe_context *_pipe, 719 void *state) 720{ 721 struct trace_context *tr_ctx = trace_context(_pipe); 722 struct pipe_context *pipe = tr_ctx->pipe; 723 724 trace_dump_call_begin("pipe_context", "bind_compute_state"); 725 trace_dump_arg(ptr, pipe); 726 trace_dump_arg(ptr, state); 727 pipe->bind_compute_state(pipe, state); 728 trace_dump_call_end(); 729} 730 731static inline void 732trace_context_delete_compute_state(struct pipe_context *_pipe, 733 void *state) 734{ 735 struct trace_context *tr_ctx = trace_context(_pipe); 736 struct pipe_context *pipe = tr_ctx->pipe; 737 738 trace_dump_call_begin("pipe_context", "delete_compute_state"); 739 trace_dump_arg(ptr, pipe); 740 trace_dump_arg(ptr, state); 741 pipe->delete_compute_state(pipe, state); 742 trace_dump_call_end(); 743} 744 745static void * 746trace_context_create_vertex_elements_state(struct pipe_context *_pipe, 747 unsigned num_elements, 748 const struct pipe_vertex_element *elements) 749{ 750 struct trace_context *tr_ctx = trace_context(_pipe); 751 struct pipe_context *pipe = tr_ctx->pipe; 752 void * result; 753 754 trace_dump_call_begin("pipe_context", "create_vertex_elements_state"); 755 756 trace_dump_arg(ptr, pipe); 757 trace_dump_arg(uint, num_elements); 758 759 trace_dump_arg_begin("elements"); 760 trace_dump_struct_array(vertex_element, elements, num_elements); 761 trace_dump_arg_end(); 762 763 result = pipe->create_vertex_elements_state(pipe, num_elements, elements); 764 765 trace_dump_ret(ptr, result); 766 767 trace_dump_call_end(); 768 769 return result; 770} 771 772 773static void 774trace_context_bind_vertex_elements_state(struct pipe_context *_pipe, 775 void *state) 776{ 777 struct trace_context *tr_ctx = trace_context(_pipe); 778 struct pipe_context *pipe = tr_ctx->pipe; 779 780 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state"); 781 782 trace_dump_arg(ptr, pipe); 783 trace_dump_arg(ptr, state); 784 785 pipe->bind_vertex_elements_state(pipe, state); 786 787 trace_dump_call_end(); 788} 789 790 791static void 792trace_context_delete_vertex_elements_state(struct pipe_context *_pipe, 793 void *state) 794{ 795 struct trace_context *tr_ctx = trace_context(_pipe); 796 struct pipe_context *pipe = tr_ctx->pipe; 797 798 trace_dump_call_begin("pipe_context", "delete_vertex_elements_state"); 799 800 trace_dump_arg(ptr, pipe); 801 trace_dump_arg(ptr, state); 802 803 pipe->delete_vertex_elements_state(pipe, state); 804 805 trace_dump_call_end(); 806} 807 808 809static void 810trace_context_set_blend_color(struct pipe_context *_pipe, 811 const struct pipe_blend_color *state) 812{ 813 struct trace_context *tr_ctx = trace_context(_pipe); 814 struct pipe_context *pipe = tr_ctx->pipe; 815 816 trace_dump_call_begin("pipe_context", "set_blend_color"); 817 818 trace_dump_arg(ptr, pipe); 819 trace_dump_arg(blend_color, state); 820 821 pipe->set_blend_color(pipe, state); 822 823 trace_dump_call_end(); 824} 825 826 827static void 828trace_context_set_stencil_ref(struct pipe_context *_pipe, 829 const struct pipe_stencil_ref state) 830{ 831 struct trace_context *tr_ctx = trace_context(_pipe); 832 struct pipe_context *pipe = tr_ctx->pipe; 833 834 trace_dump_call_begin("pipe_context", "set_stencil_ref"); 835 836 trace_dump_arg(ptr, pipe); 837 trace_dump_arg(stencil_ref, &state); 838 839 pipe->set_stencil_ref(pipe, state); 840 841 trace_dump_call_end(); 842} 843 844 845static void 846trace_context_set_clip_state(struct pipe_context *_pipe, 847 const struct pipe_clip_state *state) 848{ 849 struct trace_context *tr_ctx = trace_context(_pipe); 850 struct pipe_context *pipe = tr_ctx->pipe; 851 852 trace_dump_call_begin("pipe_context", "set_clip_state"); 853 854 trace_dump_arg(ptr, pipe); 855 trace_dump_arg(clip_state, state); 856 857 pipe->set_clip_state(pipe, state); 858 859 trace_dump_call_end(); 860} 861 862static void 863trace_context_set_sample_mask(struct pipe_context *_pipe, 864 unsigned sample_mask) 865{ 866 struct trace_context *tr_ctx = trace_context(_pipe); 867 struct pipe_context *pipe = tr_ctx->pipe; 868 869 trace_dump_call_begin("pipe_context", "set_sample_mask"); 870 871 trace_dump_arg(ptr, pipe); 872 trace_dump_arg(uint, sample_mask); 873 874 pipe->set_sample_mask(pipe, sample_mask); 875 876 trace_dump_call_end(); 877} 878 879static void 880trace_context_set_constant_buffer(struct pipe_context *_pipe, 881 enum pipe_shader_type shader, uint index, 882 bool take_ownership, 883 const struct pipe_constant_buffer *constant_buffer) 884{ 885 struct trace_context *tr_ctx = trace_context(_pipe); 886 struct pipe_context *pipe = tr_ctx->pipe; 887 888 trace_dump_call_begin("pipe_context", "set_constant_buffer"); 889 890 trace_dump_arg(ptr, pipe); 891 trace_dump_arg(uint, shader); 892 trace_dump_arg(uint, index); 893 trace_dump_arg(bool, take_ownership); 894 trace_dump_arg(constant_buffer, constant_buffer); 895 896 pipe->set_constant_buffer(pipe, shader, index, take_ownership, constant_buffer); 897 898 trace_dump_call_end(); 899} 900 901 902static void 903trace_context_set_framebuffer_state(struct pipe_context *_pipe, 904 const struct pipe_framebuffer_state *state) 905{ 906 struct trace_context *tr_ctx = trace_context(_pipe); 907 struct pipe_context *pipe = tr_ctx->pipe; 908 unsigned i; 909 910 /* Unwrap the input state */ 911 memcpy(&tr_ctx->unwrapped_state, state, sizeof(tr_ctx->unwrapped_state)); 912 for (i = 0; i < state->nr_cbufs; ++i) 913 tr_ctx->unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]); 914 for (i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i) 915 tr_ctx->unwrapped_state.cbufs[i] = NULL; 916 tr_ctx->unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf); 917 state = &tr_ctx->unwrapped_state; 918 919 dump_fb_state(tr_ctx, "set_framebuffer_state", trace_dump_is_triggered()); 920 921 pipe->set_framebuffer_state(pipe, state); 922} 923 924static void 925trace_context_set_inlinable_constants(struct pipe_context *_pipe, enum pipe_shader_type shader, 926 uint num_values, uint32_t *values) 927{ 928 struct trace_context *tr_ctx = trace_context(_pipe); 929 struct pipe_context *pipe = tr_ctx->pipe; 930 931 trace_dump_call_begin("pipe_context", "set_inlinable_constants"); 932 933 trace_dump_arg(ptr, pipe); 934 trace_dump_arg(uint, shader); 935 trace_dump_arg(uint, num_values); 936 trace_dump_arg_array(uint, values, num_values); 937 938 pipe->set_inlinable_constants(pipe, shader, num_values, values); 939 940 trace_dump_call_end(); 941} 942 943 944static void 945trace_context_set_polygon_stipple(struct pipe_context *_pipe, 946 const struct pipe_poly_stipple *state) 947{ 948 struct trace_context *tr_ctx = trace_context(_pipe); 949 struct pipe_context *pipe = tr_ctx->pipe; 950 951 trace_dump_call_begin("pipe_context", "set_polygon_stipple"); 952 953 trace_dump_arg(ptr, pipe); 954 trace_dump_arg(poly_stipple, state); 955 956 pipe->set_polygon_stipple(pipe, state); 957 958 trace_dump_call_end(); 959} 960 961static void 962trace_context_set_min_samples(struct pipe_context *_pipe, 963 unsigned min_samples) 964{ 965 struct trace_context *tr_ctx = trace_context(_pipe); 966 struct pipe_context *pipe = tr_ctx->pipe; 967 968 trace_dump_call_begin("pipe_context", "set_min_samples"); 969 970 trace_dump_arg(ptr, pipe); 971 trace_dump_arg(uint, min_samples); 972 973 pipe->set_min_samples(pipe, min_samples); 974 975 trace_dump_call_end(); 976} 977 978 979static void 980trace_context_set_scissor_states(struct pipe_context *_pipe, 981 unsigned start_slot, 982 unsigned num_scissors, 983 const struct pipe_scissor_state *states) 984{ 985 struct trace_context *tr_ctx = trace_context(_pipe); 986 struct pipe_context *pipe = tr_ctx->pipe; 987 988 trace_dump_call_begin("pipe_context", "set_scissor_states"); 989 990 trace_dump_arg(ptr, pipe); 991 trace_dump_arg(uint, start_slot); 992 trace_dump_arg(uint, num_scissors); 993 trace_dump_arg(scissor_state, states); 994 995 pipe->set_scissor_states(pipe, start_slot, num_scissors, states); 996 997 trace_dump_call_end(); 998} 999 1000 1001static void 1002trace_context_set_viewport_states(struct pipe_context *_pipe, 1003 unsigned start_slot, 1004 unsigned num_viewports, 1005 const struct pipe_viewport_state *states) 1006{ 1007 struct trace_context *tr_ctx = trace_context(_pipe); 1008 struct pipe_context *pipe = tr_ctx->pipe; 1009 1010 trace_dump_call_begin("pipe_context", "set_viewport_states"); 1011 1012 trace_dump_arg(ptr, pipe); 1013 trace_dump_arg(uint, start_slot); 1014 trace_dump_arg(uint, num_viewports); 1015 trace_dump_arg(viewport_state, states); 1016 1017 pipe->set_viewport_states(pipe, start_slot, num_viewports, states); 1018 1019 trace_dump_call_end(); 1020} 1021 1022 1023static struct pipe_sampler_view * 1024trace_context_create_sampler_view(struct pipe_context *_pipe, 1025 struct pipe_resource *resource, 1026 const struct pipe_sampler_view *templ) 1027{ 1028 struct trace_context *tr_ctx = trace_context(_pipe); 1029 struct pipe_context *pipe = tr_ctx->pipe; 1030 struct pipe_sampler_view *result; 1031 struct trace_sampler_view *tr_view; 1032 1033 trace_dump_call_begin("pipe_context", "create_sampler_view"); 1034 1035 trace_dump_arg(ptr, pipe); 1036 trace_dump_arg(ptr, resource); 1037 1038 trace_dump_arg_begin("templ"); 1039 trace_dump_sampler_view_template(templ, resource->target); 1040 trace_dump_arg_end(); 1041 1042 result = pipe->create_sampler_view(pipe, resource, templ); 1043 1044 trace_dump_ret(ptr, result); 1045 1046 trace_dump_call_end(); 1047 1048 /* 1049 * Wrap pipe_sampler_view 1050 */ 1051 tr_view = CALLOC_STRUCT(trace_sampler_view); 1052 tr_view->base = *templ; 1053 tr_view->base.reference.count = 1; 1054 tr_view->base.texture = NULL; 1055 pipe_resource_reference(&tr_view->base.texture, resource); 1056 tr_view->base.context = _pipe; 1057 tr_view->sampler_view = result; 1058 result->reference.count += 100000000; 1059 tr_view->refcount = 100000000; 1060 result = &tr_view->base; 1061 1062 return result; 1063} 1064 1065 1066static void 1067trace_context_sampler_view_destroy(struct pipe_context *_pipe, 1068 struct pipe_sampler_view *_view) 1069{ 1070 struct trace_context *tr_ctx = trace_context(_pipe); 1071 struct trace_sampler_view *tr_view = trace_sampler_view(_view); 1072 struct pipe_context *pipe = tr_ctx->pipe; 1073 struct pipe_sampler_view *view = tr_view->sampler_view; 1074 1075 trace_dump_call_begin("pipe_context", "sampler_view_destroy"); 1076 1077 trace_dump_arg(ptr, pipe); 1078 trace_dump_arg(ptr, view); 1079 1080 p_atomic_add(&tr_view->sampler_view->reference.count, -tr_view->refcount); 1081 pipe_sampler_view_reference(&tr_view->sampler_view, NULL); 1082 1083 trace_dump_call_end(); 1084 1085 pipe_resource_reference(&_view->texture, NULL); 1086 FREE(_view); 1087} 1088 1089/******************************************************************** 1090 * surface 1091 */ 1092 1093 1094static struct pipe_surface * 1095trace_context_create_surface(struct pipe_context *_pipe, 1096 struct pipe_resource *resource, 1097 const struct pipe_surface *surf_tmpl) 1098{ 1099 struct trace_context *tr_ctx = trace_context(_pipe); 1100 struct pipe_context *pipe = tr_ctx->pipe; 1101 struct pipe_surface *result = NULL; 1102 1103 trace_dump_call_begin("pipe_context", "create_surface"); 1104 1105 trace_dump_arg(ptr, pipe); 1106 trace_dump_arg(ptr, resource); 1107 1108 trace_dump_arg_begin("surf_tmpl"); 1109 trace_dump_surface_template(surf_tmpl, resource->target); 1110 trace_dump_arg_end(); 1111 1112 1113 result = pipe->create_surface(pipe, resource, surf_tmpl); 1114 1115 trace_dump_ret(ptr, result); 1116 1117 trace_dump_call_end(); 1118 1119 result = trace_surf_create(tr_ctx, resource, result); 1120 1121 return result; 1122} 1123 1124 1125static void 1126trace_context_surface_destroy(struct pipe_context *_pipe, 1127 struct pipe_surface *_surface) 1128{ 1129 struct trace_context *tr_ctx = trace_context(_pipe); 1130 struct pipe_context *pipe = tr_ctx->pipe; 1131 struct trace_surface *tr_surf = trace_surface(_surface); 1132 struct pipe_surface *surface = tr_surf->surface; 1133 1134 trace_dump_call_begin("pipe_context", "surface_destroy"); 1135 1136 trace_dump_arg(ptr, pipe); 1137 trace_dump_arg(ptr, surface); 1138 1139 trace_dump_call_end(); 1140 1141 trace_surf_destroy(tr_surf); 1142} 1143 1144 1145static void 1146trace_context_set_sampler_views(struct pipe_context *_pipe, 1147 enum pipe_shader_type shader, 1148 unsigned start, 1149 unsigned num, 1150 unsigned unbind_num_trailing_slots, 1151 bool take_ownership, 1152 struct pipe_sampler_view **views) 1153{ 1154 struct trace_context *tr_ctx = trace_context(_pipe); 1155 struct trace_sampler_view *tr_view; 1156 struct pipe_context *pipe = tr_ctx->pipe; 1157 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 1158 unsigned i; 1159 1160 /* remove this when we have pipe->set_sampler_views(..., start, ...) */ 1161 assert(start == 0); 1162 1163 for (i = 0; i < num; ++i) { 1164 tr_view = trace_sampler_view(views[i]); 1165 if (tr_view) { 1166 tr_view->refcount--; 1167 if (!tr_view->refcount) { 1168 tr_view->refcount = 100000000; 1169 p_atomic_add(&tr_view->sampler_view->reference.count, tr_view->refcount); 1170 } 1171 } 1172 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL; 1173 } 1174 views = unwrapped_views; 1175 1176 trace_dump_call_begin("pipe_context", "set_sampler_views"); 1177 1178 trace_dump_arg(ptr, pipe); 1179 trace_dump_arg(uint, shader); 1180 trace_dump_arg(uint, start); 1181 trace_dump_arg(uint, num); 1182 trace_dump_arg(uint, unbind_num_trailing_slots); 1183 trace_dump_arg(bool, take_ownership); 1184 trace_dump_arg_array(ptr, views, num); 1185 1186 pipe->set_sampler_views(pipe, shader, start, num, 1187 unbind_num_trailing_slots, take_ownership, views); 1188 1189 trace_dump_call_end(); 1190} 1191 1192 1193static void 1194trace_context_set_vertex_buffers(struct pipe_context *_pipe, 1195 unsigned start_slot, unsigned num_buffers, 1196 unsigned unbind_num_trailing_slots, 1197 bool take_ownership, 1198 const struct pipe_vertex_buffer *buffers) 1199{ 1200 struct trace_context *tr_ctx = trace_context(_pipe); 1201 struct pipe_context *pipe = tr_ctx->pipe; 1202 1203 trace_dump_call_begin("pipe_context", "set_vertex_buffers"); 1204 1205 trace_dump_arg(ptr, pipe); 1206 trace_dump_arg(uint, start_slot); 1207 trace_dump_arg(uint, num_buffers); 1208 trace_dump_arg(uint, unbind_num_trailing_slots); 1209 trace_dump_arg(bool, take_ownership); 1210 1211 trace_dump_arg_begin("buffers"); 1212 trace_dump_struct_array(vertex_buffer, buffers, num_buffers); 1213 trace_dump_arg_end(); 1214 1215 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, 1216 unbind_num_trailing_slots, take_ownership, 1217 buffers); 1218 1219 trace_dump_call_end(); 1220} 1221 1222 1223static struct pipe_stream_output_target * 1224trace_context_create_stream_output_target(struct pipe_context *_pipe, 1225 struct pipe_resource *res, 1226 unsigned buffer_offset, 1227 unsigned buffer_size) 1228{ 1229 struct trace_context *tr_ctx = trace_context(_pipe); 1230 struct pipe_context *pipe = tr_ctx->pipe; 1231 struct pipe_stream_output_target *result; 1232 1233 trace_dump_call_begin("pipe_context", "create_stream_output_target"); 1234 1235 trace_dump_arg(ptr, pipe); 1236 trace_dump_arg(ptr, res); 1237 trace_dump_arg(uint, buffer_offset); 1238 trace_dump_arg(uint, buffer_size); 1239 1240 result = pipe->create_stream_output_target(pipe, 1241 res, buffer_offset, buffer_size); 1242 1243 trace_dump_ret(ptr, result); 1244 1245 trace_dump_call_end(); 1246 1247 return result; 1248} 1249 1250 1251static void 1252trace_context_stream_output_target_destroy( 1253 struct pipe_context *_pipe, 1254 struct pipe_stream_output_target *target) 1255{ 1256 struct trace_context *tr_ctx = trace_context(_pipe); 1257 struct pipe_context *pipe = tr_ctx->pipe; 1258 1259 trace_dump_call_begin("pipe_context", "stream_output_target_destroy"); 1260 1261 trace_dump_arg(ptr, pipe); 1262 trace_dump_arg(ptr, target); 1263 1264 pipe->stream_output_target_destroy(pipe, target); 1265 1266 trace_dump_call_end(); 1267} 1268 1269 1270static void 1271trace_context_set_stream_output_targets(struct pipe_context *_pipe, 1272 unsigned num_targets, 1273 struct pipe_stream_output_target **tgs, 1274 const unsigned *offsets) 1275{ 1276 struct trace_context *tr_ctx = trace_context(_pipe); 1277 struct pipe_context *pipe = tr_ctx->pipe; 1278 1279 trace_dump_call_begin("pipe_context", "set_stream_output_targets"); 1280 1281 trace_dump_arg(ptr, pipe); 1282 trace_dump_arg(uint, num_targets); 1283 trace_dump_arg_array(ptr, tgs, num_targets); 1284 trace_dump_arg_array(uint, offsets, num_targets); 1285 1286 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets); 1287 1288 trace_dump_call_end(); 1289} 1290 1291 1292static void 1293trace_context_resource_copy_region(struct pipe_context *_pipe, 1294 struct pipe_resource *dst, 1295 unsigned dst_level, 1296 unsigned dstx, unsigned dsty, unsigned dstz, 1297 struct pipe_resource *src, 1298 unsigned src_level, 1299 const struct pipe_box *src_box) 1300{ 1301 struct trace_context *tr_ctx = trace_context(_pipe); 1302 struct pipe_context *pipe = tr_ctx->pipe; 1303 1304 trace_dump_call_begin("pipe_context", "resource_copy_region"); 1305 1306 trace_dump_arg(ptr, pipe); 1307 trace_dump_arg(ptr, dst); 1308 trace_dump_arg(uint, dst_level); 1309 trace_dump_arg(uint, dstx); 1310 trace_dump_arg(uint, dsty); 1311 trace_dump_arg(uint, dstz); 1312 trace_dump_arg(ptr, src); 1313 trace_dump_arg(uint, src_level); 1314 trace_dump_arg(box, src_box); 1315 1316 pipe->resource_copy_region(pipe, 1317 dst, dst_level, dstx, dsty, dstz, 1318 src, src_level, src_box); 1319 1320 trace_dump_call_end(); 1321} 1322 1323 1324static void 1325trace_context_blit(struct pipe_context *_pipe, 1326 const struct pipe_blit_info *_info) 1327{ 1328 struct trace_context *tr_ctx = trace_context(_pipe); 1329 struct pipe_context *pipe = tr_ctx->pipe; 1330 struct pipe_blit_info info = *_info; 1331 1332 trace_dump_call_begin("pipe_context", "blit"); 1333 1334 trace_dump_arg(ptr, pipe); 1335 trace_dump_arg(blit_info, _info); 1336 1337 pipe->blit(pipe, &info); 1338 1339 trace_dump_call_end(); 1340} 1341 1342 1343static void 1344trace_context_flush_resource(struct pipe_context *_pipe, 1345 struct pipe_resource *resource) 1346{ 1347 struct trace_context *tr_ctx = trace_context(_pipe); 1348 struct pipe_context *pipe = tr_ctx->pipe; 1349 1350 trace_dump_call_begin("pipe_context", "flush_resource"); 1351 1352 trace_dump_arg(ptr, pipe); 1353 trace_dump_arg(ptr, resource); 1354 1355 pipe->flush_resource(pipe, resource); 1356 1357 trace_dump_call_end(); 1358} 1359 1360 1361static void 1362trace_context_clear(struct pipe_context *_pipe, 1363 unsigned buffers, 1364 const struct pipe_scissor_state *scissor_state, 1365 const union pipe_color_union *color, 1366 double depth, 1367 unsigned stencil) 1368{ 1369 struct trace_context *tr_ctx = trace_context(_pipe); 1370 struct pipe_context *pipe = tr_ctx->pipe; 1371 1372 trace_dump_call_begin("pipe_context", "clear"); 1373 1374 trace_dump_arg(ptr, pipe); 1375 trace_dump_arg(uint, buffers); 1376 trace_dump_arg_begin("scissor_state"); 1377 trace_dump_scissor_state(scissor_state); 1378 trace_dump_arg_end(); 1379 trace_dump_arg_begin("color"); 1380 if (color) 1381 trace_dump_array(float, color->f, 4); 1382 else 1383 trace_dump_null(); 1384 trace_dump_arg_end(); 1385 trace_dump_arg(float, depth); 1386 trace_dump_arg(uint, stencil); 1387 1388 pipe->clear(pipe, buffers, scissor_state, color, depth, stencil); 1389 1390 trace_dump_call_end(); 1391} 1392 1393 1394static void 1395trace_context_clear_render_target(struct pipe_context *_pipe, 1396 struct pipe_surface *dst, 1397 const union pipe_color_union *color, 1398 unsigned dstx, unsigned dsty, 1399 unsigned width, unsigned height, 1400 bool render_condition_enabled) 1401{ 1402 struct trace_context *tr_ctx = trace_context(_pipe); 1403 struct pipe_context *pipe = tr_ctx->pipe; 1404 1405 dst = trace_surface_unwrap(tr_ctx, dst); 1406 1407 trace_dump_call_begin("pipe_context", "clear_render_target"); 1408 1409 trace_dump_arg(ptr, pipe); 1410 trace_dump_arg(ptr, dst); 1411 trace_dump_arg_array(float, color->f, 4); 1412 trace_dump_arg(uint, dstx); 1413 trace_dump_arg(uint, dsty); 1414 trace_dump_arg(uint, width); 1415 trace_dump_arg(uint, height); 1416 trace_dump_arg(bool, render_condition_enabled); 1417 1418 pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height, 1419 render_condition_enabled); 1420 1421 trace_dump_call_end(); 1422} 1423 1424static void 1425trace_context_clear_depth_stencil(struct pipe_context *_pipe, 1426 struct pipe_surface *dst, 1427 unsigned clear_flags, 1428 double depth, 1429 unsigned stencil, 1430 unsigned dstx, unsigned dsty, 1431 unsigned width, unsigned height, 1432 bool render_condition_enabled) 1433{ 1434 struct trace_context *tr_ctx = trace_context(_pipe); 1435 struct pipe_context *pipe = tr_ctx->pipe; 1436 1437 dst = trace_surface_unwrap(tr_ctx, dst); 1438 1439 trace_dump_call_begin("pipe_context", "clear_depth_stencil"); 1440 1441 trace_dump_arg(ptr, pipe); 1442 trace_dump_arg(ptr, dst); 1443 trace_dump_arg(uint, clear_flags); 1444 trace_dump_arg(float, depth); 1445 trace_dump_arg(uint, stencil); 1446 trace_dump_arg(uint, dstx); 1447 trace_dump_arg(uint, dsty); 1448 trace_dump_arg(uint, width); 1449 trace_dump_arg(uint, height); 1450 trace_dump_arg(bool, render_condition_enabled); 1451 1452 pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil, 1453 dstx, dsty, width, height, 1454 render_condition_enabled); 1455 1456 trace_dump_call_end(); 1457} 1458 1459static inline void 1460trace_context_clear_buffer(struct pipe_context *_pipe, 1461 struct pipe_resource *res, 1462 unsigned offset, 1463 unsigned size, 1464 const void *clear_value, 1465 int clear_value_size) 1466{ 1467 struct trace_context *tr_ctx = trace_context(_pipe); 1468 struct pipe_context *pipe = tr_ctx->pipe; 1469 1470 1471 trace_dump_call_begin("pipe_context", "clear_buffer"); 1472 1473 trace_dump_arg(ptr, pipe); 1474 trace_dump_arg(ptr, res); 1475 trace_dump_arg(uint, offset); 1476 trace_dump_arg(uint, size); 1477 trace_dump_arg(ptr, clear_value); 1478 trace_dump_arg(int, clear_value_size); 1479 1480 pipe->clear_buffer(pipe, res, offset, size, clear_value, clear_value_size); 1481 1482 trace_dump_call_end(); 1483} 1484 1485static inline void 1486trace_context_clear_texture(struct pipe_context *_pipe, 1487 struct pipe_resource *res, 1488 unsigned level, 1489 const struct pipe_box *box, 1490 const void *data) 1491{ 1492 struct trace_context *tr_ctx = trace_context(_pipe); 1493 struct pipe_context *pipe = tr_ctx->pipe; 1494 1495 1496 trace_dump_call_begin("pipe_context", "clear_texture"); 1497 1498 trace_dump_arg(ptr, pipe); 1499 trace_dump_arg(ptr, res); 1500 trace_dump_arg(uint, level); 1501 trace_dump_arg_begin("box"); 1502 trace_dump_box(box); 1503 trace_dump_arg_end(); 1504 trace_dump_arg(ptr, data); 1505 1506 pipe->clear_texture(pipe, res, level, box, data); 1507 1508 trace_dump_call_end(); 1509} 1510 1511static void 1512trace_context_flush(struct pipe_context *_pipe, 1513 struct pipe_fence_handle **fence, 1514 unsigned flags) 1515{ 1516 struct trace_context *tr_ctx = trace_context(_pipe); 1517 struct pipe_context *pipe = tr_ctx->pipe; 1518 1519 trace_dump_call_begin("pipe_context", "flush"); 1520 1521 trace_dump_arg(ptr, pipe); 1522 trace_dump_arg(uint, flags); 1523 1524 pipe->flush(pipe, fence, flags); 1525 1526 if (fence) 1527 trace_dump_ret(ptr, *fence); 1528 1529 trace_dump_call_end(); 1530 1531 if (flags & PIPE_FLUSH_END_OF_FRAME) { 1532 trace_dump_check_trigger(); 1533 tr_ctx->seen_fb_state = false; 1534 } 1535} 1536 1537 1538static void 1539trace_context_create_fence_fd(struct pipe_context *_pipe, 1540 struct pipe_fence_handle **fence, 1541 int fd, 1542 enum pipe_fd_type type) 1543{ 1544 struct trace_context *tr_ctx = trace_context(_pipe); 1545 struct pipe_context *pipe = tr_ctx->pipe; 1546 1547 trace_dump_call_begin("pipe_context", "create_fence_fd"); 1548 1549 trace_dump_arg(ptr, pipe); 1550 trace_dump_arg(int, fd); 1551 trace_dump_arg(uint, type); 1552 1553 pipe->create_fence_fd(pipe, fence, fd, type); 1554 1555 if (fence) 1556 trace_dump_ret(ptr, *fence); 1557 1558 trace_dump_call_end(); 1559} 1560 1561 1562static void 1563trace_context_fence_server_sync(struct pipe_context *_pipe, 1564 struct pipe_fence_handle *fence) 1565{ 1566 struct trace_context *tr_ctx = trace_context(_pipe); 1567 struct pipe_context *pipe = tr_ctx->pipe; 1568 1569 trace_dump_call_begin("pipe_context", "fence_server_sync"); 1570 1571 trace_dump_arg(ptr, pipe); 1572 trace_dump_arg(ptr, fence); 1573 1574 pipe->fence_server_sync(pipe, fence); 1575 1576 trace_dump_call_end(); 1577} 1578 1579 1580static inline bool 1581trace_context_generate_mipmap(struct pipe_context *_pipe, 1582 struct pipe_resource *res, 1583 enum pipe_format format, 1584 unsigned base_level, 1585 unsigned last_level, 1586 unsigned first_layer, 1587 unsigned last_layer) 1588{ 1589 struct trace_context *tr_ctx = trace_context(_pipe); 1590 struct pipe_context *pipe = tr_ctx->pipe; 1591 bool ret; 1592 1593 trace_dump_call_begin("pipe_context", "generate_mipmap"); 1594 1595 trace_dump_arg(ptr, pipe); 1596 trace_dump_arg(ptr, res); 1597 1598 trace_dump_arg(format, format); 1599 trace_dump_arg(uint, base_level); 1600 trace_dump_arg(uint, last_level); 1601 trace_dump_arg(uint, first_layer); 1602 trace_dump_arg(uint, last_layer); 1603 1604 ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level, 1605 first_layer, last_layer); 1606 1607 trace_dump_ret(bool, ret); 1608 trace_dump_call_end(); 1609 1610 return ret; 1611} 1612 1613 1614static void 1615trace_context_destroy(struct pipe_context *_pipe) 1616{ 1617 struct trace_context *tr_ctx = trace_context(_pipe); 1618 struct pipe_context *pipe = tr_ctx->pipe; 1619 1620 trace_dump_call_begin("pipe_context", "destroy"); 1621 trace_dump_arg(ptr, pipe); 1622 trace_dump_call_end(); 1623 1624 pipe->destroy(pipe); 1625 1626 ralloc_free(tr_ctx); 1627} 1628 1629 1630/******************************************************************** 1631 * transfer 1632 */ 1633 1634 1635static void * 1636trace_context_transfer_map(struct pipe_context *_context, 1637 struct pipe_resource *resource, 1638 unsigned level, 1639 unsigned usage, 1640 const struct pipe_box *box, 1641 struct pipe_transfer **transfer) 1642{ 1643 struct trace_context *tr_context = trace_context(_context); 1644 struct pipe_context *pipe = tr_context->pipe; 1645 struct pipe_transfer *xfer = NULL; 1646 void *map; 1647 1648 if (resource->target == PIPE_BUFFER) 1649 map = pipe->buffer_map(pipe, resource, level, usage, box, &xfer); 1650 else 1651 map = pipe->texture_map(pipe, resource, level, usage, box, &xfer); 1652 if (!map) 1653 return NULL; 1654 *transfer = trace_transfer_create(tr_context, resource, xfer); 1655 trace_dump_call_begin("pipe_context", resource->target == PIPE_BUFFER ? "buffer_map" : "texture_map"); 1656 1657 trace_dump_arg(ptr, pipe); 1658 trace_dump_arg(ptr, resource); 1659 trace_dump_arg(uint, level); 1660 trace_dump_arg(uint, usage); 1661 trace_dump_arg(box, box); 1662 1663 trace_dump_arg(ptr, xfer); 1664 trace_dump_ret(ptr, map); 1665 1666 trace_dump_call_end(); 1667 1668 if (map) { 1669 if (usage & PIPE_MAP_WRITE) { 1670 trace_transfer(*transfer)->map = map; 1671 } 1672 } 1673 1674 return *transfer ? map : NULL; 1675} 1676 1677static void 1678trace_context_transfer_flush_region( struct pipe_context *_context, 1679 struct pipe_transfer *_transfer, 1680 const struct pipe_box *box) 1681{ 1682 struct trace_context *tr_context = trace_context(_context); 1683 struct trace_transfer *tr_transfer = trace_transfer(_transfer); 1684 struct pipe_context *pipe = tr_context->pipe; 1685 struct pipe_transfer *transfer = tr_transfer->transfer; 1686 1687 trace_dump_call_begin("pipe_context", "transfer_flush_region"); 1688 1689 trace_dump_arg(ptr, pipe); 1690 trace_dump_arg(ptr, transfer); 1691 trace_dump_arg(box, box); 1692 1693 trace_dump_call_end(); 1694 1695 pipe->transfer_flush_region(pipe, transfer, box); 1696} 1697 1698static void 1699trace_context_transfer_unmap(struct pipe_context *_context, 1700 struct pipe_transfer *_transfer) 1701{ 1702 struct trace_context *tr_ctx = trace_context(_context); 1703 struct trace_transfer *tr_trans = trace_transfer(_transfer); 1704 struct pipe_context *context = tr_ctx->pipe; 1705 struct pipe_transfer *transfer = tr_trans->transfer; 1706 1707 1708 trace_dump_call_begin("pipe_context", "transfer_unmap"); 1709 1710 trace_dump_arg(ptr, context); 1711 trace_dump_arg(ptr, transfer); 1712 1713 trace_dump_call_end(); 1714 1715 if (tr_trans->map && !tr_ctx->threaded) { 1716 /* 1717 * Fake a texture/buffer_subdata 1718 */ 1719 1720 struct pipe_resource *resource = transfer->resource; 1721 unsigned usage = transfer->usage; 1722 const struct pipe_box *box = &transfer->box; 1723 unsigned stride = transfer->stride; 1724 unsigned layer_stride = transfer->layer_stride; 1725 1726 if (resource->target == PIPE_BUFFER) { 1727 unsigned offset = box->x; 1728 unsigned size = box->width; 1729 1730 trace_dump_call_begin("pipe_context", "buffer_subdata"); 1731 1732 trace_dump_arg(ptr, context); 1733 trace_dump_arg(ptr, resource); 1734 trace_dump_arg(uint, usage); 1735 trace_dump_arg(uint, offset); 1736 trace_dump_arg(uint, size); 1737 1738 trace_dump_arg_begin("data"); 1739 trace_dump_box_bytes(tr_trans->map, 1740 resource, 1741 box, 1742 stride, 1743 layer_stride); 1744 trace_dump_arg_end(); 1745 1746 trace_dump_arg(uint, stride); 1747 trace_dump_arg(uint, layer_stride); 1748 1749 trace_dump_call_end(); 1750 } else { 1751 unsigned level = transfer->level; 1752 1753 trace_dump_call_begin("pipe_context", "texture_subdata"); 1754 1755 trace_dump_arg(ptr, context); 1756 trace_dump_arg(ptr, resource); 1757 trace_dump_arg(uint, level); 1758 trace_dump_arg(uint, usage); 1759 trace_dump_arg(box, box); 1760 1761 trace_dump_arg_begin("data"); 1762 trace_dump_box_bytes(tr_trans->map, 1763 resource, 1764 box, 1765 stride, 1766 layer_stride); 1767 trace_dump_arg_end(); 1768 1769 trace_dump_arg(uint, stride); 1770 trace_dump_arg(uint, layer_stride); 1771 1772 trace_dump_call_end(); 1773 } 1774 1775 tr_trans->map = NULL; 1776 } 1777 1778 if (transfer->resource->target == PIPE_BUFFER) 1779 context->buffer_unmap(context, transfer); 1780 else 1781 context->texture_unmap(context, transfer); 1782 trace_transfer_destroy(tr_ctx, tr_trans); 1783} 1784 1785 1786static void 1787trace_context_buffer_subdata(struct pipe_context *_context, 1788 struct pipe_resource *resource, 1789 unsigned usage, unsigned offset, 1790 unsigned size, const void *data) 1791{ 1792 struct trace_context *tr_context = trace_context(_context); 1793 struct pipe_context *context = tr_context->pipe; 1794 struct pipe_box box; 1795 1796 trace_dump_call_begin("pipe_context", "buffer_subdata"); 1797 1798 trace_dump_arg(ptr, context); 1799 trace_dump_arg(ptr, resource); 1800 trace_dump_arg(uint, usage); 1801 trace_dump_arg(uint, offset); 1802 trace_dump_arg(uint, size); 1803 1804 trace_dump_arg_begin("data"); 1805 u_box_1d(offset, size, &box); 1806 trace_dump_box_bytes(data, resource, &box, 0, 0); 1807 trace_dump_arg_end(); 1808 1809 trace_dump_call_end(); 1810 1811 context->buffer_subdata(context, resource, usage, offset, size, data); 1812} 1813 1814 1815static void 1816trace_context_texture_subdata(struct pipe_context *_context, 1817 struct pipe_resource *resource, 1818 unsigned level, 1819 unsigned usage, 1820 const struct pipe_box *box, 1821 const void *data, 1822 unsigned stride, 1823 unsigned layer_stride) 1824{ 1825 struct trace_context *tr_context = trace_context(_context); 1826 struct pipe_context *context = tr_context->pipe; 1827 1828 trace_dump_call_begin("pipe_context", "texture_subdata"); 1829 1830 trace_dump_arg(ptr, context); 1831 trace_dump_arg(ptr, resource); 1832 trace_dump_arg(uint, level); 1833 trace_dump_arg(uint, usage); 1834 trace_dump_arg(box, box); 1835 1836 trace_dump_arg_begin("data"); 1837 trace_dump_box_bytes(data, 1838 resource, 1839 box, 1840 stride, 1841 layer_stride); 1842 trace_dump_arg_end(); 1843 1844 trace_dump_arg(uint, stride); 1845 trace_dump_arg(uint, layer_stride); 1846 1847 trace_dump_call_end(); 1848 1849 context->texture_subdata(context, resource, level, usage, box, 1850 data, stride, layer_stride); 1851} 1852 1853static void 1854trace_context_invalidate_resource(struct pipe_context *_context, 1855 struct pipe_resource *resource) 1856{ 1857 struct trace_context *tr_context = trace_context(_context); 1858 struct pipe_context *context = tr_context->pipe; 1859 1860 trace_dump_call_begin("pipe_context", "invalidate_resource"); 1861 1862 trace_dump_arg(ptr, context); 1863 trace_dump_arg(ptr, resource); 1864 1865 trace_dump_call_end(); 1866 1867 context->invalidate_resource(context, resource); 1868} 1869 1870static void 1871trace_context_set_context_param(struct pipe_context *_context, 1872 enum pipe_context_param param, 1873 unsigned value) 1874{ 1875 struct trace_context *tr_context = trace_context(_context); 1876 struct pipe_context *context = tr_context->pipe; 1877 1878 trace_dump_call_begin("pipe_context", "set_context_param"); 1879 1880 trace_dump_arg(ptr, context); 1881 trace_dump_arg(uint, param); 1882 trace_dump_arg(uint, value); 1883 1884 trace_dump_call_end(); 1885 1886 context->set_context_param(context, param, value); 1887} 1888 1889static void 1890trace_context_set_debug_callback(struct pipe_context *_context, const struct pipe_debug_callback *cb) 1891{ 1892 struct trace_context *tr_context = trace_context(_context); 1893 struct pipe_context *context = tr_context->pipe; 1894 1895 trace_dump_call_begin("pipe_context", "set_debug_callback"); 1896 1897 trace_dump_arg(ptr, context); 1898 1899 trace_dump_call_end(); 1900 1901 context->set_debug_callback(context, cb); 1902} 1903 1904static void 1905trace_context_render_condition(struct pipe_context *_context, 1906 struct pipe_query *query, 1907 bool condition, 1908 enum pipe_render_cond_flag mode) 1909{ 1910 struct trace_context *tr_context = trace_context(_context); 1911 struct pipe_context *context = tr_context->pipe; 1912 1913 query = trace_query_unwrap(query); 1914 1915 trace_dump_call_begin("pipe_context", "render_condition"); 1916 1917 trace_dump_arg(ptr, context); 1918 trace_dump_arg(ptr, query); 1919 trace_dump_arg(bool, condition); 1920 trace_dump_arg(uint, mode); 1921 1922 trace_dump_call_end(); 1923 1924 context->render_condition(context, query, condition, mode); 1925} 1926 1927 1928static void 1929trace_context_texture_barrier(struct pipe_context *_context, unsigned flags) 1930{ 1931 struct trace_context *tr_context = trace_context(_context); 1932 struct pipe_context *context = tr_context->pipe; 1933 1934 trace_dump_call_begin("pipe_context", "texture_barrier"); 1935 1936 trace_dump_arg(ptr, context); 1937 trace_dump_arg(uint, flags); 1938 1939 trace_dump_call_end(); 1940 1941 context->texture_barrier(context, flags); 1942} 1943 1944 1945static void 1946trace_context_memory_barrier(struct pipe_context *_context, 1947 unsigned flags) 1948{ 1949 struct trace_context *tr_context = trace_context(_context); 1950 struct pipe_context *context = tr_context->pipe; 1951 1952 trace_dump_call_begin("pipe_context", "memory_barrier"); 1953 trace_dump_arg(ptr, context); 1954 trace_dump_arg(uint, flags); 1955 trace_dump_call_end(); 1956 1957 context->memory_barrier(context, flags); 1958} 1959 1960 1961static bool 1962trace_context_resource_commit(struct pipe_context *_context, 1963 struct pipe_resource *resource, 1964 unsigned level, struct pipe_box *box, bool commit) 1965{ 1966 struct trace_context *tr_context = trace_context(_context); 1967 struct pipe_context *context = tr_context->pipe; 1968 1969 trace_dump_call_begin("pipe_context", "resource_commit"); 1970 trace_dump_arg(ptr, context); 1971 trace_dump_arg(ptr, resource); 1972 trace_dump_arg(uint, level); 1973 trace_dump_arg(box, box); 1974 trace_dump_arg(bool, commit); 1975 trace_dump_call_end(); 1976 1977 return context->resource_commit(context, resource, level, box, commit); 1978} 1979 1980static void 1981trace_context_set_tess_state(struct pipe_context *_context, 1982 const float default_outer_level[4], 1983 const float default_inner_level[2]) 1984{ 1985 struct trace_context *tr_context = trace_context(_context); 1986 struct pipe_context *context = tr_context->pipe; 1987 1988 trace_dump_call_begin("pipe_context", "set_tess_state"); 1989 trace_dump_arg(ptr, context); 1990 trace_dump_arg_array(float, default_outer_level, 4); 1991 trace_dump_arg_array(float, default_inner_level, 2); 1992 trace_dump_call_end(); 1993 1994 context->set_tess_state(context, default_outer_level, default_inner_level); 1995} 1996 1997static void 1998trace_context_set_patch_vertices(struct pipe_context *_context, 1999 uint8_t patch_vertices) 2000{ 2001 struct trace_context *tr_context = trace_context(_context); 2002 struct pipe_context *context = tr_context->pipe; 2003 2004 trace_dump_call_begin("pipe_context", "set_patch_vertices"); 2005 trace_dump_arg(ptr, context); 2006 trace_dump_arg(uint, patch_vertices); 2007 trace_dump_call_end(); 2008 2009 context->set_patch_vertices(context, patch_vertices); 2010} 2011 2012static void trace_context_set_shader_buffers(struct pipe_context *_context, 2013 enum pipe_shader_type shader, 2014 unsigned start, unsigned nr, 2015 const struct pipe_shader_buffer *buffers, 2016 unsigned writable_bitmask) 2017{ 2018 struct trace_context *tr_context = trace_context(_context); 2019 struct pipe_context *context = tr_context->pipe; 2020 2021 trace_dump_call_begin("pipe_context", "set_shader_buffers"); 2022 trace_dump_arg(ptr, context); 2023 trace_dump_arg(uint, shader); 2024 trace_dump_arg(uint, start); 2025 trace_dump_arg_begin("buffers"); 2026 trace_dump_struct_array(shader_buffer, buffers, nr); 2027 trace_dump_arg_end(); 2028 trace_dump_arg(uint, writable_bitmask); 2029 trace_dump_call_end(); 2030 2031 context->set_shader_buffers(context, shader, start, nr, buffers, 2032 writable_bitmask); 2033} 2034 2035static void trace_context_set_shader_images(struct pipe_context *_context, 2036 enum pipe_shader_type shader, 2037 unsigned start, unsigned nr, 2038 unsigned unbind_num_trailing_slots, 2039 const struct pipe_image_view *images) 2040{ 2041 struct trace_context *tr_context = trace_context(_context); 2042 struct pipe_context *context = tr_context->pipe; 2043 2044 trace_dump_call_begin("pipe_context", "set_shader_images"); 2045 trace_dump_arg(ptr, context); 2046 trace_dump_arg(uint, shader); 2047 trace_dump_arg(uint, start); 2048 trace_dump_arg_begin("images"); 2049 trace_dump_struct_array(image_view, images, nr); 2050 trace_dump_arg_end(); 2051 trace_dump_arg(uint, unbind_num_trailing_slots); 2052 trace_dump_call_end(); 2053 2054 context->set_shader_images(context, shader, start, nr, 2055 unbind_num_trailing_slots, images); 2056} 2057 2058static void trace_context_launch_grid(struct pipe_context *_pipe, 2059 const struct pipe_grid_info *info) 2060{ 2061 struct trace_context *tr_ctx = trace_context(_pipe); 2062 struct pipe_context *pipe = tr_ctx->pipe; 2063 2064 trace_dump_call_begin("pipe_context", "launch_grid"); 2065 2066 trace_dump_arg(ptr, pipe); 2067 trace_dump_arg(grid_info, info); 2068 2069 trace_dump_trace_flush(); 2070 2071 pipe->launch_grid(pipe, info); 2072 2073 trace_dump_call_end(); 2074} 2075 2076static uint64_t trace_context_create_texture_handle(struct pipe_context *_pipe, 2077 struct pipe_sampler_view *view, 2078 const struct pipe_sampler_state *state) 2079{ 2080 struct trace_context *tr_ctx = trace_context(_pipe); 2081 struct pipe_context *pipe = tr_ctx->pipe; 2082 uint64_t handle; 2083 2084 trace_dump_call_begin("pipe_context", "create_texture_handle"); 2085 trace_dump_arg(ptr, pipe); 2086 trace_dump_arg(ptr, view); 2087 trace_dump_arg_begin("state"); 2088 trace_dump_arg(sampler_state, state); 2089 trace_dump_arg_end(); 2090 2091 handle = pipe->create_texture_handle(pipe, view, state); 2092 2093 trace_dump_ret(uint, handle); 2094 trace_dump_call_end(); 2095 2096 return handle; 2097} 2098 2099static void trace_context_delete_texture_handle(struct pipe_context *_pipe, 2100 uint64_t handle) 2101{ 2102 struct trace_context *tr_ctx = trace_context(_pipe); 2103 struct pipe_context *pipe = tr_ctx->pipe; 2104 2105 trace_dump_call_begin("pipe_context", "delete_texture_handle"); 2106 trace_dump_arg(ptr, pipe); 2107 trace_dump_arg(uint, handle); 2108 trace_dump_call_end(); 2109 2110 pipe->delete_texture_handle(pipe, handle); 2111} 2112 2113static void trace_context_make_texture_handle_resident(struct pipe_context *_pipe, 2114 uint64_t handle, 2115 bool resident) 2116{ 2117 struct trace_context *tr_ctx = trace_context(_pipe); 2118 struct pipe_context *pipe = tr_ctx->pipe; 2119 2120 trace_dump_call_begin("pipe_context", "make_texture_handle_resident"); 2121 trace_dump_arg(ptr, pipe); 2122 trace_dump_arg(uint, handle); 2123 trace_dump_arg(bool, resident); 2124 trace_dump_call_end(); 2125 2126 pipe->make_texture_handle_resident(pipe, handle, resident); 2127} 2128 2129static uint64_t trace_context_create_image_handle(struct pipe_context *_pipe, 2130 const struct pipe_image_view *image) 2131{ 2132 struct trace_context *tr_ctx = trace_context(_pipe); 2133 struct pipe_context *pipe = tr_ctx->pipe; 2134 uint64_t handle; 2135 2136 trace_dump_call_begin("pipe_context", "create_image_handle"); 2137 trace_dump_arg(ptr, pipe); 2138 trace_dump_arg_begin("image"); 2139 trace_dump_image_view(image); 2140 trace_dump_arg_end(); 2141 2142 handle = pipe->create_image_handle(pipe, image); 2143 2144 trace_dump_ret(uint, handle); 2145 trace_dump_call_end(); 2146 2147 return handle; 2148} 2149 2150static void trace_context_delete_image_handle(struct pipe_context *_pipe, 2151 uint64_t handle) 2152{ 2153 struct trace_context *tr_ctx = trace_context(_pipe); 2154 struct pipe_context *pipe = tr_ctx->pipe; 2155 2156 trace_dump_call_begin("pipe_context", "delete_image_handle"); 2157 trace_dump_arg(ptr, pipe); 2158 trace_dump_arg(uint, handle); 2159 trace_dump_call_end(); 2160 2161 pipe->delete_image_handle(pipe, handle); 2162} 2163 2164static void trace_context_make_image_handle_resident(struct pipe_context *_pipe, 2165 uint64_t handle, 2166 unsigned access, 2167 bool resident) 2168{ 2169 struct trace_context *tr_ctx = trace_context(_pipe); 2170 struct pipe_context *pipe = tr_ctx->pipe; 2171 2172 trace_dump_call_begin("pipe_context", "make_image_handle_resident"); 2173 trace_dump_arg(ptr, pipe); 2174 trace_dump_arg(uint, handle); 2175 trace_dump_arg(uint, access); 2176 trace_dump_arg(bool, resident); 2177 trace_dump_call_end(); 2178 2179 pipe->make_image_handle_resident(pipe, handle, access, resident); 2180} 2181 2182struct pipe_context * 2183trace_context_create(struct trace_screen *tr_scr, 2184 struct pipe_context *pipe) 2185{ 2186 struct trace_context *tr_ctx; 2187 2188 if (!pipe) 2189 goto error1; 2190 2191 if (!trace_enabled()) 2192 goto error1; 2193 2194 tr_ctx = ralloc(NULL, struct trace_context); 2195 if (!tr_ctx) 2196 goto error1; 2197 2198 _mesa_hash_table_init(&tr_ctx->blend_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal); 2199 _mesa_hash_table_init(&tr_ctx->rasterizer_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal); 2200 _mesa_hash_table_init(&tr_ctx->depth_stencil_alpha_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal); 2201 2202 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */ 2203 tr_ctx->base.screen = &tr_scr->base; 2204 tr_ctx->base.stream_uploader = pipe->stream_uploader; 2205 tr_ctx->base.const_uploader = pipe->const_uploader; 2206 2207 tr_ctx->base.destroy = trace_context_destroy; 2208 2209#define TR_CTX_INIT(_member) \ 2210 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL 2211 2212 TR_CTX_INIT(draw_vbo); 2213 TR_CTX_INIT(draw_vertex_state); 2214 TR_CTX_INIT(render_condition); 2215 TR_CTX_INIT(create_query); 2216 TR_CTX_INIT(destroy_query); 2217 TR_CTX_INIT(begin_query); 2218 TR_CTX_INIT(end_query); 2219 TR_CTX_INIT(get_query_result); 2220 TR_CTX_INIT(set_active_query_state); 2221 TR_CTX_INIT(create_blend_state); 2222 TR_CTX_INIT(bind_blend_state); 2223 TR_CTX_INIT(delete_blend_state); 2224 TR_CTX_INIT(create_sampler_state); 2225 TR_CTX_INIT(bind_sampler_states); 2226 TR_CTX_INIT(delete_sampler_state); 2227 TR_CTX_INIT(create_rasterizer_state); 2228 TR_CTX_INIT(bind_rasterizer_state); 2229 TR_CTX_INIT(delete_rasterizer_state); 2230 TR_CTX_INIT(create_depth_stencil_alpha_state); 2231 TR_CTX_INIT(bind_depth_stencil_alpha_state); 2232 TR_CTX_INIT(delete_depth_stencil_alpha_state); 2233 TR_CTX_INIT(create_fs_state); 2234 TR_CTX_INIT(bind_fs_state); 2235 TR_CTX_INIT(delete_fs_state); 2236 TR_CTX_INIT(create_vs_state); 2237 TR_CTX_INIT(bind_vs_state); 2238 TR_CTX_INIT(delete_vs_state); 2239 TR_CTX_INIT(create_gs_state); 2240 TR_CTX_INIT(bind_gs_state); 2241 TR_CTX_INIT(delete_gs_state); 2242 TR_CTX_INIT(create_tcs_state); 2243 TR_CTX_INIT(bind_tcs_state); 2244 TR_CTX_INIT(delete_tcs_state); 2245 TR_CTX_INIT(create_tes_state); 2246 TR_CTX_INIT(bind_tes_state); 2247 TR_CTX_INIT(delete_tes_state); 2248 TR_CTX_INIT(create_compute_state); 2249 TR_CTX_INIT(bind_compute_state); 2250 TR_CTX_INIT(delete_compute_state); 2251 TR_CTX_INIT(create_vertex_elements_state); 2252 TR_CTX_INIT(bind_vertex_elements_state); 2253 TR_CTX_INIT(delete_vertex_elements_state); 2254 TR_CTX_INIT(set_blend_color); 2255 TR_CTX_INIT(set_stencil_ref); 2256 TR_CTX_INIT(set_clip_state); 2257 TR_CTX_INIT(set_sample_mask); 2258 TR_CTX_INIT(set_constant_buffer); 2259 TR_CTX_INIT(set_framebuffer_state); 2260 TR_CTX_INIT(set_inlinable_constants); 2261 TR_CTX_INIT(set_polygon_stipple); 2262 TR_CTX_INIT(set_min_samples); 2263 TR_CTX_INIT(set_scissor_states); 2264 TR_CTX_INIT(set_viewport_states); 2265 TR_CTX_INIT(set_sampler_views); 2266 TR_CTX_INIT(create_sampler_view); 2267 TR_CTX_INIT(sampler_view_destroy); 2268 TR_CTX_INIT(create_surface); 2269 TR_CTX_INIT(surface_destroy); 2270 TR_CTX_INIT(set_vertex_buffers); 2271 TR_CTX_INIT(create_stream_output_target); 2272 TR_CTX_INIT(stream_output_target_destroy); 2273 TR_CTX_INIT(set_stream_output_targets); 2274 /* this is lavapipe-only and can't be traced */ 2275 tr_ctx->base.stream_output_target_offset = pipe->stream_output_target_offset; 2276 TR_CTX_INIT(resource_copy_region); 2277 TR_CTX_INIT(blit); 2278 TR_CTX_INIT(flush_resource); 2279 TR_CTX_INIT(clear); 2280 TR_CTX_INIT(clear_render_target); 2281 TR_CTX_INIT(clear_depth_stencil); 2282 TR_CTX_INIT(clear_texture); 2283 TR_CTX_INIT(clear_buffer); 2284 TR_CTX_INIT(flush); 2285 TR_CTX_INIT(create_fence_fd); 2286 TR_CTX_INIT(fence_server_sync); 2287 TR_CTX_INIT(generate_mipmap); 2288 TR_CTX_INIT(texture_barrier); 2289 TR_CTX_INIT(memory_barrier); 2290 TR_CTX_INIT(resource_commit); 2291 TR_CTX_INIT(set_tess_state); 2292 TR_CTX_INIT(set_patch_vertices); 2293 TR_CTX_INIT(set_shader_buffers); 2294 TR_CTX_INIT(launch_grid); 2295 TR_CTX_INIT(set_shader_images); 2296 TR_CTX_INIT(create_texture_handle); 2297 TR_CTX_INIT(delete_texture_handle); 2298 TR_CTX_INIT(make_texture_handle_resident); 2299 TR_CTX_INIT(create_image_handle); 2300 TR_CTX_INIT(delete_image_handle); 2301 TR_CTX_INIT(make_image_handle_resident); 2302 2303 tr_ctx->base.buffer_map = tr_ctx->base.texture_map = trace_context_transfer_map; 2304 tr_ctx->base.buffer_unmap = tr_ctx->base.texture_unmap = trace_context_transfer_unmap; 2305 TR_CTX_INIT(transfer_flush_region); 2306 TR_CTX_INIT(buffer_subdata); 2307 TR_CTX_INIT(texture_subdata); 2308 TR_CTX_INIT(invalidate_resource); 2309 TR_CTX_INIT(set_context_param); 2310 TR_CTX_INIT(set_debug_callback); 2311 2312#undef TR_CTX_INIT 2313 2314 tr_ctx->pipe = pipe; 2315 2316 return &tr_ctx->base; 2317 2318error1: 2319 return pipe; 2320} 2321 2322 2323/** 2324 * Sanity checker: check that the given context really is a 2325 * trace context (and not the wrapped driver's context). 2326 */ 2327void 2328trace_context_check(const struct pipe_context *pipe) 2329{ 2330 ASSERTED struct trace_context *tr_ctx = (struct trace_context *) pipe; 2331 assert(tr_ctx->base.destroy == trace_context_destroy); 2332} 2333 2334/** 2335 * Threaded context is not wrapped, and so it may call fence functions directly 2336 */ 2337struct pipe_context * 2338trace_get_possibly_threaded_context(struct pipe_context *pipe) 2339{ 2340 return pipe->destroy == trace_context_destroy ? ((struct trace_context*)pipe)->pipe : pipe; 2341} 2342