Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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 *
  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_STENCIL0_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_STENCIL0_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_STENCIL0_VALUEMASK),
  356.          GEN_EXTRACT(dw, GEN6_ZS_DW1_STENCIL0_WRITEMASK));
  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.