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 (at) 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 * 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) 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
