1 /**************************************************************************
3 * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
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"
39 const unsigned enums_count
)
41 if (e
>= enums_count
) {
42 debug_printf( "%u", e
);
45 debug_printf( "%s", enums
[e
] );
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 ) )
58 static const char *TGSI_PROCESSOR_TYPES
[] =
65 static const char *TGSI_TOKEN_TYPES
[] =
67 "TOKEN_TYPE_DECLARATION",
68 "TOKEN_TYPE_IMMEDIATE",
69 "TOKEN_TYPE_INSTRUCTION"
72 static const char *TGSI_FILES
[TGSI_FILE_COUNT
] =
86 static const char *TGSI_INTERPOLATES
[] =
88 "INTERPOLATE_CONSTANT",
90 "INTERPOLATE_PERSPECTIVE"
93 static const char *TGSI_SEMANTICS
[] =
104 static const char *TGSI_IMMS
[] =
109 static const char *TGSI_SATS
[] =
116 static const char *TGSI_INSTRUCTION_EXTS
[] =
119 "INSTRUCTION_EXT_TYPE_LABEL",
120 "INSTRUCTION_EXT_TYPE_TEXTURE"
123 static const char *TGSI_SWIZZLES
[] =
131 static const char *TGSI_TEXTURES
[] =
144 static const char *TGSI_SRC_REGISTER_EXTS
[] =
147 "SRC_REGISTER_EXT_TYPE_MOD"
150 static const char *TGSI_WRITEMASKS
[] =
170 static const char *TGSI_DST_REGISTER_EXTS
[] =
173 "DST_REGISTER_EXT_TYPE_MODULATE"
176 static const char *TGSI_MODULATES
[] =
188 dump_declaration_verbose(
189 struct tgsi_full_declaration
*decl
,
192 struct tgsi_full_declaration
*fd
)
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
) {
201 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Y
) {
204 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Z
) {
207 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_W
) {
211 if( deflt
|| fd
->Declaration
.Interpolate
!= decl
->Declaration
.Interpolate
) {
212 TXT( "\nInterpolate: " );
213 ENM( decl
->Declaration
.Interpolate
, TGSI_INTERPOLATES
);
215 if( deflt
|| fd
->Declaration
.Semantic
!= decl
->Declaration
.Semantic
) {
216 TXT( "\nSemantic : " );
217 UID( decl
->Declaration
.Semantic
);
220 TXT( "\nPadding : " );
221 UIX( decl
->Declaration
.Padding
);
226 UID( decl
->DeclarationRange
.First
);
228 UID( decl
->DeclarationRange
.Last
);
230 if( decl
->Declaration
.Semantic
) {
232 TXT( "\nSemanticName : " );
233 ENM( decl
->Semantic
.SemanticName
, TGSI_SEMANTICS
);
234 TXT( "\nSemanticIndex: " );
235 UID( decl
->Semantic
.SemanticIndex
);
237 TXT( "\nPadding : " );
238 UIX( decl
->Semantic
.Padding
);
244 dump_immediate_verbose(
245 struct tgsi_full_immediate
*imm
,
250 TXT( "\nDataType : " );
251 ENM( imm
->Immediate
.DataType
, TGSI_IMMS
);
253 TXT( "\nPadding : " );
254 UIX( imm
->Immediate
.Padding
);
257 assert( imm
->Immediate
.NrTokens
<= 4 + 1 );
258 for( i
= 0; i
< imm
->Immediate
.NrTokens
- 1; i
++ ) {
260 switch( imm
->Immediate
.DataType
) {
261 case TGSI_IMM_FLOAT32
:
263 FLT( imm
->u
[i
].Float
);
273 dump_instruction_verbose(
274 struct tgsi_full_instruction
*inst
,
277 struct tgsi_full_instruction
*fi
)
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
);
287 if( deflt
|| fi
->Instruction
.NumDstRegs
!= inst
->Instruction
.NumDstRegs
) {
288 TXT( "\nNumDstRegs : " );
289 UID( inst
->Instruction
.NumDstRegs
);
291 if( deflt
|| fi
->Instruction
.NumSrcRegs
!= inst
->Instruction
.NumSrcRegs
) {
292 TXT( "\nNumSrcRegs : " );
293 UID( inst
->Instruction
.NumSrcRegs
);
296 TXT( "\nPadding : " );
297 UIX( inst
->Instruction
.Padding
);
300 if( deflt
|| tgsi_compare_instruction_ext_label( inst
->InstructionExtLabel
, fi
->InstructionExtLabel
) ) {
303 ENM( inst
->InstructionExtLabel
.Type
, TGSI_INSTRUCTION_EXTS
);
304 if( deflt
|| fi
->InstructionExtLabel
.Label
!= inst
->InstructionExtLabel
.Label
) {
306 UID( inst
->InstructionExtLabel
.Label
);
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
);
318 if( deflt
|| tgsi_compare_instruction_ext_texture( inst
->InstructionExtTexture
, fi
->InstructionExtTexture
) ) {
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
);
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
);
336 for( i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++ ) {
337 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
338 struct tgsi_full_dst_register
*fd
= &fi
->FullDstRegisters
[i
];
342 ENM( dst
->DstRegister
.File
, TGSI_FILES
);
343 if( deflt
|| fd
->DstRegister
.WriteMask
!= dst
->DstRegister
.WriteMask
) {
344 TXT( "\nWriteMask: " );
345 ENM( dst
->DstRegister
.WriteMask
, TGSI_WRITEMASKS
);
348 if( deflt
|| fd
->DstRegister
.Indirect
!= dst
->DstRegister
.Indirect
) {
349 TXT( "\nIndirect : " );
350 UID( dst
->DstRegister
.Indirect
);
352 if( deflt
|| fd
->DstRegister
.Dimension
!= dst
->DstRegister
.Dimension
) {
353 TXT( "\nDimension: " );
354 UID( dst
->DstRegister
.Dimension
);
357 if( deflt
|| fd
->DstRegister
.Index
!= dst
->DstRegister
.Index
) {
359 SID( dst
->DstRegister
.Index
);
362 TXT( "\nPadding : " );
363 UIX( dst
->DstRegister
.Padding
);
364 if( deflt
|| fd
->DstRegister
.Extended
!= dst
->DstRegister
.Extended
) {
365 TXT( "\nExtended : " );
366 UID( dst
->DstRegister
.Extended
);
370 if( deflt
|| tgsi_compare_dst_register_ext_modulate( dst
->DstRegisterExtModulate
, fd
->DstRegisterExtModulate
) ) {
373 ENM( dst
->DstRegisterExtModulate
.Type
, TGSI_DST_REGISTER_EXTS
);
374 if( deflt
|| fd
->DstRegisterExtModulate
.Modulate
!= dst
->DstRegisterExtModulate
.Modulate
) {
375 TXT( "\nModulate: " );
376 ENM( dst
->DstRegisterExtModulate
.Modulate
, TGSI_MODULATES
);
379 TXT( "\nPadding : " );
380 UIX( dst
->DstRegisterExtModulate
.Padding
);
381 if( deflt
|| fd
->DstRegisterExtModulate
.Extended
!= dst
->DstRegisterExtModulate
.Extended
) {
382 TXT( "\nExtended: " );
383 UID( dst
->DstRegisterExtModulate
.Extended
);
389 for( i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++ ) {
390 struct tgsi_full_src_register
*src
= &inst
->FullSrcRegisters
[i
];
391 struct tgsi_full_src_register
*fs
= &fi
->FullSrcRegisters
[i
];
395 ENM( src
->SrcRegister
.File
, TGSI_FILES
);
396 if( deflt
|| fs
->SrcRegister
.SwizzleX
!= src
->SrcRegister
.SwizzleX
) {
397 TXT( "\nSwizzleX : " );
398 ENM( src
->SrcRegister
.SwizzleX
, TGSI_SWIZZLES
);
400 if( deflt
|| fs
->SrcRegister
.SwizzleY
!= src
->SrcRegister
.SwizzleY
) {
401 TXT( "\nSwizzleY : " );
402 ENM( src
->SrcRegister
.SwizzleY
, TGSI_SWIZZLES
);
404 if( deflt
|| fs
->SrcRegister
.SwizzleZ
!= src
->SrcRegister
.SwizzleZ
) {
405 TXT( "\nSwizzleZ : " );
406 ENM( src
->SrcRegister
.SwizzleZ
, TGSI_SWIZZLES
);
408 if( deflt
|| fs
->SrcRegister
.SwizzleW
!= src
->SrcRegister
.SwizzleW
) {
409 TXT( "\nSwizzleW : " );
410 ENM( src
->SrcRegister
.SwizzleW
, TGSI_SWIZZLES
);
412 if( deflt
|| fs
->SrcRegister
.Negate
!= src
->SrcRegister
.Negate
) {
413 TXT( "\nNegate : " );
414 UID( src
->SrcRegister
.Negate
);
417 if( deflt
|| fs
->SrcRegister
.Indirect
!= src
->SrcRegister
.Indirect
) {
418 TXT( "\nIndirect : " );
419 UID( src
->SrcRegister
.Indirect
);
421 if( deflt
|| fs
->SrcRegister
.Dimension
!= src
->SrcRegister
.Dimension
) {
422 TXT( "\nDimension: " );
423 UID( src
->SrcRegister
.Dimension
);
426 if( deflt
|| fs
->SrcRegister
.Index
!= src
->SrcRegister
.Index
) {
428 SID( src
->SrcRegister
.Index
);
431 if( deflt
|| fs
->SrcRegister
.Extended
!= src
->SrcRegister
.Extended
) {
432 TXT( "\nExtended : " );
433 UID( src
->SrcRegister
.Extended
);
437 if( deflt
|| tgsi_compare_src_register_ext_mod( src
->SrcRegisterExtMod
, fs
->SrcRegisterExtMod
) ) {
440 ENM( src
->SrcRegisterExtMod
.Type
, TGSI_SRC_REGISTER_EXTS
);
441 if( deflt
|| fs
->SrcRegisterExtMod
.Complement
!= src
->SrcRegisterExtMod
.Complement
) {
442 TXT( "\nComplement: " );
443 UID( src
->SrcRegisterExtMod
.Complement
);
445 if( deflt
|| fs
->SrcRegisterExtMod
.Bias
!= src
->SrcRegisterExtMod
.Bias
) {
447 UID( src
->SrcRegisterExtMod
.Bias
);
449 if( deflt
|| fs
->SrcRegisterExtMod
.Scale2X
!= src
->SrcRegisterExtMod
.Scale2X
) {
450 TXT( "\nScale2X : " );
451 UID( src
->SrcRegisterExtMod
.Scale2X
);
453 if( deflt
|| fs
->SrcRegisterExtMod
.Absolute
!= src
->SrcRegisterExtMod
.Absolute
) {
454 TXT( "\nAbsolute : " );
455 UID( src
->SrcRegisterExtMod
.Absolute
);
457 if( deflt
|| fs
->SrcRegisterExtMod
.Negate
!= src
->SrcRegisterExtMod
.Negate
) {
458 TXT( "\nNegate : " );
459 UID( src
->SrcRegisterExtMod
.Negate
);
462 TXT( "\nPadding : " );
463 UIX( src
->SrcRegisterExtMod
.Padding
);
464 if( deflt
|| fs
->SrcRegisterExtMod
.Extended
!= src
->SrcRegisterExtMod
.Extended
) {
465 TXT( "\nExtended : " );
466 UID( src
->SrcRegisterExtMod
.Extended
);
475 const struct tgsi_token
*tokens
,
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
;
484 tgsi_parse_init( &parse
, tokens
);
486 TXT( "tgsi-dump begin -----------------" );
488 TXT( "\nMajorVersion: " );
489 UID( parse
.FullVersion
.Version
.MajorVersion
);
490 TXT( "\nMinorVersion: " );
491 UID( parse
.FullVersion
.Version
.MinorVersion
);
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
);
502 fi
= tgsi_default_full_instruction();
503 fd
= tgsi_default_full_declaration();
505 while( !tgsi_parse_end_of_tokens( &parse
) ) {
506 tgsi_parse_token( &parse
);
509 ENM( parse
.FullToken
.Token
.Type
, TGSI_TOKEN_TYPES
);
512 UID( parse
.FullToken
.Token
.NrTokens
);
513 if( deflt
|| parse
.FullToken
.Token
.Extended
) {
514 TXT( "\nExtended : " );
515 UID( parse
.FullToken
.Token
.Extended
);
519 switch( parse
.FullToken
.Token
.Type
) {
520 case TGSI_TOKEN_TYPE_DECLARATION
:
521 dump_declaration_verbose(
522 &parse
.FullToken
.FullDeclaration
,
528 case TGSI_TOKEN_TYPE_IMMEDIATE
:
529 dump_immediate_verbose(
530 &parse
.FullToken
.FullImmediate
,
534 case TGSI_TOKEN_TYPE_INSTRUCTION
:
535 dump_instruction_verbose(
536 &parse
.FullToken
.FullInstruction
,
549 TXT( "\ntgsi-dump end -------------------\n" );
551 tgsi_parse_free( &parse
);