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_parse.h"
  33 #include "tgsi_build.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_OPCODES[TGSI_OPCODE_LAST] =
 108 {
 109    "OPCODE_ARL",
 110    "OPCODE_MOV",
 111    "OPCODE_LIT",
 112    "OPCODE_RCP",
 113    "OPCODE_RSQ",
 114    "OPCODE_EXP",
 115    "OPCODE_LOG",
 116    "OPCODE_MUL",
 117    "OPCODE_ADD",
 118    "OPCODE_DP3",
 119    "OPCODE_DP4",
 120    "OPCODE_DST",
 121    "OPCODE_MIN",
 122    "OPCODE_MAX",
 123    "OPCODE_SLT",
 124    "OPCODE_SGE",
 125    "OPCODE_MAD",
 126    "OPCODE_SUB",
 127    "OPCODE_LERP",
 128    "OPCODE_CND",
 129    "OPCODE_CND0",
 130    "OPCODE_DOT2ADD",
 131    "OPCODE_INDEX",
 132    "OPCODE_NEGATE",
 133    "OPCODE_FRAC",
 134    "OPCODE_CLAMP",
 135    "OPCODE_FLOOR",
 136    "OPCODE_ROUND",
 137    "OPCODE_EXPBASE2",
 138    "OPCODE_LOGBASE2",
 139    "OPCODE_POWER",
 140    "OPCODE_CROSSPRODUCT",
 141    "OPCODE_MULTIPLYMATRIX",
 142    "OPCODE_ABS",
 143    "OPCODE_RCC",
 144    "OPCODE_DPH",
 145    "OPCODE_COS",
 146    "OPCODE_DDX",
 147    "OPCODE_DDY",
 148    "OPCODE_KILP",
 149    "OPCODE_PK2H",
 150    "OPCODE_PK2US",
 151    "OPCODE_PK4B",
 152    "OPCODE_PK4UB",
 153    "OPCODE_RFL",
 154    "OPCODE_SEQ",
 155    "OPCODE_SFL",
 156    "OPCODE_SGT",
 157    "OPCODE_SIN",
 158    "OPCODE_SLE",
 159    "OPCODE_SNE",
 160    "OPCODE_STR",
 161    "OPCODE_TEX",
 162    "OPCODE_TXD",
 163    "OPCODE_TXP",
 164    "OPCODE_UP2H",
 165    "OPCODE_UP2US",
 166    "OPCODE_UP4B",
 167    "OPCODE_UP4UB",
 168    "OPCODE_X2D",
 169    "OPCODE_ARA",
 170    "OPCODE_ARR",
 171    "OPCODE_BRA",
 172    "OPCODE_CAL",
 173    "OPCODE_RET",
 174    "OPCODE_SSG",
 175    "OPCODE_CMP",
 176    "OPCODE_SCS",
 177    "OPCODE_TXB",
 178    "OPCODE_NRM",
 179    "OPCODE_DIV",
 180    "OPCODE_DP2",
 181    "OPCODE_TXL",
 182    "OPCODE_BRK",
 183    "OPCODE_IF",
 184    "OPCODE_LOOP",
 185    "OPCODE_REP",
 186    "OPCODE_ELSE",
 187    "OPCODE_ENDIF",
 188    "OPCODE_ENDLOOP",
 189    "OPCODE_ENDREP",
 190    "OPCODE_PUSHA",
 191    "OPCODE_POPA",
 192    "OPCODE_CEIL",
 193    "OPCODE_I2F",
 194    "OPCODE_NOT",
 195    "OPCODE_TRUNC",
 196    "OPCODE_SHL",
 197    "OPCODE_SHR",
 198    "OPCODE_AND",
 199    "OPCODE_OR",
 200    "OPCODE_MOD",
 201    "OPCODE_XOR",
 202    "OPCODE_SAD",
 203    "OPCODE_TXF",
 204    "OPCODE_TXQ",
 205    "OPCODE_CONT",
 206    "OPCODE_EMIT",
 207    "OPCODE_ENDPRIM",
 208    "OPCODE_BGNLOOP2",
 209    "OPCODE_BGNSUB",
 210    "OPCODE_ENDLOOP2",
 211    "OPCODE_ENDSUB",
 212    "OPCODE_NOISE1",
 213    "OPCODE_NOISE2",
 214    "OPCODE_NOISE3",
 215    "OPCODE_NOISE4",
 216    "OPCODE_NOP",
 217    "OPCODE_M4X3",
 218    "OPCODE_M3X4",
 219    "OPCODE_M3X3",
 220    "OPCODE_M3X2",
 221    "OPCODE_NRM4",
 222    "OPCODE_CALLNZ",
 223    "OPCODE_IFC",
 224    "OPCODE_BREAKC",
 225    "OPCODE_KIL",
 226    "OPCODE_END"
 227 };
 228
 229 static const char *TGSI_SATS[] =
 230 {
 231    "SAT_NONE",
 232    "SAT_ZERO_ONE",
 233    "SAT_MINUS_PLUS_ONE"
 234 };
 235
 236 static const char *TGSI_INSTRUCTION_EXTS[] =
 237 {
 238    "INSTRUCTION_EXT_TYPE_NV",
 239    "INSTRUCTION_EXT_TYPE_LABEL",
 240    "INSTRUCTION_EXT_TYPE_TEXTURE"
 241 };
 242
 243 static const char *TGSI_PRECISIONS[] =
 244 {
 245    "PRECISION_DEFAULT",
 246    "PRECISION_FLOAT32",
 247    "PRECISION_FLOAT16",
 248    "PRECISION_FIXED12"
 249 };
 250
 251 static const char *TGSI_CCS[] =
 252 {
 253    "CC_GT",
 254    "CC_EQ",
 255    "CC_LT",
 256    "CC_UN",
 257    "CC_GE",
 258    "CC_LE",
 259    "CC_NE",
 260    "CC_TR",
 261    "CC_FL"
 262 };
 263
 264 static const char *TGSI_SWIZZLES[] =
 265 {
 266    "SWIZZLE_X",
 267    "SWIZZLE_Y",
 268    "SWIZZLE_Z",
 269    "SWIZZLE_W"
 270 };
 271
 272 static const char *TGSI_TEXTURES[] =
 273 {
 274    "TEXTURE_UNKNOWN",
 275    "TEXTURE_1D",
 276    "TEXTURE_2D",
 277    "TEXTURE_3D",
 278    "TEXTURE_CUBE",
 279    "TEXTURE_RECT",
 280    "TEXTURE_SHADOW1D",
 281    "TEXTURE_SHADOW2D",
 282    "TEXTURE_SHADOWRECT"
 283 };
 284
 285 static const char *TGSI_SRC_REGISTER_EXTS[] =
 286 {
 287    "SRC_REGISTER_EXT_TYPE_SWZ",
 288    "SRC_REGISTER_EXT_TYPE_MOD"
 289 };
 290
 291 static const char *TGSI_EXTSWIZZLES[] =
 292 {
 293    "EXTSWIZZLE_X",
 294    "EXTSWIZZLE_Y",
 295    "EXTSWIZZLE_Z",
 296    "EXTSWIZZLE_W",
 297    "EXTSWIZZLE_ZERO",
 298    "EXTSWIZZLE_ONE"
 299 };
 300
 301 static const char *TGSI_WRITEMASKS[] =
 302 {
 303    "0",
 304    "WRITEMASK_X",
 305    "WRITEMASK_Y",
 306    "WRITEMASK_XY",
 307    "WRITEMASK_Z",
 308    "WRITEMASK_XZ",
 309    "WRITEMASK_YZ",
 310    "WRITEMASK_XYZ",
 311    "WRITEMASK_W",
 312    "WRITEMASK_XW",
 313    "WRITEMASK_YW",
 314    "WRITEMASK_XYW",
 315    "WRITEMASK_ZW",
 316    "WRITEMASK_XZW",
 317    "WRITEMASK_YZW",
 318    "WRITEMASK_XYZW"
 319 };
 320
 321 static const char *TGSI_DST_REGISTER_EXTS[] =
 322 {
 323    "DST_REGISTER_EXT_TYPE_CONDCODE",
 324    "DST_REGISTER_EXT_TYPE_MODULATE"
 325 };
 326
 327 static const char *TGSI_MODULATES[] =
 328 {
 329    "MODULATE_1X",
 330    "MODULATE_2X",
 331    "MODULATE_4X",
 332    "MODULATE_8X",
 333    "MODULATE_HALF",
 334    "MODULATE_QUARTER",
 335    "MODULATE_EIGHTH"
 336 };
 337
 338 static void
 339 dump_declaration_verbose(
 340    struct tgsi_full_declaration  *decl,
 341    unsigned                      ignored,
 342    unsigned                      deflt,
 343    struct tgsi_full_declaration  *fd )
 344 {
 345    TXT( "\nFile       : " );
 346    ENM( decl->Declaration.File, TGSI_FILES );
 347    if( deflt || fd->Declaration.UsageMask != decl->Declaration.UsageMask ) {
 348       TXT( "\nUsageMask  : " );
 349       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_X ) {
 350          CHR( 'X' );
 351       }
 352       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Y ) {
 353          CHR( 'Y' );
 354       }
 355       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Z ) {
 356          CHR( 'Z' );
 357       }
 358       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_W ) {
 359          CHR( 'W' );
 360       }
 361    }
 362    if( deflt || fd->Declaration.Interpolate != decl->Declaration.Interpolate ) {
 363       TXT( "\nInterpolate: " );
 364       ENM( decl->Declaration.Interpolate, TGSI_INTERPOLATES );
 365    }
 366    if( deflt || fd->Declaration.Semantic != decl->Declaration.Semantic ) {
 367       TXT( "\nSemantic   : " );
 368       UID( decl->Declaration.Semantic );
 369    }
 370    if( ignored ) {
 371       TXT( "\nPadding    : " );
 372       UIX( decl->Declaration.Padding );
 373    }
 374
 375    EOL();
 376    TXT( "\nFirst: " );
 377    UID( decl->DeclarationRange.First );
 378    TXT( "\nLast : " );
 379    UID( decl->DeclarationRange.Last );
 380
 381    if( decl->Declaration.Semantic ) {
 382       EOL();
 383       TXT( "\nSemanticName : " );
 384       ENM( decl->Semantic.SemanticName, TGSI_SEMANTICS );
 385       TXT( "\nSemanticIndex: " );
 386       UID( decl->Semantic.SemanticIndex );
 387       if( ignored ) {
 388          TXT( "\nPadding      : " );
 389          UIX( decl->Semantic.Padding );
 390       }
 391    }
 392 }
 393
 394 static void
 395 dump_immediate_verbose(
 396    struct tgsi_full_immediate *imm,
 397    unsigned                   ignored )
 398 {
 399    unsigned i;
 400
 401    TXT( "\nDataType   : " );
 402    ENM( imm->Immediate.DataType, TGSI_IMMS );
 403    if( ignored ) {
 404       TXT( "\nPadding    : " );
 405       UIX( imm->Immediate.Padding );
 406    }
 407
 408    for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
 409       EOL();
 410       switch( imm->Immediate.DataType ) {
 411       case TGSI_IMM_FLOAT32:
 412          TXT( "\nFloat: " );
 413          FLT( imm->u.ImmediateFloat32[i].Float );
 414          break;
 415
 416       default:
 417          assert( 0 );
 418       }
 419    }
 420 }
 421
 422 static void
 423 dump_instruction_verbose(
 424    struct tgsi_full_instruction  *inst,
 425    unsigned                      ignored,
 426    unsigned                      deflt,
 427    struct tgsi_full_instruction  *fi )
 428 {
 429    unsigned i;
 430
 431    TXT( "\nOpcode     : " );
 432    ENM( inst->Instruction.Opcode, TGSI_OPCODES );
 433    if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
 434       TXT( "\nSaturate   : " );
 435       ENM( inst->Instruction.Saturate, TGSI_SATS );
 436    }
 437    if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
 438       TXT( "\nNumDstRegs : " );
 439       UID( inst->Instruction.NumDstRegs );
 440    }
 441    if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
 442       TXT( "\nNumSrcRegs : " );
 443       UID( inst->Instruction.NumSrcRegs );
 444    }
 445    if( ignored ) {
 446       TXT( "\nPadding    : " );
 447       UIX( inst->Instruction.Padding );
 448    }
 449
 450    if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi->InstructionExtNv ) ) {
 451       EOL();
 452       TXT( "\nType          : " );
 453       ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
 454       if( deflt || fi->InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
 455          TXT( "\nPrecision     : " );
 456          ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
 457       }
 458       if( deflt || fi->InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
 459          TXT( "\nCondDstIndex  : " );
 460          UID( inst->InstructionExtNv.CondDstIndex );
 461       }
 462       if( deflt || fi->InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
 463          TXT( "\nCondFlowIndex : " );
 464          UID( inst->InstructionExtNv.CondFlowIndex );
 465       }
 466       if( deflt || fi->InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
 467          TXT( "\nCondMask      : " );
 468          ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
 469       }
 470       if( deflt || fi->InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
 471          TXT( "\nCondSwizzleX  : " );
 472          ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
 473       }
 474       if( deflt || fi->InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
 475          TXT( "\nCondSwizzleY  : " );
 476          ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
 477       }
 478       if( deflt || fi->InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
 479          TXT( "\nCondSwizzleZ  : " );
 480          ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
 481       }
 482       if( deflt || fi->InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
 483          TXT( "\nCondSwizzleW  : " );
 484          ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
 485       }
 486       if( deflt || fi->InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
 487          TXT( "\nCondDstUpdate : " );
 488          UID( inst->InstructionExtNv.CondDstUpdate );
 489       }
 490       if( deflt || fi->InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
 491          TXT( "\nCondFlowEnable: " );
 492          UID( inst->InstructionExtNv.CondFlowEnable );
 493       }
 494       if( ignored ) {
 495          TXT( "\nPadding       : " );
 496          UIX( inst->InstructionExtNv.Padding );
 497          if( deflt || fi->InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
 498             TXT( "\nExtended      : " );
 499             UID( inst->InstructionExtNv.Extended );
 500          }
 501       }
 502    }
 503
 504    if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
 505       EOL();
 506       TXT( "\nType    : " );
 507       ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
 508       if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
 509          TXT( "\nLabel   : " );
 510          UID( inst->InstructionExtLabel.Label );
 511       }
 512       if( ignored ) {
 513          TXT( "\nPadding : " );
 514          UIX( inst->InstructionExtLabel.Padding );
 515          if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
 516             TXT( "\nExtended: " );
 517             UID( inst->InstructionExtLabel.Extended );
 518          }
 519       }
 520    }
 521
 522    if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
 523       EOL();
 524       TXT( "\nType    : " );
 525       ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
 526       if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
 527          TXT( "\nTexture : " );
 528          ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
 529       }
 530       if( ignored ) {
 531          TXT( "\nPadding : " );
 532          UIX( inst->InstructionExtTexture.Padding );
 533          if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
 534             TXT( "\nExtended: " );
 535             UID( inst->InstructionExtTexture.Extended );
 536          }
 537       }
 538    }
 539
 540    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
 541       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
 542       struct tgsi_full_dst_register *fd = &fi->FullDstRegisters[i];
 543
 544       EOL();
 545       TXT( "\nFile     : " );
 546       ENM( dst->DstRegister.File, TGSI_FILES );
 547       if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
 548          TXT( "\nWriteMask: " );
 549          ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
 550       }
 551       if( ignored ) {
 552          if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
 553             TXT( "\nIndirect : " );
 554             UID( dst->DstRegister.Indirect );
 555          }
 556          if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
 557             TXT( "\nDimension: " );
 558             UID( dst->DstRegister.Dimension );
 559          }
 560       }
 561       if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
 562          TXT( "\nIndex    : " );
 563          SID( dst->DstRegister.Index );
 564       }
 565       if( ignored ) {
 566          TXT( "\nPadding  : " );
 567          UIX( dst->DstRegister.Padding );
 568          if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
 569             TXT( "\nExtended : " );
 570             UID( dst->DstRegister.Extended );
 571          }
 572       }
 573
 574       if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
 575          EOL();
 576          TXT( "\nType        : " );
 577          ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
 578          if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
 579             TXT( "\nCondMask    : " );
 580             ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
 581          }
 582          if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
 583             TXT( "\nCondSwizzleX: " );
 584             ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
 585          }
 586          if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
 587             TXT( "\nCondSwizzleY: " );
 588             ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
 589          }
 590          if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
 591             TXT( "\nCondSwizzleZ: " );
 592             ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
 593          }
 594          if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
 595             TXT( "\nCondSwizzleW: " );
 596             ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
 597          }
 598          if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
 599             TXT( "\nCondSrcIndex: " );
 600             UID( dst->DstRegisterExtConcode.CondSrcIndex );
 601          }
 602          if( ignored ) {
 603             TXT( "\nPadding     : " );
 604             UIX( dst->DstRegisterExtConcode.Padding );
 605             if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
 606                TXT( "\nExtended    : " );
 607                UID( dst->DstRegisterExtConcode.Extended );
 608             }
 609          }
 610       }
 611
 612       if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
 613          EOL();
 614          TXT( "\nType    : " );
 615          ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
 616          if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
 617             TXT( "\nModulate: " );
 618             ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
 619          }
 620          if( ignored ) {
 621             TXT( "\nPadding : " );
 622             UIX( dst->DstRegisterExtModulate.Padding );
 623             if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
 624                TXT( "\nExtended: " );
 625                UID( dst->DstRegisterExtModulate.Extended );
 626             }
 627          }
 628       }
 629    }
 630
 631    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
 632       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
 633       struct tgsi_full_src_register *fs = &fi->FullSrcRegisters[i];
 634
 635       EOL();
 636       TXT( "\nFile     : ");
 637       ENM( src->SrcRegister.File, TGSI_FILES );
 638       if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
 639          TXT( "\nSwizzleX : " );
 640          ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
 641       }
 642       if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
 643          TXT( "\nSwizzleY : " );
 644          ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
 645       }
 646       if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
 647          TXT( "\nSwizzleZ : " );
 648          ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
 649       }
 650       if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
 651          TXT( "\nSwizzleW : " );
 652          ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
 653       }
 654       if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
 655          TXT( "\nNegate   : " );
 656          UID( src->SrcRegister.Negate );
 657       }
 658       if( ignored ) {
 659          if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
 660             TXT( "\nIndirect : " );
 661             UID( src->SrcRegister.Indirect );
 662          }
 663          if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
 664             TXT( "\nDimension: " );
 665             UID( src->SrcRegister.Dimension );
 666          }
 667       }
 668       if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
 669          TXT( "\nIndex    : " );
 670          SID( src->SrcRegister.Index );
 671       }
 672       if( ignored ) {
 673          if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
 674             TXT( "\nExtended : " );
 675             UID( src->SrcRegister.Extended );
 676          }
 677       }
 678
 679       if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
 680          EOL();
 681          TXT( "\nType       : " );
 682          ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
 683          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
 684             TXT( "\nExtSwizzleX: " );
 685             ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
 686          }
 687          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
 688             TXT( "\nExtSwizzleY: " );
 689             ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
 690          }
 691          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
 692             TXT( "\nExtSwizzleZ: " );
 693             ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
 694          }
 695          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
 696             TXT( "\nExtSwizzleW: " );
 697             ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
 698          }
 699          if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
 700             TXT( "\nNegateX   : " );
 701             UID( src->SrcRegisterExtSwz.NegateX );
 702          }
 703          if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
 704             TXT( "\nNegateY   : " );
 705             UID( src->SrcRegisterExtSwz.NegateY );
 706          }
 707          if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
 708             TXT( "\nNegateZ   : " );
 709             UID( src->SrcRegisterExtSwz.NegateZ );
 710          }
 711          if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
 712             TXT( "\nNegateW   : " );
 713             UID( src->SrcRegisterExtSwz.NegateW );
 714          }
 715          if( ignored ) {
 716             TXT( "\nPadding   : " );
 717             UIX( src->SrcRegisterExtSwz.Padding );
 718             if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
 719                TXT( "\nExtended   : " );
 720                UID( src->SrcRegisterExtSwz.Extended );
 721             }
 722          }
 723       }
 724
 725       if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
 726          EOL();
 727          TXT( "\nType     : " );
 728          ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
 729          if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
 730             TXT( "\nComplement: " );
 731             UID( src->SrcRegisterExtMod.Complement );
 732          }
 733          if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
 734             TXT( "\nBias     : " );
 735             UID( src->SrcRegisterExtMod.Bias );
 736          }
 737          if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
 738             TXT( "\nScale2X   : " );
 739             UID( src->SrcRegisterExtMod.Scale2X );
 740          }
 741          if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
 742             TXT( "\nAbsolute  : " );
 743             UID( src->SrcRegisterExtMod.Absolute );
 744          }
 745          if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
 746             TXT( "\nNegate   : " );
 747             UID( src->SrcRegisterExtMod.Negate );
 748          }
 749          if( ignored ) {
 750             TXT( "\nPadding   : " );
 751             UIX( src->SrcRegisterExtMod.Padding );
 752             if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
 753                TXT( "\nExtended  : " );
 754                UID( src->SrcRegisterExtMod.Extended );
 755             }
 756          }
 757       }
 758    }
 759 }
 760
 761 void
 762 tgsi_dump_c(
 763    const struct tgsi_token *tokens,
 764    uint flags )
 765 {
 766    struct tgsi_parse_context parse;
 767    struct tgsi_full_instruction fi;
 768    struct tgsi_full_declaration fd;
 769    uint ignored = flags & TGSI_DUMP_C_IGNORED;
 770    uint deflt = flags & TGSI_DUMP_C_DEFAULT;
 771    uint instno = 0;
 772
 773    /* sanity checks */
 774    assert(strcmp(TGSI_OPCODES[TGSI_OPCODE_CONT], "OPCODE_CONT") == 0);
 775    assert(strcmp(TGSI_OPCODES[TGSI_OPCODE_END], "OPCODE_END") == 0);
 776
 777    tgsi_parse_init( &parse, tokens );
 778
 779    TXT( "tgsi-dump begin -----------------" );
 780
 781    TXT( "\nMajorVersion: " );
 782    UID( parse.FullVersion.Version.MajorVersion );
 783    TXT( "\nMinorVersion: " );
 784    UID( parse.FullVersion.Version.MinorVersion );
 785    EOL();
 786
 787    TXT( "\nHeaderSize: " );
 788    UID( parse.FullHeader.Header.HeaderSize );
 789    TXT( "\nBodySize  : " );
 790    UID( parse.FullHeader.Header.BodySize );
 791    TXT( "\nProcessor : " );
 792    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
 793    EOL();
 794
 795    fi = tgsi_default_full_instruction();
 796    fd = tgsi_default_full_declaration();
 797
 798    while( !tgsi_parse_end_of_tokens( &parse ) ) {
 799       tgsi_parse_token( &parse );
 800
 801       TXT( "\nType       : " );
 802       ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
 803       if( ignored ) {
 804          TXT( "\nSize       : " );
 805          UID( parse.FullToken.Token.Size );
 806          if( deflt || parse.FullToken.Token.Extended ) {
 807             TXT( "\nExtended   : " );
 808             UID( parse.FullToken.Token.Extended );
 809          }
 810       }
 811
 812       switch( parse.FullToken.Token.Type ) {
 813       case TGSI_TOKEN_TYPE_DECLARATION:
 814          dump_declaration_verbose(
 815             &parse.FullToken.FullDeclaration,
 816             ignored,
 817             deflt,
 818             &fd );
 819          break;
 820
 821       case TGSI_TOKEN_TYPE_IMMEDIATE:
 822          dump_immediate_verbose(
 823             &parse.FullToken.FullImmediate,
 824             ignored );
 825          break;
 826
 827       case TGSI_TOKEN_TYPE_INSTRUCTION:
 828          dump_instruction_verbose(
 829             &parse.FullToken.FullInstruction,
 830             ignored,
 831             deflt,
 832             &fi );
 833          break;
 834
 835       default:
 836          assert( 0 );
 837       }
 838
 839       EOL();
 840    }
 841
 842    TXT( "\ntgsi-dump end -------------------\n" );
 843
 844    tgsi_parse_free( &parse );
 845 }