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