1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Chia-I Wu <olv@lunarg.com>
26 */
27
28 #include <stdio.h>
29 #include <stdarg.h>
30 #include "genhw/genhw.h"
31 #include "../shader/toy_compiler.h"
32
33 #include "intel_winsys.h"
34 #include "ilo_builder.h"
35
36 static const uint32_t *
writer_pointer(const struct ilo_builder * builder,enum ilo_builder_writer_type which,unsigned offset)37 writer_pointer(const struct ilo_builder *builder,
38 enum ilo_builder_writer_type which,
39 unsigned offset)
40 {
41 const struct ilo_builder_writer *writer = &builder->writers[which];
42 return (const uint32_t *) ((const char *) writer->ptr + offset);
43 }
44
45 static uint32_t _util_printf_format(5, 6)
writer_dw(const struct ilo_builder * builder,enum ilo_builder_writer_type which,unsigned offset,unsigned dw_index,const char * format,...)46 writer_dw(const struct ilo_builder *builder,
47 enum ilo_builder_writer_type which,
48 unsigned offset, unsigned dw_index,
49 const char *format, ...)
50 {
51 const uint32_t *dw = writer_pointer(builder, which, offset);
52 va_list ap;
53 char desc[16];
54 int len;
55
56 ilo_printf("0x%08x: 0x%08x: ",
57 offset + (dw_index << 2), dw[dw_index]);
58
59 va_start(ap, format);
60 len = vsnprintf(desc, sizeof(desc), format, ap);
61 va_end(ap);
62
63 if (len >= sizeof(desc)) {
64 len = sizeof(desc) - 1;
65 desc[len] = '\0';
66 }
67
68 if (desc[len - 1] == '\n') {
69 desc[len - 1] = '\0';
70 ilo_printf("%8s: \n", desc);
71 } else {
72 ilo_printf("%8s: ", desc);
73 }
74
75 return dw[dw_index];
76 }
77
78 static void
writer_decode_blob(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)79 writer_decode_blob(const struct ilo_builder *builder,
80 enum ilo_builder_writer_type which,
81 const struct ilo_builder_item *item)
82 {
83 const unsigned state_size = sizeof(uint32_t);
84 const unsigned count = item->size / state_size;
85 unsigned offset = item->offset;
86 unsigned i;
87
88 for (i = 0; i < count; i += 4) {
89 const uint32_t *dw = writer_pointer(builder, which, offset);
90
91 writer_dw(builder, which, offset, 0, "BLOB%d", i / 4);
92
93 switch (count - i) {
94 case 1:
95 ilo_printf("(%10.4f, %10c, %10c, %10c) "
96 "(0x%08x, %10c, %10c, %10c)\n",
97 uif(dw[0]), 'X', 'X', 'X',
98 dw[0], 'X', 'X', 'X');
99 break;
100 case 2:
101 ilo_printf("(%10.4f, %10.4f, %10c, %10c) "
102 "(0x%08x, 0x%08x, %10c, %10c)\n",
103 uif(dw[0]), uif(dw[1]), 'X', 'X',
104 dw[0], dw[1], 'X', 'X');
105 break;
106 case 3:
107 ilo_printf("(%10.4f, %10.4f, %10.4f, %10c) "
108 "(0x%08x, 0x%08x, 0x%08x, %10c)\n",
109 uif(dw[0]), uif(dw[1]), uif(dw[2]), 'X',
110 dw[0], dw[1], dw[2], 'X');
111 break;
112 default:
113 ilo_printf("(%10.4f, %10.4f, %10.4f, %10.4f) "
114 "(0x%08x, 0x%08x, 0x%08x, 0x%08x)\n",
115 uif(dw[0]), uif(dw[1]), uif(dw[2]), uif(dw[3]),
116 dw[0], dw[1], dw[2], dw[3]);
117 break;
118 }
119
120 offset += state_size * 4;
121 }
122 }
123
124 static void
writer_decode_clip_viewport(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)125 writer_decode_clip_viewport(const struct ilo_builder *builder,
126 enum ilo_builder_writer_type which,
127 const struct ilo_builder_item *item)
128 {
129 const unsigned state_size = sizeof(uint32_t) * 4;
130 const unsigned count = item->size / state_size;
131 unsigned offset = item->offset;
132 unsigned i;
133
134 for (i = 0; i < count; i++) {
135 uint32_t dw;
136
137 dw = writer_dw(builder, which, offset, 0, "CLIP VP%d", i);
138 ilo_printf("xmin = %f\n", uif(dw));
139
140 dw = writer_dw(builder, which, offset, 1, "CLIP VP%d", i);
141 ilo_printf("xmax = %f\n", uif(dw));
142
143 dw = writer_dw(builder, which, offset, 2, "CLIP VP%d", i);
144 ilo_printf("ymin = %f\n", uif(dw));
145
146 dw = writer_dw(builder, which, offset, 3, "CLIP VP%d", i);
147 ilo_printf("ymax = %f\n", uif(dw));
148
149 offset += state_size;
150 }
151 }
152
153 static void
writer_decode_sf_clip_viewport_gen7(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)154 writer_decode_sf_clip_viewport_gen7(const struct ilo_builder *builder,
155 enum ilo_builder_writer_type which,
156 const struct ilo_builder_item *item)
157 {
158 const unsigned state_size = sizeof(uint32_t) * 16;
159 const unsigned count = item->size / state_size;
160 unsigned offset = item->offset;
161 unsigned i;
162
163 for (i = 0; i < count; i++) {
164 uint32_t dw;
165
166 dw = writer_dw(builder, which, offset, 0, "SF_CLIP VP%d", i);
167 ilo_printf("m00 = %f\n", uif(dw));
168
169 dw = writer_dw(builder, which, offset, 1, "SF_CLIP VP%d", i);
170 ilo_printf("m11 = %f\n", uif(dw));
171
172 dw = writer_dw(builder, which, offset, 2, "SF_CLIP VP%d", i);
173 ilo_printf("m22 = %f\n", uif(dw));
174
175 dw = writer_dw(builder, which, offset, 3, "SF_CLIP VP%d", i);
176 ilo_printf("m30 = %f\n", uif(dw));
177
178 dw = writer_dw(builder, which, offset, 4, "SF_CLIP VP%d", i);
179 ilo_printf("m31 = %f\n", uif(dw));
180
181 dw = writer_dw(builder, which, offset, 5, "SF_CLIP VP%d", i);
182 ilo_printf("m32 = %f\n", uif(dw));
183
184 dw = writer_dw(builder, which, offset, 8, "SF_CLIP VP%d", i);
185 ilo_printf("guardband xmin = %f\n", uif(dw));
186
187 dw = writer_dw(builder, which, offset, 9, "SF_CLIP VP%d", i);
188 ilo_printf("guardband xmax = %f\n", uif(dw));
189
190 dw = writer_dw(builder, which, offset, 10, "SF_CLIP VP%d", i);
191 ilo_printf("guardband ymin = %f\n", uif(dw));
192
193 dw = writer_dw(builder, which, offset, 11, "SF_CLIP VP%d", i);
194 ilo_printf("guardband ymax = %f\n", uif(dw));
195
196 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
197 dw = writer_dw(builder, which, offset, 12, "SF_CLIP VP%d", i);
198 ilo_printf("extent xmin = %f\n", uif(dw));
199
200 dw = writer_dw(builder, which, offset, 13, "SF_CLIP VP%d", i);
201 ilo_printf("extent xmax = %f\n", uif(dw));
202
203 dw = writer_dw(builder, which, offset, 14, "SF_CLIP VP%d", i);
204 ilo_printf("extent ymin = %f\n", uif(dw));
205
206 dw = writer_dw(builder, which, offset, 15, "SF_CLIP VP%d", i);
207 ilo_printf("extent ymax = %f\n", uif(dw));
208 }
209
210 offset += state_size;
211 }
212 }
213
214 static void
writer_decode_sf_viewport_gen6(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)215 writer_decode_sf_viewport_gen6(const struct ilo_builder *builder,
216 enum ilo_builder_writer_type which,
217 const struct ilo_builder_item *item)
218 {
219 const unsigned state_size = sizeof(uint32_t) * 8;
220 const unsigned count = item->size / state_size;
221 unsigned offset = item->offset;
222 unsigned i;
223
224 for (i = 0; i < count; i++) {
225 uint32_t dw;
226
227 dw = writer_dw(builder, which, offset, 0, "SF VP%d", i);
228 ilo_printf("m00 = %f\n", uif(dw));
229
230 dw = writer_dw(builder, which, offset, 1, "SF VP%d", i);
231 ilo_printf("m11 = %f\n", uif(dw));
232
233 dw = writer_dw(builder, which, offset, 2, "SF VP%d", i);
234 ilo_printf("m22 = %f\n", uif(dw));
235
236 dw = writer_dw(builder, which, offset, 3, "SF VP%d", i);
237 ilo_printf("m30 = %f\n", uif(dw));
238
239 dw = writer_dw(builder, which, offset, 4, "SF VP%d", i);
240 ilo_printf("m31 = %f\n", uif(dw));
241
242 dw = writer_dw(builder, which, offset, 5, "SF VP%d", i);
243 ilo_printf("m32 = %f\n", uif(dw));
244
245 offset += state_size;
246 }
247 }
248
249 static void
writer_decode_sf_viewport(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)250 writer_decode_sf_viewport(const struct ilo_builder *builder,
251 enum ilo_builder_writer_type which,
252 const struct ilo_builder_item *item)
253 {
254 if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
255 writer_decode_sf_clip_viewport_gen7(builder, which, item);
256 else
257 writer_decode_sf_viewport_gen6(builder, which, item);
258 }
259
260 static void
writer_decode_scissor_rect(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)261 writer_decode_scissor_rect(const struct ilo_builder *builder,
262 enum ilo_builder_writer_type which,
263 const struct ilo_builder_item *item)
264 {
265 const unsigned state_size = sizeof(uint32_t) * 2;
266 const unsigned count = item->size / state_size;
267 unsigned offset = item->offset;
268 unsigned i;
269
270 for (i = 0; i < count; i++) {
271 uint32_t dw;
272
273 dw = writer_dw(builder, which, offset, 0, "SCISSOR%d", i);
274 ilo_printf("xmin %d, ymin %d\n",
275 GEN_EXTRACT(dw, GEN6_SCISSOR_DW0_MIN_X),
276 GEN_EXTRACT(dw, GEN6_SCISSOR_DW0_MIN_Y));
277
278 dw = writer_dw(builder, which, offset, 1, "SCISSOR%d", i);
279 ilo_printf("xmax %d, ymax %d\n",
280 GEN_EXTRACT(dw, GEN6_SCISSOR_DW1_MAX_X),
281 GEN_EXTRACT(dw, GEN6_SCISSOR_DW1_MAX_Y));
282
283 offset += state_size;
284 }
285 }
286
287 static void
writer_decode_cc_viewport(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)288 writer_decode_cc_viewport(const struct ilo_builder *builder,
289 enum ilo_builder_writer_type which,
290 const struct ilo_builder_item *item)
291 {
292 const unsigned state_size = sizeof(uint32_t) * 2;
293 const unsigned count = item->size / state_size;
294 unsigned offset = item->offset;
295 unsigned i;
296
297 for (i = 0; i < count; i++) {
298 uint32_t dw;
299
300 dw = writer_dw(builder, which, offset, 0, "CC VP%d", i);
301 ilo_printf("min_depth = %f\n", uif(dw));
302
303 dw = writer_dw(builder, which, offset, 1, "CC VP%d", i);
304 ilo_printf("max_depth = %f\n", uif(dw));
305
306 offset += state_size;
307 }
308 }
309
310 static void
writer_decode_color_calc(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)311 writer_decode_color_calc(const struct ilo_builder *builder,
312 enum ilo_builder_writer_type which,
313 const struct ilo_builder_item *item)
314 {
315 uint32_t dw;
316
317 dw = writer_dw(builder, which, item->offset, 0, "CC");
318 ilo_printf("alpha test format %s, round disable %d, "
319 "stencil ref %d, bf stencil ref %d\n",
320 GEN_EXTRACT(dw, GEN6_CC_DW0_ALPHATEST) ? "FLOAT32" : "UNORM8",
321 (bool) (dw & GEN6_CC_DW0_ROUND_DISABLE_DISABLE),
322 GEN_EXTRACT(dw, GEN6_CC_DW0_STENCIL_REF),
323 GEN_EXTRACT(dw, GEN6_CC_DW0_STENCIL1_REF));
324
325 writer_dw(builder, which, item->offset, 1, "CC\n");
326
327 dw = writer_dw(builder, which, item->offset, 2, "CC");
328 ilo_printf("constant red %f\n", uif(dw));
329
330 dw = writer_dw(builder, which, item->offset, 3, "CC");
331 ilo_printf("constant green %f\n", uif(dw));
332
333 dw = writer_dw(builder, which, item->offset, 4, "CC");
334 ilo_printf("constant blue %f\n", uif(dw));
335
336 dw = writer_dw(builder, which, item->offset, 5, "CC");
337 ilo_printf("constant alpha %f\n", uif(dw));
338 }
339
340 static void
writer_decode_depth_stencil(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)341 writer_decode_depth_stencil(const struct ilo_builder *builder,
342 enum ilo_builder_writer_type which,
343 const struct ilo_builder_item *item)
344 {
345 uint32_t dw;
346
347 dw = writer_dw(builder, which, item->offset, 0, "D_S");
348 ilo_printf("stencil %sable, func %d, write %sable\n",
349 (dw & GEN6_ZS_DW0_STENCIL_TEST_ENABLE) ? "en" : "dis",
350 GEN_EXTRACT(dw, GEN6_ZS_DW0_STENCIL_FUNC),
351 (dw & GEN6_ZS_DW0_STENCIL_WRITE_ENABLE) ? "en" : "dis");
352
353 dw = writer_dw(builder, which, item->offset, 1, "D_S");
354 ilo_printf("stencil test mask 0x%x, write mask 0x%x\n",
355 GEN_EXTRACT(dw, GEN6_ZS_DW1_STENCIL_TEST_MASK),
356 GEN_EXTRACT(dw, GEN6_ZS_DW1_STENCIL_WRITE_MASK));
357
358 dw = writer_dw(builder, which, item->offset, 2, "D_S");
359 ilo_printf("depth test %sable, func %d, write %sable\n",
360 (dw & GEN6_ZS_DW2_DEPTH_TEST_ENABLE) ? "en" : "dis",
361 GEN_EXTRACT(dw, GEN6_ZS_DW2_DEPTH_FUNC),
362 (dw & GEN6_ZS_DW2_DEPTH_WRITE_ENABLE) ? "en" : "dis");
363 }
364
365 static void
writer_decode_blend(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)366 writer_decode_blend(const struct ilo_builder *builder,
367 enum ilo_builder_writer_type which,
368 const struct ilo_builder_item *item)
369 {
370 const unsigned state_size = sizeof(uint32_t) * 2;
371 const unsigned count = item->size / state_size;
372 unsigned offset = item->offset;
373 unsigned i;
374
375 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
376 writer_dw(builder, which, offset, 0, "BLEND\n");
377 offset += 4;
378 }
379
380 for (i = 0; i < count; i++) {
381 writer_dw(builder, which, offset, 0, "BLEND%d\n", i);
382 writer_dw(builder, which, offset, 1, "BLEND%d\n", i);
383
384 offset += state_size;
385 }
386 }
387
388 static void
writer_decode_sampler(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)389 writer_decode_sampler(const struct ilo_builder *builder,
390 enum ilo_builder_writer_type which,
391 const struct ilo_builder_item *item)
392 {
393 const unsigned state_size = sizeof(uint32_t) * 4;
394 const unsigned count = item->size / state_size;
395 unsigned offset = item->offset;
396 unsigned i;
397
398 for (i = 0; i < count; i++) {
399 writer_dw(builder, which, offset, 0, "WM SAMP%d", i);
400 ilo_printf("filtering\n");
401
402 writer_dw(builder, which, offset, 1, "WM SAMP%d", i);
403 ilo_printf("wrapping, lod\n");
404
405 writer_dw(builder, which, offset, 2, "WM SAMP%d", i);
406 ilo_printf("default color pointer\n");
407
408 writer_dw(builder, which, offset, 3, "WM SAMP%d", i);
409 ilo_printf("chroma key, aniso\n");
410
411 offset += state_size;
412 }
413 }
414
415 static void
writer_decode_interface_descriptor(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)416 writer_decode_interface_descriptor(const struct ilo_builder *builder,
417 enum ilo_builder_writer_type which,
418 const struct ilo_builder_item *item)
419 {
420 const unsigned state_size = sizeof(uint32_t) * 8;
421 const unsigned count = item->size / state_size;
422 unsigned offset = item->offset;
423 unsigned i;
424
425 for (i = 0; i < count; i++) {
426 writer_dw(builder, which, offset, 0, "IDRT[%d]", i);
427 ilo_printf("kernel\n");
428
429 writer_dw(builder, which, offset, 1, "IDRT[%d]", i);
430 ilo_printf("spf, fp mode\n");
431
432 writer_dw(builder, which, offset, 2, "IDRT[%d]", i);
433 ilo_printf("sampler\n");
434
435 writer_dw(builder, which, offset, 3, "IDRT[%d]", i);
436 ilo_printf("binding table\n");
437
438 writer_dw(builder, which, offset, 4, "IDRT[%d]", i);
439 ilo_printf("curbe read len\n");
440
441 writer_dw(builder, which, offset, 5, "IDRT[%d]", i);
442 ilo_printf("rounding mode, slm size\n");
443
444 writer_dw(builder, which, offset, 6, "IDRT[%d]", i);
445 ilo_printf("cross-thread curbe read len\n");
446
447 writer_dw(builder, which, offset, 7, "IDRT[%d]", i);
448 ilo_printf("mbz\n");
449
450 offset += state_size;
451 }
452 }
453
454 static void
writer_decode_surface_gen7(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)455 writer_decode_surface_gen7(const struct ilo_builder *builder,
456 enum ilo_builder_writer_type which,
457 const struct ilo_builder_item *item)
458 {
459 uint32_t dw;
460
461 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
462 dw = writer_dw(builder, which, item->offset, 0, "SURF");
463 ilo_printf("type 0x%x, format 0x%x, tiling %d, %s array\n",
464 GEN_EXTRACT(dw, GEN7_SURFACE_DW0_TYPE),
465 GEN_EXTRACT(dw, GEN7_SURFACE_DW0_FORMAT),
466 GEN_EXTRACT(dw, GEN8_SURFACE_DW0_TILING),
467 (dw & GEN7_SURFACE_DW0_IS_ARRAY) ? "is" : "not");
468
469 writer_dw(builder, which, item->offset, 1, "SURF");
470 ilo_printf("qpitch\n");
471 } else {
472 dw = writer_dw(builder, which, item->offset, 0, "SURF");
473 ilo_printf("type 0x%x, format 0x%x, tiling %d, %s array\n",
474 GEN_EXTRACT(dw, GEN7_SURFACE_DW0_TYPE),
475 GEN_EXTRACT(dw, GEN7_SURFACE_DW0_FORMAT),
476 GEN_EXTRACT(dw, GEN7_SURFACE_DW0_TILING),
477 (dw & GEN7_SURFACE_DW0_IS_ARRAY) ? "is" : "not");
478
479 writer_dw(builder, which, item->offset, 1, "SURF");
480 ilo_printf("offset\n");
481 }
482
483 dw = writer_dw(builder, which, item->offset, 2, "SURF");
484 ilo_printf("%dx%d size\n",
485 GEN_EXTRACT(dw, GEN7_SURFACE_DW2_WIDTH),
486 GEN_EXTRACT(dw, GEN7_SURFACE_DW2_HEIGHT));
487
488 dw = writer_dw(builder, which, item->offset, 3, "SURF");
489 ilo_printf("depth %d, pitch %d\n",
490 GEN_EXTRACT(dw, GEN7_SURFACE_DW3_DEPTH),
491 GEN_EXTRACT(dw, GEN7_SURFACE_DW3_PITCH));
492
493 dw = writer_dw(builder, which, item->offset, 4, "SURF");
494 ilo_printf("min array element %d, array extent %d\n",
495 GEN_EXTRACT(dw, GEN7_SURFACE_DW4_MIN_ARRAY_ELEMENT),
496 GEN_EXTRACT(dw, GEN7_SURFACE_DW4_RT_VIEW_EXTENT));
497
498 dw = writer_dw(builder, which, item->offset, 5, "SURF");
499 ilo_printf("mip base %d, mips %d, x,y offset: %d,%d\n",
500 GEN_EXTRACT(dw, GEN7_SURFACE_DW5_MIN_LOD),
501 GEN_EXTRACT(dw, GEN7_SURFACE_DW5_MIP_COUNT_LOD),
502 GEN_EXTRACT(dw, GEN7_SURFACE_DW5_X_OFFSET),
503 GEN_EXTRACT(dw, GEN7_SURFACE_DW5_Y_OFFSET));
504
505 writer_dw(builder, which, item->offset, 6, "SURF\n");
506 writer_dw(builder, which, item->offset, 7, "SURF\n");
507
508 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
509 writer_dw(builder, which, item->offset, 8, "SURF\n");
510 writer_dw(builder, which, item->offset, 9, "SURF\n");
511 writer_dw(builder, which, item->offset, 10, "SURF\n");
512 writer_dw(builder, which, item->offset, 11, "SURF\n");
513 writer_dw(builder, which, item->offset, 12, "SURF\n");
514 }
515 }
516
517 static void
writer_decode_surface_gen6(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)518 writer_decode_surface_gen6(const struct ilo_builder *builder,
519 enum ilo_builder_writer_type which,
520 const struct ilo_builder_item *item)
521 {
522 uint32_t dw;
523
524 dw = writer_dw(builder, which, item->offset, 0, "SURF");
525 ilo_printf("type 0x%x, format 0x%x\n",
526 GEN_EXTRACT(dw, GEN6_SURFACE_DW0_TYPE),
527 GEN_EXTRACT(dw, GEN6_SURFACE_DW0_FORMAT));
528
529 writer_dw(builder, which, item->offset, 1, "SURF");
530 ilo_printf("offset\n");
531
532 dw = writer_dw(builder, which, item->offset, 2, "SURF");
533 ilo_printf("%dx%d size, %d mips\n",
534 GEN_EXTRACT(dw, GEN6_SURFACE_DW2_WIDTH),
535 GEN_EXTRACT(dw, GEN6_SURFACE_DW2_HEIGHT),
536 GEN_EXTRACT(dw, GEN6_SURFACE_DW2_MIP_COUNT_LOD));
537
538 dw = writer_dw(builder, which, item->offset, 3, "SURF");
539 ilo_printf("pitch %d, tiling %d\n",
540 GEN_EXTRACT(dw, GEN6_SURFACE_DW3_PITCH),
541 GEN_EXTRACT(dw, GEN6_SURFACE_DW3_TILING));
542
543 dw = writer_dw(builder, which, item->offset, 4, "SURF");
544 ilo_printf("mip base %d\n",
545 GEN_EXTRACT(dw, GEN6_SURFACE_DW4_MIN_LOD));
546
547 dw = writer_dw(builder, which, item->offset, 5, "SURF");
548 ilo_printf("x,y offset: %d,%d\n",
549 GEN_EXTRACT(dw, GEN6_SURFACE_DW5_X_OFFSET),
550 GEN_EXTRACT(dw, GEN6_SURFACE_DW5_Y_OFFSET));
551 }
552
553 static void
writer_decode_surface(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)554 writer_decode_surface(const struct ilo_builder *builder,
555 enum ilo_builder_writer_type which,
556 const struct ilo_builder_item *item)
557 {
558 if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
559 writer_decode_surface_gen7(builder, which, item);
560 else
561 writer_decode_surface_gen6(builder, which, item);
562 }
563
564 static void
writer_decode_binding_table(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)565 writer_decode_binding_table(const struct ilo_builder *builder,
566 enum ilo_builder_writer_type which,
567 const struct ilo_builder_item *item)
568 {
569 const unsigned state_size = sizeof(uint32_t) * 1;
570 const unsigned count = item->size / state_size;
571 unsigned offset = item->offset;
572 unsigned i;
573
574 for (i = 0; i < count; i++) {
575 writer_dw(builder, which, offset, 0, "BIND");
576 ilo_printf("BINDING_TABLE_STATE[%d]\n", i);
577
578 offset += state_size;
579 }
580 }
581
582 static void
writer_decode_kernel(const struct ilo_builder * builder,enum ilo_builder_writer_type which,const struct ilo_builder_item * item)583 writer_decode_kernel(const struct ilo_builder *builder,
584 enum ilo_builder_writer_type which,
585 const struct ilo_builder_item *item)
586 {
587 const void *kernel;
588
589 ilo_printf("0x%08x:\n", item->offset);
590 kernel = (const void *) writer_pointer(builder, which, item->offset);
591 toy_compiler_disassemble(builder->dev, kernel, item->size, true);
592 }
593
594 static const struct {
595 void (*func)(const struct ilo_builder *builder,
596 enum ilo_builder_writer_type which,
597 const struct ilo_builder_item *item);
598 } writer_decode_table[ILO_BUILDER_ITEM_COUNT] = {
599 [ILO_BUILDER_ITEM_BLOB] = { writer_decode_blob },
600 [ILO_BUILDER_ITEM_CLIP_VIEWPORT] = { writer_decode_clip_viewport },
601 [ILO_BUILDER_ITEM_SF_VIEWPORT] = { writer_decode_sf_viewport },
602 [ILO_BUILDER_ITEM_SCISSOR_RECT] = { writer_decode_scissor_rect },
603 [ILO_BUILDER_ITEM_CC_VIEWPORT] = { writer_decode_cc_viewport },
604 [ILO_BUILDER_ITEM_COLOR_CALC] = { writer_decode_color_calc },
605 [ILO_BUILDER_ITEM_DEPTH_STENCIL] = { writer_decode_depth_stencil },
606 [ILO_BUILDER_ITEM_BLEND] = { writer_decode_blend },
607 [ILO_BUILDER_ITEM_SAMPLER] = { writer_decode_sampler },
608 [ILO_BUILDER_ITEM_INTERFACE_DESCRIPTOR] = { writer_decode_interface_descriptor },
609 [ILO_BUILDER_ITEM_SURFACE] = { writer_decode_surface },
610 [ILO_BUILDER_ITEM_BINDING_TABLE] = { writer_decode_binding_table },
611 [ILO_BUILDER_ITEM_KERNEL] = { writer_decode_kernel },
612 };
613
614 static void
ilo_builder_writer_decode_items(struct ilo_builder * builder,enum ilo_builder_writer_type which)615 ilo_builder_writer_decode_items(struct ilo_builder *builder,
616 enum ilo_builder_writer_type which)
617 {
618 struct ilo_builder_writer *writer = &builder->writers[which];
619 int i;
620
621 if (!writer->item_used)
622 return;
623
624 writer->ptr = intel_bo_map(writer->bo, false);
625 if (!writer->ptr)
626 return;
627
628 for (i = 0; i < writer->item_used; i++) {
629 const struct ilo_builder_item *item = &writer->items[i];
630
631 writer_decode_table[item->type].func(builder, which, item);
632 }
633
634 intel_bo_unmap(writer->bo);
635 writer->ptr = NULL;
636 }
637
638 static void
ilo_builder_writer_decode(struct ilo_builder * builder,enum ilo_builder_writer_type which)639 ilo_builder_writer_decode(struct ilo_builder *builder,
640 enum ilo_builder_writer_type which)
641 {
642 struct ilo_builder_writer *writer = &builder->writers[which];
643
644 assert(writer->bo && !writer->ptr);
645
646 switch (which) {
647 case ILO_BUILDER_WRITER_BATCH:
648 ilo_printf("decoding batch buffer: %d bytes\n", writer->used);
649 if (writer->used)
650 intel_winsys_decode_bo(builder->winsys, writer->bo, writer->used);
651
652 ilo_printf("decoding dynamic/surface buffer: %d states\n",
653 writer->item_used);
654 ilo_builder_writer_decode_items(builder, which);
655 break;
656 case ILO_BUILDER_WRITER_INSTRUCTION:
657 if (true) {
658 ilo_printf("skipping instruction buffer: %d kernels\n",
659 writer->item_used);
660 } else {
661 ilo_printf("decoding instruction buffer: %d kernels\n",
662 writer->item_used);
663
664 ilo_builder_writer_decode_items(builder, which);
665 }
666 break;
667 default:
668 break;
669 }
670 }
671
672 /**
673 * Decode the builder according to the recorded items. This can be called
674 * only after a successful ilo_builder_end().
675 */
676 void
ilo_builder_decode(struct ilo_builder * builder)677 ilo_builder_decode(struct ilo_builder *builder)
678 {
679 int i;
680
681 assert(!builder->unrecoverable_error);
682
683 for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++)
684 ilo_builder_writer_decode(builder, i);
685 }
686