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