1 #include "tgsi_platform.h"
12 struct text_dump
*dump
,
16 fwrite( buffer
, size
, 1, dump
->file
);
21 struct text_dump
*dump
,
25 size_t len
= strlen( str
);
27 for( i
= 0; i
< len
; i
++ ) {
28 text_dump_write( dump
, &str
[i
], 1 );
30 if( str
[i
] == '\n' ) {
33 for( i
= 0; i
< dump
->tabs
; i
++ ) {
34 text_dump_write( dump
, " ", 4 );
42 struct text_dump
*dump
,
49 text_dump_str( dump
, str
);
54 struct text_dump
*dump
,
59 sprintf( str
, "0x%x", ui
);
60 text_dump_str( dump
, str
);
65 struct text_dump
*dump
,
70 sprintf( str
, "%u", ui
);
71 text_dump_str( dump
, str
);
76 struct text_dump
*dump
,
81 sprintf( str
, "%d", si
);
82 text_dump_str( dump
, str
);
87 struct text_dump
*dump
,
92 sprintf( str
, "%40.6f", f
);
93 text_dump_str( dump
, str
);
98 struct text_dump
*dump
,
101 const unsigned enums_count
)
103 if( e
>= enums_count
) {
104 text_dump_uid( dump
, e
);
107 text_dump_str( dump
, enums
[e
] );
113 struct text_dump
*dump
)
120 struct text_dump
*dump
)
122 assert( dump
->tabs
> 0 );
127 #define TXT(S) text_dump_str( dump, S )
128 #define CHR(C) text_dump_chr( dump, C )
129 #define UIX(I) text_dump_uix( dump, I )
130 #define UID(I) text_dump_uid( dump, I )
131 #define SID(I) text_dump_sid( dump, I )
132 #define FLT(F) text_dump_flt( dump, F )
133 #define TAB() text_dump_tab( dump )
134 #define UNT() text_dump_untab( dump )
135 #define ENM(E,ENUMS) text_dump_enum( dump, E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
137 static const char *TGSI_PROCESSOR_TYPES
[] =
139 "PROCESSOR_FRAGMENT",
144 static const char *TGSI_PROCESSOR_TYPES_SHORT
[] =
151 static const char *TGSI_TOKEN_TYPES
[] =
153 "TOKEN_TYPE_DECLARATION",
154 "TOKEN_TYPE_IMMEDIATE",
155 "TOKEN_TYPE_INSTRUCTION"
158 static const char *TGSI_FILES
[] =
170 static const char *TGSI_FILES_SHORT
[] =
182 static const char *TGSI_DECLARES
[] =
188 static const char *TGSI_INTERPOLATES
[] =
190 "INTERPOLATE_CONSTANT",
191 "INTERPOLATE_LINEAR",
192 "INTERPOLATE_PERSPECTIVE"
195 static const char *TGSI_INTERPOLATES_SHORT
[] =
202 static const char *TGSI_SEMANTICS
[] =
212 static const char *TGSI_SEMANTICS_SHORT
[] =
222 static const char *TGSI_IMMS
[] =
227 static const char *TGSI_IMMS_SHORT
[] =
232 static const char *TGSI_OPCODES
[] =
265 "OPCODE_CROSSPRODUCT",
266 "OPCODE_MULTIPLYMATRIX",
348 "OPCODE_TEXM3X3SPEC",
349 "OPCODE_TEXM3X3VSPEC",
355 "OPCODE_TEXM3X2DEPTH",
369 static const char *TGSI_OPCODES_SHORT
[] =
505 static const char *TGSI_SATS
[] =
512 static const char *TGSI_INSTRUCTION_EXTS
[] =
514 "INSTRUCTION_EXT_TYPE_NV",
515 "INSTRUCTION_EXT_TYPE_LABEL",
516 "INSTRUCTION_EXT_TYPE_TEXTURE"
519 static const char *TGSI_PRECISIONS
[] =
522 "TGSI_PRECISION_FLOAT32",
523 "TGSI_PRECISION_FLOAT16",
524 "TGSI_PRECISION_FIXED12"
527 static const char *TGSI_CCS
[] =
540 static const char *TGSI_SWIZZLES
[] =
548 static const char *TGSI_SWIZZLES_SHORT
[] =
556 static const char *TGSI_TEXTURES
[] =
569 static const char *TGSI_SRC_REGISTER_EXTS
[] =
571 "SRC_REGISTER_EXT_TYPE_SWZ",
572 "SRC_REGISTER_EXT_TYPE_MOD"
575 static const char *TGSI_EXTSWIZZLES
[] =
585 static const char *TGSI_WRITEMASKS
[] =
605 static const char *TGSI_DST_REGISTER_EXTS
[] =
607 "DST_REGISTER_EXT_TYPE_CONDCODE",
608 "DST_REGISTER_EXT_TYPE_MODULATE"
611 static const char *TGSI_MODULATES
[] =
623 dump_declaration_short(
624 struct text_dump
*dump
,
625 struct tgsi_full_declaration
*decl
)
628 ENM( decl
->Declaration
.File
, TGSI_FILES_SHORT
);
630 switch( decl
->Declaration
.Declare
) {
631 case TGSI_DECLARE_RANGE
:
633 UID( decl
->u
.DeclarationRange
.First
);
634 if( decl
->u
.DeclarationRange
.First
!= decl
->u
.DeclarationRange
.Last
) {
636 UID( decl
->u
.DeclarationRange
.Last
);
644 if( decl
->Declaration
.UsageMask
!= TGSI_WRITEMASK_XYZW
) {
646 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_X
) {
649 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Y
) {
652 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Z
) {
655 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_W
) {
660 if( decl
->Declaration
.Interpolate
) {
662 ENM( decl
->Interpolation
.Interpolate
, TGSI_INTERPOLATES_SHORT
);
665 if( decl
->Declaration
.Semantic
) {
667 ENM( decl
->Semantic
.SemanticName
, TGSI_SEMANTICS_SHORT
);
669 UID( decl
->Semantic
.SemanticIndex
);
675 dump_declaration_verbose(
676 struct text_dump
*dump
,
677 struct tgsi_full_declaration
*decl
,
680 struct tgsi_full_declaration
*fd
)
683 ENM( decl
->Declaration
.File
, TGSI_FILES
);
684 TXT( "\nDeclare : " );
685 ENM( decl
->Declaration
.Declare
, TGSI_DECLARES
);
686 if( deflt
|| fd
->Declaration
.UsageMask
!= decl
->Declaration
.UsageMask
) {
687 TXT( "\nUsageMask : " );
688 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_X
) {
691 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Y
) {
694 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Z
) {
697 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_W
) {
701 if( deflt
|| fd
->Declaration
.Interpolate
!= decl
->Declaration
.Interpolate
) {
702 TXT( "\nInterpolate: " );
703 UID( decl
->Declaration
.Interpolate
);
705 if( deflt
|| fd
->Declaration
.Semantic
!= decl
->Declaration
.Semantic
) {
706 TXT( "\nSemantic : " );
707 UID( decl
->Declaration
.Semantic
);
710 TXT( "\nPadding : " );
711 UIX( decl
->Declaration
.Padding
);
715 switch( decl
->Declaration
.Declare
) {
716 case TGSI_DECLARE_RANGE
:
718 UID( decl
->u
.DeclarationRange
.First
);
720 UID( decl
->u
.DeclarationRange
.Last
);
723 case TGSI_DECLARE_MASK
:
725 UIX( decl
->u
.DeclarationMask
.Mask
);
732 if( decl
->Declaration
.Interpolate
) {
734 TXT( "\nInterpolate: " );
735 ENM( decl
->Interpolation
.Interpolate
, TGSI_INTERPOLATES
);
737 TXT( "\nPadding : " );
738 UIX( decl
->Interpolation
.Padding
);
742 if( decl
->Declaration
.Semantic
) {
744 TXT( "\nSemanticName : " );
745 ENM( decl
->Semantic
.SemanticName
, TGSI_SEMANTICS
);
746 TXT( "\nSemanticIndex: " );
747 UID( decl
->Semantic
.SemanticIndex
);
749 TXT( "\nPadding : " );
750 UIX( decl
->Semantic
.Padding
);
756 dump_immediate_short(
757 struct text_dump
*dump
,
758 struct tgsi_full_immediate
*imm
)
763 ENM( imm
->Immediate
.DataType
, TGSI_IMMS_SHORT
);
766 for( i
= 0; i
< imm
->Immediate
.Size
- 1; i
++ ) {
767 switch( imm
->Immediate
.DataType
) {
768 case TGSI_IMM_FLOAT32
:
769 FLT( imm
->u
.ImmediateFloat32
[i
].Float
);
776 if( i
< imm
->Immediate
.Size
- 2 ) {
784 dump_immediate_verbose(
785 struct text_dump
*dump
,
786 struct tgsi_full_immediate
*imm
,
791 TXT( "\nDataType : " );
792 ENM( imm
->Immediate
.DataType
, TGSI_IMMS
);
794 TXT( "\nPadding : " );
795 UIX( imm
->Immediate
.Padding
);
798 for( i
= 0; i
< imm
->Immediate
.Size
- 1; i
++ ) {
800 switch( imm
->Immediate
.DataType
) {
801 case TGSI_IMM_FLOAT32
:
803 FLT( imm
->u
.ImmediateFloat32
[i
].Float
);
813 dump_instruction_short(
814 struct text_dump
*dump
,
815 struct tgsi_full_instruction
*inst
,
819 boolean first_reg
= TRUE
;
824 ENM( inst
->Instruction
.Opcode
, TGSI_OPCODES_SHORT
);
826 switch( inst
->Instruction
.Saturate
) {
829 case TGSI_SAT_ZERO_ONE
:
832 case TGSI_SAT_MINUS_PLUS_ONE
:
839 for( i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++ ) {
840 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
847 ENM( dst
->DstRegister
.File
, TGSI_FILES_SHORT
);
850 SID( dst
->DstRegister
.Index
);
853 if( dst
->DstRegister
.WriteMask
!= TGSI_WRITEMASK_XYZW
) {
855 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_X
) {
858 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_Y
) {
861 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_Z
) {
864 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_W
) {
872 for( i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++ ) {
873 struct tgsi_full_src_register
*src
= &inst
->FullSrcRegisters
[i
];
880 if( src
->SrcRegisterExtMod
.Negate
) {
883 if( src
->SrcRegisterExtMod
.Absolute
) {
886 if( src
->SrcRegister
.Negate
) {
890 ENM( src
->SrcRegister
.File
, TGSI_FILES_SHORT
);
893 SID( src
->SrcRegister
.Index
);
896 if( src
->SrcRegister
.SwizzleX
!= TGSI_SWIZZLE_X
||
897 src
->SrcRegister
.SwizzleY
!= TGSI_SWIZZLE_Y
||
898 src
->SrcRegister
.SwizzleZ
!= TGSI_SWIZZLE_Z
||
899 src
->SrcRegister
.SwizzleW
!= TGSI_SWIZZLE_W
) {
901 ENM( src
->SrcRegister
.SwizzleX
, TGSI_SWIZZLES_SHORT
);
902 ENM( src
->SrcRegister
.SwizzleY
, TGSI_SWIZZLES_SHORT
);
903 ENM( src
->SrcRegister
.SwizzleZ
, TGSI_SWIZZLES_SHORT
);
904 ENM( src
->SrcRegister
.SwizzleW
, TGSI_SWIZZLES_SHORT
);
907 if( src
->SrcRegisterExtMod
.Absolute
) {
914 switch( inst
->Instruction
.Opcode
) {
916 case TGSI_OPCODE_ELSE
:
918 UID( inst
->InstructionExtLabel
.Label
);
924 dump_instruction_verbose(
925 struct text_dump
*dump
,
926 struct tgsi_full_instruction
*inst
,
929 struct tgsi_full_instruction
*fi
)
933 TXT( "\nOpcode : " );
934 ENM( inst
->Instruction
.Opcode
, TGSI_OPCODES
);
935 if( deflt
|| fi
->Instruction
.Saturate
!= inst
->Instruction
.Saturate
) {
936 TXT( "\nSaturate : " );
937 ENM( inst
->Instruction
.Saturate
, TGSI_SATS
);
939 if( deflt
|| fi
->Instruction
.NumDstRegs
!= inst
->Instruction
.NumDstRegs
) {
940 TXT( "\nNumDstRegs : " );
941 UID( inst
->Instruction
.NumDstRegs
);
943 if( deflt
|| fi
->Instruction
.NumSrcRegs
!= inst
->Instruction
.NumSrcRegs
) {
944 TXT( "\nNumSrcRegs : " );
945 UID( inst
->Instruction
.NumSrcRegs
);
948 TXT( "\nPadding : " );
949 UIX( inst
->Instruction
.Padding
);
952 if( deflt
|| tgsi_compare_instruction_ext_nv( inst
->InstructionExtNv
, fi
->InstructionExtNv
) ) {
955 ENM( inst
->InstructionExtNv
.Type
, TGSI_INSTRUCTION_EXTS
);
956 if( deflt
|| fi
->InstructionExtNv
.Precision
!= inst
->InstructionExtNv
.Precision
) {
957 TXT( "\nPrecision : " );
958 ENM( inst
->InstructionExtNv
.Precision
, TGSI_PRECISIONS
);
960 if( deflt
|| fi
->InstructionExtNv
.CondDstIndex
!= inst
->InstructionExtNv
.CondDstIndex
) {
961 TXT( "\nCondDstIndex : " );
962 UID( inst
->InstructionExtNv
.CondDstIndex
);
964 if( deflt
|| fi
->InstructionExtNv
.CondFlowIndex
!= inst
->InstructionExtNv
.CondFlowIndex
) {
965 TXT( "\nCondFlowIndex : " );
966 UID( inst
->InstructionExtNv
.CondFlowIndex
);
968 if( deflt
|| fi
->InstructionExtNv
.CondMask
!= inst
->InstructionExtNv
.CondMask
) {
969 TXT( "\nCondMask : " );
970 ENM( inst
->InstructionExtNv
.CondMask
, TGSI_CCS
);
972 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleX
!= inst
->InstructionExtNv
.CondSwizzleX
) {
973 TXT( "\nCondSwizzleX : " );
974 ENM( inst
->InstructionExtNv
.CondSwizzleX
, TGSI_SWIZZLES
);
976 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleY
!= inst
->InstructionExtNv
.CondSwizzleY
) {
977 TXT( "\nCondSwizzleY : " );
978 ENM( inst
->InstructionExtNv
.CondSwizzleY
, TGSI_SWIZZLES
);
980 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleZ
!= inst
->InstructionExtNv
.CondSwizzleZ
) {
981 TXT( "\nCondSwizzleZ : " );
982 ENM( inst
->InstructionExtNv
.CondSwizzleZ
, TGSI_SWIZZLES
);
984 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleW
!= inst
->InstructionExtNv
.CondSwizzleW
) {
985 TXT( "\nCondSwizzleW : " );
986 ENM( inst
->InstructionExtNv
.CondSwizzleW
, TGSI_SWIZZLES
);
988 if( deflt
|| fi
->InstructionExtNv
.CondDstUpdate
!= inst
->InstructionExtNv
.CondDstUpdate
) {
989 TXT( "\nCondDstUpdate : " );
990 UID( inst
->InstructionExtNv
.CondDstUpdate
);
992 if( deflt
|| fi
->InstructionExtNv
.CondFlowEnable
!= inst
->InstructionExtNv
.CondFlowEnable
) {
993 TXT( "\nCondFlowEnable: " );
994 UID( inst
->InstructionExtNv
.CondFlowEnable
);
997 TXT( "\nPadding : " );
998 UIX( inst
->InstructionExtNv
.Padding
);
999 if( deflt
|| fi
->InstructionExtNv
.Extended
!= inst
->InstructionExtNv
.Extended
) {
1000 TXT( "\nExtended : " );
1001 UID( inst
->InstructionExtNv
.Extended
);
1006 if( deflt
|| tgsi_compare_instruction_ext_label( inst
->InstructionExtLabel
, fi
->InstructionExtLabel
) ) {
1009 ENM( inst
->InstructionExtLabel
.Type
, TGSI_INSTRUCTION_EXTS
);
1010 if( deflt
|| fi
->InstructionExtLabel
.Label
!= inst
->InstructionExtLabel
.Label
) {
1011 TXT( "\nLabel : " );
1012 UID( inst
->InstructionExtLabel
.Label
);
1015 TXT( "\nPadding : " );
1016 UIX( inst
->InstructionExtLabel
.Padding
);
1017 if( deflt
|| fi
->InstructionExtLabel
.Extended
!= inst
->InstructionExtLabel
.Extended
) {
1018 TXT( "\nExtended: " );
1019 UID( inst
->InstructionExtLabel
.Extended
);
1024 if( deflt
|| tgsi_compare_instruction_ext_texture( inst
->InstructionExtTexture
, fi
->InstructionExtTexture
) ) {
1027 ENM( inst
->InstructionExtTexture
.Type
, TGSI_INSTRUCTION_EXTS
);
1028 if( deflt
|| fi
->InstructionExtTexture
.Texture
!= inst
->InstructionExtTexture
.Texture
) {
1029 TXT( "\nTexture : " );
1030 ENM( inst
->InstructionExtTexture
.Texture
, TGSI_TEXTURES
);
1033 TXT( "\nPadding : " );
1034 UIX( inst
->InstructionExtTexture
.Padding
);
1035 if( deflt
|| fi
->InstructionExtTexture
.Extended
!= inst
->InstructionExtTexture
.Extended
) {
1036 TXT( "\nExtended: " );
1037 UID( inst
->InstructionExtTexture
.Extended
);
1042 for( i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++ ) {
1043 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
1044 struct tgsi_full_dst_register
*fd
= &fi
->FullDstRegisters
[i
];
1048 ENM( dst
->DstRegister
.File
, TGSI_FILES
);
1049 if( deflt
|| fd
->DstRegister
.WriteMask
!= dst
->DstRegister
.WriteMask
) {
1050 TXT( "\nWriteMask: " );
1051 ENM( dst
->DstRegister
.WriteMask
, TGSI_WRITEMASKS
);
1054 if( deflt
|| fd
->DstRegister
.Indirect
!= dst
->DstRegister
.Indirect
) {
1055 TXT( "\nIndirect : " );
1056 UID( dst
->DstRegister
.Indirect
);
1058 if( deflt
|| fd
->DstRegister
.Dimension
!= dst
->DstRegister
.Dimension
) {
1059 TXT( "\nDimension: " );
1060 UID( dst
->DstRegister
.Dimension
);
1063 if( deflt
|| fd
->DstRegister
.Index
!= dst
->DstRegister
.Index
) {
1064 TXT( "\nIndex : " );
1065 SID( dst
->DstRegister
.Index
);
1068 TXT( "\nPadding : " );
1069 UIX( dst
->DstRegister
.Padding
);
1070 if( deflt
|| fd
->DstRegister
.Extended
!= dst
->DstRegister
.Extended
) {
1071 TXT( "\nExtended : " );
1072 UID( dst
->DstRegister
.Extended
);
1076 if( deflt
|| tgsi_compare_dst_register_ext_concode( dst
->DstRegisterExtConcode
, fd
->DstRegisterExtConcode
) ) {
1079 ENM( dst
->DstRegisterExtConcode
.Type
, TGSI_DST_REGISTER_EXTS
);
1080 if( deflt
|| fd
->DstRegisterExtConcode
.CondMask
!= dst
->DstRegisterExtConcode
.CondMask
) {
1081 TXT( "\nCondMask : " );
1082 ENM( dst
->DstRegisterExtConcode
.CondMask
, TGSI_CCS
);
1084 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleX
!= dst
->DstRegisterExtConcode
.CondSwizzleX
) {
1085 TXT( "\nCondSwizzleX: " );
1086 ENM( dst
->DstRegisterExtConcode
.CondSwizzleX
, TGSI_SWIZZLES
);
1088 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleY
!= dst
->DstRegisterExtConcode
.CondSwizzleY
) {
1089 TXT( "\nCondSwizzleY: " );
1090 ENM( dst
->DstRegisterExtConcode
.CondSwizzleY
, TGSI_SWIZZLES
);
1092 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleZ
!= dst
->DstRegisterExtConcode
.CondSwizzleZ
) {
1093 TXT( "\nCondSwizzleZ: " );
1094 ENM( dst
->DstRegisterExtConcode
.CondSwizzleZ
, TGSI_SWIZZLES
);
1096 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleW
!= dst
->DstRegisterExtConcode
.CondSwizzleW
) {
1097 TXT( "\nCondSwizzleW: " );
1098 ENM( dst
->DstRegisterExtConcode
.CondSwizzleW
, TGSI_SWIZZLES
);
1100 if( deflt
|| fd
->DstRegisterExtConcode
.CondSrcIndex
!= dst
->DstRegisterExtConcode
.CondSrcIndex
) {
1101 TXT( "\nCondSrcIndex: " );
1102 UID( dst
->DstRegisterExtConcode
.CondSrcIndex
);
1105 TXT( "\nPadding : " );
1106 UIX( dst
->DstRegisterExtConcode
.Padding
);
1107 if( deflt
|| fd
->DstRegisterExtConcode
.Extended
!= dst
->DstRegisterExtConcode
.Extended
) {
1108 TXT( "\nExtended : " );
1109 UID( dst
->DstRegisterExtConcode
.Extended
);
1114 if( deflt
|| tgsi_compare_dst_register_ext_modulate( dst
->DstRegisterExtModulate
, fd
->DstRegisterExtModulate
) ) {
1117 ENM( dst
->DstRegisterExtModulate
.Type
, TGSI_DST_REGISTER_EXTS
);
1118 if( deflt
|| fd
->DstRegisterExtModulate
.Modulate
!= dst
->DstRegisterExtModulate
.Modulate
) {
1119 TXT( "\nModulate: " );
1120 ENM( dst
->DstRegisterExtModulate
.Modulate
, TGSI_MODULATES
);
1123 TXT( "\nPadding : " );
1124 UIX( dst
->DstRegisterExtModulate
.Padding
);
1125 if( deflt
|| fd
->DstRegisterExtModulate
.Extended
!= dst
->DstRegisterExtModulate
.Extended
) {
1126 TXT( "\nExtended: " );
1127 UID( dst
->DstRegisterExtModulate
.Extended
);
1133 for( i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++ ) {
1134 struct tgsi_full_src_register
*src
= &inst
->FullSrcRegisters
[i
];
1135 struct tgsi_full_src_register
*fs
= &fi
->FullSrcRegisters
[i
];
1139 ENM( src
->SrcRegister
.File
, TGSI_FILES
);
1140 if( deflt
|| fs
->SrcRegister
.SwizzleX
!= src
->SrcRegister
.SwizzleX
) {
1141 TXT( "\nSwizzleX : " );
1142 ENM( src
->SrcRegister
.SwizzleX
, TGSI_SWIZZLES
);
1144 if( deflt
|| fs
->SrcRegister
.SwizzleY
!= src
->SrcRegister
.SwizzleY
) {
1145 TXT( "\nSwizzleY : " );
1146 ENM( src
->SrcRegister
.SwizzleY
, TGSI_SWIZZLES
);
1148 if( deflt
|| fs
->SrcRegister
.SwizzleZ
!= src
->SrcRegister
.SwizzleZ
) {
1149 TXT( "\nSwizzleZ : " );
1150 ENM( src
->SrcRegister
.SwizzleZ
, TGSI_SWIZZLES
);
1152 if( deflt
|| fs
->SrcRegister
.SwizzleW
!= src
->SrcRegister
.SwizzleW
) {
1153 TXT( "\nSwizzleW : " );
1154 ENM( src
->SrcRegister
.SwizzleW
, TGSI_SWIZZLES
);
1156 if( deflt
|| fs
->SrcRegister
.Negate
!= src
->SrcRegister
.Negate
) {
1157 TXT( "\nNegate : " );
1158 UID( src
->SrcRegister
.Negate
);
1161 if( deflt
|| fs
->SrcRegister
.Indirect
!= src
->SrcRegister
.Indirect
) {
1162 TXT( "\nIndirect : " );
1163 UID( src
->SrcRegister
.Indirect
);
1165 if( deflt
|| fs
->SrcRegister
.Dimension
!= src
->SrcRegister
.Dimension
) {
1166 TXT( "\nDimension: " );
1167 UID( src
->SrcRegister
.Dimension
);
1170 if( deflt
|| fs
->SrcRegister
.Index
!= src
->SrcRegister
.Index
) {
1171 TXT( "\nIndex : " );
1172 SID( src
->SrcRegister
.Index
);
1175 if( deflt
|| fs
->SrcRegister
.Extended
!= src
->SrcRegister
.Extended
) {
1176 TXT( "\nExtended : " );
1177 UID( src
->SrcRegister
.Extended
);
1181 if( deflt
|| tgsi_compare_src_register_ext_swz( src
->SrcRegisterExtSwz
, fs
->SrcRegisterExtSwz
) ) {
1184 ENM( src
->SrcRegisterExtSwz
.Type
, TGSI_SRC_REGISTER_EXTS
);
1185 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleX
!= src
->SrcRegisterExtSwz
.ExtSwizzleX
) {
1186 TXT( "\nExtSwizzleX: " );
1187 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleX
, TGSI_EXTSWIZZLES
);
1189 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleY
!= src
->SrcRegisterExtSwz
.ExtSwizzleY
) {
1190 TXT( "\nExtSwizzleY: " );
1191 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleY
, TGSI_EXTSWIZZLES
);
1193 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleZ
!= src
->SrcRegisterExtSwz
.ExtSwizzleZ
) {
1194 TXT( "\nExtSwizzleZ: " );
1195 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleZ
, TGSI_EXTSWIZZLES
);
1197 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleW
!= src
->SrcRegisterExtSwz
.ExtSwizzleW
) {
1198 TXT( "\nExtSwizzleW: " );
1199 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleW
, TGSI_EXTSWIZZLES
);
1201 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateX
!= src
->SrcRegisterExtSwz
.NegateX
) {
1202 TXT( "\nNegateX : " );
1203 UID( src
->SrcRegisterExtSwz
.NegateX
);
1205 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateY
!= src
->SrcRegisterExtSwz
.NegateY
) {
1206 TXT( "\nNegateY : " );
1207 UID( src
->SrcRegisterExtSwz
.NegateY
);
1209 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateZ
!= src
->SrcRegisterExtSwz
.NegateZ
) {
1210 TXT( "\nNegateZ : " );
1211 UID( src
->SrcRegisterExtSwz
.NegateZ
);
1213 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateW
!= src
->SrcRegisterExtSwz
.NegateW
) {
1214 TXT( "\nNegateW : " );
1215 UID( src
->SrcRegisterExtSwz
.NegateW
);
1217 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtDivide
!= src
->SrcRegisterExtSwz
.ExtDivide
) {
1218 TXT( "\nExtDivide : " );
1219 ENM( src
->SrcRegisterExtSwz
.ExtDivide
, TGSI_EXTSWIZZLES
);
1222 TXT( "\nPadding : " );
1223 UIX( src
->SrcRegisterExtSwz
.Padding
);
1224 if( deflt
|| fs
->SrcRegisterExtSwz
.Extended
!= src
->SrcRegisterExtSwz
.Extended
) {
1225 TXT( "\nExtended : " );
1226 UID( src
->SrcRegisterExtSwz
.Extended
);
1231 if( deflt
|| tgsi_compare_src_register_ext_mod( src
->SrcRegisterExtMod
, fs
->SrcRegisterExtMod
) ) {
1234 ENM( src
->SrcRegisterExtMod
.Type
, TGSI_SRC_REGISTER_EXTS
);
1235 if( deflt
|| fs
->SrcRegisterExtMod
.Complement
!= src
->SrcRegisterExtMod
.Complement
) {
1236 TXT( "\nComplement: " );
1237 UID( src
->SrcRegisterExtMod
.Complement
);
1239 if( deflt
|| fs
->SrcRegisterExtMod
.Bias
!= src
->SrcRegisterExtMod
.Bias
) {
1241 UID( src
->SrcRegisterExtMod
.Bias
);
1243 if( deflt
|| fs
->SrcRegisterExtMod
.Scale2X
!= src
->SrcRegisterExtMod
.Scale2X
) {
1244 TXT( "\nScale2X : " );
1245 UID( src
->SrcRegisterExtMod
.Scale2X
);
1247 if( deflt
|| fs
->SrcRegisterExtMod
.Absolute
!= src
->SrcRegisterExtMod
.Absolute
) {
1248 TXT( "\nAbsolute : " );
1249 UID( src
->SrcRegisterExtMod
.Absolute
);
1251 if( deflt
|| fs
->SrcRegisterExtMod
.Negate
!= src
->SrcRegisterExtMod
.Negate
) {
1252 TXT( "\nNegate : " );
1253 UID( src
->SrcRegisterExtMod
.Negate
);
1256 TXT( "\nPadding : " );
1257 UIX( src
->SrcRegisterExtMod
.Padding
);
1258 if( deflt
|| fs
->SrcRegisterExtMod
.Extended
!= src
->SrcRegisterExtMod
.Extended
) {
1259 TXT( "\nExtended : " );
1260 UID( src
->SrcRegisterExtMod
.Extended
);
1269 const struct tgsi_token
*tokens
,
1272 struct text_dump _dump
;
1273 struct text_dump
*dump
= &_dump
;
1274 struct tgsi_parse_context parse
;
1275 struct tgsi_full_instruction fi
;
1276 struct tgsi_full_declaration fd
;
1277 unsigned verbose
= flags
& TGSI_DUMP_VERBOSE
;
1278 unsigned ignored
= !(flags
& TGSI_DUMP_NO_IGNORED
);
1279 unsigned deflt
= !(flags
& TGSI_DUMP_NO_DEFAULT
);
1280 unsigned instno
= 0;
1284 static unsigned counter
= 0;
1287 sprintf( buffer
, "tgsi-dump-%.4u.txt", counter
++ );
1288 dump
->file
= fopen( buffer
, "wt" );
1290 dump
->file
= stderr
;
1296 assert(strcmp(TGSI_OPCODES
[TGSI_OPCODE_CONT
], "OPCODE_CONT") == 0);
1298 tgsi_parse_init( &parse
, tokens
);
1300 TXT( "tgsi-dump begin -----------------" );
1303 ENM( parse
.FullHeader
.Processor
.Processor
, TGSI_PROCESSOR_TYPES_SHORT
);
1305 UID( parse
.FullVersion
.Version
.MajorVersion
);
1307 UID( parse
.FullVersion
.Version
.MinorVersion
);
1310 TXT( "\nMajorVersion: " );
1311 UID( parse
.FullVersion
.Version
.MajorVersion
);
1312 TXT( "\nMinorVersion: " );
1313 UID( parse
.FullVersion
.Version
.MinorVersion
);
1316 TXT( "\nHeaderSize: " );
1317 UID( parse
.FullHeader
.Header
.HeaderSize
);
1318 TXT( "\nBodySize : " );
1319 UID( parse
.FullHeader
.Header
.BodySize
);
1320 TXT( "\nProcessor : " );
1321 ENM( parse
.FullHeader
.Processor
.Processor
, TGSI_PROCESSOR_TYPES
);
1325 fi
= tgsi_default_full_instruction();
1326 fd
= tgsi_default_full_declaration();
1328 while( !tgsi_parse_end_of_tokens( &parse
) ) {
1329 tgsi_parse_token( &parse
);
1331 switch( parse
.FullToken
.Token
.Type
) {
1332 case TGSI_TOKEN_TYPE_DECLARATION
:
1333 dump_declaration_short(
1335 &parse
.FullToken
.FullDeclaration
);
1338 case TGSI_TOKEN_TYPE_IMMEDIATE
:
1339 dump_immediate_short(
1341 &parse
.FullToken
.FullImmediate
);
1344 case TGSI_TOKEN_TYPE_INSTRUCTION
:
1345 dump_instruction_short(
1347 &parse
.FullToken
.FullInstruction
,
1358 ENM( parse
.FullToken
.Token
.Type
, TGSI_TOKEN_TYPES
);
1361 UID( parse
.FullToken
.Token
.Size
);
1362 if( deflt
|| parse
.FullToken
.Token
.Extended
) {
1363 TXT( "\nExtended : " );
1364 UID( parse
.FullToken
.Token
.Extended
);
1368 switch( parse
.FullToken
.Token
.Type
) {
1369 case TGSI_TOKEN_TYPE_DECLARATION
:
1370 dump_declaration_verbose(
1372 &parse
.FullToken
.FullDeclaration
,
1378 case TGSI_TOKEN_TYPE_IMMEDIATE
:
1379 dump_immediate_verbose(
1381 &parse
.FullToken
.FullImmediate
,
1385 case TGSI_TOKEN_TYPE_INSTRUCTION
:
1386 dump_instruction_verbose(
1388 &parse
.FullToken
.FullInstruction
,
1402 TXT( "\ntgsi-dump end -------------------\n" );
1404 tgsi_parse_free( &parse
);
1406 if (dump
->file
!= stderr
&&
1407 dump
->file
!= stdout
)
1408 fclose( dump
->file
);