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
29 #include "pipe/p_compiler.h"
30 #include "util/u_memory.h"
31 #include "util/u_format.h"
32 #include "tgsi/tgsi_dump.h"
33
34 #include "tr_dump.h"
35 #include "tr_dump_defines.h"
36 #include "tr_dump_state.h"
37
38
trace_dump_resource_template(const struct pipe_resource * templat)39 void trace_dump_resource_template(const struct pipe_resource *templat)
40 {
41 if (!trace_dumping_enabled_locked())
42 return;
43
44 if (!templat) {
45 trace_dump_null();
46 return;
47 }
48
49 trace_dump_struct_begin("pipe_resource");
50
51 trace_dump_member(int, templat, target);
52 trace_dump_member(format, templat, format);
53
54 trace_dump_member_begin("width");
55 trace_dump_uint(templat->width0);
56 trace_dump_member_end();
57
58 trace_dump_member_begin("height");
59 trace_dump_uint(templat->height0);
60 trace_dump_member_end();
61
62 trace_dump_member_begin("depth");
63 trace_dump_uint(templat->depth0);
64 trace_dump_member_end();
65
66 trace_dump_member_begin("array_size");
67 trace_dump_uint(templat->array_size);
68 trace_dump_member_end();
69
70 trace_dump_member(uint, templat, last_level);
71 trace_dump_member(uint, templat, nr_samples);
72 trace_dump_member(uint, templat, usage);
73 trace_dump_member(uint, templat, bind);
74 trace_dump_member(uint, templat, flags);
75
76 trace_dump_struct_end();
77 }
78
79
trace_dump_box(const struct pipe_box * box)80 void trace_dump_box(const struct pipe_box *box)
81 {
82 if (!trace_dumping_enabled_locked())
83 return;
84
85 if (!box) {
86 trace_dump_null();
87 return;
88 }
89
90 trace_dump_struct_begin("pipe_box");
91
92 trace_dump_member(int, box, x);
93 trace_dump_member(int, box, y);
94 trace_dump_member(int, box, z);
95 trace_dump_member(int, box, width);
96 trace_dump_member(int, box, height);
97 trace_dump_member(int, box, depth);
98
99 trace_dump_struct_end();
100 }
101
102
trace_dump_rasterizer_state(const struct pipe_rasterizer_state * state)103 void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
104 {
105 if (!trace_dumping_enabled_locked())
106 return;
107
108 if (!state) {
109 trace_dump_null();
110 return;
111 }
112
113 trace_dump_struct_begin("pipe_rasterizer_state");
114
115 trace_dump_member(bool, state, flatshade);
116 trace_dump_member(bool, state, light_twoside);
117 trace_dump_member(bool, state, clamp_vertex_color);
118 trace_dump_member(bool, state, clamp_fragment_color);
119 trace_dump_member(uint, state, front_ccw);
120 trace_dump_member(uint, state, cull_face);
121 trace_dump_member(uint, state, fill_front);
122 trace_dump_member(uint, state, fill_back);
123 trace_dump_member(bool, state, offset_point);
124 trace_dump_member(bool, state, offset_line);
125 trace_dump_member(bool, state, offset_tri);
126 trace_dump_member(bool, state, scissor);
127 trace_dump_member(bool, state, poly_smooth);
128 trace_dump_member(bool, state, poly_stipple_enable);
129 trace_dump_member(bool, state, point_smooth);
130 trace_dump_member(bool, state, sprite_coord_mode);
131 trace_dump_member(bool, state, point_quad_rasterization);
132 trace_dump_member(bool, state, point_size_per_vertex);
133 trace_dump_member(bool, state, multisample);
134 trace_dump_member(bool, state, line_smooth);
135 trace_dump_member(bool, state, line_stipple_enable);
136 trace_dump_member(bool, state, line_last_pixel);
137
138 trace_dump_member(bool, state, flatshade_first);
139
140 trace_dump_member(bool, state, half_pixel_center);
141 trace_dump_member(bool, state, bottom_edge_rule);
142
143 trace_dump_member(bool, state, rasterizer_discard);
144
145 trace_dump_member(bool, state, depth_clip);
146
147 trace_dump_member(bool, state, clip_halfz);
148
149 trace_dump_member(uint, state, clip_plane_enable);
150
151 trace_dump_member(uint, state, line_stipple_factor);
152 trace_dump_member(uint, state, line_stipple_pattern);
153
154 trace_dump_member(uint, state, sprite_coord_enable);
155
156 trace_dump_member(float, state, line_width);
157 trace_dump_member(float, state, point_size);
158 trace_dump_member(float, state, offset_units);
159 trace_dump_member(float, state, offset_scale);
160 trace_dump_member(float, state, offset_clamp);
161
162 trace_dump_struct_end();
163 }
164
165
trace_dump_poly_stipple(const struct pipe_poly_stipple * state)166 void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
167 {
168 if (!trace_dumping_enabled_locked())
169 return;
170
171 if (!state) {
172 trace_dump_null();
173 return;
174 }
175
176 trace_dump_struct_begin("pipe_poly_stipple");
177
178 trace_dump_member_begin("stipple");
179 trace_dump_array(uint,
180 state->stipple,
181 ARRAY_SIZE(state->stipple));
182 trace_dump_member_end();
183
184 trace_dump_struct_end();
185 }
186
187
trace_dump_viewport_state(const struct pipe_viewport_state * state)188 void trace_dump_viewport_state(const struct pipe_viewport_state *state)
189 {
190 if (!trace_dumping_enabled_locked())
191 return;
192
193 if (!state) {
194 trace_dump_null();
195 return;
196 }
197
198 trace_dump_struct_begin("pipe_viewport_state");
199
200 trace_dump_member_array(float, state, scale);
201 trace_dump_member_array(float, state, translate);
202
203 trace_dump_struct_end();
204 }
205
206
trace_dump_scissor_state(const struct pipe_scissor_state * state)207 void trace_dump_scissor_state(const struct pipe_scissor_state *state)
208 {
209 if (!trace_dumping_enabled_locked())
210 return;
211
212 if (!state) {
213 trace_dump_null();
214 return;
215 }
216
217 trace_dump_struct_begin("pipe_scissor_state");
218
219 trace_dump_member(uint, state, minx);
220 trace_dump_member(uint, state, miny);
221 trace_dump_member(uint, state, maxx);
222 trace_dump_member(uint, state, maxy);
223
224 trace_dump_struct_end();
225 }
226
227
trace_dump_clip_state(const struct pipe_clip_state * state)228 void trace_dump_clip_state(const struct pipe_clip_state *state)
229 {
230 unsigned i;
231
232 if (!trace_dumping_enabled_locked())
233 return;
234
235 if (!state) {
236 trace_dump_null();
237 return;
238 }
239
240 trace_dump_struct_begin("pipe_clip_state");
241
242 trace_dump_member_begin("ucp");
243 trace_dump_array_begin();
244 for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) {
245 trace_dump_elem_begin();
246 trace_dump_array(float, state->ucp[i], 4);
247 trace_dump_elem_end();
248 }
249 trace_dump_array_end();
250 trace_dump_member_end();
251
252 trace_dump_struct_end();
253 }
254
255
trace_dump_shader_state(const struct pipe_shader_state * state)256 void trace_dump_shader_state(const struct pipe_shader_state *state)
257 {
258 unsigned i;
259
260 if (!trace_dumping_enabled_locked())
261 return;
262
263 if (!state) {
264 trace_dump_null();
265 return;
266 }
267
268
269 trace_dump_struct_begin("pipe_shader_state");
270
271 trace_dump_member_begin("tokens");
272 if (state->tokens) {
273 static char str[64 * 1024];
274 tgsi_dump_str(state->tokens, 0, str, sizeof(str));
275 trace_dump_string(str);
276 } else {
277 trace_dump_null();
278 }
279 trace_dump_member_end();
280
281 trace_dump_member_begin("stream_output");
282 trace_dump_struct_begin("pipe_stream_output_info");
283 trace_dump_member(uint, &state->stream_output, num_outputs);
284 trace_dump_member_array(uint, &state->stream_output, stride);
285 trace_dump_member_begin("output");
286 trace_dump_array_begin();
287 for(i = 0; i < state->stream_output.num_outputs; ++i) {
288 trace_dump_elem_begin();
289 trace_dump_struct_begin(""); /* anonymous */
290 trace_dump_member(uint, &state->stream_output.output[i], register_index);
291 trace_dump_member(uint, &state->stream_output.output[i], start_component);
292 trace_dump_member(uint, &state->stream_output.output[i], num_components);
293 trace_dump_member(uint, &state->stream_output.output[i], output_buffer);
294 trace_dump_member(uint, &state->stream_output.output[i], dst_offset);
295 trace_dump_member(uint, &state->stream_output.output[i], stream);
296 trace_dump_struct_end();
297 trace_dump_elem_end();
298 }
299 trace_dump_array_end();
300 trace_dump_member_end(); // output
301 trace_dump_struct_end();
302 trace_dump_member_end(); // stream_output
303
304 trace_dump_struct_end();
305 }
306
307
trace_dump_compute_state(const struct pipe_compute_state * state)308 void trace_dump_compute_state(const struct pipe_compute_state *state)
309 {
310 if (!trace_dumping_enabled_locked())
311 return;
312
313 if (!state) {
314 trace_dump_null();
315 return;
316 }
317
318 trace_dump_struct_begin("pipe_compute_state");
319
320 trace_dump_member(uint, state, ir_type);
321
322 trace_dump_member_begin("prog");
323 if (state->prog && state->ir_type == PIPE_SHADER_IR_TGSI) {
324 static char str[64 * 1024];
325 tgsi_dump_str(state->prog, 0, str, sizeof(str));
326 trace_dump_string(str);
327 } else {
328 trace_dump_null();
329 }
330 trace_dump_member_end();
331
332 trace_dump_member(uint, state, req_local_mem);
333 trace_dump_member(uint, state, req_private_mem);
334 trace_dump_member(uint, state, req_input_mem);
335
336 trace_dump_struct_end();
337 }
338
339
trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state * state)340 void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
341 {
342 unsigned i;
343
344 if (!trace_dumping_enabled_locked())
345 return;
346
347 if (!state) {
348 trace_dump_null();
349 return;
350 }
351
352 trace_dump_struct_begin("pipe_depth_stencil_alpha_state");
353
354 trace_dump_member_begin("depth");
355 trace_dump_struct_begin("pipe_depth_state");
356 trace_dump_member(bool, &state->depth, enabled);
357 trace_dump_member(bool, &state->depth, writemask);
358 trace_dump_member(uint, &state->depth, func);
359 trace_dump_struct_end();
360 trace_dump_member_end();
361
362 trace_dump_member_begin("stencil");
363 trace_dump_array_begin();
364 for(i = 0; i < ARRAY_SIZE(state->stencil); ++i) {
365 trace_dump_elem_begin();
366 trace_dump_struct_begin("pipe_stencil_state");
367 trace_dump_member(bool, &state->stencil[i], enabled);
368 trace_dump_member(uint, &state->stencil[i], func);
369 trace_dump_member(uint, &state->stencil[i], fail_op);
370 trace_dump_member(uint, &state->stencil[i], zpass_op);
371 trace_dump_member(uint, &state->stencil[i], zfail_op);
372 trace_dump_member(uint, &state->stencil[i], valuemask);
373 trace_dump_member(uint, &state->stencil[i], writemask);
374 trace_dump_struct_end();
375 trace_dump_elem_end();
376 }
377 trace_dump_array_end();
378 trace_dump_member_end();
379
380 trace_dump_member_begin("alpha");
381 trace_dump_struct_begin("pipe_alpha_state");
382 trace_dump_member(bool, &state->alpha, enabled);
383 trace_dump_member(uint, &state->alpha, func);
384 trace_dump_member(float, &state->alpha, ref_value);
385 trace_dump_struct_end();
386 trace_dump_member_end();
387
388 trace_dump_struct_end();
389 }
390
trace_dump_rt_blend_state(const struct pipe_rt_blend_state * state)391 static void trace_dump_rt_blend_state(const struct pipe_rt_blend_state *state)
392 {
393 trace_dump_struct_begin("pipe_rt_blend_state");
394
395 trace_dump_member(uint, state, blend_enable);
396
397 trace_dump_member(uint, state, rgb_func);
398 trace_dump_member(uint, state, rgb_src_factor);
399 trace_dump_member(uint, state, rgb_dst_factor);
400
401 trace_dump_member(uint, state, alpha_func);
402 trace_dump_member(uint, state, alpha_src_factor);
403 trace_dump_member(uint, state, alpha_dst_factor);
404
405 trace_dump_member(uint, state, colormask);
406
407 trace_dump_struct_end();
408 }
409
trace_dump_blend_state(const struct pipe_blend_state * state)410 void trace_dump_blend_state(const struct pipe_blend_state *state)
411 {
412 unsigned valid_entries = 1;
413
414 if (!trace_dumping_enabled_locked())
415 return;
416
417 if (!state) {
418 trace_dump_null();
419 return;
420 }
421
422 trace_dump_struct_begin("pipe_blend_state");
423
424 trace_dump_member(bool, state, dither);
425
426 trace_dump_member(bool, state, logicop_enable);
427 trace_dump_member(uint, state, logicop_func);
428
429 trace_dump_member(bool, state, independent_blend_enable);
430
431 trace_dump_member_begin("rt");
432 if (state->independent_blend_enable)
433 valid_entries = PIPE_MAX_COLOR_BUFS;
434 trace_dump_struct_array(rt_blend_state, state->rt, valid_entries);
435 trace_dump_member_end();
436
437 trace_dump_struct_end();
438 }
439
440
trace_dump_blend_color(const struct pipe_blend_color * state)441 void trace_dump_blend_color(const struct pipe_blend_color *state)
442 {
443 if (!trace_dumping_enabled_locked())
444 return;
445
446 if (!state) {
447 trace_dump_null();
448 return;
449 }
450
451 trace_dump_struct_begin("pipe_blend_color");
452
453 trace_dump_member_array(float, state, color);
454
455 trace_dump_struct_end();
456 }
457
trace_dump_stencil_ref(const struct pipe_stencil_ref * state)458 void trace_dump_stencil_ref(const struct pipe_stencil_ref *state)
459 {
460 if (!trace_dumping_enabled_locked())
461 return;
462
463 if (!state) {
464 trace_dump_null();
465 return;
466 }
467
468 trace_dump_struct_begin("pipe_stencil_ref");
469
470 trace_dump_member_array(uint, state, ref_value);
471
472 trace_dump_struct_end();
473 }
474
trace_dump_framebuffer_state(const struct pipe_framebuffer_state * state)475 void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
476 {
477 if (!trace_dumping_enabled_locked())
478 return;
479
480 trace_dump_struct_begin("pipe_framebuffer_state");
481
482 trace_dump_member(uint, state, width);
483 trace_dump_member(uint, state, height);
484 trace_dump_member(uint, state, samples);
485 trace_dump_member(uint, state, layers);
486 trace_dump_member(uint, state, nr_cbufs);
487 trace_dump_member_array(ptr, state, cbufs);
488 trace_dump_member(ptr, state, zsbuf);
489
490 trace_dump_struct_end();
491 }
492
493
trace_dump_sampler_state(const struct pipe_sampler_state * state)494 void trace_dump_sampler_state(const struct pipe_sampler_state *state)
495 {
496 if (!trace_dumping_enabled_locked())
497 return;
498
499 if (!state) {
500 trace_dump_null();
501 return;
502 }
503
504 trace_dump_struct_begin("pipe_sampler_state");
505
506 trace_dump_member(uint, state, wrap_s);
507 trace_dump_member(uint, state, wrap_t);
508 trace_dump_member(uint, state, wrap_r);
509 trace_dump_member(uint, state, min_img_filter);
510 trace_dump_member(uint, state, min_mip_filter);
511 trace_dump_member(uint, state, mag_img_filter);
512 trace_dump_member(uint, state, compare_mode);
513 trace_dump_member(uint, state, compare_func);
514 trace_dump_member(bool, state, normalized_coords);
515 trace_dump_member(uint, state, max_anisotropy);
516 trace_dump_member(bool, state, seamless_cube_map);
517 trace_dump_member(float, state, lod_bias);
518 trace_dump_member(float, state, min_lod);
519 trace_dump_member(float, state, max_lod);
520 trace_dump_member_array(float, state, border_color.f);
521
522 trace_dump_struct_end();
523 }
524
525
trace_dump_sampler_view_template(const struct pipe_sampler_view * state,enum pipe_texture_target target)526 void trace_dump_sampler_view_template(const struct pipe_sampler_view *state,
527 enum pipe_texture_target target)
528 {
529 if (!trace_dumping_enabled_locked())
530 return;
531
532 if (!state) {
533 trace_dump_null();
534 return;
535 }
536
537 trace_dump_struct_begin("pipe_sampler_view");
538
539 trace_dump_member(format, state, format);
540
541 trace_dump_member_begin("u");
542 trace_dump_struct_begin(""); /* anonymous */
543 if (target == PIPE_BUFFER) {
544 trace_dump_member_begin("buf");
545 trace_dump_struct_begin(""); /* anonymous */
546 trace_dump_member(uint, &state->u.buf, offset);
547 trace_dump_member(uint, &state->u.buf, size);
548 trace_dump_struct_end(); /* anonymous */
549 trace_dump_member_end(); /* buf */
550 } else {
551 trace_dump_member_begin("tex");
552 trace_dump_struct_begin(""); /* anonymous */
553 trace_dump_member(uint, &state->u.tex, first_layer);
554 trace_dump_member(uint, &state->u.tex, last_layer);
555 trace_dump_member(uint, &state->u.tex, first_level);
556 trace_dump_member(uint, &state->u.tex, last_level);
557 trace_dump_struct_end(); /* anonymous */
558 trace_dump_member_end(); /* tex */
559 }
560 trace_dump_struct_end(); /* anonymous */
561 trace_dump_member_end(); /* u */
562
563 trace_dump_member(uint, state, swizzle_r);
564 trace_dump_member(uint, state, swizzle_g);
565 trace_dump_member(uint, state, swizzle_b);
566 trace_dump_member(uint, state, swizzle_a);
567
568 trace_dump_struct_end();
569 }
570
571
trace_dump_surface_template(const struct pipe_surface * state,enum pipe_texture_target target)572 void trace_dump_surface_template(const struct pipe_surface *state,
573 enum pipe_texture_target target)
574 {
575 if (!trace_dumping_enabled_locked())
576 return;
577
578 if (!state) {
579 trace_dump_null();
580 return;
581 }
582
583 trace_dump_struct_begin("pipe_surface");
584
585 trace_dump_member(format, state, format);
586 trace_dump_member(uint, state, width);
587 trace_dump_member(uint, state, height);
588
589 trace_dump_member_begin("u");
590 trace_dump_struct_begin(""); /* anonymous */
591 if (target == PIPE_BUFFER) {
592 trace_dump_member_begin("buf");
593 trace_dump_struct_begin(""); /* anonymous */
594 trace_dump_member(uint, &state->u.buf, first_element);
595 trace_dump_member(uint, &state->u.buf, last_element);
596 trace_dump_struct_end(); /* anonymous */
597 trace_dump_member_end(); /* buf */
598 } else {
599 trace_dump_member_begin("tex");
600 trace_dump_struct_begin(""); /* anonymous */
601 trace_dump_member(uint, &state->u.tex, level);
602 trace_dump_member(uint, &state->u.tex, first_layer);
603 trace_dump_member(uint, &state->u.tex, last_layer);
604 trace_dump_struct_end(); /* anonymous */
605 trace_dump_member_end(); /* tex */
606 }
607 trace_dump_struct_end(); /* anonymous */
608 trace_dump_member_end(); /* u */
609
610 trace_dump_struct_end();
611 }
612
613
trace_dump_transfer(const struct pipe_transfer * state)614 void trace_dump_transfer(const struct pipe_transfer *state)
615 {
616 if (!trace_dumping_enabled_locked())
617 return;
618
619 if (!state) {
620 trace_dump_null();
621 return;
622 }
623
624 trace_dump_struct_begin("pipe_transfer");
625
626 trace_dump_member(uint, state, box.x);
627 trace_dump_member(uint, state, box.y);
628 trace_dump_member(uint, state, box.z);
629 trace_dump_member(uint, state, box.width);
630 trace_dump_member(uint, state, box.height);
631 trace_dump_member(uint, state, box.depth);
632
633 trace_dump_member(uint, state, stride);
634 trace_dump_member(uint, state, layer_stride);
635 trace_dump_member(uint, state, usage);
636
637 trace_dump_member(ptr, state, resource);
638
639 trace_dump_struct_end();
640 }
641
642
trace_dump_vertex_buffer(const struct pipe_vertex_buffer * state)643 void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
644 {
645 if (!trace_dumping_enabled_locked())
646 return;
647
648 if (!state) {
649 trace_dump_null();
650 return;
651 }
652
653 trace_dump_struct_begin("pipe_vertex_buffer");
654
655 trace_dump_member(uint, state, stride);
656 trace_dump_member(uint, state, buffer_offset);
657 trace_dump_member(resource_ptr, state, buffer);
658 trace_dump_member(ptr, state, user_buffer);
659
660 trace_dump_struct_end();
661 }
662
663
trace_dump_index_buffer(const struct pipe_index_buffer * state)664 void trace_dump_index_buffer(const struct pipe_index_buffer *state)
665 {
666 if (!trace_dumping_enabled_locked())
667 return;
668
669 if (!state) {
670 trace_dump_null();
671 return;
672 }
673
674 trace_dump_struct_begin("pipe_index_buffer");
675
676 trace_dump_member(uint, state, index_size);
677 trace_dump_member(uint, state, offset);
678 trace_dump_member(resource_ptr, state, buffer);
679 trace_dump_member(ptr, state, user_buffer);
680
681 trace_dump_struct_end();
682 }
683
684
trace_dump_vertex_element(const struct pipe_vertex_element * state)685 void trace_dump_vertex_element(const struct pipe_vertex_element *state)
686 {
687 if (!trace_dumping_enabled_locked())
688 return;
689
690 if (!state) {
691 trace_dump_null();
692 return;
693 }
694
695 trace_dump_struct_begin("pipe_vertex_element");
696
697 trace_dump_member(uint, state, src_offset);
698
699 trace_dump_member(uint, state, vertex_buffer_index);
700
701 trace_dump_member(format, state, src_format);
702
703 trace_dump_struct_end();
704 }
705
706
trace_dump_constant_buffer(const struct pipe_constant_buffer * state)707 void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
708 {
709 if (!trace_dumping_enabled_locked())
710 return;
711
712 if (!state) {
713 trace_dump_null();
714 return;
715 }
716
717 trace_dump_struct_begin("pipe_constant_buffer");
718 trace_dump_member(ptr, state, buffer);
719 trace_dump_member(uint, state, buffer_offset);
720 trace_dump_member(uint, state, buffer_size);
721 trace_dump_struct_end();
722 }
723
724
trace_dump_shader_buffer(const struct pipe_shader_buffer * state)725 void trace_dump_shader_buffer(const struct pipe_shader_buffer *state)
726 {
727 if (!trace_dumping_enabled_locked())
728 return;
729
730 if(!state) {
731 trace_dump_null();
732 return;
733 }
734
735 trace_dump_struct_begin("pipe_shader_buffer");
736 trace_dump_member(resource_ptr, state, buffer);
737 trace_dump_member(uint, state, buffer_offset);
738 trace_dump_member(uint, state, buffer_size);
739 trace_dump_struct_end();
740 }
741
742
trace_dump_image_view(const struct pipe_image_view * state)743 void trace_dump_image_view(const struct pipe_image_view *state)
744 {
745 if (!trace_dumping_enabled_locked())
746 return;
747
748 if(!state) {
749 trace_dump_null();
750 return;
751 }
752
753 trace_dump_struct_begin("pipe_image_view");
754 trace_dump_member(resource_ptr, state, resource);
755 trace_dump_member(uint, state, format);
756 trace_dump_member(uint, state, access);
757
758 trace_dump_member_begin("u");
759 trace_dump_struct_begin(""); /* anonymous */
760 if (state->resource->target == PIPE_BUFFER) {
761 trace_dump_member_begin("buf");
762 trace_dump_struct_begin(""); /* anonymous */
763 trace_dump_member(uint, &state->u.buf, offset);
764 trace_dump_member(uint, &state->u.buf, size);
765 trace_dump_struct_end(); /* anonymous */
766 trace_dump_member_end(); /* buf */
767 } else {
768 trace_dump_member_begin("tex");
769 trace_dump_struct_begin(""); /* anonymous */
770 trace_dump_member(uint, &state->u.tex, first_layer);
771 trace_dump_member(uint, &state->u.tex, last_layer);
772 trace_dump_member(uint, &state->u.tex, level);
773 trace_dump_struct_end(); /* anonymous */
774 trace_dump_member_end(); /* tex */
775 }
776 trace_dump_struct_end(); /* anonymous */
777 trace_dump_member_end(); /* u */
778
779 trace_dump_struct_end();
780 }
781
782
trace_dump_draw_info(const struct pipe_draw_info * state)783 void trace_dump_draw_info(const struct pipe_draw_info *state)
784 {
785 if (!trace_dumping_enabled_locked())
786 return;
787
788 if (!state) {
789 trace_dump_null();
790 return;
791 }
792
793 trace_dump_struct_begin("pipe_draw_info");
794
795 trace_dump_member(bool, state, indexed);
796
797 trace_dump_member(uint, state, mode);
798 trace_dump_member(uint, state, start);
799 trace_dump_member(uint, state, count);
800
801 trace_dump_member(uint, state, start_instance);
802 trace_dump_member(uint, state, instance_count);
803
804 trace_dump_member(uint, state, vertices_per_patch);
805
806 trace_dump_member(int, state, index_bias);
807 trace_dump_member(uint, state, min_index);
808 trace_dump_member(uint, state, max_index);
809
810 trace_dump_member(bool, state, primitive_restart);
811 trace_dump_member(uint, state, restart_index);
812
813 trace_dump_member(ptr, state, count_from_stream_output);
814
815 trace_dump_member(ptr, state, indirect);
816 trace_dump_member(uint, state, indirect_offset);
817
818 trace_dump_struct_end();
819 }
820
trace_dump_blit_info(const struct pipe_blit_info * info)821 void trace_dump_blit_info(const struct pipe_blit_info *info)
822 {
823 char mask[7];
824
825 if (!trace_dumping_enabled_locked())
826 return;
827
828 if (!info) {
829 trace_dump_null();
830 return;
831 }
832
833 trace_dump_struct_begin("pipe_blit_info");
834
835 trace_dump_member_begin("dst");
836 trace_dump_struct_begin("dst");
837 trace_dump_member(resource_ptr, &info->dst, resource);
838 trace_dump_member(uint, &info->dst, level);
839 trace_dump_member(format, &info->dst, format);
840 trace_dump_member_begin("box");
841 trace_dump_box(&info->dst.box);
842 trace_dump_member_end();
843 trace_dump_struct_end();
844 trace_dump_member_end();
845
846 trace_dump_member_begin("src");
847 trace_dump_struct_begin("src");
848 trace_dump_member(resource_ptr, &info->src, resource);
849 trace_dump_member(uint, &info->src, level);
850 trace_dump_member(format, &info->src, format);
851 trace_dump_member_begin("box");
852 trace_dump_box(&info->src.box);
853 trace_dump_member_end();
854 trace_dump_struct_end();
855 trace_dump_member_end();
856
857 mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
858 mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
859 mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
860 mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
861 mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
862 mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
863 mask[6] = 0;
864
865 trace_dump_member_begin("mask");
866 trace_dump_string(mask);
867 trace_dump_member_end();
868 trace_dump_member(uint, info, filter);
869
870 trace_dump_member(bool, info, scissor_enable);
871 trace_dump_member_begin("scissor");
872 trace_dump_scissor_state(&info->scissor);
873 trace_dump_member_end();
874
875 trace_dump_struct_end();
876 }
877
878 void
trace_dump_query_result(unsigned query_type,const union pipe_query_result * result)879 trace_dump_query_result(unsigned query_type,
880 const union pipe_query_result *result)
881 {
882 if (!trace_dumping_enabled_locked())
883 return;
884
885 if (!result) {
886 trace_dump_null();
887 return;
888 }
889
890 switch (query_type) {
891 case PIPE_QUERY_OCCLUSION_PREDICATE:
892 case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
893 case PIPE_QUERY_GPU_FINISHED:
894 trace_dump_bool(result->b);
895 break;
896
897 case PIPE_QUERY_OCCLUSION_COUNTER:
898 case PIPE_QUERY_TIMESTAMP:
899 case PIPE_QUERY_TIME_ELAPSED:
900 case PIPE_QUERY_PRIMITIVES_GENERATED:
901 case PIPE_QUERY_PRIMITIVES_EMITTED:
902 trace_dump_uint(result->u64);
903 break;
904
905 case PIPE_QUERY_SO_STATISTICS:
906 trace_dump_struct_begin("pipe_query_data_so_statistics");
907 trace_dump_member(uint, &result->so_statistics, num_primitives_written);
908 trace_dump_member(uint, &result->so_statistics, primitives_storage_needed);
909 trace_dump_struct_end();
910 break;
911
912 case PIPE_QUERY_TIMESTAMP_DISJOINT:
913 trace_dump_struct_begin("pipe_query_data_timestamp_disjoint");
914 trace_dump_member(uint, &result->timestamp_disjoint, frequency);
915 trace_dump_member(bool, &result->timestamp_disjoint, disjoint);
916 trace_dump_struct_end();
917 break;
918
919 case PIPE_QUERY_PIPELINE_STATISTICS:
920 trace_dump_struct_begin("pipe_query_data_pipeline_statistics");
921 trace_dump_member(uint, &result->pipeline_statistics, ia_vertices);
922 trace_dump_member(uint, &result->pipeline_statistics, ia_primitives);
923 trace_dump_member(uint, &result->pipeline_statistics, vs_invocations);
924 trace_dump_member(uint, &result->pipeline_statistics, gs_invocations);
925 trace_dump_member(uint, &result->pipeline_statistics, gs_primitives);
926 trace_dump_member(uint, &result->pipeline_statistics, c_invocations);
927 trace_dump_member(uint, &result->pipeline_statistics, c_primitives);
928 trace_dump_member(uint, &result->pipeline_statistics, ps_invocations);
929 trace_dump_member(uint, &result->pipeline_statistics, hs_invocations);
930 trace_dump_member(uint, &result->pipeline_statistics, ds_invocations);
931 trace_dump_member(uint, &result->pipeline_statistics, cs_invocations);
932 trace_dump_struct_end();
933 break;
934
935 default:
936 assert(query_type >= PIPE_QUERY_DRIVER_SPECIFIC);
937 trace_dump_uint(result->u64);
938 break;
939 }
940 }
941
trace_dump_grid_info(const struct pipe_grid_info * state)942 void trace_dump_grid_info(const struct pipe_grid_info *state)
943 {
944 if (!trace_dumping_enabled_locked())
945 return;
946
947 if (!state) {
948 trace_dump_null();
949 return;
950 }
951
952 trace_dump_struct_begin("pipe_grid_info");
953
954 trace_dump_member(uint, state, pc);
955 trace_dump_member(ptr, state, input);
956
957 trace_dump_member_begin("block");
958 trace_dump_array(uint, state->block, ARRAY_SIZE(state->block));
959 trace_dump_member_end();
960
961 trace_dump_member_begin("grid");
962 trace_dump_array(uint, state->grid, ARRAY_SIZE(state->grid));
963 trace_dump_member_end();
964
965 trace_dump_member(ptr, state, indirect);
966 trace_dump_member(uint, state, indirect_offset);
967
968 trace_dump_struct_end();
969 }
970
971