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       if (src->SrcRegisterExtSwz.ExtDivide != TGSI_EXTSWIZZLE_ONE) {
1051          CHR( '/' );
1052          ENM( src->SrcRegisterExtSwz.ExtDivide, TGSI_EXTSWIZZLES_SHORT );
1053       }
1054
1055       first_reg = FALSE;
1056    }
1057
1058    if (inst->InstructionExtTexture.Texture != TGSI_TEXTURE_UNKNOWN) {
1059       TXT( ", " );
1060       ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES_SHORT );
1061    }
1062
1063    switch( inst->Instruction.Opcode ) {
1064    case TGSI_OPCODE_IF:
1065    case TGSI_OPCODE_ELSE:
1066    case TGSI_OPCODE_BGNLOOP2:
1067    case TGSI_OPCODE_ENDLOOP2:
1068    case TGSI_OPCODE_CAL:
1069       TXT( " :" );
1070       UID( inst->InstructionExtLabel.Label );
1071       break;
1072    }
1073 }
1074
1075 static void
1076 dump_instruction_verbose(
1077    struct gen_dump               *dump,
1078    struct tgsi_full_instruction  *inst,
1079    unsigned                      ignored,
1080    unsigned                      deflt,
1081    struct tgsi_full_instruction  *fi )
1082 {
1083    unsigned i;
1084
1085    TXT( "\nOpcode     : " );
1086    ENM( inst->Instruction.Opcode, TGSI_OPCODES );
1087    if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
1088       TXT( "\nSaturate   : " );
1089       ENM( inst->Instruction.Saturate, TGSI_SATS );
1090    }
1091    if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
1092       TXT( "\nNumDstRegs : " );
1093       UID( inst->Instruction.NumDstRegs );
1094    }
1095    if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
1096       TXT( "\nNumSrcRegs : " );
1097       UID( inst->Instruction.NumSrcRegs );
1098    }
1099    if( ignored ) {
1100       TXT( "\nPadding    : " );
1101       UIX( inst->Instruction.Padding );
1102    }
1103
1104    if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi->InstructionExtNv ) ) {
1105       CHR( '\n' );
1106       TXT( "\nType          : " );
1107       ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
1108       if( deflt || fi->InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
1109          TXT( "\nPrecision     : " );
1110          ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
1111       }
1112       if( deflt || fi->InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
1113          TXT( "\nCondDstIndex  : " );
1114          UID( inst->InstructionExtNv.CondDstIndex );
1115       }
1116       if( deflt || fi->InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
1117          TXT( "\nCondFlowIndex : " );
1118          UID( inst->InstructionExtNv.CondFlowIndex );
1119       }
1120       if( deflt || fi->InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
1121          TXT( "\nCondMask      : " );
1122          ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
1123       }
1124       if( deflt || fi->InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
1125          TXT( "\nCondSwizzleX  : " );
1126          ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
1127       }
1128       if( deflt || fi->InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
1129          TXT( "\nCondSwizzleY  : " );
1130          ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
1131       }
1132       if( deflt || fi->InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
1133          TXT( "\nCondSwizzleZ  : " );
1134          ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
1135       }
1136       if( deflt || fi->InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
1137          TXT( "\nCondSwizzleW  : " );
1138          ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
1139       }
1140       if( deflt || fi->InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
1141          TXT( "\nCondDstUpdate : " );
1142          UID( inst->InstructionExtNv.CondDstUpdate );
1143       }
1144       if( deflt || fi->InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
1145          TXT( "\nCondFlowEnable: " );
1146          UID( inst->InstructionExtNv.CondFlowEnable );
1147       }
1148       if( ignored ) {
1149          TXT( "\nPadding       : " );
1150          UIX( inst->InstructionExtNv.Padding );
1151          if( deflt || fi->InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
1152             TXT( "\nExtended      : " );
1153             UID( inst->InstructionExtNv.Extended );
1154          }
1155       }
1156    }
1157
1158    if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
1159       CHR( '\n' );
1160       TXT( "\nType    : " );
1161       ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
1162       if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
1163          TXT( "\nLabel   : " );
1164          UID( inst->InstructionExtLabel.Label );
1165       }
1166       if( ignored ) {
1167          TXT( "\nPadding : " );
1168          UIX( inst->InstructionExtLabel.Padding );
1169          if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
1170             TXT( "\nExtended: " );
1171             UID( inst->InstructionExtLabel.Extended );
1172          }
1173       }
1174    }
1175
1176    if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
1177       CHR( '\n' );
1178       TXT( "\nType    : " );
1179       ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
1180       if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
1181          TXT( "\nTexture : " );
1182          ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
1183       }
1184       if( ignored ) {
1185          TXT( "\nPadding : " );
1186          UIX( inst->InstructionExtTexture.Padding );
1187          if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
1188             TXT( "\nExtended: " );
1189             UID( inst->InstructionExtTexture.Extended );
1190          }
1191       }
1192    }
1193
1194    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
1195       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
1196       struct tgsi_full_dst_register *fd = &fi->FullDstRegisters[i];
1197
1198       CHR( '\n' );
1199       TXT( "\nFile     : " );
1200       ENM( dst->DstRegister.File, TGSI_FILES );
1201       if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
1202          TXT( "\nWriteMask: " );
1203          ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
1204       }
1205       if( ignored ) {
1206          if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
1207             TXT( "\nIndirect : " );
1208             UID( dst->DstRegister.Indirect );
1209          }
1210          if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
1211             TXT( "\nDimension: " );
1212             UID( dst->DstRegister.Dimension );
1213          }
1214       }
1215       if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
1216          TXT( "\nIndex    : " );
1217          SID( dst->DstRegister.Index );
1218       }
1219       if( ignored ) {
1220          TXT( "\nPadding  : " );
1221          UIX( dst->DstRegister.Padding );
1222          if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
1223             TXT( "\nExtended : " );
1224             UID( dst->DstRegister.Extended );
1225          }
1226       }
1227
1228       if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
1229          CHR( '\n' );
1230          TXT( "\nType        : " );
1231          ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
1232          if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
1233             TXT( "\nCondMask    : " );
1234             ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
1235          }
1236          if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
1237             TXT( "\nCondSwizzleX: " );
1238             ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
1239          }
1240          if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
1241             TXT( "\nCondSwizzleY: " );
1242             ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
1243          }
1244          if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
1245             TXT( "\nCondSwizzleZ: " );
1246             ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
1247          }
1248          if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
1249             TXT( "\nCondSwizzleW: " );
1250             ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
1251          }
1252          if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
1253             TXT( "\nCondSrcIndex: " );
1254             UID( dst->DstRegisterExtConcode.CondSrcIndex );
1255          }
1256          if( ignored ) {
1257             TXT( "\nPadding     : " );
1258             UIX( dst->DstRegisterExtConcode.Padding );
1259             if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
1260                TXT( "\nExtended    : " );
1261                UID( dst->DstRegisterExtConcode.Extended );
1262             }
1263          }
1264       }
1265
1266       if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
1267          CHR( '\n' );
1268          TXT( "\nType    : " );
1269          ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
1270          if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
1271             TXT( "\nModulate: " );
1272             ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
1273          }
1274          if( ignored ) {
1275             TXT( "\nPadding : " );
1276             UIX( dst->DstRegisterExtModulate.Padding );
1277             if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
1278                TXT( "\nExtended: " );
1279                UID( dst->DstRegisterExtModulate.Extended );
1280             }
1281          }
1282       }
1283    }
1284
1285    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
1286       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
1287       struct tgsi_full_src_register *fs = &fi->FullSrcRegisters[i];
1288
1289       CHR( '\n' );
1290       TXT( "\nFile     : ");
1291       ENM( src->SrcRegister.File, TGSI_FILES );
1292       if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
1293          TXT( "\nSwizzleX : " );
1294          ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
1295       }
1296       if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
1297          TXT( "\nSwizzleY : " );
1298          ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
1299       }
1300       if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
1301          TXT( "\nSwizzleZ : " );
1302          ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
1303       }
1304       if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
1305          TXT( "\nSwizzleW : " );
1306          ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
1307       }
1308       if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
1309          TXT( "\nNegate   : " );
1310          UID( src->SrcRegister.Negate );
1311       }
1312       if( ignored ) {
1313          if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
1314             TXT( "\nIndirect : " );
1315             UID( src->SrcRegister.Indirect );
1316          }
1317          if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
1318             TXT( "\nDimension: " );
1319             UID( src->SrcRegister.Dimension );
1320          }
1321       }
1322       if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
1323          TXT( "\nIndex    : " );
1324          SID( src->SrcRegister.Index );
1325       }
1326       if( ignored ) {
1327          if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
1328             TXT( "\nExtended : " );
1329             UID( src->SrcRegister.Extended );
1330          }
1331       }
1332
1333       if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
1334          CHR( '\n' );
1335          TXT( "\nType       : " );
1336          ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
1337          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
1338             TXT( "\nExtSwizzleX: " );
1339             ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
1340          }
1341          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
1342             TXT( "\nExtSwizzleY: " );
1343             ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
1344          }
1345          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
1346             TXT( "\nExtSwizzleZ: " );
1347             ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
1348          }
1349          if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
1350             TXT( "\nExtSwizzleW: " );
1351             ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
1352          }
1353          if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
1354             TXT( "\nNegateX   : " );
1355             UID( src->SrcRegisterExtSwz.NegateX );
1356          }
1357          if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
1358             TXT( "\nNegateY   : " );
1359             UID( src->SrcRegisterExtSwz.NegateY );
1360          }
1361          if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
1362             TXT( "\nNegateZ   : " );
1363             UID( src->SrcRegisterExtSwz.NegateZ );
1364          }
1365          if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
1366             TXT( "\nNegateW   : " );
1367             UID( src->SrcRegisterExtSwz.NegateW );
1368          }
1369          if( deflt || fs->SrcRegisterExtSwz.ExtDivide != src->SrcRegisterExtSwz.ExtDivide ) {
1370             TXT( "\nExtDivide  : " );
1371             ENM( src->SrcRegisterExtSwz.ExtDivide, TGSI_EXTSWIZZLES );
1372          }
1373          if( ignored ) {
1374             TXT( "\nPadding   : " );
1375             UIX( src->SrcRegisterExtSwz.Padding );
1376             if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
1377                TXT( "\nExtended   : " );
1378                UID( src->SrcRegisterExtSwz.Extended );
1379             }
1380          }
1381       }
1382
1383       if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
1384          CHR( '\n' );
1385          TXT( "\nType     : " );
1386          ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
1387          if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
1388             TXT( "\nComplement: " );
1389             UID( src->SrcRegisterExtMod.Complement );
1390          }
1391          if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
1392             TXT( "\nBias     : " );
1393             UID( src->SrcRegisterExtMod.Bias );
1394          }
1395          if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
1396             TXT( "\nScale2X   : " );
1397             UID( src->SrcRegisterExtMod.Scale2X );
1398          }
1399          if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
1400             TXT( "\nAbsolute  : " );
1401             UID( src->SrcRegisterExtMod.Absolute );
1402          }
1403          if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
1404             TXT( "\nNegate   : " );
1405             UID( src->SrcRegisterExtMod.Negate );
1406          }
1407          if( ignored ) {
1408             TXT( "\nPadding   : " );
1409             UIX( src->SrcRegisterExtMod.Padding );
1410             if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
1411                TXT( "\nExtended  : " );
1412                UID( src->SrcRegisterExtMod.Extended );
1413             }
1414          }
1415       }
1416    }
1417 }
1418
1419 static void
1420 dump_gen(
1421    struct gen_dump         *dump,
1422    const struct tgsi_token *tokens,
1423    unsigned                flags )
1424 {
1425    struct tgsi_parse_context parse;
1426    struct tgsi_full_instruction fi;
1427    struct tgsi_full_declaration fd;
1428    unsigned verbose = flags & TGSI_DUMP_VERBOSE;
1429    unsigned ignored = !(flags & TGSI_DUMP_NO_IGNORED);
1430    unsigned deflt = !(flags & TGSI_DUMP_NO_DEFAULT);
1431    unsigned instno = 0;
1432
1433    dump->tabs = 0;
1434
1435    /* sanity check */
1436    assert(strcmp(TGSI_OPCODES[TGSI_OPCODE_CONT], "OPCODE_CONT") == 0);
1437
1438    tgsi_parse_init( &parse, tokens );
1439
1440    TXT( "tgsi-dump begin -----------------" );
1441
1442    CHR( '\n' );
1443    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES_SHORT );
1444    CHR( ' ' );
1445    UID( parse.FullVersion.Version.MajorVersion );
1446    CHR( '.' );
1447    UID( parse.FullVersion.Version.MinorVersion );
1448
1449    if( verbose ) {
1450       TXT( "\nMajorVersion: " );
1451       UID( parse.FullVersion.Version.MajorVersion );
1452       TXT( "\nMinorVersion: " );
1453       UID( parse.FullVersion.Version.MinorVersion );
1454       CHR( '\n' );
1455
1456       TXT( "\nHeaderSize: " );
1457       UID( parse.FullHeader.Header.HeaderSize );
1458       TXT( "\nBodySize  : " );
1459       UID( parse.FullHeader.Header.BodySize );
1460       TXT( "\nProcessor : " );
1461       ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
1462       CHR( '\n' );
1463    }
1464
1465    fi = tgsi_default_full_instruction();
1466    fd = tgsi_default_full_declaration();
1467
1468    while( !tgsi_parse_end_of_tokens( &parse ) ) {
1469       tgsi_parse_token( &parse );
1470
1471       switch( parse.FullToken.Token.Type ) {
1472       case TGSI_TOKEN_TYPE_DECLARATION:
1473          dump_declaration_short(
1474             dump,
1475             &parse.FullToken.FullDeclaration );
1476          break;
1477
1478       case TGSI_TOKEN_TYPE_IMMEDIATE:
1479          dump_immediate_short(
1480             dump,
1481             &parse.FullToken.FullImmediate );
1482          break;
1483
1484       case TGSI_TOKEN_TYPE_INSTRUCTION:
1485          dump_instruction_short(
1486             dump,
1487             &parse.FullToken.FullInstruction,
1488             instno );
1489          instno++;
1490          break;
1491
1492       default:
1493          assert( 0 );
1494       }
1495
1496       if( verbose ) {
1497          TXT( "\nType       : " );
1498          ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
1499          if( ignored ) {
1500             TXT( "\nSize       : " );
1501             UID( parse.FullToken.Token.Size );
1502             if( deflt || parse.FullToken.Token.Extended ) {
1503                TXT( "\nExtended   : " );
1504                UID( parse.FullToken.Token.Extended );
1505             }
1506          }
1507
1508          switch( parse.FullToken.Token.Type ) {
1509          case TGSI_TOKEN_TYPE_DECLARATION:
1510             dump_declaration_verbose(
1511                dump,
1512                &parse.FullToken.FullDeclaration,
1513                ignored,
1514                deflt,
1515                &fd );
1516             break;
1517
1518          case TGSI_TOKEN_TYPE_IMMEDIATE:
1519             dump_immediate_verbose(
1520                dump,
1521                &parse.FullToken.FullImmediate,
1522                ignored );
1523             break;
1524
1525          case TGSI_TOKEN_TYPE_INSTRUCTION:
1526             dump_instruction_verbose(
1527                dump,
1528                &parse.FullToken.FullInstruction,
1529                ignored,
1530                deflt,
1531                &fi );
1532             break;
1533
1534          default:
1535             assert( 0 );
1536          }
1537
1538          CHR( '\n' );
1539       }
1540    }
1541
1542    TXT( "\ntgsi-dump end -------------------\n" );
1543
1544    tgsi_parse_free( &parse );
1545 }
1546
1547
1548 static void
1549 sanity_checks(void)
1550 {
1551    assert(strcmp(TGSI_OPCODES[TGSI_OPCODE_END], "OPCODE_END") == 0);
1552    assert(strcmp(TGSI_OPCODES_SHORT[TGSI_OPCODE_END], "END") == 0);
1553 }
1554
1555
1556 void
1557 tgsi_dump(
1558    const struct tgsi_token *tokens,
1559    unsigned                flags )
1560 {
1561    struct file_dump  dump;
1562
1563    sanity_checks();
1564
1565    dump.base.write = _file_dump_write;
1566 #if 0
1567    {
1568       static unsigned   counter = 0;
1569       char              buffer[64];
1570       sprintf( buffer, "tgsi-dump-%.4u.txt", counter++ );
1571       dump.file = fopen( buffer, "wt" );
1572    }
1573 #else
1574    dump.file = stderr;
1575 #endif
1576
1577    dump_gen(
1578       &dump.base,
1579       tokens,
1580       flags );
1581
1582 #if 0
1583    fclose( dump.file );
1584 #endif
1585 }
1586
1587 void
1588 tgsi_dump_str(
1589    char                    **str,
1590    const struct tgsi_token *tokens,
1591    unsigned                flags )
1592 {
1593    struct text_dump  dump;
1594
1595    dump.base.write = _text_dump_write;
1596    dump.text = NULL;
1597    dump.length = 0;
1598    dump.capacity = 0;
1599
1600    dump_gen(
1601       &dump.base,
1602       tokens,
1603       flags );
1604
1605    *str = dump.text;
1606 }