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 #include "tr_util.h"
45
46
47 struct trace_query
48 {
49 struct threaded_query base;
50 unsigned type;
51 unsigned index;
52
53 struct pipe_query *query;
54 };
55
56
57 static inline struct trace_query *
trace_query(struct pipe_query * query)58 trace_query(struct pipe_query *query)
59 {
60 return (struct trace_query *)query;
61 }
62
63
64 static inline struct pipe_query *
trace_query_unwrap(struct pipe_query * query)65 trace_query_unwrap(struct pipe_query *query)
66 {
67 if (query) {
68 return trace_query(query)->query;
69 } else {
70 return NULL;
71 }
72 }
73
74
75 static inline struct pipe_surface *
trace_surface_unwrap(struct trace_context * tr_ctx,struct pipe_surface * surface)76 trace_surface_unwrap(struct trace_context *tr_ctx,
77 struct pipe_surface *surface)
78 {
79 struct trace_surface *tr_surf;
80
81 if (!surface)
82 return NULL;
83
84 assert(surface->texture);
85 if (!surface->texture)
86 return surface;
87
88 tr_surf = trace_surface(surface);
89
90 assert(tr_surf->surface);
91 return tr_surf->surface;
92 }
93
94 static void
dump_fb_state(struct trace_context * tr_ctx,const char * method,bool deep)95 dump_fb_state(struct trace_context *tr_ctx,
96 const char *method,
97 bool deep)
98 {
99 struct pipe_context *pipe = tr_ctx->pipe;
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, &tr_ctx->unwrapped_state);
106 else
107 trace_dump_arg(framebuffer_state, &tr_ctx->unwrapped_state);
108 trace_dump_call_end();
109
110 tr_ctx->seen_fb_state = true;
111 }
112
113 static void
trace_context_draw_vbo(struct pipe_context * _pipe,const struct pipe_draw_info * info,unsigned drawid_offset,const struct pipe_draw_indirect_info * indirect,const struct pipe_draw_start_count_bias * draws,unsigned num_draws)114 trace_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
146 static void
trace_context_draw_vertex_state(struct pipe_context * _pipe,struct pipe_vertex_state * state,uint32_t partial_velem_mask,struct pipe_draw_vertex_state_info info,const struct pipe_draw_start_count_bias * draws,unsigned num_draws)147 trace_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
179 static struct pipe_query *
trace_context_create_query(struct pipe_context * _pipe,unsigned query_type,unsigned index)180 trace_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
218 static void
trace_context_destroy_query(struct pipe_context * _pipe,struct pipe_query * _query)219 trace_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
240 static bool
trace_context_begin_query(struct pipe_context * _pipe,struct pipe_query * query)241 trace_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
262 static bool
trace_context_end_query(struct pipe_context * _pipe,struct pipe_query * _query)263 trace_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
286 static bool
trace_context_get_query_result(struct pipe_context * _pipe,struct pipe_query * _query,bool wait,union pipe_query_result * result)287 trace_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
324 static void
trace_context_get_query_result_resource(struct pipe_context * _pipe,struct pipe_query * _query,enum pipe_query_flags flags,enum pipe_query_value_type result_type,int index,struct pipe_resource * resource,unsigned offset)325 trace_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
357 static void
trace_context_set_active_query_state(struct pipe_context * _pipe,bool enable)358 trace_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
375 static void *
trace_context_create_blend_state(struct pipe_context * _pipe,const struct pipe_blend_state * state)376 trace_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
404 static void
trace_context_bind_blend_state(struct pipe_context * _pipe,void * state)405 trace_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
429 static void
trace_context_delete_blend_state(struct pipe_context * _pipe,void * state)430 trace_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
455 static void *
trace_context_create_sampler_state(struct pipe_context * _pipe,const struct pipe_sampler_state * state)456 trace_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
478 static void
trace_context_bind_sampler_states(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num_states,void ** states)479 trace_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
505 static void
trace_context_delete_sampler_state(struct pipe_context * _pipe,void * state)506 trace_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
523 static void *
trace_context_create_rasterizer_state(struct pipe_context * _pipe,const struct pipe_rasterizer_state * state)524 trace_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
552 static void
trace_context_bind_rasterizer_state(struct pipe_context * _pipe,void * state)553 trace_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
577 static void
trace_context_delete_rasterizer_state(struct pipe_context * _pipe,void * state)578 trace_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
603 static void *
trace_context_create_depth_stencil_alpha_state(struct pipe_context * _pipe,const struct pipe_depth_stencil_alpha_state * state)604 trace_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
632 static void
trace_context_bind_depth_stencil_alpha_state(struct pipe_context * _pipe,void * state)633 trace_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
657 static void
trace_context_delete_depth_stencil_alpha_state(struct pipe_context * _pipe,void * state)658 trace_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
726 TRACE_SHADER_STATE(fs)
TRACE_SHADER_STATE(vs)727 TRACE_SHADER_STATE(vs)
728 TRACE_SHADER_STATE(gs)
729 TRACE_SHADER_STATE(tcs)
730 TRACE_SHADER_STATE(tes)
731
732 #undef TRACE_SHADER_STATE
733
734
735 static inline void *
736 trace_context_create_compute_state(struct pipe_context *_pipe,
737 const struct pipe_compute_state *state)
738 {
739 struct trace_context *tr_ctx = trace_context(_pipe);
740 struct pipe_context *pipe = tr_ctx->pipe;
741 void * result;
742
743 trace_dump_call_begin("pipe_context", "create_compute_state");
744 trace_dump_arg(ptr, pipe);
745 trace_dump_arg(compute_state, state);
746 result = pipe->create_compute_state(pipe, state);
747 trace_dump_ret(ptr, result);
748 trace_dump_call_end();
749 return result;
750 }
751
752 static inline void
trace_context_bind_compute_state(struct pipe_context * _pipe,void * state)753 trace_context_bind_compute_state(struct pipe_context *_pipe,
754 void *state)
755 {
756 struct trace_context *tr_ctx = trace_context(_pipe);
757 struct pipe_context *pipe = tr_ctx->pipe;
758
759 trace_dump_call_begin("pipe_context", "bind_compute_state");
760 trace_dump_arg(ptr, pipe);
761 trace_dump_arg(ptr, state);
762 pipe->bind_compute_state(pipe, state);
763 trace_dump_call_end();
764 }
765
766 static inline void
trace_context_delete_compute_state(struct pipe_context * _pipe,void * state)767 trace_context_delete_compute_state(struct pipe_context *_pipe,
768 void *state)
769 {
770 struct trace_context *tr_ctx = trace_context(_pipe);
771 struct pipe_context *pipe = tr_ctx->pipe;
772
773 trace_dump_call_begin("pipe_context", "delete_compute_state");
774 trace_dump_arg(ptr, pipe);
775 trace_dump_arg(ptr, state);
776 pipe->delete_compute_state(pipe, state);
777 trace_dump_call_end();
778 }
779
780 static void *
trace_context_create_vertex_elements_state(struct pipe_context * _pipe,unsigned num_elements,const struct pipe_vertex_element * elements)781 trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
782 unsigned num_elements,
783 const struct pipe_vertex_element *elements)
784 {
785 struct trace_context *tr_ctx = trace_context(_pipe);
786 struct pipe_context *pipe = tr_ctx->pipe;
787 void * result;
788
789 trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
790
791 trace_dump_arg(ptr, pipe);
792 trace_dump_arg(uint, num_elements);
793
794 trace_dump_arg_begin("elements");
795 trace_dump_struct_array(vertex_element, elements, num_elements);
796 trace_dump_arg_end();
797
798 result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
799
800 trace_dump_ret(ptr, result);
801
802 trace_dump_call_end();
803
804 return result;
805 }
806
807
808 static void
trace_context_bind_vertex_elements_state(struct pipe_context * _pipe,void * state)809 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
810 void *state)
811 {
812 struct trace_context *tr_ctx = trace_context(_pipe);
813 struct pipe_context *pipe = tr_ctx->pipe;
814
815 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
816
817 trace_dump_arg(ptr, pipe);
818 trace_dump_arg(ptr, state);
819
820 pipe->bind_vertex_elements_state(pipe, state);
821
822 trace_dump_call_end();
823 }
824
825
826 static void
trace_context_delete_vertex_elements_state(struct pipe_context * _pipe,void * state)827 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
828 void *state)
829 {
830 struct trace_context *tr_ctx = trace_context(_pipe);
831 struct pipe_context *pipe = tr_ctx->pipe;
832
833 trace_dump_call_begin("pipe_context", "delete_vertex_elements_state");
834
835 trace_dump_arg(ptr, pipe);
836 trace_dump_arg(ptr, state);
837
838 pipe->delete_vertex_elements_state(pipe, state);
839
840 trace_dump_call_end();
841 }
842
843
844 static void
trace_context_set_blend_color(struct pipe_context * _pipe,const struct pipe_blend_color * state)845 trace_context_set_blend_color(struct pipe_context *_pipe,
846 const struct pipe_blend_color *state)
847 {
848 struct trace_context *tr_ctx = trace_context(_pipe);
849 struct pipe_context *pipe = tr_ctx->pipe;
850
851 trace_dump_call_begin("pipe_context", "set_blend_color");
852
853 trace_dump_arg(ptr, pipe);
854 trace_dump_arg(blend_color, state);
855
856 pipe->set_blend_color(pipe, state);
857
858 trace_dump_call_end();
859 }
860
861
862 static void
trace_context_set_stencil_ref(struct pipe_context * _pipe,const struct pipe_stencil_ref state)863 trace_context_set_stencil_ref(struct pipe_context *_pipe,
864 const struct pipe_stencil_ref state)
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_stencil_ref");
870
871 trace_dump_arg(ptr, pipe);
872 trace_dump_arg(stencil_ref, &state);
873
874 pipe->set_stencil_ref(pipe, state);
875
876 trace_dump_call_end();
877 }
878
879
880 static void
trace_context_set_clip_state(struct pipe_context * _pipe,const struct pipe_clip_state * state)881 trace_context_set_clip_state(struct pipe_context *_pipe,
882 const struct pipe_clip_state *state)
883 {
884 struct trace_context *tr_ctx = trace_context(_pipe);
885 struct pipe_context *pipe = tr_ctx->pipe;
886
887 trace_dump_call_begin("pipe_context", "set_clip_state");
888
889 trace_dump_arg(ptr, pipe);
890 trace_dump_arg(clip_state, state);
891
892 pipe->set_clip_state(pipe, state);
893
894 trace_dump_call_end();
895 }
896
897 static void
trace_context_set_sample_mask(struct pipe_context * _pipe,unsigned sample_mask)898 trace_context_set_sample_mask(struct pipe_context *_pipe,
899 unsigned sample_mask)
900 {
901 struct trace_context *tr_ctx = trace_context(_pipe);
902 struct pipe_context *pipe = tr_ctx->pipe;
903
904 trace_dump_call_begin("pipe_context", "set_sample_mask");
905
906 trace_dump_arg(ptr, pipe);
907 trace_dump_arg(uint, sample_mask);
908
909 pipe->set_sample_mask(pipe, sample_mask);
910
911 trace_dump_call_end();
912 }
913
914 static void
trace_context_set_constant_buffer(struct pipe_context * _pipe,enum pipe_shader_type shader,uint index,bool take_ownership,const struct pipe_constant_buffer * constant_buffer)915 trace_context_set_constant_buffer(struct pipe_context *_pipe,
916 enum pipe_shader_type shader, uint index,
917 bool take_ownership,
918 const struct pipe_constant_buffer *constant_buffer)
919 {
920 struct trace_context *tr_ctx = trace_context(_pipe);
921 struct pipe_context *pipe = tr_ctx->pipe;
922
923 trace_dump_call_begin("pipe_context", "set_constant_buffer");
924
925 trace_dump_arg(ptr, pipe);
926 trace_dump_arg_enum(shader, tr_util_pipe_shader_type_name(shader));
927 trace_dump_arg(uint, index);
928 trace_dump_arg(bool, take_ownership);
929 trace_dump_arg(constant_buffer, constant_buffer);
930
931 pipe->set_constant_buffer(pipe, shader, index, take_ownership, constant_buffer);
932
933 trace_dump_call_end();
934 }
935
936
937 static void
trace_context_set_framebuffer_state(struct pipe_context * _pipe,const struct pipe_framebuffer_state * state)938 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
939 const struct pipe_framebuffer_state *state)
940 {
941 struct trace_context *tr_ctx = trace_context(_pipe);
942 struct pipe_context *pipe = tr_ctx->pipe;
943 unsigned i;
944
945 /* Unwrap the input state */
946 memcpy(&tr_ctx->unwrapped_state, state, sizeof(tr_ctx->unwrapped_state));
947 for (i = 0; i < state->nr_cbufs; ++i)
948 tr_ctx->unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
949 for (i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
950 tr_ctx->unwrapped_state.cbufs[i] = NULL;
951 tr_ctx->unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
952 state = &tr_ctx->unwrapped_state;
953
954 dump_fb_state(tr_ctx, "set_framebuffer_state", trace_dump_is_triggered());
955
956 pipe->set_framebuffer_state(pipe, state);
957 }
958
959 static void
trace_context_set_inlinable_constants(struct pipe_context * _pipe,enum pipe_shader_type shader,uint num_values,uint32_t * values)960 trace_context_set_inlinable_constants(struct pipe_context *_pipe, enum pipe_shader_type shader,
961 uint num_values, uint32_t *values)
962 {
963 struct trace_context *tr_ctx = trace_context(_pipe);
964 struct pipe_context *pipe = tr_ctx->pipe;
965
966 trace_dump_call_begin("pipe_context", "set_inlinable_constants");
967
968 trace_dump_arg(ptr, pipe);
969 trace_dump_arg_enum(shader, tr_util_pipe_shader_type_name(shader));
970 trace_dump_arg(uint, num_values);
971 trace_dump_arg_array(uint, values, num_values);
972
973 pipe->set_inlinable_constants(pipe, shader, num_values, values);
974
975 trace_dump_call_end();
976 }
977
978
979 static void
trace_context_set_polygon_stipple(struct pipe_context * _pipe,const struct pipe_poly_stipple * state)980 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
981 const struct pipe_poly_stipple *state)
982 {
983 struct trace_context *tr_ctx = trace_context(_pipe);
984 struct pipe_context *pipe = tr_ctx->pipe;
985
986 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
987
988 trace_dump_arg(ptr, pipe);
989 trace_dump_arg(poly_stipple, state);
990
991 pipe->set_polygon_stipple(pipe, state);
992
993 trace_dump_call_end();
994 }
995
996 static void
trace_context_set_min_samples(struct pipe_context * _pipe,unsigned min_samples)997 trace_context_set_min_samples(struct pipe_context *_pipe,
998 unsigned min_samples)
999 {
1000 struct trace_context *tr_ctx = trace_context(_pipe);
1001 struct pipe_context *pipe = tr_ctx->pipe;
1002
1003 trace_dump_call_begin("pipe_context", "set_min_samples");
1004
1005 trace_dump_arg(ptr, pipe);
1006 trace_dump_arg(uint, min_samples);
1007
1008 pipe->set_min_samples(pipe, min_samples);
1009
1010 trace_dump_call_end();
1011 }
1012
1013
1014 static void
trace_context_set_scissor_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_scissors,const struct pipe_scissor_state * states)1015 trace_context_set_scissor_states(struct pipe_context *_pipe,
1016 unsigned start_slot,
1017 unsigned num_scissors,
1018 const struct pipe_scissor_state *states)
1019 {
1020 struct trace_context *tr_ctx = trace_context(_pipe);
1021 struct pipe_context *pipe = tr_ctx->pipe;
1022
1023 trace_dump_call_begin("pipe_context", "set_scissor_states");
1024
1025 trace_dump_arg(ptr, pipe);
1026 trace_dump_arg(uint, start_slot);
1027 trace_dump_arg(uint, num_scissors);
1028 trace_dump_arg(scissor_state, states);
1029
1030 pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
1031
1032 trace_dump_call_end();
1033 }
1034
1035
1036 static void
trace_context_set_viewport_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_viewports,const struct pipe_viewport_state * states)1037 trace_context_set_viewport_states(struct pipe_context *_pipe,
1038 unsigned start_slot,
1039 unsigned num_viewports,
1040 const struct pipe_viewport_state *states)
1041 {
1042 struct trace_context *tr_ctx = trace_context(_pipe);
1043 struct pipe_context *pipe = tr_ctx->pipe;
1044
1045 trace_dump_call_begin("pipe_context", "set_viewport_states");
1046
1047 trace_dump_arg(ptr, pipe);
1048 trace_dump_arg(uint, start_slot);
1049 trace_dump_arg(uint, num_viewports);
1050 trace_dump_arg(viewport_state, states);
1051
1052 pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
1053
1054 trace_dump_call_end();
1055 }
1056
1057
1058 static struct pipe_sampler_view *
trace_context_create_sampler_view(struct pipe_context * _pipe,struct pipe_resource * resource,const struct pipe_sampler_view * templ)1059 trace_context_create_sampler_view(struct pipe_context *_pipe,
1060 struct pipe_resource *resource,
1061 const struct pipe_sampler_view *templ)
1062 {
1063 struct trace_context *tr_ctx = trace_context(_pipe);
1064 struct pipe_context *pipe = tr_ctx->pipe;
1065 struct pipe_sampler_view *result;
1066 struct trace_sampler_view *tr_view;
1067
1068 trace_dump_call_begin("pipe_context", "create_sampler_view");
1069
1070 trace_dump_arg(ptr, pipe);
1071 trace_dump_arg(ptr, resource);
1072
1073 trace_dump_arg_begin("templ");
1074 trace_dump_sampler_view_template(templ, resource->target);
1075 trace_dump_arg_end();
1076
1077 result = pipe->create_sampler_view(pipe, resource, templ);
1078
1079 trace_dump_ret(ptr, result);
1080
1081 trace_dump_call_end();
1082
1083 /*
1084 * Wrap pipe_sampler_view
1085 */
1086 tr_view = CALLOC_STRUCT(trace_sampler_view);
1087 tr_view->base = *templ;
1088 tr_view->base.reference.count = 1;
1089 tr_view->base.texture = NULL;
1090 pipe_resource_reference(&tr_view->base.texture, resource);
1091 tr_view->base.context = _pipe;
1092 tr_view->sampler_view = result;
1093 result->reference.count += 100000000;
1094 tr_view->refcount = 100000000;
1095 result = &tr_view->base;
1096
1097 return result;
1098 }
1099
1100
1101 static void
trace_context_sampler_view_destroy(struct pipe_context * _pipe,struct pipe_sampler_view * _view)1102 trace_context_sampler_view_destroy(struct pipe_context *_pipe,
1103 struct pipe_sampler_view *_view)
1104 {
1105 struct trace_context *tr_ctx = trace_context(_pipe);
1106 struct trace_sampler_view *tr_view = trace_sampler_view(_view);
1107 struct pipe_context *pipe = tr_ctx->pipe;
1108 struct pipe_sampler_view *view = tr_view->sampler_view;
1109
1110 trace_dump_call_begin("pipe_context", "sampler_view_destroy");
1111
1112 trace_dump_arg(ptr, pipe);
1113 trace_dump_arg(ptr, view);
1114
1115 p_atomic_add(&tr_view->sampler_view->reference.count, -tr_view->refcount);
1116 pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
1117
1118 trace_dump_call_end();
1119
1120 pipe_resource_reference(&_view->texture, NULL);
1121 FREE(_view);
1122 }
1123
1124 /********************************************************************
1125 * surface
1126 */
1127
1128
1129 static struct pipe_surface *
trace_context_create_surface(struct pipe_context * _pipe,struct pipe_resource * resource,const struct pipe_surface * surf_tmpl)1130 trace_context_create_surface(struct pipe_context *_pipe,
1131 struct pipe_resource *resource,
1132 const struct pipe_surface *surf_tmpl)
1133 {
1134 struct trace_context *tr_ctx = trace_context(_pipe);
1135 struct pipe_context *pipe = tr_ctx->pipe;
1136 struct pipe_surface *result = NULL;
1137
1138 trace_dump_call_begin("pipe_context", "create_surface");
1139
1140 trace_dump_arg(ptr, pipe);
1141 trace_dump_arg(ptr, resource);
1142
1143 trace_dump_arg_begin("surf_tmpl");
1144 trace_dump_surface_template(surf_tmpl, resource->target);
1145 trace_dump_arg_end();
1146
1147
1148 result = pipe->create_surface(pipe, resource, surf_tmpl);
1149
1150 trace_dump_ret(ptr, result);
1151
1152 trace_dump_call_end();
1153
1154 result = trace_surf_create(tr_ctx, resource, result);
1155
1156 return result;
1157 }
1158
1159
1160 static void
trace_context_surface_destroy(struct pipe_context * _pipe,struct pipe_surface * _surface)1161 trace_context_surface_destroy(struct pipe_context *_pipe,
1162 struct pipe_surface *_surface)
1163 {
1164 struct trace_context *tr_ctx = trace_context(_pipe);
1165 struct pipe_context *pipe = tr_ctx->pipe;
1166 struct trace_surface *tr_surf = trace_surface(_surface);
1167 struct pipe_surface *surface = tr_surf->surface;
1168
1169 trace_dump_call_begin("pipe_context", "surface_destroy");
1170
1171 trace_dump_arg(ptr, pipe);
1172 trace_dump_arg(ptr, surface);
1173
1174 trace_dump_call_end();
1175
1176 trace_surf_destroy(tr_surf);
1177 }
1178
1179
1180 static void
trace_context_set_sampler_views(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num,unsigned unbind_num_trailing_slots,bool take_ownership,struct pipe_sampler_view ** views)1181 trace_context_set_sampler_views(struct pipe_context *_pipe,
1182 enum pipe_shader_type shader,
1183 unsigned start,
1184 unsigned num,
1185 unsigned unbind_num_trailing_slots,
1186 bool take_ownership,
1187 struct pipe_sampler_view **views)
1188 {
1189 struct trace_context *tr_ctx = trace_context(_pipe);
1190 struct trace_sampler_view *tr_view;
1191 struct pipe_context *pipe = tr_ctx->pipe;
1192 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
1193 unsigned i;
1194
1195 /* remove this when we have pipe->set_sampler_views(..., start, ...) */
1196 assert(start == 0);
1197
1198 for (i = 0; i < num; ++i) {
1199 tr_view = trace_sampler_view(views[i]);
1200 if (tr_view) {
1201 tr_view->refcount--;
1202 if (!tr_view->refcount) {
1203 tr_view->refcount = 100000000;
1204 p_atomic_add(&tr_view->sampler_view->reference.count, tr_view->refcount);
1205 }
1206 }
1207 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1208 }
1209 views = unwrapped_views;
1210
1211 trace_dump_call_begin("pipe_context", "set_sampler_views");
1212
1213 trace_dump_arg(ptr, pipe);
1214 trace_dump_arg_enum(shader, tr_util_pipe_shader_type_name(shader));
1215 trace_dump_arg(uint, start);
1216 trace_dump_arg(uint, num);
1217 trace_dump_arg(uint, unbind_num_trailing_slots);
1218 trace_dump_arg(bool, take_ownership);
1219 trace_dump_arg_array(ptr, views, num);
1220
1221 pipe->set_sampler_views(pipe, shader, start, num,
1222 unbind_num_trailing_slots, take_ownership, views);
1223
1224 trace_dump_call_end();
1225 }
1226
1227
1228 static void
trace_context_set_vertex_buffers(struct pipe_context * _pipe,unsigned start_slot,unsigned num_buffers,unsigned unbind_num_trailing_slots,bool take_ownership,const struct pipe_vertex_buffer * buffers)1229 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1230 unsigned start_slot, unsigned num_buffers,
1231 unsigned unbind_num_trailing_slots,
1232 bool take_ownership,
1233 const struct pipe_vertex_buffer *buffers)
1234 {
1235 struct trace_context *tr_ctx = trace_context(_pipe);
1236 struct pipe_context *pipe = tr_ctx->pipe;
1237
1238 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1239
1240 trace_dump_arg(ptr, pipe);
1241 trace_dump_arg(uint, start_slot);
1242 trace_dump_arg(uint, num_buffers);
1243 trace_dump_arg(uint, unbind_num_trailing_slots);
1244 trace_dump_arg(bool, take_ownership);
1245
1246 trace_dump_arg_begin("buffers");
1247 trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1248 trace_dump_arg_end();
1249
1250 pipe->set_vertex_buffers(pipe, start_slot, num_buffers,
1251 unbind_num_trailing_slots, take_ownership,
1252 buffers);
1253
1254 trace_dump_call_end();
1255 }
1256
1257
1258 static struct pipe_stream_output_target *
trace_context_create_stream_output_target(struct pipe_context * _pipe,struct pipe_resource * res,unsigned buffer_offset,unsigned buffer_size)1259 trace_context_create_stream_output_target(struct pipe_context *_pipe,
1260 struct pipe_resource *res,
1261 unsigned buffer_offset,
1262 unsigned buffer_size)
1263 {
1264 struct trace_context *tr_ctx = trace_context(_pipe);
1265 struct pipe_context *pipe = tr_ctx->pipe;
1266 struct pipe_stream_output_target *result;
1267
1268 trace_dump_call_begin("pipe_context", "create_stream_output_target");
1269
1270 trace_dump_arg(ptr, pipe);
1271 trace_dump_arg(ptr, res);
1272 trace_dump_arg(uint, buffer_offset);
1273 trace_dump_arg(uint, buffer_size);
1274
1275 result = pipe->create_stream_output_target(pipe,
1276 res, buffer_offset, buffer_size);
1277
1278 trace_dump_ret(ptr, result);
1279
1280 trace_dump_call_end();
1281
1282 return result;
1283 }
1284
1285
1286 static void
trace_context_stream_output_target_destroy(struct pipe_context * _pipe,struct pipe_stream_output_target * target)1287 trace_context_stream_output_target_destroy(
1288 struct pipe_context *_pipe,
1289 struct pipe_stream_output_target *target)
1290 {
1291 struct trace_context *tr_ctx = trace_context(_pipe);
1292 struct pipe_context *pipe = tr_ctx->pipe;
1293
1294 trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1295
1296 trace_dump_arg(ptr, pipe);
1297 trace_dump_arg(ptr, target);
1298
1299 pipe->stream_output_target_destroy(pipe, target);
1300
1301 trace_dump_call_end();
1302 }
1303
1304
1305 static void
trace_context_set_stream_output_targets(struct pipe_context * _pipe,unsigned num_targets,struct pipe_stream_output_target ** tgs,const unsigned * offsets)1306 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1307 unsigned num_targets,
1308 struct pipe_stream_output_target **tgs,
1309 const unsigned *offsets)
1310 {
1311 struct trace_context *tr_ctx = trace_context(_pipe);
1312 struct pipe_context *pipe = tr_ctx->pipe;
1313
1314 trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1315
1316 trace_dump_arg(ptr, pipe);
1317 trace_dump_arg(uint, num_targets);
1318 trace_dump_arg_array(ptr, tgs, num_targets);
1319 trace_dump_arg_array(uint, offsets, num_targets);
1320
1321 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
1322
1323 trace_dump_call_end();
1324 }
1325
1326
1327 static void
trace_context_resource_copy_region(struct pipe_context * _pipe,struct pipe_resource * dst,unsigned dst_level,unsigned dstx,unsigned dsty,unsigned dstz,struct pipe_resource * src,unsigned src_level,const struct pipe_box * src_box)1328 trace_context_resource_copy_region(struct pipe_context *_pipe,
1329 struct pipe_resource *dst,
1330 unsigned dst_level,
1331 unsigned dstx, unsigned dsty, unsigned dstz,
1332 struct pipe_resource *src,
1333 unsigned src_level,
1334 const struct pipe_box *src_box)
1335 {
1336 struct trace_context *tr_ctx = trace_context(_pipe);
1337 struct pipe_context *pipe = tr_ctx->pipe;
1338
1339 trace_dump_call_begin("pipe_context", "resource_copy_region");
1340
1341 trace_dump_arg(ptr, pipe);
1342 trace_dump_arg(ptr, dst);
1343 trace_dump_arg(uint, dst_level);
1344 trace_dump_arg(uint, dstx);
1345 trace_dump_arg(uint, dsty);
1346 trace_dump_arg(uint, dstz);
1347 trace_dump_arg(ptr, src);
1348 trace_dump_arg(uint, src_level);
1349 trace_dump_arg(box, src_box);
1350
1351 pipe->resource_copy_region(pipe,
1352 dst, dst_level, dstx, dsty, dstz,
1353 src, src_level, src_box);
1354
1355 trace_dump_call_end();
1356 }
1357
1358
1359 static void
trace_context_blit(struct pipe_context * _pipe,const struct pipe_blit_info * _info)1360 trace_context_blit(struct pipe_context *_pipe,
1361 const struct pipe_blit_info *_info)
1362 {
1363 struct trace_context *tr_ctx = trace_context(_pipe);
1364 struct pipe_context *pipe = tr_ctx->pipe;
1365 struct pipe_blit_info info = *_info;
1366
1367 trace_dump_call_begin("pipe_context", "blit");
1368
1369 trace_dump_arg(ptr, pipe);
1370 trace_dump_arg(blit_info, _info);
1371
1372 pipe->blit(pipe, &info);
1373
1374 trace_dump_call_end();
1375 }
1376
1377
1378 static void
trace_context_flush_resource(struct pipe_context * _pipe,struct pipe_resource * resource)1379 trace_context_flush_resource(struct pipe_context *_pipe,
1380 struct pipe_resource *resource)
1381 {
1382 struct trace_context *tr_ctx = trace_context(_pipe);
1383 struct pipe_context *pipe = tr_ctx->pipe;
1384
1385 trace_dump_call_begin("pipe_context", "flush_resource");
1386
1387 trace_dump_arg(ptr, pipe);
1388 trace_dump_arg(ptr, resource);
1389
1390 pipe->flush_resource(pipe, resource);
1391
1392 trace_dump_call_end();
1393 }
1394
1395
1396 static void
trace_context_clear(struct pipe_context * _pipe,unsigned buffers,const struct pipe_scissor_state * scissor_state,const union pipe_color_union * color,double depth,unsigned stencil)1397 trace_context_clear(struct pipe_context *_pipe,
1398 unsigned buffers,
1399 const struct pipe_scissor_state *scissor_state,
1400 const union pipe_color_union *color,
1401 double depth,
1402 unsigned stencil)
1403 {
1404 struct trace_context *tr_ctx = trace_context(_pipe);
1405 struct pipe_context *pipe = tr_ctx->pipe;
1406
1407 trace_dump_call_begin("pipe_context", "clear");
1408
1409 trace_dump_arg(ptr, pipe);
1410 trace_dump_arg(uint, buffers);
1411 trace_dump_arg_begin("scissor_state");
1412 trace_dump_scissor_state(scissor_state);
1413 trace_dump_arg_end();
1414 if (color)
1415 trace_dump_arg_array(uint, color->ui, 4);
1416 else
1417 trace_dump_null();
1418 trace_dump_arg(float, depth);
1419 trace_dump_arg(uint, stencil);
1420
1421 pipe->clear(pipe, buffers, scissor_state, color, depth, stencil);
1422
1423 trace_dump_call_end();
1424 }
1425
1426
1427 static void
trace_context_clear_render_target(struct pipe_context * _pipe,struct pipe_surface * dst,const union pipe_color_union * color,unsigned dstx,unsigned dsty,unsigned width,unsigned height,bool render_condition_enabled)1428 trace_context_clear_render_target(struct pipe_context *_pipe,
1429 struct pipe_surface *dst,
1430 const union pipe_color_union *color,
1431 unsigned dstx, unsigned dsty,
1432 unsigned width, unsigned height,
1433 bool render_condition_enabled)
1434 {
1435 struct trace_context *tr_ctx = trace_context(_pipe);
1436 struct pipe_context *pipe = tr_ctx->pipe;
1437
1438 dst = trace_surface_unwrap(tr_ctx, dst);
1439
1440 trace_dump_call_begin("pipe_context", "clear_render_target");
1441
1442 trace_dump_arg(ptr, pipe);
1443 trace_dump_arg(ptr, dst);
1444 trace_dump_arg_array(uint, color->ui, 4);
1445 trace_dump_arg(uint, dstx);
1446 trace_dump_arg(uint, dsty);
1447 trace_dump_arg(uint, width);
1448 trace_dump_arg(uint, height);
1449 trace_dump_arg(bool, render_condition_enabled);
1450
1451 pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height,
1452 render_condition_enabled);
1453
1454 trace_dump_call_end();
1455 }
1456
1457 static void
trace_context_clear_depth_stencil(struct pipe_context * _pipe,struct pipe_surface * dst,unsigned clear_flags,double depth,unsigned stencil,unsigned dstx,unsigned dsty,unsigned width,unsigned height,bool render_condition_enabled)1458 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1459 struct pipe_surface *dst,
1460 unsigned clear_flags,
1461 double depth,
1462 unsigned stencil,
1463 unsigned dstx, unsigned dsty,
1464 unsigned width, unsigned height,
1465 bool render_condition_enabled)
1466 {
1467 struct trace_context *tr_ctx = trace_context(_pipe);
1468 struct pipe_context *pipe = tr_ctx->pipe;
1469
1470 dst = trace_surface_unwrap(tr_ctx, dst);
1471
1472 trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1473
1474 trace_dump_arg(ptr, pipe);
1475 trace_dump_arg(ptr, dst);
1476 trace_dump_arg(uint, clear_flags);
1477 trace_dump_arg(float, depth);
1478 trace_dump_arg(uint, stencil);
1479 trace_dump_arg(uint, dstx);
1480 trace_dump_arg(uint, dsty);
1481 trace_dump_arg(uint, width);
1482 trace_dump_arg(uint, height);
1483 trace_dump_arg(bool, render_condition_enabled);
1484
1485 pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1486 dstx, dsty, width, height,
1487 render_condition_enabled);
1488
1489 trace_dump_call_end();
1490 }
1491
1492 static inline void
trace_context_clear_buffer(struct pipe_context * _pipe,struct pipe_resource * res,unsigned offset,unsigned size,const void * clear_value,int clear_value_size)1493 trace_context_clear_buffer(struct pipe_context *_pipe,
1494 struct pipe_resource *res,
1495 unsigned offset,
1496 unsigned size,
1497 const void *clear_value,
1498 int clear_value_size)
1499 {
1500 struct trace_context *tr_ctx = trace_context(_pipe);
1501 struct pipe_context *pipe = tr_ctx->pipe;
1502
1503
1504 trace_dump_call_begin("pipe_context", "clear_buffer");
1505
1506 trace_dump_arg(ptr, pipe);
1507 trace_dump_arg(ptr, res);
1508 trace_dump_arg(uint, offset);
1509 trace_dump_arg(uint, size);
1510 trace_dump_arg(ptr, clear_value);
1511 trace_dump_arg(int, clear_value_size);
1512
1513 pipe->clear_buffer(pipe, res, offset, size, clear_value, clear_value_size);
1514
1515 trace_dump_call_end();
1516 }
1517
1518 static inline void
trace_context_clear_texture(struct pipe_context * _pipe,struct pipe_resource * res,unsigned level,const struct pipe_box * box,const void * data)1519 trace_context_clear_texture(struct pipe_context *_pipe,
1520 struct pipe_resource *res,
1521 unsigned level,
1522 const struct pipe_box *box,
1523 const void *data)
1524 {
1525 struct trace_context *tr_ctx = trace_context(_pipe);
1526 const struct util_format_description *desc = util_format_description(res->format);
1527 struct pipe_context *pipe = tr_ctx->pipe;
1528 union pipe_color_union color;
1529 float depth = 0.0f;
1530 uint8_t stencil = 0;
1531
1532 trace_dump_call_begin("pipe_context", "clear_texture");
1533 trace_dump_arg(ptr, pipe);
1534 trace_dump_arg(ptr, res);
1535 trace_dump_arg(uint, level);
1536 trace_dump_arg_begin("box");
1537 trace_dump_box(box);
1538 trace_dump_arg_end();
1539 if (util_format_has_depth(desc)) {
1540 util_format_unpack_z_float(res->format, &depth, data, 1);
1541 trace_dump_arg(float, depth);
1542 }
1543 if (util_format_has_stencil(desc)) {
1544 util_format_unpack_s_8uint(res->format, &stencil, data, 1);
1545 trace_dump_arg(uint, stencil);
1546 }
1547 if (!util_format_is_depth_or_stencil(res->format)) {
1548 util_format_unpack_rgba(res->format, color.ui, data, 1);
1549 trace_dump_arg_array(uint, color.ui, 4);
1550 }
1551
1552 pipe->clear_texture(pipe, res, level, box, data);
1553
1554 trace_dump_call_end();
1555 }
1556
1557 static void
trace_context_flush(struct pipe_context * _pipe,struct pipe_fence_handle ** fence,unsigned flags)1558 trace_context_flush(struct pipe_context *_pipe,
1559 struct pipe_fence_handle **fence,
1560 unsigned flags)
1561 {
1562 struct trace_context *tr_ctx = trace_context(_pipe);
1563 struct pipe_context *pipe = tr_ctx->pipe;
1564
1565 trace_dump_call_begin("pipe_context", "flush");
1566
1567 trace_dump_arg(ptr, pipe);
1568 trace_dump_arg(uint, flags);
1569
1570 pipe->flush(pipe, fence, flags);
1571
1572 if (fence)
1573 trace_dump_ret(ptr, *fence);
1574
1575 trace_dump_call_end();
1576
1577 if (flags & PIPE_FLUSH_END_OF_FRAME) {
1578 trace_dump_check_trigger();
1579 tr_ctx->seen_fb_state = false;
1580 }
1581 }
1582
1583
1584 static void
trace_context_create_fence_fd(struct pipe_context * _pipe,struct pipe_fence_handle ** fence,int fd,enum pipe_fd_type type)1585 trace_context_create_fence_fd(struct pipe_context *_pipe,
1586 struct pipe_fence_handle **fence,
1587 int fd,
1588 enum pipe_fd_type type)
1589 {
1590 struct trace_context *tr_ctx = trace_context(_pipe);
1591 struct pipe_context *pipe = tr_ctx->pipe;
1592
1593 trace_dump_call_begin("pipe_context", "create_fence_fd");
1594
1595 trace_dump_arg(ptr, pipe);
1596 trace_dump_arg_enum(fd, tr_util_pipe_fd_type_name(fd));
1597 trace_dump_arg(uint, type);
1598
1599 pipe->create_fence_fd(pipe, fence, fd, type);
1600
1601 if (fence)
1602 trace_dump_ret(ptr, *fence);
1603
1604 trace_dump_call_end();
1605 }
1606
1607
1608 static void
trace_context_fence_server_sync(struct pipe_context * _pipe,struct pipe_fence_handle * fence)1609 trace_context_fence_server_sync(struct pipe_context *_pipe,
1610 struct pipe_fence_handle *fence)
1611 {
1612 struct trace_context *tr_ctx = trace_context(_pipe);
1613 struct pipe_context *pipe = tr_ctx->pipe;
1614
1615 trace_dump_call_begin("pipe_context", "fence_server_sync");
1616
1617 trace_dump_arg(ptr, pipe);
1618 trace_dump_arg(ptr, fence);
1619
1620 pipe->fence_server_sync(pipe, fence);
1621
1622 trace_dump_call_end();
1623 }
1624
1625
1626 static void
trace_context_fence_server_signal(struct pipe_context * _pipe,struct pipe_fence_handle * fence)1627 trace_context_fence_server_signal(struct pipe_context *_pipe,
1628 struct pipe_fence_handle *fence)
1629 {
1630 struct trace_context *tr_ctx = trace_context(_pipe);
1631 struct pipe_context *pipe = tr_ctx->pipe;
1632
1633 trace_dump_call_begin("pipe_context", "fence_server_signal");
1634
1635 trace_dump_arg(ptr, pipe);
1636 trace_dump_arg(ptr, fence);
1637
1638 pipe->fence_server_signal(pipe, fence);
1639
1640 trace_dump_call_end();
1641 }
1642
1643
1644 static inline bool
trace_context_generate_mipmap(struct pipe_context * _pipe,struct pipe_resource * res,enum pipe_format format,unsigned base_level,unsigned last_level,unsigned first_layer,unsigned last_layer)1645 trace_context_generate_mipmap(struct pipe_context *_pipe,
1646 struct pipe_resource *res,
1647 enum pipe_format format,
1648 unsigned base_level,
1649 unsigned last_level,
1650 unsigned first_layer,
1651 unsigned last_layer)
1652 {
1653 struct trace_context *tr_ctx = trace_context(_pipe);
1654 struct pipe_context *pipe = tr_ctx->pipe;
1655 bool ret;
1656
1657 trace_dump_call_begin("pipe_context", "generate_mipmap");
1658
1659 trace_dump_arg(ptr, pipe);
1660 trace_dump_arg(ptr, res);
1661
1662 trace_dump_arg(format, format);
1663 trace_dump_arg(uint, base_level);
1664 trace_dump_arg(uint, last_level);
1665 trace_dump_arg(uint, first_layer);
1666 trace_dump_arg(uint, last_layer);
1667
1668 ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level,
1669 first_layer, last_layer);
1670
1671 trace_dump_ret(bool, ret);
1672 trace_dump_call_end();
1673
1674 return ret;
1675 }
1676
1677
1678 static void
trace_context_destroy(struct pipe_context * _pipe)1679 trace_context_destroy(struct pipe_context *_pipe)
1680 {
1681 struct trace_context *tr_ctx = trace_context(_pipe);
1682 struct pipe_context *pipe = tr_ctx->pipe;
1683
1684 trace_dump_call_begin("pipe_context", "destroy");
1685 trace_dump_arg(ptr, pipe);
1686 trace_dump_call_end();
1687
1688 pipe->destroy(pipe);
1689
1690 ralloc_free(tr_ctx);
1691 }
1692
1693
1694 /********************************************************************
1695 * transfer
1696 */
1697
1698
1699 static void *
trace_context_transfer_map(struct pipe_context * _context,struct pipe_resource * resource,unsigned level,unsigned usage,const struct pipe_box * box,struct pipe_transfer ** transfer)1700 trace_context_transfer_map(struct pipe_context *_context,
1701 struct pipe_resource *resource,
1702 unsigned level,
1703 unsigned usage,
1704 const struct pipe_box *box,
1705 struct pipe_transfer **transfer)
1706 {
1707 struct trace_context *tr_context = trace_context(_context);
1708 struct pipe_context *pipe = tr_context->pipe;
1709 struct pipe_transfer *xfer = NULL;
1710 void *map;
1711
1712 if (resource->target == PIPE_BUFFER)
1713 map = pipe->buffer_map(pipe, resource, level, usage, box, &xfer);
1714 else
1715 map = pipe->texture_map(pipe, resource, level, usage, box, &xfer);
1716 if (!map)
1717 return NULL;
1718 *transfer = trace_transfer_create(tr_context, resource, xfer);
1719 trace_dump_call_begin("pipe_context", resource->target == PIPE_BUFFER ? "buffer_map" : "texture_map");
1720
1721 trace_dump_arg(ptr, pipe);
1722 trace_dump_arg(ptr, resource);
1723 trace_dump_arg(uint, level);
1724 trace_dump_arg(uint, usage);
1725 trace_dump_arg(box, box);
1726
1727 trace_dump_arg(ptr, xfer);
1728 trace_dump_ret(ptr, map);
1729
1730 trace_dump_call_end();
1731
1732 if (map) {
1733 if (usage & PIPE_MAP_WRITE) {
1734 trace_transfer(*transfer)->map = map;
1735 }
1736 }
1737
1738 return *transfer ? map : NULL;
1739 }
1740
1741 static void
trace_context_transfer_flush_region(struct pipe_context * _context,struct pipe_transfer * _transfer,const struct pipe_box * box)1742 trace_context_transfer_flush_region( struct pipe_context *_context,
1743 struct pipe_transfer *_transfer,
1744 const struct pipe_box *box)
1745 {
1746 struct trace_context *tr_context = trace_context(_context);
1747 struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1748 struct pipe_context *pipe = tr_context->pipe;
1749 struct pipe_transfer *transfer = tr_transfer->transfer;
1750
1751 trace_dump_call_begin("pipe_context", "transfer_flush_region");
1752
1753 trace_dump_arg(ptr, pipe);
1754 trace_dump_arg(ptr, transfer);
1755 trace_dump_arg(box, box);
1756
1757 trace_dump_call_end();
1758
1759 pipe->transfer_flush_region(pipe, transfer, box);
1760 }
1761
1762 static void
trace_context_transfer_unmap(struct pipe_context * _context,struct pipe_transfer * _transfer)1763 trace_context_transfer_unmap(struct pipe_context *_context,
1764 struct pipe_transfer *_transfer)
1765 {
1766 struct trace_context *tr_ctx = trace_context(_context);
1767 struct trace_transfer *tr_trans = trace_transfer(_transfer);
1768 struct pipe_context *context = tr_ctx->pipe;
1769 struct pipe_transfer *transfer = tr_trans->transfer;
1770
1771
1772 trace_dump_call_begin("pipe_context", "transfer_unmap");
1773
1774 trace_dump_arg(ptr, context);
1775 trace_dump_arg(ptr, transfer);
1776
1777 trace_dump_call_end();
1778
1779 if (tr_trans->map && !tr_ctx->threaded) {
1780 /*
1781 * Fake a texture/buffer_subdata
1782 */
1783
1784 struct pipe_resource *resource = transfer->resource;
1785 unsigned usage = transfer->usage;
1786 const struct pipe_box *box = &transfer->box;
1787 unsigned stride = transfer->stride;
1788 unsigned layer_stride = transfer->layer_stride;
1789
1790 if (resource->target == PIPE_BUFFER) {
1791 unsigned offset = box->x;
1792 unsigned size = box->width;
1793
1794 trace_dump_call_begin("pipe_context", "buffer_subdata");
1795
1796 trace_dump_arg(ptr, context);
1797 trace_dump_arg(ptr, resource);
1798 trace_dump_arg(uint, usage);
1799 trace_dump_arg(uint, offset);
1800 trace_dump_arg(uint, size);
1801
1802 trace_dump_arg_begin("data");
1803 trace_dump_box_bytes(tr_trans->map,
1804 resource,
1805 box,
1806 stride,
1807 layer_stride);
1808 trace_dump_arg_end();
1809
1810 trace_dump_arg(uint, stride);
1811 trace_dump_arg(uint, layer_stride);
1812
1813 trace_dump_call_end();
1814 } else {
1815 unsigned level = transfer->level;
1816
1817 trace_dump_call_begin("pipe_context", "texture_subdata");
1818
1819 trace_dump_arg(ptr, context);
1820 trace_dump_arg(ptr, resource);
1821 trace_dump_arg(uint, level);
1822 trace_dump_arg(uint, usage);
1823 trace_dump_arg(box, box);
1824
1825 trace_dump_arg_begin("data");
1826 trace_dump_box_bytes(tr_trans->map,
1827 resource,
1828 box,
1829 stride,
1830 layer_stride);
1831 trace_dump_arg_end();
1832
1833 trace_dump_arg(uint, stride);
1834 trace_dump_arg(uint, layer_stride);
1835
1836 trace_dump_call_end();
1837 }
1838
1839 tr_trans->map = NULL;
1840 }
1841
1842 if (transfer->resource->target == PIPE_BUFFER)
1843 context->buffer_unmap(context, transfer);
1844 else
1845 context->texture_unmap(context, transfer);
1846 trace_transfer_destroy(tr_ctx, tr_trans);
1847 }
1848
1849
1850 static void
trace_context_buffer_subdata(struct pipe_context * _context,struct pipe_resource * resource,unsigned usage,unsigned offset,unsigned size,const void * data)1851 trace_context_buffer_subdata(struct pipe_context *_context,
1852 struct pipe_resource *resource,
1853 unsigned usage, unsigned offset,
1854 unsigned size, const void *data)
1855 {
1856 struct trace_context *tr_context = trace_context(_context);
1857 struct pipe_context *context = tr_context->pipe;
1858 struct pipe_box box;
1859
1860 trace_dump_call_begin("pipe_context", "buffer_subdata");
1861
1862 trace_dump_arg(ptr, context);
1863 trace_dump_arg(ptr, resource);
1864 trace_dump_arg(uint, usage);
1865 trace_dump_arg(uint, offset);
1866 trace_dump_arg(uint, size);
1867
1868 trace_dump_arg_begin("data");
1869 u_box_1d(offset, size, &box);
1870 trace_dump_box_bytes(data, resource, &box, 0, 0);
1871 trace_dump_arg_end();
1872
1873 trace_dump_call_end();
1874
1875 context->buffer_subdata(context, resource, usage, offset, size, data);
1876 }
1877
1878
1879 static void
trace_context_texture_subdata(struct pipe_context * _context,struct pipe_resource * resource,unsigned level,unsigned usage,const struct pipe_box * box,const void * data,unsigned stride,unsigned layer_stride)1880 trace_context_texture_subdata(struct pipe_context *_context,
1881 struct pipe_resource *resource,
1882 unsigned level,
1883 unsigned usage,
1884 const struct pipe_box *box,
1885 const void *data,
1886 unsigned stride,
1887 unsigned layer_stride)
1888 {
1889 struct trace_context *tr_context = trace_context(_context);
1890 struct pipe_context *context = tr_context->pipe;
1891
1892 trace_dump_call_begin("pipe_context", "texture_subdata");
1893
1894 trace_dump_arg(ptr, context);
1895 trace_dump_arg(ptr, resource);
1896 trace_dump_arg(uint, level);
1897 trace_dump_arg(uint, usage);
1898 trace_dump_arg(box, box);
1899
1900 trace_dump_arg_begin("data");
1901 trace_dump_box_bytes(data,
1902 resource,
1903 box,
1904 stride,
1905 layer_stride);
1906 trace_dump_arg_end();
1907
1908 trace_dump_arg(uint, stride);
1909 trace_dump_arg(uint, layer_stride);
1910
1911 trace_dump_call_end();
1912
1913 context->texture_subdata(context, resource, level, usage, box,
1914 data, stride, layer_stride);
1915 }
1916
1917 static void
trace_context_invalidate_resource(struct pipe_context * _context,struct pipe_resource * resource)1918 trace_context_invalidate_resource(struct pipe_context *_context,
1919 struct pipe_resource *resource)
1920 {
1921 struct trace_context *tr_context = trace_context(_context);
1922 struct pipe_context *context = tr_context->pipe;
1923
1924 trace_dump_call_begin("pipe_context", "invalidate_resource");
1925
1926 trace_dump_arg(ptr, context);
1927 trace_dump_arg(ptr, resource);
1928
1929 trace_dump_call_end();
1930
1931 context->invalidate_resource(context, resource);
1932 }
1933
1934 static void
trace_context_set_context_param(struct pipe_context * _context,enum pipe_context_param param,unsigned value)1935 trace_context_set_context_param(struct pipe_context *_context,
1936 enum pipe_context_param param,
1937 unsigned value)
1938 {
1939 struct trace_context *tr_context = trace_context(_context);
1940 struct pipe_context *context = tr_context->pipe;
1941
1942 trace_dump_call_begin("pipe_context", "set_context_param");
1943
1944 trace_dump_arg(ptr, context);
1945 trace_dump_arg(uint, param);
1946 trace_dump_arg(uint, value);
1947
1948 trace_dump_call_end();
1949
1950 context->set_context_param(context, param, value);
1951 }
1952
1953 static void
trace_context_set_debug_callback(struct pipe_context * _context,const struct pipe_debug_callback * cb)1954 trace_context_set_debug_callback(struct pipe_context *_context, const struct pipe_debug_callback *cb)
1955 {
1956 struct trace_context *tr_context = trace_context(_context);
1957 struct pipe_context *context = tr_context->pipe;
1958
1959 trace_dump_call_begin("pipe_context", "set_debug_callback");
1960
1961 trace_dump_arg(ptr, context);
1962
1963 trace_dump_call_end();
1964
1965 context->set_debug_callback(context, cb);
1966 }
1967
1968 static void
trace_context_render_condition(struct pipe_context * _context,struct pipe_query * query,bool condition,enum pipe_render_cond_flag mode)1969 trace_context_render_condition(struct pipe_context *_context,
1970 struct pipe_query *query,
1971 bool condition,
1972 enum pipe_render_cond_flag mode)
1973 {
1974 struct trace_context *tr_context = trace_context(_context);
1975 struct pipe_context *context = tr_context->pipe;
1976
1977 query = trace_query_unwrap(query);
1978
1979 trace_dump_call_begin("pipe_context", "render_condition");
1980
1981 trace_dump_arg(ptr, context);
1982 trace_dump_arg(ptr, query);
1983 trace_dump_arg(bool, condition);
1984 trace_dump_arg(uint, mode);
1985
1986 trace_dump_call_end();
1987
1988 context->render_condition(context, query, condition, mode);
1989 }
1990
1991 static void
trace_context_render_condition_mem(struct pipe_context * _context,struct pipe_resource * buffer,uint32_t offset,bool condition)1992 trace_context_render_condition_mem(struct pipe_context *_context,
1993 struct pipe_resource *buffer,
1994 uint32_t offset,
1995 bool condition)
1996 {
1997 struct trace_context *tr_context = trace_context(_context);
1998 struct pipe_context *context = tr_context->pipe;
1999
2000 trace_dump_call_begin("pipe_context", "render_condition_mem");
2001
2002 trace_dump_arg(ptr, context);
2003 trace_dump_arg(ptr, buffer);
2004 trace_dump_arg(uint, offset);
2005 trace_dump_arg(bool, condition);
2006
2007 trace_dump_call_end();
2008
2009 context->render_condition_mem(context, buffer, offset, condition);
2010 }
2011
2012
2013 static void
trace_context_texture_barrier(struct pipe_context * _context,unsigned flags)2014 trace_context_texture_barrier(struct pipe_context *_context, unsigned flags)
2015 {
2016 struct trace_context *tr_context = trace_context(_context);
2017 struct pipe_context *context = tr_context->pipe;
2018
2019 trace_dump_call_begin("pipe_context", "texture_barrier");
2020
2021 trace_dump_arg(ptr, context);
2022 trace_dump_arg(uint, flags);
2023
2024 trace_dump_call_end();
2025
2026 context->texture_barrier(context, flags);
2027 }
2028
2029
2030 static void
trace_context_memory_barrier(struct pipe_context * _context,unsigned flags)2031 trace_context_memory_barrier(struct pipe_context *_context,
2032 unsigned flags)
2033 {
2034 struct trace_context *tr_context = trace_context(_context);
2035 struct pipe_context *context = tr_context->pipe;
2036
2037 trace_dump_call_begin("pipe_context", "memory_barrier");
2038 trace_dump_arg(ptr, context);
2039 trace_dump_arg(uint, flags);
2040 trace_dump_call_end();
2041
2042 context->memory_barrier(context, flags);
2043 }
2044
2045
2046 static bool
trace_context_resource_commit(struct pipe_context * _context,struct pipe_resource * resource,unsigned level,struct pipe_box * box,bool commit)2047 trace_context_resource_commit(struct pipe_context *_context,
2048 struct pipe_resource *resource,
2049 unsigned level, struct pipe_box *box, bool commit)
2050 {
2051 struct trace_context *tr_context = trace_context(_context);
2052 struct pipe_context *context = tr_context->pipe;
2053
2054 trace_dump_call_begin("pipe_context", "resource_commit");
2055 trace_dump_arg(ptr, context);
2056 trace_dump_arg(ptr, resource);
2057 trace_dump_arg(uint, level);
2058 trace_dump_arg(box, box);
2059 trace_dump_arg(bool, commit);
2060 trace_dump_call_end();
2061
2062 return context->resource_commit(context, resource, level, box, commit);
2063 }
2064
2065 static void
trace_context_set_tess_state(struct pipe_context * _context,const float default_outer_level[4],const float default_inner_level[2])2066 trace_context_set_tess_state(struct pipe_context *_context,
2067 const float default_outer_level[4],
2068 const float default_inner_level[2])
2069 {
2070 struct trace_context *tr_context = trace_context(_context);
2071 struct pipe_context *context = tr_context->pipe;
2072
2073 trace_dump_call_begin("pipe_context", "set_tess_state");
2074 trace_dump_arg(ptr, context);
2075 trace_dump_arg_array(float, default_outer_level, 4);
2076 trace_dump_arg_array(float, default_inner_level, 2);
2077 trace_dump_call_end();
2078
2079 context->set_tess_state(context, default_outer_level, default_inner_level);
2080 }
2081
2082 static void
trace_context_set_patch_vertices(struct pipe_context * _context,uint8_t patch_vertices)2083 trace_context_set_patch_vertices(struct pipe_context *_context,
2084 uint8_t patch_vertices)
2085 {
2086 struct trace_context *tr_context = trace_context(_context);
2087 struct pipe_context *context = tr_context->pipe;
2088
2089 trace_dump_call_begin("pipe_context", "set_patch_vertices");
2090 trace_dump_arg(ptr, context);
2091 trace_dump_arg(uint, patch_vertices);
2092 trace_dump_call_end();
2093
2094 context->set_patch_vertices(context, patch_vertices);
2095 }
2096
trace_context_set_shader_buffers(struct pipe_context * _context,enum pipe_shader_type shader,unsigned start,unsigned nr,const struct pipe_shader_buffer * buffers,unsigned writable_bitmask)2097 static void trace_context_set_shader_buffers(struct pipe_context *_context,
2098 enum pipe_shader_type shader,
2099 unsigned start, unsigned nr,
2100 const struct pipe_shader_buffer *buffers,
2101 unsigned writable_bitmask)
2102 {
2103 struct trace_context *tr_context = trace_context(_context);
2104 struct pipe_context *context = tr_context->pipe;
2105
2106 trace_dump_call_begin("pipe_context", "set_shader_buffers");
2107 trace_dump_arg(ptr, context);
2108 trace_dump_arg(uint, shader);
2109 trace_dump_arg(uint, start);
2110 trace_dump_arg_begin("buffers");
2111 trace_dump_struct_array(shader_buffer, buffers, nr);
2112 trace_dump_arg_end();
2113 trace_dump_arg(uint, writable_bitmask);
2114 trace_dump_call_end();
2115
2116 context->set_shader_buffers(context, shader, start, nr, buffers,
2117 writable_bitmask);
2118 }
2119
trace_context_set_shader_images(struct pipe_context * _context,enum pipe_shader_type shader,unsigned start,unsigned nr,unsigned unbind_num_trailing_slots,const struct pipe_image_view * images)2120 static void trace_context_set_shader_images(struct pipe_context *_context,
2121 enum pipe_shader_type shader,
2122 unsigned start, unsigned nr,
2123 unsigned unbind_num_trailing_slots,
2124 const struct pipe_image_view *images)
2125 {
2126 struct trace_context *tr_context = trace_context(_context);
2127 struct pipe_context *context = tr_context->pipe;
2128
2129 trace_dump_call_begin("pipe_context", "set_shader_images");
2130 trace_dump_arg(ptr, context);
2131 trace_dump_arg(uint, shader);
2132 trace_dump_arg(uint, start);
2133 trace_dump_arg_begin("images");
2134 trace_dump_struct_array(image_view, images, nr);
2135 trace_dump_arg_end();
2136 trace_dump_arg(uint, unbind_num_trailing_slots);
2137 trace_dump_call_end();
2138
2139 context->set_shader_images(context, shader, start, nr,
2140 unbind_num_trailing_slots, images);
2141 }
2142
trace_context_launch_grid(struct pipe_context * _pipe,const struct pipe_grid_info * info)2143 static void trace_context_launch_grid(struct pipe_context *_pipe,
2144 const struct pipe_grid_info *info)
2145 {
2146 struct trace_context *tr_ctx = trace_context(_pipe);
2147 struct pipe_context *pipe = tr_ctx->pipe;
2148
2149 trace_dump_call_begin("pipe_context", "launch_grid");
2150
2151 trace_dump_arg(ptr, pipe);
2152 trace_dump_arg(grid_info, info);
2153
2154 trace_dump_trace_flush();
2155
2156 pipe->launch_grid(pipe, info);
2157
2158 trace_dump_call_end();
2159 }
2160
trace_context_create_texture_handle(struct pipe_context * _pipe,struct pipe_sampler_view * view,const struct pipe_sampler_state * state)2161 static uint64_t trace_context_create_texture_handle(struct pipe_context *_pipe,
2162 struct pipe_sampler_view *view,
2163 const struct pipe_sampler_state *state)
2164 {
2165 struct trace_context *tr_ctx = trace_context(_pipe);
2166 struct pipe_context *pipe = tr_ctx->pipe;
2167 uint64_t handle;
2168
2169 trace_dump_call_begin("pipe_context", "create_texture_handle");
2170 trace_dump_arg(ptr, pipe);
2171 trace_dump_arg(ptr, view);
2172 trace_dump_arg_begin("state");
2173 trace_dump_arg(sampler_state, state);
2174 trace_dump_arg_end();
2175
2176 handle = pipe->create_texture_handle(pipe, view, state);
2177
2178 trace_dump_ret(uint, handle);
2179 trace_dump_call_end();
2180
2181 return handle;
2182 }
2183
trace_context_delete_texture_handle(struct pipe_context * _pipe,uint64_t handle)2184 static void trace_context_delete_texture_handle(struct pipe_context *_pipe,
2185 uint64_t handle)
2186 {
2187 struct trace_context *tr_ctx = trace_context(_pipe);
2188 struct pipe_context *pipe = tr_ctx->pipe;
2189
2190 trace_dump_call_begin("pipe_context", "delete_texture_handle");
2191 trace_dump_arg(ptr, pipe);
2192 trace_dump_arg(uint, handle);
2193 trace_dump_call_end();
2194
2195 pipe->delete_texture_handle(pipe, handle);
2196 }
2197
trace_context_make_texture_handle_resident(struct pipe_context * _pipe,uint64_t handle,bool resident)2198 static void trace_context_make_texture_handle_resident(struct pipe_context *_pipe,
2199 uint64_t handle,
2200 bool resident)
2201 {
2202 struct trace_context *tr_ctx = trace_context(_pipe);
2203 struct pipe_context *pipe = tr_ctx->pipe;
2204
2205 trace_dump_call_begin("pipe_context", "make_texture_handle_resident");
2206 trace_dump_arg(ptr, pipe);
2207 trace_dump_arg(uint, handle);
2208 trace_dump_arg(bool, resident);
2209 trace_dump_call_end();
2210
2211 pipe->make_texture_handle_resident(pipe, handle, resident);
2212 }
2213
trace_context_create_image_handle(struct pipe_context * _pipe,const struct pipe_image_view * image)2214 static uint64_t trace_context_create_image_handle(struct pipe_context *_pipe,
2215 const struct pipe_image_view *image)
2216 {
2217 struct trace_context *tr_ctx = trace_context(_pipe);
2218 struct pipe_context *pipe = tr_ctx->pipe;
2219 uint64_t handle;
2220
2221 trace_dump_call_begin("pipe_context", "create_image_handle");
2222 trace_dump_arg(ptr, pipe);
2223 trace_dump_arg_begin("image");
2224 trace_dump_image_view(image);
2225 trace_dump_arg_end();
2226
2227 handle = pipe->create_image_handle(pipe, image);
2228
2229 trace_dump_ret(uint, handle);
2230 trace_dump_call_end();
2231
2232 return handle;
2233 }
2234
trace_context_delete_image_handle(struct pipe_context * _pipe,uint64_t handle)2235 static void trace_context_delete_image_handle(struct pipe_context *_pipe,
2236 uint64_t handle)
2237 {
2238 struct trace_context *tr_ctx = trace_context(_pipe);
2239 struct pipe_context *pipe = tr_ctx->pipe;
2240
2241 trace_dump_call_begin("pipe_context", "delete_image_handle");
2242 trace_dump_arg(ptr, pipe);
2243 trace_dump_arg(uint, handle);
2244 trace_dump_call_end();
2245
2246 pipe->delete_image_handle(pipe, handle);
2247 }
2248
trace_context_make_image_handle_resident(struct pipe_context * _pipe,uint64_t handle,unsigned access,bool resident)2249 static void trace_context_make_image_handle_resident(struct pipe_context *_pipe,
2250 uint64_t handle,
2251 unsigned access,
2252 bool resident)
2253 {
2254 struct trace_context *tr_ctx = trace_context(_pipe);
2255 struct pipe_context *pipe = tr_ctx->pipe;
2256
2257 trace_dump_call_begin("pipe_context", "make_image_handle_resident");
2258 trace_dump_arg(ptr, pipe);
2259 trace_dump_arg(uint, handle);
2260 trace_dump_arg(uint, access);
2261 trace_dump_arg(bool, resident);
2262 trace_dump_call_end();
2263
2264 pipe->make_image_handle_resident(pipe, handle, access, resident);
2265 }
2266
2267 struct pipe_context *
trace_context_create(struct trace_screen * tr_scr,struct pipe_context * pipe)2268 trace_context_create(struct trace_screen *tr_scr,
2269 struct pipe_context *pipe)
2270 {
2271 struct trace_context *tr_ctx;
2272
2273 if (!pipe)
2274 goto error1;
2275
2276 if (!trace_enabled())
2277 goto error1;
2278
2279 tr_ctx = rzalloc(NULL, struct trace_context);
2280 if (!tr_ctx)
2281 goto error1;
2282
2283 _mesa_hash_table_init(&tr_ctx->blend_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
2284 _mesa_hash_table_init(&tr_ctx->rasterizer_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
2285 _mesa_hash_table_init(&tr_ctx->depth_stencil_alpha_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
2286
2287 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
2288 tr_ctx->base.screen = &tr_scr->base;
2289 tr_ctx->base.stream_uploader = pipe->stream_uploader;
2290 tr_ctx->base.const_uploader = pipe->const_uploader;
2291
2292 tr_ctx->base.destroy = trace_context_destroy;
2293
2294 #define TR_CTX_INIT(_member) \
2295 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
2296
2297 TR_CTX_INIT(draw_vbo);
2298 TR_CTX_INIT(draw_vertex_state);
2299 TR_CTX_INIT(render_condition);
2300 TR_CTX_INIT(render_condition_mem);
2301 TR_CTX_INIT(create_query);
2302 TR_CTX_INIT(destroy_query);
2303 TR_CTX_INIT(begin_query);
2304 TR_CTX_INIT(end_query);
2305 TR_CTX_INIT(get_query_result);
2306 TR_CTX_INIT(get_query_result_resource);
2307 TR_CTX_INIT(set_active_query_state);
2308 TR_CTX_INIT(create_blend_state);
2309 TR_CTX_INIT(bind_blend_state);
2310 TR_CTX_INIT(delete_blend_state);
2311 TR_CTX_INIT(create_sampler_state);
2312 TR_CTX_INIT(bind_sampler_states);
2313 TR_CTX_INIT(delete_sampler_state);
2314 TR_CTX_INIT(create_rasterizer_state);
2315 TR_CTX_INIT(bind_rasterizer_state);
2316 TR_CTX_INIT(delete_rasterizer_state);
2317 TR_CTX_INIT(create_depth_stencil_alpha_state);
2318 TR_CTX_INIT(bind_depth_stencil_alpha_state);
2319 TR_CTX_INIT(delete_depth_stencil_alpha_state);
2320 TR_CTX_INIT(create_fs_state);
2321 TR_CTX_INIT(bind_fs_state);
2322 TR_CTX_INIT(delete_fs_state);
2323 TR_CTX_INIT(create_vs_state);
2324 TR_CTX_INIT(bind_vs_state);
2325 TR_CTX_INIT(delete_vs_state);
2326 TR_CTX_INIT(create_gs_state);
2327 TR_CTX_INIT(bind_gs_state);
2328 TR_CTX_INIT(delete_gs_state);
2329 TR_CTX_INIT(create_tcs_state);
2330 TR_CTX_INIT(bind_tcs_state);
2331 TR_CTX_INIT(delete_tcs_state);
2332 TR_CTX_INIT(create_tes_state);
2333 TR_CTX_INIT(bind_tes_state);
2334 TR_CTX_INIT(delete_tes_state);
2335 TR_CTX_INIT(create_compute_state);
2336 TR_CTX_INIT(bind_compute_state);
2337 TR_CTX_INIT(delete_compute_state);
2338 TR_CTX_INIT(create_vertex_elements_state);
2339 TR_CTX_INIT(bind_vertex_elements_state);
2340 TR_CTX_INIT(delete_vertex_elements_state);
2341 TR_CTX_INIT(set_blend_color);
2342 TR_CTX_INIT(set_stencil_ref);
2343 TR_CTX_INIT(set_clip_state);
2344 TR_CTX_INIT(set_sample_mask);
2345 TR_CTX_INIT(set_constant_buffer);
2346 TR_CTX_INIT(set_framebuffer_state);
2347 TR_CTX_INIT(set_inlinable_constants);
2348 TR_CTX_INIT(set_polygon_stipple);
2349 TR_CTX_INIT(set_min_samples);
2350 TR_CTX_INIT(set_scissor_states);
2351 TR_CTX_INIT(set_viewport_states);
2352 TR_CTX_INIT(set_sampler_views);
2353 TR_CTX_INIT(create_sampler_view);
2354 TR_CTX_INIT(sampler_view_destroy);
2355 TR_CTX_INIT(create_surface);
2356 TR_CTX_INIT(surface_destroy);
2357 TR_CTX_INIT(set_vertex_buffers);
2358 TR_CTX_INIT(create_stream_output_target);
2359 TR_CTX_INIT(stream_output_target_destroy);
2360 TR_CTX_INIT(set_stream_output_targets);
2361 /* this is lavapipe-only and can't be traced */
2362 tr_ctx->base.stream_output_target_offset = pipe->stream_output_target_offset;
2363 TR_CTX_INIT(resource_copy_region);
2364 TR_CTX_INIT(blit);
2365 TR_CTX_INIT(flush_resource);
2366 TR_CTX_INIT(clear);
2367 TR_CTX_INIT(clear_render_target);
2368 TR_CTX_INIT(clear_depth_stencil);
2369 TR_CTX_INIT(clear_texture);
2370 TR_CTX_INIT(clear_buffer);
2371 TR_CTX_INIT(flush);
2372 TR_CTX_INIT(create_fence_fd);
2373 TR_CTX_INIT(fence_server_sync);
2374 TR_CTX_INIT(fence_server_signal);
2375 TR_CTX_INIT(generate_mipmap);
2376 TR_CTX_INIT(texture_barrier);
2377 TR_CTX_INIT(memory_barrier);
2378 TR_CTX_INIT(resource_commit);
2379 TR_CTX_INIT(set_tess_state);
2380 TR_CTX_INIT(set_patch_vertices);
2381 TR_CTX_INIT(set_shader_buffers);
2382 TR_CTX_INIT(launch_grid);
2383 TR_CTX_INIT(set_shader_images);
2384 TR_CTX_INIT(create_texture_handle);
2385 TR_CTX_INIT(delete_texture_handle);
2386 TR_CTX_INIT(make_texture_handle_resident);
2387 TR_CTX_INIT(create_image_handle);
2388 TR_CTX_INIT(delete_image_handle);
2389 TR_CTX_INIT(make_image_handle_resident);
2390
2391 tr_ctx->base.buffer_map = tr_ctx->base.texture_map = trace_context_transfer_map;
2392 tr_ctx->base.buffer_unmap = tr_ctx->base.texture_unmap = trace_context_transfer_unmap;
2393 TR_CTX_INIT(transfer_flush_region);
2394 TR_CTX_INIT(buffer_subdata);
2395 TR_CTX_INIT(texture_subdata);
2396 TR_CTX_INIT(invalidate_resource);
2397 TR_CTX_INIT(set_context_param);
2398 TR_CTX_INIT(set_debug_callback);
2399
2400 #undef TR_CTX_INIT
2401
2402 tr_ctx->pipe = pipe;
2403
2404 return &tr_ctx->base;
2405
2406 error1:
2407 return pipe;
2408 }
2409
2410
2411 /**
2412 * Sanity checker: check that the given context really is a
2413 * trace context (and not the wrapped driver's context).
2414 */
2415 void
trace_context_check(const struct pipe_context * pipe)2416 trace_context_check(const struct pipe_context *pipe)
2417 {
2418 ASSERTED struct trace_context *tr_ctx = (struct trace_context *) pipe;
2419 assert(tr_ctx->base.destroy == trace_context_destroy);
2420 }
2421
2422 /**
2423 * Threaded context is not wrapped, and so it may call fence functions directly
2424 */
2425 struct pipe_context *
trace_get_possibly_threaded_context(struct pipe_context * pipe)2426 trace_get_possibly_threaded_context(struct pipe_context *pipe)
2427 {
2428 return pipe->destroy == trace_context_destroy ? ((struct trace_context*)pipe)->pipe : pipe;
2429 }
2430