src/gallium/auxiliary/tgsi/tgsi_dump_c.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_debug.h"
  29 #include "util/u_string.h"
  30 #include "tgsi_dump_c.h"
  31 #include "tgsi_build.h"
  32 #include "tgsi_info.h"
  33 #include "tgsi_parse.h"
  34
  35 static void
  36 dump_enum(
  37    const unsigned    e,
  38    const char        **enums,
  39    const unsigned    enums_count )
  40 {
  41    if (e >= enums_count) {
  42       debug_printf( "%u", e );
  43    }
  44    else {
  45       debug_printf( "%s", enums[e] );
  46    }
  47 }
  48
  49 #define EOL()           debug_printf( "\n" )
  50 #define TXT(S)          debug_printf( "%s", S )
  51 #define CHR(C)          debug_printf( "%c", C )
  52 #define UIX(I)          debug_printf( "0x%x", I )
  53 #define UID(I)          debug_printf( "%u", I )
  54 #define SID(I)          debug_printf( "%d", I )
  55 #define FLT(F)          debug_printf( "%10.4f", F )
  56 #define ENM(E,ENUMS)    dump_enum( E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
  57
  58 static const char *TGSI_PROCESSOR_TYPES[] =
  59 {
  60    "PROCESSOR_FRAGMENT",
  61    "PROCESSOR_VERTEX",
  62    "PROCESSOR_GEOMETRY"
  63 };
  64
  65 static const char *TGSI_TOKEN_TYPES[] =
  66 {
  67    "TOKEN_TYPE_DECLARATION",
  68    "TOKEN_TYPE_IMMEDIATE",
  69    "TOKEN_TYPE_INSTRUCTION"
  70 };
  71
  72 static const char *TGSI_FILES[] =
  73 {
  74    "FILE_NULL",
  75    "FILE_CONSTANT",
  76    "FILE_INPUT",
  77    "FILE_OUTPUT",
  78    "FILE_TEMPORARY",
  79    "FILE_SAMPLER",
  80    "FILE_ADDRESS",
  81    "FILE_IMMEDIATE"
  82 };
  83
  84 static const char *TGSI_INTERPOLATES[] =
  85 {
  86    "INTERPOLATE_CONSTANT",
  87    "INTERPOLATE_LINEAR",
  88    "INTERPOLATE_PERSPECTIVE"
  89 };
  90
  91 static const char *TGSI_SEMANTICS[] =
  92 {
  93    "SEMANTIC_POSITION",
  94    "SEMANTIC_COLOR",
  95    "SEMANTIC_BCOLOR",
  96    "SEMANTIC_FOG",
  97    "SEMANTIC_PSIZE",
  98    "SEMANTIC_GENERIC",
  99    "SEMANTIC_NORMAL"
 100 };
 101
 102 static const char *TGSI_IMMS[] =
 103 {
 104    "IMM_FLOAT32"
 105 };
 106
 107 static const char *TGSI_SATS[] =
 108 {
 109    "SAT_NONE",
 110    "SAT_ZERO_ONE",
 111    "SAT_MINUS_PLUS_ONE"
 112 };
 113
 114 static const char *TGSI_INSTRUCTION_EXTS[] =
 115 {
 116    "INSTRUCTION_EXT_TYPE_NV",
 117    "INSTRUCTION_EXT_TYPE_LABEL",
 118    "INSTRUCTION_EXT_TYPE_TEXTURE"
 119 };
 120
 121 static const char *TGSI_PRECISIONS[] =
 122 {
 123    "PRECISION_DEFAULT",
 124    "PRECISION_FLOAT32",
 125    "PRECISION_FLOAT16",
 126    "PRECISION_FIXED12"
 127 };
 128
 129 static const char *TGSI_CCS[] =
 130 {
 131    "CC_GT",
 132    "CC_EQ",
 133    "CC_LT",
 134    "CC_UN",
 135    "CC_GE",
 136    "CC_LE",
 137    "CC_NE",
 138    "CC_TR",
 139    "CC_FL"
 140 };
 141
 142 static const char *TGSI_SWIZZLES[] =
 143 {
 144    "SWIZZLE_X",
 145    "SWIZZLE_Y",
 146    "SWIZZLE_Z",
 147    "SWIZZLE_W"
 148 };
 149
 150 static const char *TGSI_TEXTURES[] =
 151 {
 152    "TEXTURE_UNKNOWN",
 153    "TEXTURE_1D",
 154    "TEXTURE_2D",
 155    "TEXTURE_3D",
 156    "TEXTURE_CUBE",
 157    "TEXTURE_RECT",
 158    "TEXTURE_SHADOW1D",
 159    "TEXTURE_SHADOW2D",
 160    "TEXTURE_SHADOWRECT"
 161 };
 162
 163 static const char *TGSI_SRC_REGISTER_EXTS[] =
 164 {
 165    "SRC_REGISTER_EXT_TYPE_SWZ",
 166    "SRC_REGISTER_EXT_TYPE_MOD"
 167 };
 168
 169 static const char *TGSI_EXTSWIZZLES[] =
 170 {
 171    "EXTSWIZZLE_X",
 172    "EXTSWIZZLE_Y",
 173    "EXTSWIZZLE_Z",
 174    "EXTSWIZZLE_W",
 175    "EXTSWIZZLE_ZERO",
 176    "EXTSWIZZLE_ONE"
 177 };
 178
 179 static const char *TGSI_WRITEMASKS[] =
 180 {
 181    "0",
 182    "WRITEMASK_X",
 183    "WRITEMASK_Y",
 184    "WRITEMASK_XY",
 185    "WRITEMASK_Z",
 186    "WRITEMASK_XZ",
 187    "WRITEMASK_YZ",
 188    "WRITEMASK_XYZ",
 189    "WRITEMASK_W",
 190    "WRITEMASK_XW",
 191    "WRITEMASK_YW",
 192    "WRITEMASK_XYW",
 193    "WRITEMASK_ZW",
 194    "WRITEMASK_XZW",
 195    "WRITEMASK_YZW",
 196    "WRITEMASK_XYZW"
 197 };
 198
 199 static const char *TGSI_DST_REGISTER_EXTS[] =
 200 {
 201    "DST_REGISTER_EXT_TYPE_CONDCODE",
 202    "DST_REGISTER_EXT_TYPE_MODULATE"
 203 };
 204
 205 static const char *TGSI_MODULATES[] =
 206 {
 207    "MODULATE_1X",
 208    "MODULATE_2X",
 209    "MODULATE_4X",
 210    "MODULATE_8X",
 211    "MODULATE_HALF",
 212    "MODULATE_QUARTER",
 213    "MODULATE_EIGHTH"
 214 };
 215
 216 static void
 217 dump_declaration_verbose(
 218    struct tgsi_full_declaration  *decl,
 219    unsigned                      ignored,
 220    unsigned                      deflt,
 221    struct tgsi_full_declaration  *fd )
 222 {
 223    TXT( "\nFile       : " );
 224    ENM( decl->Declaration.File, TGSI_FILES );
 225    if( deflt || fd->Declaration.UsageMask != decl->Declaration.UsageMask ) {
 226       TXT( "\nUsageMask  : " );
 227       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_X ) {
 228          CHR( 'X' );
 229       }
 230       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Y ) {
 231          CHR( 'Y' );
 232       }
 233       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Z ) {
 234          CHR( 'Z' );
 235       }
 236       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_W ) {
 237          CHR( 'W' );
 238       }
 239    }
 240    if( deflt || fd->Declaration.Interpolate != decl->Declaration.Interpolate ) {
 241       TXT( "\nInterpolate: " );
 242       ENM( decl->Declaration.Interpolate, TGSI_INTERPOLATES );
 243    }
 244    if( deflt || fd->Declaration.Semantic != decl->Declaration.Semantic ) {
 245       TXT( "\nSemantic   : " );
 246       UID( decl->Declaration.Semantic );
 247    }
 248    if( ignored ) {
 249       TXT( "\nPadding    : " );
 250       UIX( decl->Declaration.Padding );
 251    }
 252
 253    EOL();
 254    TXT( "\nFirst: " );
 255    UID( decl->DeclarationRange.First );
 256    TXT( "\nLast : " );
 257    UID( decl->DeclarationRange.Last );
 258
 259    if( decl->Declaration.Semantic ) {
 260       EOL();
 261       TXT( "\nSemanticName : " );
 262       ENM( decl->Semantic.SemanticName, TGSI_SEMANTICS );
 263       TXT( "\nSemanticIndex: " );
 264       UID( decl->Semantic.SemanticIndex );
 265       if( ignored ) {
 266          TXT( "\nPadding      : " );
 267          UIX( decl->Semantic.Padding );
 268       }
 269    }
 270 }
 271
 272 static void
 273 dump_immediate_verbose(
 274    struct tgsi_full_immediate *imm,
 275    unsigned                   ignored )
 276 {
 277    unsigned i;
 278
 279    TXT( "\nDataType   : " );
 280    ENM( imm->Immediate.DataType, TGSI_IMMS );
 281    if( ignored ) {
 282       TXT( "\nPadding    : " );
 283       UIX( imm->Immediate.Padding );
 284    }
 285
 286    for( i = 0; i < imm->Immediate.NrTokens - 1; i++ ) {
 287       EOL();
 288       switch( imm->Immediate.DataType ) {
 289       case TGSI_IMM_FLOAT32:
 290          TXT( "\nFloat: " );
 291          FLT( imm->u.ImmediateFloat32[i].Float );
 292          break;
 293
 294       default:
 295          assert( 0 );
 296       }
 297    }
 298 }
 299
 300 static void
 301 dump_instruction_verbose(
 302    struct tgsi_full_instruction  *inst,
 303    unsigned                      ignored,
 304    unsigned                      deflt,
 305    struct tgsi_full_instruction  *fi )
 306 {
 307    unsigned i;
 308
 309    TXT( "\nOpcode     : OPCODE_" );
 310    TXT( tgsi_get_opcode_info( inst->Instruction.Opcode )->mnemonic );
 311    if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
 312       TXT( "\nSaturate   : " );
 313       ENM( inst->Instruction.Saturate, TGSI_SATS );
 314    }
 315    if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
 316       TXT( "\nNumDstRegs : " );
 317       UID( inst->Instruction.NumDstRegs );
 318    }
 319    if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
 320       TXT( "\nNumSrcRegs : " );
 321       UID( inst->Instruction.NumSrcRegs );
 322    }
 323    if( ignored ) {
 324       TXT( "\nPadding    : " );
 325       UIX( inst->Instruction.Padding );
 326    }
 327
 328    if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi->InstructionExtNv ) ) {
 329       EOL();
 330       TXT( "\nType          : " );
 331       ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
 332       if( deflt || fi->InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
 333          TXT( "\nPrecision     : " );
 334          ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
 335       }
 336       if( deflt || fi->InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
 337          TXT( "\nCondDstIndex  : " );
 338          UID( inst->InstructionExtNv.CondDstIndex );
 339       }
 340       if( deflt || fi->InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
 341          TXT( "\nCondFlowIndex : " );
 342          UID( inst->InstructionExtNv.CondFlowIndex );
 343       }
 344       if( deflt || fi->InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
 345          TXT( "\nCondMask      : " );
 346          ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
 347       }
 348       if( deflt || fi->InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
 349          TXT( "\nCondSwizzleX  : " );
 350          ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
 351       }
 352       if( deflt || fi->InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
 353          TXT( "\nCondSwizzleY  : " );
 354          ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
 355       }
 356       if( deflt || fi->InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
 357          TXT( "\nCondSwizzleZ  : " );
 358          ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
 359       }
 360       if( deflt || fi->InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
 361          TXT( "\nCondSwizzleW  : " );
 362          ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
 363       }
 364       if( deflt || fi->InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
 365          TXT( "\nCondDstUpdate : " );
 366          UID( inst->InstructionExtNv.CondDstUpdate );
 367       }
 368       if( deflt || fi->InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
 369          TXT( "\nCondFlowEnable: " );
 370          UID( inst->InstructionExtNv.CondFlowEnable );
 371       }
 372       if( ignored ) {
 373          TXT( "\nPadding       : " );
 374          UIX( inst->InstructionExtNv.Padding );
 375          if( deflt || fi->InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
 376             TXT( "\nExtended      : " );
 377             UID( inst->InstructionExtNv.Extended );
 378          }
 379       }
 380    }
 381
 382    if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
 383       EOL();
 384       TXT( "\nType    : " );
 385       ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
 386       if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
 387          TXT( "\nLabel   : " );
 388          UID( inst->InstructionExtLabel.Label );
 389       }
 390       if( ignored ) {
 391          TXT( "\nPadding : " );
 392          UIX( inst->InstructionExtLabel.Padding );
 393          if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
 394             TXT( "\nExtended: " );
 395             UID( inst->InstructionExtLabel.Extended );
 396          }
 397       }
 398    }
 399
 400    if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
 401       EOL();
 402       TXT( "\nType    : " );
 403       ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
 404       if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
 405          TXT( "\nTexture : " );
 406          ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
 407       }
 408       if( ignored ) {
 409          TXT( "\nPadding : " );
 410          UIX( inst->InstructionExtTexture.Padding );
 411          if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
 412             TXT( "\nExtended: " );
 413             UID( inst->InstructionExtTexture.Extended );
 414          }
 415       }
 416    }
 417
 418    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
 419       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
 420       struct tgsi_full_dst_register *fd = &fi->FullDstRegisters[i];
 421
 422       EOL();
 423       TXT( "\nFile     : " );
 424       ENM( dst->DstRegister.File, TGSI_FILES );
 425       if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
 426          TXT( "\nWriteMask: " );
 427          ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
 428       }
 429       if( ignored ) {
 430          if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
 431             TXT( "\nIndirect : " );
 432             UID( dst->DstRegister.Indirect );
 433          }
 434          if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
 435             TXT( "\nDimension: " );
 436             UID( dst->DstRegister.Dimension );
 437          }
 438       }
 439       if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
 440          TXT( "\nIndex    : " );
 441          SID( dst->DstRegister.Index );
 442       }
 443       if( ignored ) {
 444          TXT( "\nPadding  : " );
 445          UIX( dst->DstRegister.Padding );
 446          if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
 447             TXT( "\nExtended : " );
 448             UID( dst->DstRegister.Extended );
 449          }
 450       }
 451
 452       if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
 453          EOL();
 454          TXT( "\nType        : " );
 455          ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
 456          if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
 457             TXT( "\nCondMask    : " );
 458             ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
 459          }
 460          if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
 461             TXT( "\nCondSwizzleX: " );
 462             ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
 463          }
 464          if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
 465             TXT( "\nCondSwizzleY: " );
 466             ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
 467          }
 468          if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
 469             TXT( "\nCondSwizzleZ: " );
 470             ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
 471          }
 472          if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
 473             TXT( "\nCondSwizzleW: " );
 474             ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
 475          }
 476          if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
 477             TXT( "\nCondSrcIndex: " );
 478             UID( dst->DstRegisterExtConcode.CondSrcIndex );
 479          }
 480          if( ignored ) {
 481             TXT( "\nPadding     : " );
 482             UIX( dst->DstRegisterExtConcode.Padding );
 483             if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
 484                TXT( "\nExtended    : " );
 485                UID( dst->DstRegisterExtConcode.Extended );
 486             }
 487          }
 488       }
 489
 490       if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
 491          EOL();
 492          TXT( "\nType    : " );
 493          ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
 494          if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
 495             TXT( "\nModulate: " );
 496             ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
 497          }
 498          if( ignored ) {
 499             TXT( "\nPadding : " );
 500             UIX( dst->DstRegisterExtModulate.Padding );
 501             if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
 502                TXT( "\nExtended: " );
 503                UID( dst->DstRegisterExtModulate.Extended );
 504             }
 505          }
 506       }
 507    }
 508
 509    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
 510       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
 511       struct tgsi_full_src_register *fs = &fi->FullSrcRegisters[i];
 512
 513       EOL();
 514       TXT( "\nFile     : ");
 515       ENM( src->SrcRegister.File, TGSI_FILES );
 516       if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
 517          TXT( "\nSwizzleX : " );
 518          ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
 519       }
 520       if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
 521          TXT( "\nSwizzleY : " );
 522          ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
 523       }
 524       if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
 525          TXT( "\nSwizzleZ : " );
 526          ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
 527       }
 528       if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
 529          TXT( "\nSwizzleW : " );
 530          ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
 531       }
 532       if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
 533          TXT( "\nNegate   : " );
 534          UID( src->SrcRegister.Negate );
 535       }
 536       if( ignored ) {
 537          if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
 538             TXT( "\nIndirect : " );
 539             UID( src->SrcRegister.Indirect );
 540          }
 541          if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
 542             TXT( "\nDimension: " );
 543             UID( src->SrcRegister.Dimension );
 544          }
 545       }
 546       if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
 547          TXT( "\nIndex    : " );
 548          SID( src->SrcRegister.Index );
 549       }
 550       if( ignored ) {
 551          if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
 552             TXT( "\nExtended : " );
 553             UID( src->SrcRegister.Extended );
 554          }
 555       }
 556
 557       if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
 558          EOL();
 559          TXT( "\nType       : " );
 560          ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
 561          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
 562             TXT( "\nExtSwizzleX: " );
 563             ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
 564          }
 565          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
 566             TXT( "\nExtSwizzleY: " );
 567             ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
 568          }
 569          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
 570             TXT( "\nExtSwizzleZ: " );
 571             ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
 572          }
 573          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
 574             TXT( "\nExtSwizzleW: " );
 575             ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
 576          }
 577          if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
 578             TXT( "\nNegateX   : " );
 579             UID( src->SrcRegisterExtSwz.NegateX );
 580          }
 581          if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
 582             TXT( "\nNegateY   : " );
 583             UID( src->SrcRegisterExtSwz.NegateY );
 584          }
 585          if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
 586             TXT( "\nNegateZ   : " );
 587             UID( src->SrcRegisterExtSwz.NegateZ );
 588          }
 589          if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
 590             TXT( "\nNegateW   : " );
 591             UID( src->SrcRegisterExtSwz.NegateW );
 592          }
 593          if( ignored ) {
 594             TXT( "\nPadding   : " );
 595             UIX( src->SrcRegisterExtSwz.Padding );
 596             if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
 597                TXT( "\nExtended   : " );
 598                UID( src->SrcRegisterExtSwz.Extended );
 599             }
 600          }
 601       }
 602
 603       if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
 604          EOL();
 605          TXT( "\nType     : " );
 606          ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
 607          if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
 608             TXT( "\nComplement: " );
 609             UID( src->SrcRegisterExtMod.Complement );
 610          }
 611          if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
 612             TXT( "\nBias     : " );
 613             UID( src->SrcRegisterExtMod.Bias );
 614          }
 615          if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
 616             TXT( "\nScale2X   : " );
 617             UID( src->SrcRegisterExtMod.Scale2X );
 618          }
 619          if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
 620             TXT( "\nAbsolute  : " );
 621             UID( src->SrcRegisterExtMod.Absolute );
 622          }
 623          if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
 624             TXT( "\nNegate   : " );
 625             UID( src->SrcRegisterExtMod.Negate );
 626          }
 627          if( ignored ) {
 628             TXT( "\nPadding   : " );
 629             UIX( src->SrcRegisterExtMod.Padding );
 630             if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
 631                TXT( "\nExtended  : " );
 632                UID( src->SrcRegisterExtMod.Extended );
 633             }
 634          }
 635       }
 636    }
 637 }
 638
 639 void
 640 tgsi_dump_c(
 641    const struct tgsi_token *tokens,
 642    uint flags )
 643 {
 644    struct tgsi_parse_context parse;
 645    struct tgsi_full_instruction fi;
 646    struct tgsi_full_declaration fd;
 647    uint ignored = flags & TGSI_DUMP_C_IGNORED;
 648    uint deflt = flags & TGSI_DUMP_C_DEFAULT;
 649
 650    tgsi_parse_init( &parse, tokens );
 651
 652    TXT( "tgsi-dump begin -----------------" );
 653
 654    TXT( "\nMajorVersion: " );
 655    UID( parse.FullVersion.Version.MajorVersion );
 656    TXT( "\nMinorVersion: " );
 657    UID( parse.FullVersion.Version.MinorVersion );
 658    EOL();
 659
 660    TXT( "\nHeaderSize: " );
 661    UID( parse.FullHeader.Header.HeaderSize );
 662    TXT( "\nBodySize  : " );
 663    UID( parse.FullHeader.Header.BodySize );
 664    TXT( "\nProcessor : " );
 665    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
 666    EOL();
 667
 668    fi = tgsi_default_full_instruction();
 669    fd = tgsi_default_full_declaration();
 670
 671    while( !tgsi_parse_end_of_tokens( &parse ) ) {
 672       tgsi_parse_token( &parse );
 673
 674       TXT( "\nType       : " );
 675       ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
 676       if( ignored ) {
 677          TXT( "\nSize       : " );
 678          UID( parse.FullToken.Token.NrTokens );
 679          if( deflt || parse.FullToken.Token.Extended ) {
 680             TXT( "\nExtended   : " );
 681             UID( parse.FullToken.Token.Extended );
 682          }
 683       }
 684
 685       switch( parse.FullToken.Token.Type ) {
 686       case TGSI_TOKEN_TYPE_DECLARATION:
 687          dump_declaration_verbose(
 688             &parse.FullToken.FullDeclaration,
 689             ignored,
 690             deflt,
 691             &fd );
 692          break;
 693
 694       case TGSI_TOKEN_TYPE_IMMEDIATE:
 695          dump_immediate_verbose(
 696             &parse.FullToken.FullImmediate,
 697             ignored );
 698          break;
 699
 700       case TGSI_TOKEN_TYPE_INSTRUCTION:
 701          dump_instruction_verbose(
 702             &parse.FullToken.FullInstruction,
 703             ignored,
 704             deflt,
 705             &fi );
 706          break;
 707
 708       default:
 709          assert( 0 );
 710       }
 711
 712       EOL();
 713    }
 714
 715    TXT( "\ntgsi-dump end -------------------\n" );
 716
 717    tgsi_parse_free( &parse );
 718 }