src/gallium/auxiliary/tgsi/tgsi_dump_c.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007-2008 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 "util/u_debug.h"
  29 #include "util/u_string.h"
  30 #include "tgsi_dump_c.h"
  31 #include "tgsi_build.h"
  32 #include "tgsi_info.h"
  33 #include "tgsi_parse.h"
  34
  35 static void
  36 dump_enum(
  37    const unsigned    e,
  38    const char        **enums,
  39    const unsigned    enums_count )
  40 {
  41    if (e >= enums_count) {
  42       debug_printf( "%u", e );
  43    }
  44    else {
  45       debug_printf( "%s", enums[e] );
  46    }
  47 }
  48
  49 #define EOL()           debug_printf( "\n" )
  50 #define TXT(S)          debug_printf( "%s", S )
  51 #define CHR(C)          debug_printf( "%c", C )
  52 #define UIX(I)          debug_printf( "0x%x", I )
  53 #define UID(I)          debug_printf( "%u", I )
  54 #define SID(I)          debug_printf( "%d", I )
  55 #define FLT(F)          debug_printf( "%10.4f", F )
  56 #define ENM(E,ENUMS)    dump_enum( E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
  57
  58 static const char *TGSI_PROCESSOR_TYPES[] =
  59 {
  60    "PROCESSOR_FRAGMENT",
  61    "PROCESSOR_VERTEX",
  62    "PROCESSOR_GEOMETRY"
  63 };
  64
  65 static const char *TGSI_TOKEN_TYPES[] =
  66 {
  67    "TOKEN_TYPE_DECLARATION",
  68    "TOKEN_TYPE_IMMEDIATE",
  69    "TOKEN_TYPE_INSTRUCTION"
  70 };
  71
  72 static const char *TGSI_FILES[TGSI_FILE_COUNT] =
  73 {
  74    "FILE_NULL",
  75    "FILE_CONSTANT",
  76    "FILE_INPUT",
  77    "FILE_OUTPUT",
  78    "FILE_TEMPORARY",
  79    "FILE_SAMPLER",
  80    "FILE_ADDRESS",
  81    "FILE_IMMEDIATE",
  82    "FILE_LOOP",
  83    "FILE_PREDICATE"
  84 };
  85
  86 static const char *TGSI_INTERPOLATES[] =
  87 {
  88    "INTERPOLATE_CONSTANT",
  89    "INTERPOLATE_LINEAR",
  90    "INTERPOLATE_PERSPECTIVE"
  91 };
  92
  93 static const char *TGSI_SEMANTICS[] =
  94 {
  95    "SEMANTIC_POSITION",
  96    "SEMANTIC_COLOR",
  97    "SEMANTIC_BCOLOR",
  98    "SEMANTIC_FOG",
  99    "SEMANTIC_PSIZE",
 100    "SEMANTIC_GENERIC",
 101    "SEMANTIC_NORMAL"
 102 };
 103
 104 static const char *TGSI_IMMS[] =
 105 {
 106    "IMM_FLOAT32"
 107 };
 108
 109 static const char *TGSI_SATS[] =
 110 {
 111    "SAT_NONE",
 112    "SAT_ZERO_ONE",
 113    "SAT_MINUS_PLUS_ONE"
 114 };
 115
 116 static const char *TGSI_INSTRUCTION_EXTS[] =
 117 {
 118    "",
 119    "INSTRUCTION_EXT_TYPE_LABEL",
 120    "INSTRUCTION_EXT_TYPE_TEXTURE"
 121 };
 122
 123 static const char *TGSI_SWIZZLES[] =
 124 {
 125    "SWIZZLE_X",
 126    "SWIZZLE_Y",
 127    "SWIZZLE_Z",
 128    "SWIZZLE_W"
 129 };
 130
 131 static const char *TGSI_TEXTURES[] =
 132 {
 133    "TEXTURE_UNKNOWN",
 134    "TEXTURE_1D",
 135    "TEXTURE_2D",
 136    "TEXTURE_3D",
 137    "TEXTURE_CUBE",
 138    "TEXTURE_RECT",
 139    "TEXTURE_SHADOW1D",
 140    "TEXTURE_SHADOW2D",
 141    "TEXTURE_SHADOWRECT"
 142 };
 143
 144 static const char *TGSI_SRC_REGISTER_EXTS[] =
 145 {
 146    "",
 147    "SRC_REGISTER_EXT_TYPE_MOD"
 148 };
 149
 150 static const char *TGSI_WRITEMASKS[] =
 151 {
 152    "0",
 153    "WRITEMASK_X",
 154    "WRITEMASK_Y",
 155    "WRITEMASK_XY",
 156    "WRITEMASK_Z",
 157    "WRITEMASK_XZ",
 158    "WRITEMASK_YZ",
 159    "WRITEMASK_XYZ",
 160    "WRITEMASK_W",
 161    "WRITEMASK_XW",
 162    "WRITEMASK_YW",
 163    "WRITEMASK_XYW",
 164    "WRITEMASK_ZW",
 165    "WRITEMASK_XZW",
 166    "WRITEMASK_YZW",
 167    "WRITEMASK_XYZW"
 168 };
 169
 170 static const char *TGSI_DST_REGISTER_EXTS[] =
 171 {
 172    "",
 173    "DST_REGISTER_EXT_TYPE_MODULATE"
 174 };
 175
 176 static const char *TGSI_MODULATES[] =
 177 {
 178    "MODULATE_1X",
 179    "MODULATE_2X",
 180    "MODULATE_4X",
 181    "MODULATE_8X",
 182    "MODULATE_HALF",
 183    "MODULATE_QUARTER",
 184    "MODULATE_EIGHTH"
 185 };
 186
 187 static void
 188 dump_declaration_verbose(
 189    struct tgsi_full_declaration  *decl,
 190    unsigned                      ignored,
 191    unsigned                      deflt,
 192    struct tgsi_full_declaration  *fd )
 193 {
 194    TXT( "\nFile       : " );
 195    ENM( decl->Declaration.File, TGSI_FILES );
 196    if( deflt || fd->Declaration.UsageMask != decl->Declaration.UsageMask ) {
 197       TXT( "\nUsageMask  : " );
 198       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_X ) {
 199          CHR( 'X' );
 200       }
 201       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Y ) {
 202          CHR( 'Y' );
 203       }
 204       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_Z ) {
 205          CHR( 'Z' );
 206       }
 207       if( decl->Declaration.UsageMask & TGSI_WRITEMASK_W ) {
 208          CHR( 'W' );
 209       }
 210    }
 211    if( deflt || fd->Declaration.Interpolate != decl->Declaration.Interpolate ) {
 212       TXT( "\nInterpolate: " );
 213       ENM( decl->Declaration.Interpolate, TGSI_INTERPOLATES );
 214    }
 215    if( deflt || fd->Declaration.Semantic != decl->Declaration.Semantic ) {
 216       TXT( "\nSemantic   : " );
 217       UID( decl->Declaration.Semantic );
 218    }
 219    if( ignored ) {
 220       TXT( "\nPadding    : " );
 221       UIX( decl->Declaration.Padding );
 222    }
 223
 224    EOL();
 225    TXT( "\nFirst: " );
 226    UID( decl->Range.First );
 227    TXT( "\nLast : " );
 228    UID( decl->Range.Last );
 229
 230    if( decl->Declaration.Semantic ) {
 231       EOL();
 232       TXT( "\nName : " );
 233       ENM( decl->Semantic.Name, TGSI_SEMANTICS );
 234       TXT( "\nIndex: " );
 235       UID( decl->Semantic.Index );
 236       if( ignored ) {
 237          TXT( "\nPadding      : " );
 238          UIX( decl->Semantic.Padding );
 239       }
 240    }
 241 }
 242
 243 static void
 244 dump_immediate_verbose(
 245    struct tgsi_full_immediate *imm,
 246    unsigned                   ignored )
 247 {
 248    unsigned i;
 249
 250    TXT( "\nDataType   : " );
 251    ENM( imm->Immediate.DataType, TGSI_IMMS );
 252    if( ignored ) {
 253       TXT( "\nPadding    : " );
 254       UIX( imm->Immediate.Padding );
 255    }
 256
 257    assert( imm->Immediate.NrTokens <= 4 + 1 );
 258    for( i = 0; i < imm->Immediate.NrTokens - 1; i++ ) {
 259       EOL();
 260       switch( imm->Immediate.DataType ) {
 261       case TGSI_IMM_FLOAT32:
 262          TXT( "\nFloat: " );
 263          FLT( imm->u[i].Float );
 264          break;
 265
 266       default:
 267          assert( 0 );
 268       }
 269    }
 270 }
 271
 272 static void
 273 dump_instruction_verbose(
 274    struct tgsi_full_instruction  *inst,
 275    unsigned                      ignored,
 276    unsigned                      deflt,
 277    struct tgsi_full_instruction  *fi )
 278 {
 279    unsigned i;
 280
 281    TXT( "\nOpcode     : OPCODE_" );
 282    TXT( tgsi_get_opcode_info( inst->Instruction.Opcode )->mnemonic );
 283    if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
 284       TXT( "\nSaturate   : " );
 285       ENM( inst->Instruction.Saturate, TGSI_SATS );
 286    }
 287    if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
 288       TXT( "\nNumDstRegs : " );
 289       UID( inst->Instruction.NumDstRegs );
 290    }
 291    if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
 292       TXT( "\nNumSrcRegs : " );
 293       UID( inst->Instruction.NumSrcRegs );
 294    }
 295    if( ignored ) {
 296       TXT( "\nPadding    : " );
 297       UIX( inst->Instruction.Padding );
 298    }
 299
 300    if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
 301       EOL();
 302       TXT( "\nType    : " );
 303       ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
 304       if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
 305          TXT( "\nLabel   : " );
 306          UID( inst->InstructionExtLabel.Label );
 307       }
 308       if( ignored ) {
 309          TXT( "\nPadding : " );
 310          UIX( inst->InstructionExtLabel.Padding );
 311          if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
 312             TXT( "\nExtended: " );
 313             UID( inst->InstructionExtLabel.Extended );
 314          }
 315       }
 316    }
 317
 318    if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
 319       EOL();
 320       TXT( "\nType    : " );
 321       ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
 322       if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
 323          TXT( "\nTexture : " );
 324          ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
 325       }
 326       if( ignored ) {
 327          TXT( "\nPadding : " );
 328          UIX( inst->InstructionExtTexture.Padding );
 329          if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
 330             TXT( "\nExtended: " );
 331             UID( inst->InstructionExtTexture.Extended );
 332          }
 333       }
 334    }
 335
 336    for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
 337       struct tgsi_full_dst_register *dst = &inst->Dst[i];
 338       struct tgsi_full_dst_register *fd = &fi->Dst[i];
 339
 340       EOL();
 341       TXT( "\nFile     : " );
 342       ENM( dst->Register.File, TGSI_FILES );
 343       if( deflt || fd->Register.WriteMask != dst->Register.WriteMask ) {
 344          TXT( "\nWriteMask: " );
 345          ENM( dst->Register.WriteMask, TGSI_WRITEMASKS );
 346       }
 347       if( ignored ) {
 348          if( deflt || fd->Register.Indirect != dst->Register.Indirect ) {
 349             TXT( "\nIndirect : " );
 350             UID( dst->Register.Indirect );
 351          }
 352          if( deflt || fd->Register.Dimension != dst->Register.Dimension ) {
 353             TXT( "\nDimension: " );
 354             UID( dst->Register.Dimension );
 355          }
 356       }
 357       if( deflt || fd->Register.Index != dst->Register.Index ) {
 358          TXT( "\nIndex    : " );
 359          SID( dst->Register.Index );
 360       }
 361       if( ignored ) {
 362          TXT( "\nPadding  : " );
 363          UIX( dst->Register.Padding );
 364          if( deflt || fd->Register.Extended != dst->Register.Extended ) {
 365             TXT( "\nExtended : " );
 366             UID( dst->Register.Extended );
 367          }
 368       }
 369
 370       if( deflt || tgsi_compare_dst_register_ext_modulate( dst->RegisterExtModulate, fd->RegisterExtModulate ) ) {
 371          EOL();
 372          TXT( "\nType    : " );
 373          ENM( dst->RegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
 374          if( deflt || fd->RegisterExtModulate.Modulate != dst->RegisterExtModulate.Modulate ) {
 375             TXT( "\nModulate: " );
 376             ENM( dst->RegisterExtModulate.Modulate, TGSI_MODULATES );
 377          }
 378          if( ignored ) {
 379             TXT( "\nPadding : " );
 380             UIX( dst->RegisterExtModulate.Padding );
 381             if( deflt || fd->RegisterExtModulate.Extended != dst->RegisterExtModulate.Extended ) {
 382                TXT( "\nExtended: " );
 383                UID( dst->RegisterExtModulate.Extended );
 384             }
 385          }
 386       }
 387    }
 388
 389    for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
 390       struct tgsi_full_src_register *src = &inst->Src[i];
 391       struct tgsi_full_src_register *fs = &fi->Src[i];
 392
 393       EOL();
 394       TXT( "\nFile     : ");
 395       ENM( src->Register.File, TGSI_FILES );
 396       if( deflt || fs->Register.SwizzleX != src->Register.SwizzleX ) {
 397          TXT( "\nSwizzleX : " );
 398          ENM( src->Register.SwizzleX, TGSI_SWIZZLES );
 399       }
 400       if( deflt || fs->Register.SwizzleY != src->Register.SwizzleY ) {
 401          TXT( "\nSwizzleY : " );
 402          ENM( src->Register.SwizzleY, TGSI_SWIZZLES );
 403       }
 404       if( deflt || fs->Register.SwizzleZ != src->Register.SwizzleZ ) {
 405          TXT( "\nSwizzleZ : " );
 406          ENM( src->Register.SwizzleZ, TGSI_SWIZZLES );
 407       }
 408       if( deflt || fs->Register.SwizzleW != src->Register.SwizzleW ) {
 409          TXT( "\nSwizzleW : " );
 410          ENM( src->Register.SwizzleW, TGSI_SWIZZLES );
 411       }
 412       if( deflt || fs->Register.Negate != src->Register.Negate ) {
 413          TXT( "\nNegate   : " );
 414          UID( src->Register.Negate );
 415       }
 416       if( ignored ) {
 417          if( deflt || fs->Register.Indirect != src->Register.Indirect ) {
 418             TXT( "\nIndirect : " );
 419             UID( src->Register.Indirect );
 420          }
 421          if( deflt || fs->Register.Dimension != src->Register.Dimension ) {
 422             TXT( "\nDimension: " );
 423             UID( src->Register.Dimension );
 424          }
 425       }
 426       if( deflt || fs->Register.Index != src->Register.Index ) {
 427          TXT( "\nIndex    : " );
 428          SID( src->Register.Index );
 429       }
 430       if( ignored ) {
 431          if( deflt || fs->Register.Extended != src->Register.Extended ) {
 432             TXT( "\nExtended : " );
 433             UID( src->Register.Extended );
 434          }
 435       }
 436
 437       if( deflt || tgsi_compare_src_register_ext_mod( src->RegisterExtMod, fs->RegisterExtMod ) ) {
 438          EOL();
 439          TXT( "\nType     : " );
 440          ENM( src->RegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
 441          if( deflt || fs->RegisterExtMod.Complement != src->RegisterExtMod.Complement ) {
 442             TXT( "\nComplement: " );
 443             UID( src->RegisterExtMod.Complement );
 444          }
 445          if( deflt || fs->RegisterExtMod.Bias != src->RegisterExtMod.Bias ) {
 446             TXT( "\nBias     : " );
 447             UID( src->RegisterExtMod.Bias );
 448          }
 449          if( deflt || fs->RegisterExtMod.Scale2X != src->RegisterExtMod.Scale2X ) {
 450             TXT( "\nScale2X   : " );
 451             UID( src->RegisterExtMod.Scale2X );
 452          }
 453          if( deflt || fs->RegisterExtMod.Absolute != src->RegisterExtMod.Absolute ) {
 454             TXT( "\nAbsolute  : " );
 455             UID( src->RegisterExtMod.Absolute );
 456          }
 457          if( deflt || fs->RegisterExtMod.Negate != src->RegisterExtMod.Negate ) {
 458             TXT( "\nNegate   : " );
 459             UID( src->RegisterExtMod.Negate );
 460          }
 461          if( ignored ) {
 462             TXT( "\nPadding   : " );
 463             UIX( src->RegisterExtMod.Padding );
 464             if( deflt || fs->RegisterExtMod.Extended != src->RegisterExtMod.Extended ) {
 465                TXT( "\nExtended  : " );
 466                UID( src->RegisterExtMod.Extended );
 467             }
 468          }
 469       }
 470    }
 471 }
 472
 473 void
 474 tgsi_dump_c(
 475    const struct tgsi_token *tokens,
 476    uint flags )
 477 {
 478    struct tgsi_parse_context parse;
 479    struct tgsi_full_instruction fi;
 480    struct tgsi_full_declaration fd;
 481    uint ignored = flags & TGSI_DUMP_C_IGNORED;
 482    uint deflt = flags & TGSI_DUMP_C_DEFAULT;
 483
 484    tgsi_parse_init( &parse, tokens );
 485
 486    TXT( "tgsi-dump begin -----------------" );
 487
 488    TXT( "\nMajor: " );
 489    UID( parse.FullVersion.Version.Major );
 490    TXT( "\nMinor: " );
 491    UID( parse.FullVersion.Version.Minor );
 492    EOL();
 493
 494    TXT( "\nHeaderSize: " );
 495    UID( parse.FullHeader.Header.HeaderSize );
 496    TXT( "\nBodySize  : " );
 497    UID( parse.FullHeader.Header.BodySize );
 498    TXT( "\nProcessor : " );
 499    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
 500    EOL();
 501
 502    fi = tgsi_default_full_instruction();
 503    fd = tgsi_default_full_declaration();
 504
 505    while( !tgsi_parse_end_of_tokens( &parse ) ) {
 506       tgsi_parse_token( &parse );
 507
 508       TXT( "\nType       : " );
 509       ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
 510       if( ignored ) {
 511          TXT( "\nSize       : " );
 512          UID( parse.FullToken.Token.NrTokens );
 513          if( deflt || parse.FullToken.Token.Extended ) {
 514             TXT( "\nExtended   : " );
 515             UID( parse.FullToken.Token.Extended );
 516          }
 517       }
 518
 519       switch( parse.FullToken.Token.Type ) {
 520       case TGSI_TOKEN_TYPE_DECLARATION:
 521          dump_declaration_verbose(
 522             &parse.FullToken.FullDeclaration,
 523             ignored,
 524             deflt,
 525             &fd );
 526          break;
 527
 528       case TGSI_TOKEN_TYPE_IMMEDIATE:
 529          dump_immediate_verbose(
 530             &parse.FullToken.FullImmediate,
 531             ignored );
 532          break;
 533
 534       case TGSI_TOKEN_TYPE_INSTRUCTION:
 535          dump_instruction_verbose(
 536             &parse.FullToken.FullInstruction,
 537             ignored,
 538             deflt,
 539             &fi );
 540          break;
 541
 542       default:
 543          assert( 0 );
 544       }
 545
 546       EOL();
 547    }
 548
 549    TXT( "\ntgsi-dump end -------------------\n" );
 550
 551    tgsi_parse_free( &parse );
 552 }