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