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