src/gallium/auxiliary/tgsi/util/tgsi_dump.c

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