← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/driver_trace/tr_dump_state.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

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