"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.9/src/gallium/drivers/svga/svgadump/svga_shader_dump.c" (30 Sep 2020, 18418 Bytes) of package /linux/misc/mesa-20.1.9.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /**********************************************************
    2  * Copyright 2008-2009 VMware, Inc.  All rights reserved.
    3  *
    4  * Permission is hereby granted, free of charge, to any person
    5  * obtaining a copy of this software and associated documentation
    6  * files (the "Software"), to deal in the Software without
    7  * restriction, including without limitation the rights to use, copy,
    8  * modify, merge, publish, distribute, sublicense, and/or sell copies
    9  * of the Software, and to permit persons to whom the Software is
   10  * furnished to do so, subject to the following conditions:
   11  *
   12  * The above copyright notice and this permission notice shall be
   13  * included in all copies or substantial portions of the Software.
   14  *
   15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   22  * SOFTWARE.
   23  *
   24  **********************************************************/
   25 
   26 /**
   27  * @file
   28  * SVGA Shader Dump Facilities
   29  * 
   30  * @author Michal Krol <michal@vmware.com>
   31  */
   32 
   33 #include <assert.h>
   34 #include <string.h>
   35 
   36 #include "svga_shader.h"
   37 #include "svga_shader_dump.h"
   38 #include "svga_shader_op.h"
   39 #include "util/u_debug.h"
   40 
   41 #include "../svga_hw_reg.h"
   42 #include "svga3d_shaderdefs.h"
   43 
   44 struct dump_info
   45 {
   46    uint32 version;
   47    boolean is_ps;
   48    int indent;
   49 };
   50 
   51 #define DUMP_MAX_OP_SRC 4
   52 
   53 struct dump_op
   54 {
   55    struct sh_op op;
   56    struct sh_dstreg dst;
   57    struct sh_srcreg dstind;
   58    struct sh_srcreg src[DUMP_MAX_OP_SRC];
   59    struct sh_srcreg srcind[DUMP_MAX_OP_SRC];
   60    struct sh_srcreg p0;
   61 };
   62 
   63 static void
   64 dump_indent(int indent)
   65 {
   66    int i;
   67 
   68    for (i = 0; i < indent; ++i) {
   69       _debug_printf("  ");
   70    }
   71 }
   72 
   73 static void dump_op( struct sh_op op, const char *mnemonic )
   74 {
   75    assert( op.is_reg == 0 );
   76 
   77    if (op.predicated) {
   78       _debug_printf("(p0) ");
   79    }
   80    if (op.coissue)
   81       _debug_printf( "+" );
   82    _debug_printf( "%s", mnemonic );
   83 
   84    switch (op.opcode) {
   85    case SVGA3DOP_TEX:
   86       switch (op.control) {
   87       case 0:
   88          break;
   89       case 1 /* PROJECT */:
   90          _debug_printf("p");
   91          break;
   92       case 2 /* BIAS */:
   93          _debug_printf("b");
   94          break;
   95       default:
   96          assert(0);
   97       }
   98       break;
   99 
  100    case SVGA3DOP_IFC:
  101    case SVGA3DOP_BREAKC:
  102    case SVGA3DOP_SETP:
  103       switch (op.control) {
  104       case SVGA3DOPCOMP_GT:
  105          _debug_printf("_gt");
  106          break;
  107       case SVGA3DOPCOMP_EQ:
  108          _debug_printf("_eq");
  109          break;
  110       case SVGA3DOPCOMP_GE:
  111          _debug_printf("_ge");
  112          break;
  113       case SVGA3DOPCOMP_LT:
  114          _debug_printf("_lt");
  115          break;
  116       case SVGA3DOPCOMPC_NE:
  117          _debug_printf("_ne");
  118          break;
  119       case SVGA3DOPCOMP_LE:
  120          _debug_printf("_le");
  121          break;
  122       default:
  123          assert(0);
  124       }
  125       break;
  126 
  127    default:
  128       assert(op.control == 0);
  129    }
  130 }
  131 
  132 static void
  133 format_reg(const char *name,
  134            const struct sh_reg reg,
  135            const struct sh_srcreg *indreg)
  136 {
  137    if (reg.relative) {
  138       assert(indreg);
  139 
  140       if (sh_srcreg_type(*indreg) == SVGA3DREG_LOOP) {
  141          _debug_printf("%s[aL+%u]", name, reg.number);
  142       } else {
  143          _debug_printf("%s[a%u.x+%u]", name, indreg->number, reg.number);
  144       }
  145    } else {
  146       _debug_printf("%s%u", name, reg.number);
  147    }
  148 }
  149 
  150 static void dump_reg( struct sh_reg reg, struct sh_srcreg *indreg, const struct dump_info *di )
  151 {
  152    assert( reg.is_reg == 1 );
  153 
  154    switch (sh_reg_type( reg )) {
  155    case SVGA3DREG_TEMP:
  156       format_reg("r", reg, NULL);
  157       break;
  158 
  159    case SVGA3DREG_INPUT:
  160       format_reg("v", reg, indreg);
  161       break;
  162 
  163    case SVGA3DREG_CONST:
  164       format_reg("c", reg, indreg);
  165       break;
  166 
  167    case SVGA3DREG_ADDR:    /* VS */
  168    /* SVGA3DREG_TEXTURE */ /* PS */
  169       assert(!reg.relative);
  170       if (di->is_ps) {
  171          format_reg("t", reg, NULL);
  172       } else {
  173          format_reg("a", reg, NULL);
  174       }
  175       break;
  176 
  177    case SVGA3DREG_RASTOUT:
  178       assert(!reg.relative);
  179       switch (reg.number) {
  180       case 0 /*POSITION*/:
  181          _debug_printf( "oPos" );
  182          break;
  183       case 1 /*FOG*/:
  184          _debug_printf( "oFog" );
  185          break;
  186       case 2 /*POINT_SIZE*/:
  187          _debug_printf( "oPts" );
  188          break;
  189       default:
  190          assert( 0 );
  191          _debug_printf( "???" );
  192       }
  193       break;
  194 
  195    case SVGA3DREG_ATTROUT:
  196       assert( reg.number < 2 );
  197       format_reg("oD", reg, NULL);
  198       break;
  199 
  200    case SVGA3DREG_TEXCRDOUT:  /* VS */
  201    /* SVGA3DREG_OUTPUT */     /* VS3.0+ */
  202       if (!di->is_ps && di->version >= SVGA3D_VS_30) {
  203          format_reg("o", reg, indreg);
  204       } else {
  205          format_reg("oT", reg, NULL);
  206       }
  207       break;
  208 
  209    case SVGA3DREG_COLOROUT:
  210       format_reg("oC", reg, NULL);
  211       break;
  212 
  213    case SVGA3DREG_DEPTHOUT:
  214       assert(!reg.relative);
  215       assert(reg.number == 0);
  216       _debug_printf("oDepth");
  217       break;
  218 
  219    case SVGA3DREG_SAMPLER:
  220       format_reg("s", reg, NULL);
  221       break;
  222 
  223    case SVGA3DREG_CONSTBOOL:
  224       format_reg("b", reg, NULL);
  225       break;
  226 
  227    case SVGA3DREG_CONSTINT:
  228       format_reg("i", reg, NULL);
  229       break;
  230 
  231    case SVGA3DREG_LOOP:
  232       assert(!reg.relative);
  233       assert( reg.number == 0 );
  234       _debug_printf( "aL" );
  235       break;
  236 
  237    case SVGA3DREG_MISCTYPE:
  238       assert(!reg.relative);
  239       switch (reg.number) {
  240       case SVGA3DMISCREG_POSITION:
  241          _debug_printf("vPos");
  242          break;
  243       case SVGA3DMISCREG_FACE:
  244          _debug_printf("vFace");
  245          break;
  246       default:
  247          assert(0);
  248          _debug_printf("???");
  249       }
  250       break;
  251 
  252    case SVGA3DREG_LABEL:
  253       format_reg("l", reg, NULL);
  254       break;
  255 
  256    case SVGA3DREG_PREDICATE:
  257       format_reg("p", reg, NULL);
  258       break;
  259 
  260    default:
  261       assert( 0 );
  262       _debug_printf( "???" );
  263    }
  264 }
  265 
  266 static void dump_cdata( struct sh_cdata cdata )
  267 {
  268    _debug_printf( "%f, %f, %f, %f", cdata.xyzw[0], cdata.xyzw[1], cdata.xyzw[2], cdata.xyzw[3] );
  269 }
  270 
  271 static void dump_idata( struct sh_idata idata )
  272 {
  273    _debug_printf( "%d, %d, %d, %d", idata.xyzw[0], idata.xyzw[1], idata.xyzw[2], idata.xyzw[3] );
  274 }
  275 
  276 static void dump_bdata( boolean bdata )
  277 {
  278    _debug_printf( bdata ? "TRUE" : "FALSE" );
  279 }
  280 
  281 static void
  282 dump_sampleinfo(struct sh_sampleinfo sampleinfo)
  283 {
  284    assert( sampleinfo.is_reg == 1 );
  285 
  286    switch (sampleinfo.texture_type) {
  287    case SVGA3DSAMP_2D:
  288       _debug_printf( "_2d" );
  289       break;
  290    case SVGA3DSAMP_2D_SHADOW:
  291       _debug_printf( "_2dshadow" );
  292       break;
  293    case SVGA3DSAMP_CUBE:
  294       _debug_printf( "_cube" );
  295       break;
  296    case SVGA3DSAMP_VOLUME:
  297       _debug_printf( "_volume" );
  298       break;
  299    default:
  300       assert( 0 );
  301    }
  302 }
  303 
  304 static void
  305 dump_semantic(uint usage,
  306               uint usage_index)
  307 {
  308    switch (usage) {
  309    case SVGA3D_DECLUSAGE_POSITION:
  310       _debug_printf("_position");
  311       break;
  312    case SVGA3D_DECLUSAGE_BLENDWEIGHT:
  313       _debug_printf("_blendweight");
  314       break;
  315    case SVGA3D_DECLUSAGE_BLENDINDICES:
  316       _debug_printf("_blendindices");
  317       break;
  318    case SVGA3D_DECLUSAGE_NORMAL:
  319       _debug_printf("_normal");
  320       break;
  321    case SVGA3D_DECLUSAGE_PSIZE:
  322       _debug_printf("_psize");
  323       break;
  324    case SVGA3D_DECLUSAGE_TEXCOORD:
  325       _debug_printf("_texcoord");
  326       break;
  327    case SVGA3D_DECLUSAGE_TANGENT:
  328       _debug_printf("_tangent");
  329       break;
  330    case SVGA3D_DECLUSAGE_BINORMAL:
  331       _debug_printf("_binormal");
  332       break;
  333    case SVGA3D_DECLUSAGE_TESSFACTOR:
  334       _debug_printf("_tessfactor");
  335       break;
  336    case SVGA3D_DECLUSAGE_POSITIONT:
  337       _debug_printf("_positiont");
  338       break;
  339    case SVGA3D_DECLUSAGE_COLOR:
  340       _debug_printf("_color");
  341       break;
  342    case SVGA3D_DECLUSAGE_FOG:
  343       _debug_printf("_fog");
  344       break;
  345    case SVGA3D_DECLUSAGE_DEPTH:
  346       _debug_printf("_depth");
  347       break;
  348    case SVGA3D_DECLUSAGE_SAMPLE:
  349       _debug_printf("_sample");
  350       break;
  351    default:
  352       assert(!"Unknown usage");
  353       _debug_printf("_???");
  354    }
  355 
  356    if (usage_index) {
  357       _debug_printf("%u", usage_index);
  358    }
  359 }
  360 
  361 static void
  362 dump_dstreg(struct sh_dstreg dstreg,
  363             struct sh_srcreg *indreg,
  364             const struct dump_info *di)
  365 {
  366    union {
  367       struct sh_reg reg;
  368       struct sh_dstreg dstreg;
  369    } u;
  370 
  371    memset(&u, 0, sizeof(u));
  372 
  373    assert( (dstreg.modifier & (SVGA3DDSTMOD_SATURATE | SVGA3DDSTMOD_PARTIALPRECISION)) == dstreg.modifier );
  374 
  375    if (dstreg.modifier & SVGA3DDSTMOD_SATURATE)
  376       _debug_printf( "_sat" );
  377    if (dstreg.modifier & SVGA3DDSTMOD_PARTIALPRECISION)
  378       _debug_printf( "_pp" );
  379    switch (dstreg.shift_scale) {
  380    case 0:
  381       break;
  382    case 1:
  383       _debug_printf( "_x2" );
  384       break;
  385    case 2:
  386       _debug_printf( "_x4" );
  387       break;
  388    case 3:
  389       _debug_printf( "_x8" );
  390       break;
  391    case 13:
  392       _debug_printf( "_d8" );
  393       break;
  394    case 14:
  395       _debug_printf( "_d4" );
  396       break;
  397    case 15:
  398       _debug_printf( "_d2" );
  399       break;
  400    default:
  401       assert( 0 );
  402    }
  403    _debug_printf( " " );
  404 
  405    u.dstreg = dstreg;
  406    dump_reg( u.reg, indreg, di);
  407    if (dstreg.write_mask != SVGA3DWRITEMASK_ALL) {
  408       _debug_printf( "." );
  409       if (dstreg.write_mask & SVGA3DWRITEMASK_0)
  410          _debug_printf( "x" );
  411       if (dstreg.write_mask & SVGA3DWRITEMASK_1)
  412          _debug_printf( "y" );
  413       if (dstreg.write_mask & SVGA3DWRITEMASK_2)
  414          _debug_printf( "z" );
  415       if (dstreg.write_mask & SVGA3DWRITEMASK_3)
  416          _debug_printf( "w" );
  417    }
  418 }
  419 
  420 static void dump_srcreg( struct sh_srcreg srcreg, struct sh_srcreg *indreg, const struct dump_info *di )
  421 {
  422    struct sh_reg srcreg_sh = {0};
  423    /* bit-fields carefully aligned, ensure they stay that way. */
  424    STATIC_ASSERT(sizeof(struct sh_reg) == sizeof(struct sh_srcreg));
  425    memcpy(&srcreg_sh, &srcreg, sizeof(srcreg_sh));
  426 
  427    switch (srcreg.modifier) {
  428    case SVGA3DSRCMOD_NEG:
  429    case SVGA3DSRCMOD_BIASNEG:
  430    case SVGA3DSRCMOD_SIGNNEG:
  431    case SVGA3DSRCMOD_X2NEG:
  432    case SVGA3DSRCMOD_ABSNEG:
  433       _debug_printf( "-" );
  434       break;
  435    case SVGA3DSRCMOD_COMP:
  436       _debug_printf( "1-" );
  437       break;
  438    case SVGA3DSRCMOD_NOT:
  439       _debug_printf( "!" );
  440    }
  441    dump_reg(srcreg_sh, indreg, di );
  442    switch (srcreg.modifier) {
  443    case SVGA3DSRCMOD_NONE:
  444    case SVGA3DSRCMOD_NEG:
  445    case SVGA3DSRCMOD_COMP:
  446    case SVGA3DSRCMOD_NOT:
  447       break;
  448    case SVGA3DSRCMOD_BIAS:
  449    case SVGA3DSRCMOD_BIASNEG:
  450       _debug_printf( "_bias" );
  451       break;
  452    case SVGA3DSRCMOD_SIGN:
  453    case SVGA3DSRCMOD_SIGNNEG:
  454       _debug_printf( "_bx2" );
  455       break;
  456    case SVGA3DSRCMOD_X2:
  457    case SVGA3DSRCMOD_X2NEG:
  458       _debug_printf( "_x2" );
  459       break;
  460    case SVGA3DSRCMOD_DZ:
  461       _debug_printf( "_dz" );
  462       break;
  463    case SVGA3DSRCMOD_DW:
  464       _debug_printf( "_dw" );
  465       break;
  466    case SVGA3DSRCMOD_ABS:
  467    case SVGA3DSRCMOD_ABSNEG:
  468       _debug_printf("_abs");
  469       break;
  470    default:
  471       assert( 0 );
  472    }
  473    if (srcreg.swizzle_x != 0 || srcreg.swizzle_y != 1 || srcreg.swizzle_z != 2 || srcreg.swizzle_w != 3) {
  474       _debug_printf( "." );
  475       if (srcreg.swizzle_x == srcreg.swizzle_y && srcreg.swizzle_y == srcreg.swizzle_z && srcreg.swizzle_z == srcreg.swizzle_w) {
  476          _debug_printf( "%c", "xyzw"[srcreg.swizzle_x] );
  477       }
  478       else {
  479          _debug_printf( "%c", "xyzw"[srcreg.swizzle_x] );
  480          _debug_printf( "%c", "xyzw"[srcreg.swizzle_y] );
  481          _debug_printf( "%c", "xyzw"[srcreg.swizzle_z] );
  482          _debug_printf( "%c", "xyzw"[srcreg.swizzle_w] );
  483       }
  484    }
  485 }
  486 
  487 static void
  488 parse_op(struct dump_info *di,
  489          const uint **token,
  490          struct dump_op *op,
  491          uint num_dst,
  492          uint num_src)
  493 {
  494    uint i;
  495 
  496    assert(num_dst <= 1);
  497    assert(num_src <= DUMP_MAX_OP_SRC);
  498 
  499    op->op = *(struct sh_op *)*token;
  500    *token += sizeof(struct sh_op) / sizeof(uint);
  501 
  502    if (num_dst >= 1) {
  503       op->dst = *(struct sh_dstreg *)*token;
  504       *token += sizeof(struct sh_dstreg) / sizeof(uint);
  505       if (op->dst.relative &&
  506           (!di->is_ps && di->version >= SVGA3D_VS_30)) {
  507          op->dstind = *(struct sh_srcreg *)*token;
  508          *token += sizeof(struct sh_srcreg) / sizeof(uint);
  509       }
  510    }
  511 
  512    if (op->op.predicated) {
  513       op->p0 = *(struct sh_srcreg *)*token;
  514       *token += sizeof(struct sh_srcreg) / sizeof(uint);
  515    }
  516 
  517    for (i = 0; i < num_src; ++i) {
  518       op->src[i] = *(struct sh_srcreg *)*token;
  519       *token += sizeof(struct sh_srcreg) / sizeof(uint);
  520       if (op->src[i].relative &&
  521           ((!di->is_ps && di->version >= SVGA3D_VS_20) ||
  522           (di->is_ps && di->version >= SVGA3D_PS_30))) {
  523          op->srcind[i] = *(struct sh_srcreg *)*token;
  524          *token += sizeof(struct sh_srcreg) / sizeof(uint);
  525       }
  526    }
  527 }
  528 
  529 static void
  530 dump_inst(struct dump_info *di,
  531           const unsigned **assem,
  532           struct sh_op op,
  533           const struct sh_opcode_info *info)
  534 {
  535    struct dump_op dop;
  536    boolean not_first_arg = FALSE;
  537    uint i;
  538 
  539    assert(info->num_dst <= 1);
  540 
  541    di->indent -= info->pre_dedent;
  542    dump_indent(di->indent);
  543    di->indent += info->post_indent;
  544 
  545    dump_op(op, info->mnemonic);
  546 
  547    parse_op(di, assem, &dop, info->num_dst, info->num_src);
  548    if (info->num_dst > 0) {
  549       dump_dstreg(dop.dst, &dop.dstind, di);
  550       not_first_arg = TRUE;
  551    }
  552 
  553    for (i = 0; i < info->num_src; i++) {
  554       if (not_first_arg) {
  555          _debug_printf(", ");
  556       } else {
  557          _debug_printf(" ");
  558       }
  559       dump_srcreg(dop.src[i], &dop.srcind[i], di);
  560       not_first_arg = TRUE;
  561    }
  562 
  563    _debug_printf("\n");
  564 }
  565 
  566 void
  567 svga_shader_dump(
  568    const unsigned *assem,
  569    unsigned dwords,
  570    unsigned do_binary )
  571 {
  572    boolean finished = FALSE;
  573    struct dump_info di;
  574 
  575    di.version = *assem++;
  576    di.is_ps = (di.version & 0xFFFF0000) == 0xFFFF0000;
  577    di.indent = 0;
  578 
  579    _debug_printf(
  580       "%s_%u_%u\n",
  581       di.is_ps ? "ps" : "vs",
  582       (di.version >> 8) & 0xff,
  583       di.version & 0xff );
  584 
  585    while (!finished) {
  586       struct sh_op op = *(struct sh_op *) assem;
  587 
  588       switch (op.opcode) {
  589       case SVGA3DOP_DCL:
  590          {
  591             struct sh_dcl dcl = *(struct sh_dcl *) assem;
  592 
  593             _debug_printf( "dcl" );
  594             switch (sh_dstreg_type(dcl.reg)) {
  595             case SVGA3DREG_INPUT:
  596                if ((di.is_ps && di.version >= SVGA3D_PS_30) ||
  597                    (!di.is_ps && di.version >= SVGA3D_VS_30)) {
  598                   dump_semantic(dcl.u.semantic.usage,
  599                                 dcl.u.semantic.usage_index);
  600                }
  601                break;
  602             case SVGA3DREG_TEXCRDOUT:
  603                if (!di.is_ps && di.version >= SVGA3D_VS_30) {
  604                   dump_semantic(dcl.u.semantic.usage,
  605                                 dcl.u.semantic.usage_index);
  606                }
  607                break;
  608             case SVGA3DREG_SAMPLER:
  609                dump_sampleinfo( dcl.u.sampleinfo );
  610                break;
  611             }
  612             dump_dstreg(dcl.reg, NULL, &di);
  613             _debug_printf( "\n" );
  614             assem += sizeof( struct sh_dcl ) / sizeof( unsigned );
  615          }
  616          break;
  617 
  618       case SVGA3DOP_DEFB:
  619          {
  620             struct sh_defb defb = *(struct sh_defb *) assem;
  621 
  622             _debug_printf( "defb " );
  623             dump_reg( defb.reg, NULL, &di );
  624             _debug_printf( ", " );
  625             dump_bdata( defb.data );
  626             _debug_printf( "\n" );
  627             assem += sizeof( struct sh_defb ) / sizeof( unsigned );
  628          }
  629          break;
  630 
  631       case SVGA3DOP_DEFI:
  632          {
  633             struct sh_defi defi = *(struct sh_defi *) assem;
  634 
  635             _debug_printf( "defi " );
  636             dump_reg( defi.reg, NULL, &di );
  637             _debug_printf( ", " );
  638             dump_idata( defi.idata );
  639             _debug_printf( "\n" );
  640             assem += sizeof( struct sh_defi ) / sizeof( unsigned );
  641          }
  642          break;
  643 
  644       case SVGA3DOP_TEXCOORD:
  645          {
  646             struct sh_opcode_info info = *svga_opcode_info(op.opcode);
  647 
  648             assert(di.is_ps);
  649             if (di.version > SVGA3D_PS_13) {
  650                assert(info.num_src == 0);
  651 
  652                info.num_src = 1;
  653             }
  654 
  655             dump_inst(&di, &assem, op, &info);
  656          }
  657          break;
  658 
  659       case SVGA3DOP_TEX:
  660          {
  661             struct sh_opcode_info info = *svga_opcode_info(op.opcode);
  662 
  663             assert(di.is_ps);
  664             if (di.version > SVGA3D_PS_13) {
  665                assert(info.num_src == 0);
  666 
  667                if (di.version > SVGA3D_PS_14) {
  668                   info.num_src = 2;
  669                   info.mnemonic = "texld";
  670                } else {
  671                   info.num_src = 1;
  672                }
  673             }
  674 
  675             dump_inst(&di, &assem, op, &info);
  676          }
  677          break;
  678 
  679       case SVGA3DOP_DEF:
  680          {
  681             struct sh_def def = *(struct sh_def *) assem;
  682 
  683             _debug_printf( "def " );
  684             dump_reg( def.reg, NULL, &di );
  685             _debug_printf( ", " );
  686             dump_cdata( def.cdata );
  687             _debug_printf( "\n" );
  688             assem += sizeof( struct sh_def ) / sizeof( unsigned );
  689          }
  690          break;
  691 
  692       case SVGA3DOP_SINCOS:
  693          {
  694             struct sh_opcode_info info = *svga_opcode_info(op.opcode);
  695 
  696             if ((di.is_ps && di.version >= SVGA3D_PS_30) ||
  697                 (!di.is_ps && di.version >= SVGA3D_VS_30)) {
  698                assert(info.num_src == 3);
  699 
  700                info.num_src = 1;
  701             }
  702 
  703             dump_inst(&di, &assem, op, &info);
  704          }
  705          break;
  706 
  707       case SVGA3DOP_PHASE:
  708          _debug_printf( "phase\n" );
  709          assem += sizeof( struct sh_op ) / sizeof( unsigned );
  710          break;
  711 
  712       case SVGA3DOP_COMMENT:
  713          {
  714             struct sh_comment comment = *(struct sh_comment *)assem;
  715 
  716             /* Ignore comment contents. */
  717             assem += sizeof(struct sh_comment) / sizeof(unsigned) + comment.size;
  718          }
  719          break;
  720 
  721       case SVGA3DOP_END:
  722          finished = TRUE;
  723          break;
  724 
  725       default:
  726          {
  727             const struct sh_opcode_info *info = svga_opcode_info(op.opcode);
  728 
  729             dump_inst(&di, &assem, op, info);
  730          }
  731       }
  732    }
  733 }