src/mesa/pipe/tgsi/exec/tgsi_dump.c

   1 #include "tgsi_platform.h"
   2 #include "tgsi_core.h"
   3
   4 struct text_dump
   5 {
   6    FILE     *file;
   7    unsigned tabs;
   8 };
   9
  10 static void
  11 text_dump_write(
  12    struct text_dump *dump,
  13    const void *buffer,
  14    unsigned size )
  15 {
  16    fwrite( buffer, size, 1, dump->file );
  17 }
  18
  19 static void
  20 text_dump_str(
  21    struct text_dump *dump,
  22    const char *str )
  23 {
  24    unsigned i;
  25    size_t len = strlen( str );
  26
  27    for( i = 0; i < len; i++ ) {
  28       text_dump_write( dump, &str[i], 1 );
  29
  30       if( str[i] == '\n' ) {
  31          unsigned i;
  32
  33          for( i = 0; i < dump->tabs; i++ ) {
  34             text_dump_write( dump, "    ", 4 );
  35          }
  36       }
  37    }
  38 }
  39
  40 static void
  41 text_dump_chr(
  42    struct text_dump *dump,
  43    const char chr )
  44 {
  45    char str[2];
  46
  47    str[0] = chr;
  48    str[1] = '\0';
  49    text_dump_str( dump, str );
  50 }
  51
  52 static void
  53 text_dump_uix(
  54    struct text_dump *dump,
  55    const unsigned ui )
  56 {
  57    char str[36];
  58
  59    sprintf( str, "0x%x", ui );
  60    text_dump_str( dump, str );
  61 }
  62
  63 static void
  64 text_dump_uid(
  65    struct text_dump *dump,
  66    const unsigned ui )
  67 {
  68    char str[16];
  69
  70    sprintf( str, "%u", ui );
  71    text_dump_str( dump, str );
  72 }
  73
  74 static void
  75 text_dump_sid(
  76    struct text_dump *dump,
  77    const int si )
  78 {
  79    char str[16];
  80
  81    sprintf( str, "%d", si );
  82    text_dump_str( dump, str );
  83 }
  84
  85 static void
  86 text_dump_flt(
  87    struct text_dump *dump,
  88    const float f )
  89 {
  90    char str[48];
  91
  92    sprintf( str, "%40.6f", f );
  93    text_dump_str( dump, str );
  94 }
  95
  96 static void
  97 text_dump_enum(
  98    struct text_dump *dump,
  99    const unsigned e,
 100    const char **enums,
 101    const unsigned enums_count )
 102 {
 103    if( e >= enums_count ) {
 104       text_dump_uid( dump, e );
 105    }
 106    else {
 107       text_dump_str( dump, enums[e] );
 108    }
 109 }
 110
 111 static void
 112 text_dump_tab(
 113    struct text_dump *dump )
 114 {
 115    dump->tabs++;
 116 }
 117
 118 static void
 119 text_dump_untab(
 120    struct text_dump *dump )
 121 {
 122    assert( dump->tabs > 0 );
 123
 124    --dump->tabs;
 125 }
 126
 127 #define TXT(S)          text_dump_str( dump, S )
 128 #define CHR(C)          text_dump_chr( dump, C )
 129 #define UIX(I)          text_dump_uix( dump, I )
 130 #define UID(I)          text_dump_uid( dump, I )
 131 #define SID(I)          text_dump_sid( dump, I )
 132 #define FLT(F)          text_dump_flt( dump, F )
 133 #define TAB()           text_dump_tab( dump )
 134 #define UNT()           text_dump_untab( dump )
 135 #define ENM(E,ENUMS)    text_dump_enum( dump, E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
 136
 137 static const char *TGSI_PROCESSOR_TYPES[] =
 138 {
 139    "PROCESSOR_FRAGMENT",
 140    "PROCESSOR_VERTEX",
 141    "PROCESSOR_GEOMETRY"
 142 };
 143
 144 static const char *TGSI_PROCESSOR_TYPES_SHORT[] =
 145 {
 146    "FRAG",
 147    "VERT",
 148    "GEOM"
 149 };
 150
 151 static const char *TGSI_TOKEN_TYPES[] =
 152 {
 153    "TOKEN_TYPE_DECLARATION",
 154    "TOKEN_TYPE_IMMEDIATE",
 155    "TOKEN_TYPE_INSTRUCTION"
 156 };
 157
 158 static const char *TGSI_FILES[] =
 159 {
 160    "FILE_NULL",
 161    "FILE_CONSTANT",
 162    "FILE_INPUT",
 163    "FILE_OUTPUT",
 164    "FILE_TEMPORARY",
 165    "FILE_SAMPLER",
 166    "FILE_ADDRESS",
 167    "FILE_IMMEDIATE"
 168 };
 169
 170 static const char *TGSI_FILES_SHORT[] =
 171 {
 172    "NULL",
 173    "CONST",
 174    "IN",
 175    "OUT",
 176    "TEMP",
 177    "SAMP",
 178    "ADDR",
 179    "IMM"
 180 };
 181
 182 static const char *TGSI_DECLARES[] =
 183 {
 184    "DECLARE_RANGE",
 185    "DECLARE_MASK"
 186 };
 187
 188 static const char *TGSI_INTERPOLATES[] =
 189 {
 190    "INTERPOLATE_CONSTANT",
 191    "INTERPOLATE_LINEAR",
 192    "INTERPOLATE_PERSPECTIVE"
 193 };
 194
 195 static const char *TGSI_INTERPOLATES_SHORT[] =
 196 {
 197    "CONSTANT",
 198    "LINEAR",
 199    "PERSPECTIVE"
 200 };
 201
 202 static const char *TGSI_SEMANTICS[] =
 203 {
 204    "SEMANTIC_POSITION",
 205    "SEMANTIC_COLOR",
 206    "SEMANTIC_BCOLOR",
 207    "SEMANTIC_FOG",
 208    "SEMANTIC_GENERIC,"
 209 };
 210
 211 static const char *TGSI_SEMANTICS_SHORT[] =
 212 {
 213    "POSITION",
 214    "COLOR",
 215    "BCOLOR",
 216    "FOG",
 217    "GENERIC",
 218 };
 219
 220 static const char *TGSI_IMMS[] =
 221 {
 222    "IMM_FLOAT32"
 223 };
 224
 225 static const char *TGSI_IMMS_SHORT[] =
 226 {
 227    "FLT32"
 228 };
 229
 230 static const char *TGSI_OPCODES[] =
 231 {
 232    "OPCODE_ARL",
 233    "OPCODE_MOV",
 234    "OPCODE_LIT",
 235    "OPCODE_RCP",
 236    "OPCODE_RSQ",
 237    "OPCODE_EXP",
 238    "OPCODE_LOG",
 239    "OPCODE_MUL",
 240    "OPCODE_ADD",
 241    "OPCODE_DP3",
 242    "OPCODE_DP4",
 243    "OPCODE_DST",
 244    "OPCODE_MIN",
 245    "OPCODE_MAX",
 246    "OPCODE_SLT",
 247    "OPCODE_SGE",
 248    "OPCODE_MAD",
 249    "OPCODE_SUB",
 250    "OPCODE_LERP",
 251    "OPCODE_CND",
 252    "OPCODE_CND0",
 253    "OPCODE_DOT2ADD",
 254    "OPCODE_INDEX",
 255    "OPCODE_NEGATE",
 256    "OPCODE_FRAC",
 257    "OPCODE_CLAMP",
 258    "OPCODE_FLOOR",
 259    "OPCODE_ROUND",
 260    "OPCODE_EXPBASE2",
 261    "OPCODE_LOGBASE2",
 262    "OPCODE_POWER",
 263    "OPCODE_CROSSPRODUCT",
 264    "OPCODE_MULTIPLYMATRIX",
 265    "OPCODE_ABS",
 266    "OPCODE_RCC",
 267    "OPCODE_DPH",
 268    "OPCODE_COS",
 269    "OPCODE_DDX",
 270    "OPCODE_DDY",
 271    "OPCODE_KIL",
 272    "OPCODE_PK2H",
 273    "OPCODE_PK2US",
 274    "OPCODE_PK4B",
 275    "OPCODE_PK4UB",
 276    "OPCODE_RFL",
 277    "OPCODE_SEQ",
 278    "OPCODE_SFL",
 279    "OPCODE_SGT",
 280    "OPCODE_SIN",
 281    "OPCODE_SLE",
 282    "OPCODE_SNE",
 283    "OPCODE_STR",
 284    "OPCODE_TEX",
 285    "OPCODE_TXD",
 286    "OPCODE_UP2H",
 287    "OPCODE_UP2US",
 288    "OPCODE_UP4B",
 289    "OPCODE_UP4UB",
 290    "OPCODE_X2D",
 291    "OPCODE_ARA",
 292    "OPCODE_ARR",
 293    "OPCODE_BRA",
 294    "OPCODE_CAL",
 295    "OPCODE_RET",
 296    "OPCODE_SSG",
 297    "OPCODE_CMP",
 298    "OPCODE_SCS",
 299    "OPCODE_TXB",
 300    "OPCODE_NRM",
 301    "OPCODE_DIV",
 302    "OPCODE_DP2",
 303    "OPCODE_TXL",
 304    "OPCODE_BRK",
 305    "OPCODE_IF",
 306    "OPCODE_LOOP",
 307    "OPCODE_REP",
 308    "OPCODE_ELSE",
 309    "OPCODE_ENDIF",
 310    "OPCODE_ENDLOOP",
 311    "OPCODE_ENDREP",
 312    "OPCODE_PUSHA",
 313    "OPCODE_POPA",
 314    "OPCODE_CEIL",
 315    "OPCODE_I2F",
 316    "OPCODE_NOT",
 317    "OPCODE_TRUNC",
 318    "OPCODE_SHL",
 319    "OPCODE_SHR",
 320    "OPCODE_AND",
 321    "OPCODE_OR",
 322    "OPCODE_MOD",
 323    "OPCODE_XOR",
 324    "OPCODE_SAD",
 325    "OPCODE_TXF",
 326    "OPCODE_TXQ",
 327    "OPCODE_CONT",
 328    "OPCODE_EMIT",
 329    "OPCODE_ENDPRIM",
 330    "OPCODE_BGNLOOP2",
 331    "OPCODE_BGNSUB",
 332    "OPCODE_ENDLOOP2",
 333    "OPCODE_ENDSUB",
 334    "OPCODE_NOISE1",
 335    "OPCODE_NOISE2",
 336    "OPCODE_NOISE3",
 337    "OPCODE_NOISE4",
 338    "OPCODE_NOP",
 339    "OPCODE_TEXBEM",
 340    "OPCODE_TEXBEML",
 341    "OPCODE_TEXREG2AR",
 342    "OPCODE_TEXM3X2PAD",
 343    "OPCODE_TEXM3X2TEX",
 344    "OPCODE_TEXM3X3PAD",
 345    "OPCODE_TEXM3X3TEX",
 346    "OPCODE_TEXM3X3SPEC",
 347    "OPCODE_TEXM3X3VSPEC",
 348    "OPCODE_TEXREG2GB",
 349    "OPCODE_TEXREG2RGB",
 350    "OPCODE_TEXDP3TEX",
 351    "OPCODE_TEXDP3",
 352    "OPCODE_TEXM3X3",
 353    "OPCODE_TEXM3X2DEPTH",
 354    "OPCODE_TEXDEPTH",
 355    "OPCODE_BEM",
 356    "OPCODE_M4X3",
 357    "OPCODE_M3X4",
 358    "OPCODE_M3X3",
 359    "OPCODE_M3X2",
 360    "OPCODE_NRM4",
 361    "OPCODE_CALLNZ",
 362    "OPCODE_IFC",
 363    "OPCODE_BREAKC",
 364    "OPCODE_TXP"
 365 };
 366
 367 static const char *TGSI_OPCODES_SHORT[] =
 368 {
 369    "ARL",
 370    "MOV",
 371    "LIT",
 372    "RCP",
 373    "RSQ",
 374    "EXP",
 375    "LOG",
 376    "MUL",
 377    "ADD",
 378    "DP3",
 379    "DP4",
 380    "DST",
 381    "MIN",
 382    "MAX",
 383    "SLT",
 384    "SGE",
 385    "MAD",
 386    "SUB",
 387    "LERP",
 388    "CND",
 389    "CND0",
 390    "DOT2ADD",
 391    "INDEX",
 392    "NEGATE",
 393    "FRAC",
 394    "CLAMP",
 395    "FLOOR",
 396    "ROUND",
 397    "EXPBASE2",
 398    "LOGBASE2",
 399    "POWER",
 400    "CROSSPRODUCT",
 401    "MULTIPLYMATRIX",
 402    "ABS",
 403    "RCC",
 404    "DPH",
 405    "COS",
 406    "DDX",
 407    "DDY",
 408    "KIL",
 409    "PK2H",
 410    "PK2US",
 411    "PK4B",
 412    "PK4UB",
 413    "RFL",
 414    "SEQ",
 415    "SFL",
 416    "SGT",
 417    "SIN",
 418    "SLE",
 419    "SNE",
 420    "STR",
 421    "TEX",
 422    "TXD",
 423    "UP2H",
 424    "UP2US",
 425    "UP4B",
 426    "UP4UB",
 427    "X2D",
 428    "ARA",
 429    "ARR",
 430    "BRA",
 431    "CAL",
 432    "RET",
 433    "SSG",
 434    "CMP",
 435    "SCS",
 436    "TXB",
 437    "NRM",
 438    "DIV",
 439    "DP2",
 440    "TXL",
 441    "BRK",
 442    "IF",
 443    "LOOP",
 444    "REP",
 445    "ELSE",
 446    "ENDIF",
 447    "ENDLOOP",
 448    "ENDREP",
 449    "PUSHA",
 450    "POPA",
 451    "CEIL",
 452    "I2F",
 453    "NOT",
 454    "TRUNC",
 455    "SHL",
 456    "SHR",
 457    "AND",
 458    "OR",
 459    "MOD",
 460    "XOR",
 461    "SAD",
 462    "TXF",
 463    "TXQ",
 464    "CONT",
 465    "EMIT",
 466    "ENDPRIM",
 467    "BGNLOOP2",
 468    "BGNSUB",
 469    "ENDLOOP2",
 470    "ENDSUB",
 471    "NOISE1",
 472    "NOISE2",
 473    "NOISE3",
 474    "NOISE4",
 475    "NOP",
 476    "TEXBEM",
 477    "TEXBEML",
 478    "TEXREG2AR",
 479    "TEXM3X2PAD",
 480    "TEXM3X2TEX",
 481    "TEXM3X3PAD",
 482    "TEXM3X3TEX",
 483    "TEXM3X3SPEC",
 484    "TEXM3X3VSPEC",
 485    "TEXREG2GB",
 486    "TEXREG2RGB",
 487    "TEXDP3TEX",
 488    "TEXDP3",
 489    "TEXM3X3",
 490    "TEXM3X2DEPTH",
 491    "TEXDEPTH",
 492    "BEM",
 493    "M4X3",
 494    "M3X4",
 495    "M3X3",
 496    "M3X2",
 497    "NRM4",
 498    "CALLNZ",
 499    "IFC",
 500    "BREAKC",
 501 };
 502
 503 static const char *TGSI_SATS[] =
 504 {
 505    "SAT_NONE",
 506    "SAT_ZERO_ONE",
 507    "SAT_MINUS_PLUS_ONE"
 508 };
 509
 510 static const char *TGSI_INSTRUCTION_EXTS[] =
 511 {
 512    "INSTRUCTION_EXT_TYPE_NV",
 513    "INSTRUCTION_EXT_TYPE_LABEL",
 514    "INSTRUCTION_EXT_TYPE_TEXTURE"
 515 };
 516
 517 static const char *TGSI_PRECISIONS[] =
 518 {
 519    "PRECISION_DEFAULT",
 520    "TGSI_PRECISION_FLOAT32",
 521    "TGSI_PRECISION_FLOAT16",
 522    "TGSI_PRECISION_FIXED12"
 523 };
 524
 525 static const char *TGSI_CCS[] =
 526 {
 527    "CC_GT",
 528    "CC_EQ",
 529    "CC_LT",
 530    "CC_UN",
 531    "CC_GE",
 532    "CC_LE",
 533    "CC_NE",
 534    "CC_TR",
 535    "CC_FL"
 536 };
 537
 538 static const char *TGSI_SWIZZLES[] =
 539 {
 540    "SWIZZLE_X",
 541    "SWIZZLE_Y",
 542    "SWIZZLE_Z",
 543    "SWIZZLE_W"
 544 };
 545
 546 static const char *TGSI_SWIZZLES_SHORT[] =
 547 {
 548    "x",
 549    "y",
 550    "z",
 551    "w"
 552 };
 553
 554 static const char *TGSI_TEXTURES[] =
 555 {
 556    "TEXTURE_UNKNOWN",
 557    "TEXTURE_1D",
 558    "TEXTURE_2D",
 559    "TEXTURE_3D",
 560    "TEXTURE_CUBE",
 561    "TEXTURE_RECT",
 562    "TEXTURE_SHADOW1D",
 563    "TEXTURE_SHADOW2D",
 564    "TEXTURE_SHADOWRECT"
 565 };
 566
 567 static const char *TGSI_SRC_REGISTER_EXTS[] =
 568 {
 569    "SRC_REGISTER_EXT_TYPE_SWZ",
 570    "SRC_REGISTER_EXT_TYPE_MOD"
 571 };
 572
 573 static const char *TGSI_EXTSWIZZLES[] =
 574 {
 575    "EXTSWIZZLE_X",
 576    "EXTSWIZZLE_Y",
 577    "EXTSWIZZLE_Z",
 578    "EXTSWIZZLE_W",
 579    "EXTSWIZZLE_ZERO",
 580    "EXTSWIZZLE_ONE"
 581 };
 582
 583 static const char *TGSI_WRITEMASKS[] =
 584 {
 585    "0",
 586    "WRITEMASK_X",
 587    "WRITEMASK_Y",
 588    "WRITEMASK_XY",
 589    "WRITEMASK_Z",
 590    "WRITEMASK_XZ",
 591    "WRITEMASK_YZ",
 592    "WRITEMASK_XYZ",
 593    "WRITEMASK_W",
 594    "WRITEMASK_XW",
 595    "WRITEMASK_YW",
 596    "WRITEMASK_XYW",
 597    "WRITEMASK_ZW",
 598    "WRITEMASK_XZW",
 599    "WRITEMASK_YZW",
 600    "WRITEMASK_XYZW"
 601 };
 602
 603 static const char *TGSI_DST_REGISTER_EXTS[] =
 604 {
 605    "DST_REGISTER_EXT_TYPE_CONDCODE",
 606    "DST_REGISTER_EXT_TYPE_MODULATE"
 607 };
 608
 609 static const char *TGSI_MODULATES[] =
 610 {
 611    "MODULATE_1X",
 612    "MODULATE_2X",
 613    "MODULATE_4X",
 614    "MODULATE_8X",
 615    "MODULATE_HALF",
 616    "MODULATE_QUARTER",
 617    "MODULATE_EIGHTH"
 618 };
 619
 620 static void
 621 dump_declaration_short(
 622    struct text_dump *dump,
 623    struct tgsi_full_declaration *decl )
 624 {
 625    TXT( "\nDCL " );
 626    ENM( decl->Declaration.File, TGSI_FILES_SHORT );
 627
 628    switch( decl->Declaration.Declare ) {
 629    case TGSI_DECLARE_RANGE:
 630       CHR( '[' );
 631       UID( decl->u.DeclarationRange.First );
 632       if( decl->u.DeclarationRange.First != decl->u.DeclarationRange.Last ) {
 633          TXT( ".." );
 634          UID( decl->u.DeclarationRange.Last );
 635       }
 636       CHR( ']' );
 637       break;
 638    default:
 639       assert( 0 );
 640    }
 641
 642    if( decl->Declaration.UsageMask != TGSI_WRITEMASK_XYZW ) {
 643       CHR( '.' );
 644       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_X ) {
 645          CHR( 'x' );
 646       }
 647       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Y ) {
 648          CHR( 'y' );
 649       }
 650       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Z ) {
 651          CHR( 'z' );
 652       }
 653       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_W ) {
 654          CHR( 'w' );
 655       }
 656    }
 657
 658    if( decl->Declaration.Interpolate ) {
 659       TXT( ", " );
 660       ENM( decl->Interpolation.Interpolate, TGSI_INTERPOLATES_SHORT );
 661    }
 662
 663    if( decl->Declaration.Semantic ) {
 664       TXT( ", " );
 665       ENM( decl->Semantic.SemanticName, TGSI_SEMANTICS_SHORT );
 666       CHR( '[' );
 667       UID( decl->Semantic.SemanticIndex );
 668       CHR( ']' );
 669    }
 670 }
 671
 672 static void
 673 dump_declaration_verbose(
 674    struct text_dump *dump,
 675    struct tgsi_full_declaration *decl,
 676    unsigned ignored,
 677    unsigned deflt,
 678    struct tgsi_full_declaration *fd )
 679 {
 680    TXT( "\nFile       : " );
 681    ENM( decl->Declaration.File, TGSI_FILES );
 682    TXT( "\nDeclare    : " );
 683    ENM( decl->Declaration.Declare, TGSI_DECLARES );
 684    if( deflt || fd->Declaration.UsageMask != decl->Declaration.UsageMask ) {
 685       TXT( "\nUsageMask  : " );
 686       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_X ) {
 687          CHR( 'X' );
 688       }
 689       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Y ) {
 690          CHR( 'Y' );
 691       }
 692       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Z ) {
 693          CHR( 'Z' );
 694       }
 695       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_W ) {
 696          CHR( 'W' );
 697       }
 698    }
 699    if( deflt || fd->Declaration.Interpolate != decl->Declaration.Interpolate ) {
 700       TXT( "\nInterpolate: " );
 701       UID( decl->Declaration.Interpolate );
 702    }
 703    if( deflt || fd->Declaration.Semantic != decl->Declaration.Semantic ) {
 704       TXT( "\nSemantic   : " );
 705       UID( decl->Declaration.Semantic );
 706    }
 707    if( ignored ) {
 708       TXT( "\nPadding    : " );
 709       UIX( decl->Declaration.Padding );
 710    }
 711
 712    CHR( '\n' );
 713    switch( decl->Declaration.Declare ) {
 714    case TGSI_DECLARE_RANGE:
 715       TXT( "\nFirst: " );
 716       UID( decl->u.DeclarationRange.First );
 717       TXT( "\nLast : " );
 718       UID( decl->u.DeclarationRange.Last );
 719       break;
 720
 721    case TGSI_DECLARE_MASK:
 722       TXT( "\nMask: " );
 723       UIX( decl->u.DeclarationMask.Mask );
 724       break;
 725
 726    default:
 727       assert( 0 );
 728    }
 729
 730    if( decl->Declaration.Interpolate ) {
 731       CHR( '\n' );
 732       TXT( "\nInterpolate: " );
 733       ENM( decl->Interpolation.Interpolate, TGSI_INTERPOLATES );
 734       if( ignored ) {
 735          TXT( "\nPadding    : " );
 736          UIX( decl->Interpolation.Padding );
 737       }
 738    }
 739
 740    if( decl->Declaration.Semantic ) {
 741       CHR( '\n' );
 742       TXT( "\nSemanticName : " );
 743       ENM( decl->Semantic.SemanticName, TGSI_SEMANTICS );
 744       TXT( "\nSemanticIndex: " );
 745       UID( decl->Semantic.SemanticIndex );
 746       if( ignored ) {
 747          TXT( "\nPadding      : " );
 748          UIX( decl->Semantic.Padding );
 749       }
 750    }
 751 }
 752
 753 static void
 754 dump_immediate_short(
 755    struct text_dump *dump,
 756    struct tgsi_full_immediate *imm )
 757 {
 758    unsigned i;
 759
 760    TXT( "\nIMM " );
 761    ENM( imm->Immediate.DataType, TGSI_IMMS_SHORT );
 762
 763    TXT( " { " );
 764    for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
 765       switch( imm->Immediate.DataType ) {
 766       case TGSI_IMM_FLOAT32:
 767          FLT( imm->u.ImmediateFloat32[i].Float );
 768          break;
 769
 770       default:
 771          assert( 0 );
 772       }
 773
 774       if( i < imm->Immediate.Size - 2 ) {
 775          TXT( ", " );
 776       }
 777    }
 778    TXT( " }" );
 779 }
 780
 781 static void
 782 dump_immediate_verbose(
 783    struct text_dump *dump,
 784    struct tgsi_full_immediate *imm,
 785    unsigned ignored )
 786 {
 787    unsigned i;
 788
 789    TXT( "\nDataType   : " );
 790    ENM( imm->Immediate.DataType, TGSI_IMMS );
 791    if( ignored ) {
 792       TXT( "\nPadding    : " );
 793       UIX( imm->Immediate.Padding );
 794    }
 795
 796    for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
 797       CHR( '\n' );
 798       switch( imm->Immediate.DataType ) {
 799       case TGSI_IMM_FLOAT32:
 800          TXT( "\nFloat: " );
 801          FLT( imm->u.ImmediateFloat32[i].Float );
 802          break;
 803
 804       default:
 805          assert( 0 );
 806       }
 807    }
 808 }
 809
 810 static void
 811 dump_instruction_short(
 812    struct text_dump *dump,
 813    struct tgsi_full_instruction *inst,
 814    unsigned instno )
 815 {
 816    unsigned i;
 817    boolean first_reg = TRUE;
 818
 819    CHR( '\n' );
 820    UID( instno );
 821    CHR( ':' );
 822    ENM( inst->Instruction.Opcode, TGSI_OPCODES_SHORT );
 823
 824    switch( inst->Instruction.Saturate ) {
 825    case TGSI_SAT_NONE:
 826       break;
 827    case TGSI_SAT_ZERO_ONE:
 828       TXT( "_SAT" );
 829       break;
 830    case TGSI_SAT_MINUS_PLUS_ONE:
 831       TXT( "_SAT[-1,1]" );
 832       break;
 833    default:
 834       assert( 0 );
 835    }
 836
 837    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
 838       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
 839
 840       if( !first_reg ) {
 841          CHR( ',' );
 842       }
 843       CHR( ' ' );
 844
 845       ENM( dst->DstRegister.File, TGSI_FILES_SHORT );
 846
 847       CHR( '[' );
 848       SID( dst->DstRegister.Index );
 849       CHR( ']' );
 850
 851       if( dst->DstRegister.WriteMask != TGSI_WRITEMASK_XYZW ) {
 852          CHR( '.' );
 853          if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_X ) {
 854             CHR( 'x' );
 855          }
 856          if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_Y ) {
 857             CHR( 'y' );
 858          }
 859          if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_Z ) {
 860             CHR( 'z' );
 861          }
 862          if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_W ) {
 863             CHR( 'w' );
 864          }
 865       }
 866
 867       first_reg = FALSE;
 868    }
 869
 870    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
 871       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
 872
 873       if( !first_reg ) {
 874          CHR( ',' );
 875       }
 876       CHR( ' ' );
 877
 878       if( src->SrcRegisterExtMod.Negate  ) {
 879          CHR( '-' );
 880       }
 881       if( src->SrcRegisterExtMod.Absolute ) {
 882          CHR( '|' );
 883       }
 884       if( src->SrcRegister.Negate ) {
 885          CHR( '-' );
 886       }
 887
 888       ENM( src->SrcRegister.File, TGSI_FILES_SHORT );
 889
 890       CHR( '[' );
 891       SID( src->SrcRegister.Index );
 892       CHR( ']' );
 893
 894       if( src->SrcRegister.SwizzleX != TGSI_SWIZZLE_X ||
 895             src->SrcRegister.SwizzleY != TGSI_SWIZZLE_Y ||
 896             src->SrcRegister.SwizzleZ != TGSI_SWIZZLE_Z ||
 897             src->SrcRegister.SwizzleW != TGSI_SWIZZLE_W ) {
 898          CHR( '.' );
 899          ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES_SHORT );
 900          ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES_SHORT );
 901          ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES_SHORT );
 902          ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES_SHORT );
 903       }
 904
 905       if( src->SrcRegisterExtMod.Absolute ) {
 906          CHR( '|' );
 907       }
 908
 909       first_reg = FALSE;
 910    }
 911
 912    switch( inst->Instruction.Opcode ) {
 913    case TGSI_OPCODE_IF:
 914    case TGSI_OPCODE_ELSE:
 915       TXT( " :" );
 916       UID( inst->InstructionExtLabel.Label );
 917       break;
 918    }
 919 }
 920
 921 static void
 922 dump_instruction_verbose(
 923    struct text_dump *dump,
 924    struct tgsi_full_instruction *inst,
 925    unsigned ignored,
 926    unsigned deflt,
 927    struct tgsi_full_instruction *fi )
 928 {
 929    unsigned i;
 930
 931    TXT( "\nOpcode     : " );
 932    ENM( inst->Instruction.Opcode, TGSI_OPCODES );
 933    if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
 934       TXT( "\nSaturate   : " );
 935       ENM( inst->Instruction.Saturate, TGSI_SATS );
 936    }
 937    if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
 938       TXT( "\nNumDstRegs : " );
 939       UID( inst->Instruction.NumDstRegs );
 940    }
 941    if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
 942       TXT( "\nNumSrcRegs : " );
 943       UID( inst->Instruction.NumSrcRegs );
 944    }
 945    if( ignored ) {
 946       TXT( "\nPadding    : " );
 947       UIX( inst->Instruction.Padding );
 948    }
 949
 950    if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi->InstructionExtNv ) ) {
 951       CHR( '\n' );
 952       TXT( "\nType          : " );
 953       ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
 954       if( deflt || fi->InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
 955          TXT( "\nPrecision     : " );
 956          ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
 957       }
 958       if( deflt || fi->InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
 959          TXT( "\nCondDstIndex  : " );
 960          UID( inst->InstructionExtNv.CondDstIndex );
 961       }
 962       if( deflt || fi->InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
 963          TXT( "\nCondFlowIndex : " );
 964          UID( inst->InstructionExtNv.CondFlowIndex );
 965       }
 966       if( deflt || fi->InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
 967          TXT( "\nCondMask      : " );
 968          ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
 969       }
 970       if( deflt || fi->InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
 971          TXT( "\nCondSwizzleX  : " );
 972          ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
 973       }
 974       if( deflt || fi->InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
 975          TXT( "\nCondSwizzleY  : " );
 976          ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
 977       }
 978       if( deflt || fi->InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
 979          TXT( "\nCondSwizzleZ  : " );
 980          ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
 981       }
 982       if( deflt || fi->InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
 983          TXT( "\nCondSwizzleW  : " );
 984          ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
 985       }
 986       if( deflt || fi->InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
 987          TXT( "\nCondDstUpdate : " );
 988          UID( inst->InstructionExtNv.CondDstUpdate );
 989       }
 990       if( deflt || fi->InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
 991          TXT( "\nCondFlowEnable: " );
 992          UID( inst->InstructionExtNv.CondFlowEnable );
 993       }
 994       if( ignored ) {
 995          TXT( "\nPadding       : " );
 996          UIX( inst->InstructionExtNv.Padding );
 997          if( deflt || fi->InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
 998             TXT( "\nExtended      : " );
 999             UID( inst->InstructionExtNv.Extended );
1000          }
1001       }
1002    }
1003
1004    if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
1005       CHR( '\n' );
1006       TXT( "\nType    : " );
1007       ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
1008       if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
1009          TXT( "\nLabel   : " );
1010          UID( inst->InstructionExtLabel.Label );
1011       }
1012       if( ignored ) {
1013          TXT( "\nPadding : " );
1014          UIX( inst->InstructionExtLabel.Padding );
1015          if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
1016             TXT( "\nExtended: " );
1017             UID( inst->InstructionExtLabel.Extended );
1018          }
1019       }
1020    }
1021
1022    if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
1023       CHR( '\n' );
1024       TXT( "\nType    : " );
1025       ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
1026       if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
1027          TXT( "\nTexture : " );
1028          ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
1029       }
1030       if( ignored ) {
1031          TXT( "\nPadding : " );
1032          UIX( inst->InstructionExtTexture.Padding );
1033          if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
1034             TXT( "\nExtended: " );
1035             UID( inst->InstructionExtTexture.Extended );
1036          }
1037       }
1038    }
1039
1040    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
1041       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
1042       struct tgsi_full_dst_register *fd = &fi->FullDstRegisters[i];
1043
1044       CHR( '\n' );
1045       TXT( "\nFile     : " );
1046       ENM( dst->DstRegister.File, TGSI_FILES );
1047       if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
1048          TXT( "\nWriteMask: " );
1049          ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
1050       }
1051       if( ignored ) {
1052          if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
1053             TXT( "\nIndirect : " );
1054             UID( dst->DstRegister.Indirect );
1055          }
1056          if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
1057             TXT( "\nDimension: " );
1058             UID( dst->DstRegister.Dimension );
1059          }
1060       }
1061       if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
1062          TXT( "\nIndex    : " );
1063          SID( dst->DstRegister.Index );
1064       }
1065       if( ignored ) {
1066          TXT( "\nPadding  : " );
1067          UIX( dst->DstRegister.Padding );
1068          if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
1069             TXT( "\nExtended : " );
1070             UID( dst->DstRegister.Extended );
1071          }
1072       }
1073
1074       if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
1075          CHR( '\n' );
1076          TXT( "\nType        : " );
1077          ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
1078          if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
1079             TXT( "\nCondMask    : " );
1080             ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
1081          }
1082          if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
1083             TXT( "\nCondSwizzleX: " );
1084             ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
1085          }
1086          if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
1087             TXT( "\nCondSwizzleY: " );
1088             ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
1089          }
1090          if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
1091             TXT( "\nCondSwizzleZ: " );
1092             ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
1093          }
1094          if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
1095             TXT( "\nCondSwizzleW: " );
1096             ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
1097          }
1098          if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
1099             TXT( "\nCondSrcIndex: " );
1100             UID( dst->DstRegisterExtConcode.CondSrcIndex );
1101          }
1102          if( ignored ) {
1103             TXT( "\nPadding     : " );
1104             UIX( dst->DstRegisterExtConcode.Padding );
1105             if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
1106                TXT( "\nExtended    : " );
1107                UID( dst->DstRegisterExtConcode.Extended );
1108             }
1109          }
1110       }
1111
1112       if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
1113          CHR( '\n' );
1114          TXT( "\nType    : " );
1115          ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
1116          if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
1117             TXT( "\nModulate: " );
1118             ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
1119          }
1120          if( ignored ) {
1121             TXT( "\nPadding : " );
1122             UIX( dst->DstRegisterExtModulate.Padding );
1123             if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
1124                TXT( "\nExtended: " );
1125                UID( dst->DstRegisterExtModulate.Extended );
1126             }
1127          }
1128       }
1129    }
1130
1131    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
1132       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
1133       struct tgsi_full_src_register *fs = &fi->FullSrcRegisters[i];
1134
1135       CHR( '\n' );
1136       TXT( "\nFile     : ");
1137       ENM( src->SrcRegister.File, TGSI_FILES );
1138       if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
1139          TXT( "\nSwizzleX : " );
1140          ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
1141       }
1142       if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
1143          TXT( "\nSwizzleY : " );
1144          ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
1145       }
1146       if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
1147          TXT( "\nSwizzleZ : " );
1148          ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
1149       }
1150       if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
1151          TXT( "\nSwizzleW : " );
1152          ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
1153       }
1154       if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
1155          TXT( "\nNegate   : " );
1156          UID( src->SrcRegister.Negate );
1157       }
1158       if( ignored ) {
1159          if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
1160             TXT( "\nIndirect : " );
1161             UID( src->SrcRegister.Indirect );
1162          }
1163          if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
1164             TXT( "\nDimension: " );
1165             UID( src->SrcRegister.Dimension );
1166          }
1167       }
1168       if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
1169          TXT( "\nIndex    : " );
1170          SID( src->SrcRegister.Index );
1171       }
1172       if( ignored ) {
1173          if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
1174             TXT( "\nExtended : " );
1175             UID( src->SrcRegister.Extended );
1176          }
1177       }
1178
1179       if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
1180          CHR( '\n' );
1181          TXT( "\nType       : " );
1182          ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
1183          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
1184             TXT( "\nExtSwizzleX: " );
1185             ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
1186          }
1187          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
1188             TXT( "\nExtSwizzleY: " );
1189             ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
1190          }
1191          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
1192             TXT( "\nExtSwizzleZ: " );
1193             ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
1194          }
1195          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
1196             TXT( "\nExtSwizzleW: " );
1197             ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
1198          }
1199          if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
1200             TXT( "\nNegateX   : " );
1201             UID( src->SrcRegisterExtSwz.NegateX );
1202          }
1203          if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
1204             TXT( "\nNegateY   : " );
1205             UID( src->SrcRegisterExtSwz.NegateY );
1206          }
1207          if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
1208             TXT( "\nNegateZ   : " );
1209             UID( src->SrcRegisterExtSwz.NegateZ );
1210          }
1211          if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
1212             TXT( "\nNegateW   : " );
1213             UID( src->SrcRegisterExtSwz.NegateW );
1214          }
1215          if( deflt || fs->SrcRegisterExtSwz.ExtDivide != src->SrcRegisterExtSwz.ExtDivide ) {
1216             TXT( "\nExtDivide  : " );
1217             ENM( src->SrcRegisterExtSwz.ExtDivide, TGSI_EXTSWIZZLES );
1218          }
1219          if( ignored ) {
1220             TXT( "\nPadding   : " );
1221             UIX( src->SrcRegisterExtSwz.Padding );
1222             if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
1223                TXT( "\nExtended   : " );
1224                UID( src->SrcRegisterExtSwz.Extended );
1225             }
1226          }
1227       }
1228
1229       if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
1230          CHR( '\n' );
1231          TXT( "\nType     : " );
1232          ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
1233          if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
1234             TXT( "\nComplement: " );
1235             UID( src->SrcRegisterExtMod.Complement );
1236          }
1237          if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
1238             TXT( "\nBias     : " );
1239             UID( src->SrcRegisterExtMod.Bias );
1240          }
1241          if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
1242             TXT( "\nScale2X   : " );
1243             UID( src->SrcRegisterExtMod.Scale2X );
1244          }
1245          if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
1246             TXT( "\nAbsolute  : " );
1247             UID( src->SrcRegisterExtMod.Absolute );
1248          }
1249          if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
1250             TXT( "\nNegate   : " );
1251             UID( src->SrcRegisterExtMod.Negate );
1252          }
1253          if( ignored ) {
1254             TXT( "\nPadding   : " );
1255             UIX( src->SrcRegisterExtMod.Padding );
1256             if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
1257                TXT( "\nExtended  : " );
1258                UID( src->SrcRegisterExtMod.Extended );
1259             }
1260          }
1261       }
1262    }
1263 }
1264
1265 void
1266 tgsi_dump(
1267    const struct tgsi_token *tokens,
1268    unsigned flags )
1269 {
1270    struct text_dump _dump;
1271    struct text_dump *dump = &_dump;
1272    struct tgsi_parse_context parse;
1273    struct tgsi_full_instruction fi;
1274    struct tgsi_full_declaration fd;
1275    unsigned verbose = flags & TGSI_DUMP_VERBOSE;
1276    unsigned ignored = !(flags & TGSI_DUMP_NO_IGNORED);
1277    unsigned deflt = !(flags & TGSI_DUMP_NO_DEFAULT);
1278    unsigned instno = 0;
1279
1280    {
1281 #if 0
1282       static unsigned counter = 0;
1283       char buffer[64];
1284
1285       sprintf( buffer, "tgsi-dump-%.4u.txt", counter++ );
1286       dump->file = fopen( buffer, "wt" );
1287 #else
1288       dump->file = stderr;
1289 #endif
1290       dump->tabs = 0;
1291    }
1292
1293    /* sanity check */
1294    assert(strcmp(TGSI_OPCODES[TGSI_OPCODE_CONT], "OPCODE_CONT") == 0);
1295
1296    tgsi_parse_init( &parse, tokens );
1297
1298    TXT( "tgsi-dump begin -----------------" );
1299
1300    CHR( '\n' );
1301    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES_SHORT );
1302    CHR( ' ' );
1303    UID( parse.FullVersion.Version.MajorVersion );
1304    CHR( '.' );
1305    UID( parse.FullVersion.Version.MinorVersion );
1306
1307    if( verbose ) {
1308       TXT( "\nMajorVersion: " );
1309       UID( parse.FullVersion.Version.MajorVersion );
1310       TXT( "\nMinorVersion: " );
1311       UID( parse.FullVersion.Version.MinorVersion );
1312       CHR( '\n' );
1313
1314       TXT( "\nHeaderSize: " );
1315       UID( parse.FullHeader.Header.HeaderSize );
1316       TXT( "\nBodySize  : " );
1317       UID( parse.FullHeader.Header.BodySize );
1318       TXT( "\nProcessor : " );
1319       ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
1320       CHR( '\n' );
1321    }
1322
1323    fi = tgsi_default_full_instruction();
1324    fd = tgsi_default_full_declaration();
1325
1326    while( !tgsi_parse_end_of_tokens( &parse ) ) {
1327       tgsi_parse_token( &parse );
1328
1329       switch( parse.FullToken.Token.Type ) {
1330       case TGSI_TOKEN_TYPE_DECLARATION:
1331          dump_declaration_short(
1332             dump,
1333             &parse.FullToken.FullDeclaration );
1334          break;
1335
1336       case TGSI_TOKEN_TYPE_IMMEDIATE:
1337          dump_immediate_short(
1338             dump,
1339             &parse.FullToken.FullImmediate );
1340          break;
1341
1342       case TGSI_TOKEN_TYPE_INSTRUCTION:
1343          dump_instruction_short(
1344             dump,
1345             &parse.FullToken.FullInstruction,
1346             instno );
1347          instno++;
1348          break;
1349
1350       default:
1351          assert( 0 );
1352       }
1353
1354       if( verbose ) {
1355          TXT( "\nType       : " );
1356          ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
1357          if( ignored ) {
1358             TXT( "\nSize       : " );
1359             UID( parse.FullToken.Token.Size );
1360             if( deflt || parse.FullToken.Token.Extended ) {
1361                TXT( "\nExtended   : " );
1362                UID( parse.FullToken.Token.Extended );
1363             }
1364          }
1365
1366          switch( parse.FullToken.Token.Type ) {
1367          case TGSI_TOKEN_TYPE_DECLARATION:
1368             dump_declaration_verbose(
1369                dump,
1370                &parse.FullToken.FullDeclaration,
1371                ignored,
1372                deflt,
1373                &fd );
1374             break;
1375
1376          case TGSI_TOKEN_TYPE_IMMEDIATE:
1377             dump_immediate_verbose(
1378                dump,
1379                &parse.FullToken.FullImmediate,
1380                ignored );
1381             break;
1382
1383          case TGSI_TOKEN_TYPE_INSTRUCTION:
1384             dump_instruction_verbose(
1385                dump,
1386                &parse.FullToken.FullInstruction,
1387                ignored,
1388                deflt,
1389                &fi );
1390             break;
1391
1392          default:
1393             assert( 0 );
1394          }
1395
1396          CHR( '\n' );
1397       }
1398    }
1399
1400    TXT( "\ntgsi-dump end -------------------\n" );
1401
1402    tgsi_parse_free( &parse );
1403
1404    if (dump->file != stderr &&
1405        dump->file != stdout)
1406       fclose( dump->file );
1407 }
1408