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