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
[] =
215 static const char *TGSI_SEMANTICS_SHORT
[] =
228 static const char *TGSI_IMMS
[] =
233 static const char *TGSI_IMMS_SHORT
[] =
238 static const char *TGSI_OPCODES
[] =
271 "OPCODE_CROSSPRODUCT",
272 "OPCODE_MULTIPLYMATRIX",
354 "OPCODE_TEXM3X3SPEC",
355 "OPCODE_TEXM3X3VSPEC",
361 "OPCODE_TEXM3X2DEPTH",
375 static const char *TGSI_OPCODES_SHORT
[] =
511 static const char *TGSI_SATS
[] =
518 static const char *TGSI_INSTRUCTION_EXTS
[] =
520 "INSTRUCTION_EXT_TYPE_NV",
521 "INSTRUCTION_EXT_TYPE_LABEL",
522 "INSTRUCTION_EXT_TYPE_TEXTURE"
525 static const char *TGSI_PRECISIONS
[] =
528 "TGSI_PRECISION_FLOAT32",
529 "TGSI_PRECISION_FLOAT16",
530 "TGSI_PRECISION_FIXED12"
533 static const char *TGSI_CCS
[] =
546 static const char *TGSI_SWIZZLES
[] =
554 static const char *TGSI_SWIZZLES_SHORT
[] =
562 static const char *TGSI_TEXTURES
[] =
575 static const char *TGSI_SRC_REGISTER_EXTS
[] =
577 "SRC_REGISTER_EXT_TYPE_SWZ",
578 "SRC_REGISTER_EXT_TYPE_MOD"
581 static const char *TGSI_EXTSWIZZLES
[] =
591 static const char *TGSI_WRITEMASKS
[] =
611 static const char *TGSI_DST_REGISTER_EXTS
[] =
613 "DST_REGISTER_EXT_TYPE_CONDCODE",
614 "DST_REGISTER_EXT_TYPE_MODULATE"
617 static const char *TGSI_MODULATES
[] =
629 dump_declaration_short(
630 struct text_dump
*dump
,
631 struct tgsi_full_declaration
*decl
)
634 ENM( decl
->Declaration
.File
, TGSI_FILES_SHORT
);
636 switch( decl
->Declaration
.Declare
) {
637 case TGSI_DECLARE_RANGE
:
639 UID( decl
->u
.DeclarationRange
.First
);
640 if( decl
->u
.DeclarationRange
.First
!= decl
->u
.DeclarationRange
.Last
) {
642 UID( decl
->u
.DeclarationRange
.Last
);
650 if( decl
->Declaration
.UsageMask
!= TGSI_WRITEMASK_XYZW
) {
652 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_X
) {
655 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Y
) {
658 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Z
) {
661 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_W
) {
666 if( decl
->Declaration
.Interpolate
) {
668 ENM( decl
->Interpolation
.Interpolate
, TGSI_INTERPOLATES_SHORT
);
671 if( decl
->Declaration
.Semantic
) {
673 ENM( decl
->Semantic
.SemanticName
, TGSI_SEMANTICS_SHORT
);
675 UID( decl
->Semantic
.SemanticIndex
);
681 dump_declaration_verbose(
682 struct text_dump
*dump
,
683 struct tgsi_full_declaration
*decl
,
686 struct tgsi_full_declaration
*fd
)
689 ENM( decl
->Declaration
.File
, TGSI_FILES
);
690 TXT( "\nDeclare : " );
691 ENM( decl
->Declaration
.Declare
, TGSI_DECLARES
);
692 if( deflt
|| fd
->Declaration
.UsageMask
!= decl
->Declaration
.UsageMask
) {
693 TXT( "\nUsageMask : " );
694 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_X
) {
697 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Y
) {
700 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_Z
) {
703 if( decl
->Declaration
.UsageMask
& TGSI_WRITEMASK_W
) {
707 if( deflt
|| fd
->Declaration
.Interpolate
!= decl
->Declaration
.Interpolate
) {
708 TXT( "\nInterpolate: " );
709 UID( decl
->Declaration
.Interpolate
);
711 if( deflt
|| fd
->Declaration
.Semantic
!= decl
->Declaration
.Semantic
) {
712 TXT( "\nSemantic : " );
713 UID( decl
->Declaration
.Semantic
);
716 TXT( "\nPadding : " );
717 UIX( decl
->Declaration
.Padding
);
721 switch( decl
->Declaration
.Declare
) {
722 case TGSI_DECLARE_RANGE
:
724 UID( decl
->u
.DeclarationRange
.First
);
726 UID( decl
->u
.DeclarationRange
.Last
);
729 case TGSI_DECLARE_MASK
:
731 UIX( decl
->u
.DeclarationMask
.Mask
);
738 if( decl
->Declaration
.Interpolate
) {
740 TXT( "\nInterpolate: " );
741 ENM( decl
->Interpolation
.Interpolate
, TGSI_INTERPOLATES
);
743 TXT( "\nPadding : " );
744 UIX( decl
->Interpolation
.Padding
);
748 if( decl
->Declaration
.Semantic
) {
750 TXT( "\nSemanticName : " );
751 ENM( decl
->Semantic
.SemanticName
, TGSI_SEMANTICS
);
752 TXT( "\nSemanticIndex: " );
753 UID( decl
->Semantic
.SemanticIndex
);
755 TXT( "\nPadding : " );
756 UIX( decl
->Semantic
.Padding
);
762 dump_immediate_short(
763 struct text_dump
*dump
,
764 struct tgsi_full_immediate
*imm
)
769 ENM( imm
->Immediate
.DataType
, TGSI_IMMS_SHORT
);
772 for( i
= 0; i
< imm
->Immediate
.Size
- 1; i
++ ) {
773 switch( imm
->Immediate
.DataType
) {
774 case TGSI_IMM_FLOAT32
:
775 FLT( imm
->u
.ImmediateFloat32
[i
].Float
);
782 if( i
< imm
->Immediate
.Size
- 2 ) {
790 dump_immediate_verbose(
791 struct text_dump
*dump
,
792 struct tgsi_full_immediate
*imm
,
797 TXT( "\nDataType : " );
798 ENM( imm
->Immediate
.DataType
, TGSI_IMMS
);
800 TXT( "\nPadding : " );
801 UIX( imm
->Immediate
.Padding
);
804 for( i
= 0; i
< imm
->Immediate
.Size
- 1; i
++ ) {
806 switch( imm
->Immediate
.DataType
) {
807 case TGSI_IMM_FLOAT32
:
809 FLT( imm
->u
.ImmediateFloat32
[i
].Float
);
819 dump_instruction_short(
820 struct text_dump
*dump
,
821 struct tgsi_full_instruction
*inst
,
825 boolean first_reg
= TRUE
;
830 ENM( inst
->Instruction
.Opcode
, TGSI_OPCODES_SHORT
);
832 switch( inst
->Instruction
.Saturate
) {
835 case TGSI_SAT_ZERO_ONE
:
838 case TGSI_SAT_MINUS_PLUS_ONE
:
845 for( i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++ ) {
846 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
853 ENM( dst
->DstRegister
.File
, TGSI_FILES_SHORT
);
856 SID( dst
->DstRegister
.Index
);
859 if( dst
->DstRegister
.WriteMask
!= TGSI_WRITEMASK_XYZW
) {
861 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_X
) {
864 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_Y
) {
867 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_Z
) {
870 if( dst
->DstRegister
.WriteMask
& TGSI_WRITEMASK_W
) {
878 for( i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++ ) {
879 struct tgsi_full_src_register
*src
= &inst
->FullSrcRegisters
[i
];
886 if( src
->SrcRegisterExtMod
.Negate
) {
889 if( src
->SrcRegisterExtMod
.Absolute
) {
892 if( src
->SrcRegister
.Negate
) {
896 ENM( src
->SrcRegister
.File
, TGSI_FILES_SHORT
);
899 SID( src
->SrcRegister
.Index
);
902 if( src
->SrcRegister
.SwizzleX
!= TGSI_SWIZZLE_X
||
903 src
->SrcRegister
.SwizzleY
!= TGSI_SWIZZLE_Y
||
904 src
->SrcRegister
.SwizzleZ
!= TGSI_SWIZZLE_Z
||
905 src
->SrcRegister
.SwizzleW
!= TGSI_SWIZZLE_W
) {
907 ENM( src
->SrcRegister
.SwizzleX
, TGSI_SWIZZLES_SHORT
);
908 ENM( src
->SrcRegister
.SwizzleY
, TGSI_SWIZZLES_SHORT
);
909 ENM( src
->SrcRegister
.SwizzleZ
, TGSI_SWIZZLES_SHORT
);
910 ENM( src
->SrcRegister
.SwizzleW
, TGSI_SWIZZLES_SHORT
);
913 if( src
->SrcRegisterExtMod
.Absolute
) {
920 switch( inst
->Instruction
.Opcode
) {
922 case TGSI_OPCODE_ELSE
:
924 UID( inst
->InstructionExtLabel
.Label
);
930 dump_instruction_verbose(
931 struct text_dump
*dump
,
932 struct tgsi_full_instruction
*inst
,
935 struct tgsi_full_instruction
*fi
)
939 TXT( "\nOpcode : " );
940 ENM( inst
->Instruction
.Opcode
, TGSI_OPCODES
);
941 if( deflt
|| fi
->Instruction
.Saturate
!= inst
->Instruction
.Saturate
) {
942 TXT( "\nSaturate : " );
943 ENM( inst
->Instruction
.Saturate
, TGSI_SATS
);
945 if( deflt
|| fi
->Instruction
.NumDstRegs
!= inst
->Instruction
.NumDstRegs
) {
946 TXT( "\nNumDstRegs : " );
947 UID( inst
->Instruction
.NumDstRegs
);
949 if( deflt
|| fi
->Instruction
.NumSrcRegs
!= inst
->Instruction
.NumSrcRegs
) {
950 TXT( "\nNumSrcRegs : " );
951 UID( inst
->Instruction
.NumSrcRegs
);
954 TXT( "\nPadding : " );
955 UIX( inst
->Instruction
.Padding
);
958 if( deflt
|| tgsi_compare_instruction_ext_nv( inst
->InstructionExtNv
, fi
->InstructionExtNv
) ) {
961 ENM( inst
->InstructionExtNv
.Type
, TGSI_INSTRUCTION_EXTS
);
962 if( deflt
|| fi
->InstructionExtNv
.Precision
!= inst
->InstructionExtNv
.Precision
) {
963 TXT( "\nPrecision : " );
964 ENM( inst
->InstructionExtNv
.Precision
, TGSI_PRECISIONS
);
966 if( deflt
|| fi
->InstructionExtNv
.CondDstIndex
!= inst
->InstructionExtNv
.CondDstIndex
) {
967 TXT( "\nCondDstIndex : " );
968 UID( inst
->InstructionExtNv
.CondDstIndex
);
970 if( deflt
|| fi
->InstructionExtNv
.CondFlowIndex
!= inst
->InstructionExtNv
.CondFlowIndex
) {
971 TXT( "\nCondFlowIndex : " );
972 UID( inst
->InstructionExtNv
.CondFlowIndex
);
974 if( deflt
|| fi
->InstructionExtNv
.CondMask
!= inst
->InstructionExtNv
.CondMask
) {
975 TXT( "\nCondMask : " );
976 ENM( inst
->InstructionExtNv
.CondMask
, TGSI_CCS
);
978 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleX
!= inst
->InstructionExtNv
.CondSwizzleX
) {
979 TXT( "\nCondSwizzleX : " );
980 ENM( inst
->InstructionExtNv
.CondSwizzleX
, TGSI_SWIZZLES
);
982 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleY
!= inst
->InstructionExtNv
.CondSwizzleY
) {
983 TXT( "\nCondSwizzleY : " );
984 ENM( inst
->InstructionExtNv
.CondSwizzleY
, TGSI_SWIZZLES
);
986 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleZ
!= inst
->InstructionExtNv
.CondSwizzleZ
) {
987 TXT( "\nCondSwizzleZ : " );
988 ENM( inst
->InstructionExtNv
.CondSwizzleZ
, TGSI_SWIZZLES
);
990 if( deflt
|| fi
->InstructionExtNv
.CondSwizzleW
!= inst
->InstructionExtNv
.CondSwizzleW
) {
991 TXT( "\nCondSwizzleW : " );
992 ENM( inst
->InstructionExtNv
.CondSwizzleW
, TGSI_SWIZZLES
);
994 if( deflt
|| fi
->InstructionExtNv
.CondDstUpdate
!= inst
->InstructionExtNv
.CondDstUpdate
) {
995 TXT( "\nCondDstUpdate : " );
996 UID( inst
->InstructionExtNv
.CondDstUpdate
);
998 if( deflt
|| fi
->InstructionExtNv
.CondFlowEnable
!= inst
->InstructionExtNv
.CondFlowEnable
) {
999 TXT( "\nCondFlowEnable: " );
1000 UID( inst
->InstructionExtNv
.CondFlowEnable
);
1003 TXT( "\nPadding : " );
1004 UIX( inst
->InstructionExtNv
.Padding
);
1005 if( deflt
|| fi
->InstructionExtNv
.Extended
!= inst
->InstructionExtNv
.Extended
) {
1006 TXT( "\nExtended : " );
1007 UID( inst
->InstructionExtNv
.Extended
);
1012 if( deflt
|| tgsi_compare_instruction_ext_label( inst
->InstructionExtLabel
, fi
->InstructionExtLabel
) ) {
1015 ENM( inst
->InstructionExtLabel
.Type
, TGSI_INSTRUCTION_EXTS
);
1016 if( deflt
|| fi
->InstructionExtLabel
.Label
!= inst
->InstructionExtLabel
.Label
) {
1017 TXT( "\nLabel : " );
1018 UID( inst
->InstructionExtLabel
.Label
);
1021 TXT( "\nPadding : " );
1022 UIX( inst
->InstructionExtLabel
.Padding
);
1023 if( deflt
|| fi
->InstructionExtLabel
.Extended
!= inst
->InstructionExtLabel
.Extended
) {
1024 TXT( "\nExtended: " );
1025 UID( inst
->InstructionExtLabel
.Extended
);
1030 if( deflt
|| tgsi_compare_instruction_ext_texture( inst
->InstructionExtTexture
, fi
->InstructionExtTexture
) ) {
1033 ENM( inst
->InstructionExtTexture
.Type
, TGSI_INSTRUCTION_EXTS
);
1034 if( deflt
|| fi
->InstructionExtTexture
.Texture
!= inst
->InstructionExtTexture
.Texture
) {
1035 TXT( "\nTexture : " );
1036 ENM( inst
->InstructionExtTexture
.Texture
, TGSI_TEXTURES
);
1039 TXT( "\nPadding : " );
1040 UIX( inst
->InstructionExtTexture
.Padding
);
1041 if( deflt
|| fi
->InstructionExtTexture
.Extended
!= inst
->InstructionExtTexture
.Extended
) {
1042 TXT( "\nExtended: " );
1043 UID( inst
->InstructionExtTexture
.Extended
);
1048 for( i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++ ) {
1049 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
1050 struct tgsi_full_dst_register
*fd
= &fi
->FullDstRegisters
[i
];
1054 ENM( dst
->DstRegister
.File
, TGSI_FILES
);
1055 if( deflt
|| fd
->DstRegister
.WriteMask
!= dst
->DstRegister
.WriteMask
) {
1056 TXT( "\nWriteMask: " );
1057 ENM( dst
->DstRegister
.WriteMask
, TGSI_WRITEMASKS
);
1060 if( deflt
|| fd
->DstRegister
.Indirect
!= dst
->DstRegister
.Indirect
) {
1061 TXT( "\nIndirect : " );
1062 UID( dst
->DstRegister
.Indirect
);
1064 if( deflt
|| fd
->DstRegister
.Dimension
!= dst
->DstRegister
.Dimension
) {
1065 TXT( "\nDimension: " );
1066 UID( dst
->DstRegister
.Dimension
);
1069 if( deflt
|| fd
->DstRegister
.Index
!= dst
->DstRegister
.Index
) {
1070 TXT( "\nIndex : " );
1071 SID( dst
->DstRegister
.Index
);
1074 TXT( "\nPadding : " );
1075 UIX( dst
->DstRegister
.Padding
);
1076 if( deflt
|| fd
->DstRegister
.Extended
!= dst
->DstRegister
.Extended
) {
1077 TXT( "\nExtended : " );
1078 UID( dst
->DstRegister
.Extended
);
1082 if( deflt
|| tgsi_compare_dst_register_ext_concode( dst
->DstRegisterExtConcode
, fd
->DstRegisterExtConcode
) ) {
1085 ENM( dst
->DstRegisterExtConcode
.Type
, TGSI_DST_REGISTER_EXTS
);
1086 if( deflt
|| fd
->DstRegisterExtConcode
.CondMask
!= dst
->DstRegisterExtConcode
.CondMask
) {
1087 TXT( "\nCondMask : " );
1088 ENM( dst
->DstRegisterExtConcode
.CondMask
, TGSI_CCS
);
1090 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleX
!= dst
->DstRegisterExtConcode
.CondSwizzleX
) {
1091 TXT( "\nCondSwizzleX: " );
1092 ENM( dst
->DstRegisterExtConcode
.CondSwizzleX
, TGSI_SWIZZLES
);
1094 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleY
!= dst
->DstRegisterExtConcode
.CondSwizzleY
) {
1095 TXT( "\nCondSwizzleY: " );
1096 ENM( dst
->DstRegisterExtConcode
.CondSwizzleY
, TGSI_SWIZZLES
);
1098 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleZ
!= dst
->DstRegisterExtConcode
.CondSwizzleZ
) {
1099 TXT( "\nCondSwizzleZ: " );
1100 ENM( dst
->DstRegisterExtConcode
.CondSwizzleZ
, TGSI_SWIZZLES
);
1102 if( deflt
|| fd
->DstRegisterExtConcode
.CondSwizzleW
!= dst
->DstRegisterExtConcode
.CondSwizzleW
) {
1103 TXT( "\nCondSwizzleW: " );
1104 ENM( dst
->DstRegisterExtConcode
.CondSwizzleW
, TGSI_SWIZZLES
);
1106 if( deflt
|| fd
->DstRegisterExtConcode
.CondSrcIndex
!= dst
->DstRegisterExtConcode
.CondSrcIndex
) {
1107 TXT( "\nCondSrcIndex: " );
1108 UID( dst
->DstRegisterExtConcode
.CondSrcIndex
);
1111 TXT( "\nPadding : " );
1112 UIX( dst
->DstRegisterExtConcode
.Padding
);
1113 if( deflt
|| fd
->DstRegisterExtConcode
.Extended
!= dst
->DstRegisterExtConcode
.Extended
) {
1114 TXT( "\nExtended : " );
1115 UID( dst
->DstRegisterExtConcode
.Extended
);
1120 if( deflt
|| tgsi_compare_dst_register_ext_modulate( dst
->DstRegisterExtModulate
, fd
->DstRegisterExtModulate
) ) {
1123 ENM( dst
->DstRegisterExtModulate
.Type
, TGSI_DST_REGISTER_EXTS
);
1124 if( deflt
|| fd
->DstRegisterExtModulate
.Modulate
!= dst
->DstRegisterExtModulate
.Modulate
) {
1125 TXT( "\nModulate: " );
1126 ENM( dst
->DstRegisterExtModulate
.Modulate
, TGSI_MODULATES
);
1129 TXT( "\nPadding : " );
1130 UIX( dst
->DstRegisterExtModulate
.Padding
);
1131 if( deflt
|| fd
->DstRegisterExtModulate
.Extended
!= dst
->DstRegisterExtModulate
.Extended
) {
1132 TXT( "\nExtended: " );
1133 UID( dst
->DstRegisterExtModulate
.Extended
);
1139 for( i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++ ) {
1140 struct tgsi_full_src_register
*src
= &inst
->FullSrcRegisters
[i
];
1141 struct tgsi_full_src_register
*fs
= &fi
->FullSrcRegisters
[i
];
1145 ENM( src
->SrcRegister
.File
, TGSI_FILES
);
1146 if( deflt
|| fs
->SrcRegister
.SwizzleX
!= src
->SrcRegister
.SwizzleX
) {
1147 TXT( "\nSwizzleX : " );
1148 ENM( src
->SrcRegister
.SwizzleX
, TGSI_SWIZZLES
);
1150 if( deflt
|| fs
->SrcRegister
.SwizzleY
!= src
->SrcRegister
.SwizzleY
) {
1151 TXT( "\nSwizzleY : " );
1152 ENM( src
->SrcRegister
.SwizzleY
, TGSI_SWIZZLES
);
1154 if( deflt
|| fs
->SrcRegister
.SwizzleZ
!= src
->SrcRegister
.SwizzleZ
) {
1155 TXT( "\nSwizzleZ : " );
1156 ENM( src
->SrcRegister
.SwizzleZ
, TGSI_SWIZZLES
);
1158 if( deflt
|| fs
->SrcRegister
.SwizzleW
!= src
->SrcRegister
.SwizzleW
) {
1159 TXT( "\nSwizzleW : " );
1160 ENM( src
->SrcRegister
.SwizzleW
, TGSI_SWIZZLES
);
1162 if( deflt
|| fs
->SrcRegister
.Negate
!= src
->SrcRegister
.Negate
) {
1163 TXT( "\nNegate : " );
1164 UID( src
->SrcRegister
.Negate
);
1167 if( deflt
|| fs
->SrcRegister
.Indirect
!= src
->SrcRegister
.Indirect
) {
1168 TXT( "\nIndirect : " );
1169 UID( src
->SrcRegister
.Indirect
);
1171 if( deflt
|| fs
->SrcRegister
.Dimension
!= src
->SrcRegister
.Dimension
) {
1172 TXT( "\nDimension: " );
1173 UID( src
->SrcRegister
.Dimension
);
1176 if( deflt
|| fs
->SrcRegister
.Index
!= src
->SrcRegister
.Index
) {
1177 TXT( "\nIndex : " );
1178 SID( src
->SrcRegister
.Index
);
1181 if( deflt
|| fs
->SrcRegister
.Extended
!= src
->SrcRegister
.Extended
) {
1182 TXT( "\nExtended : " );
1183 UID( src
->SrcRegister
.Extended
);
1187 if( deflt
|| tgsi_compare_src_register_ext_swz( src
->SrcRegisterExtSwz
, fs
->SrcRegisterExtSwz
) ) {
1190 ENM( src
->SrcRegisterExtSwz
.Type
, TGSI_SRC_REGISTER_EXTS
);
1191 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleX
!= src
->SrcRegisterExtSwz
.ExtSwizzleX
) {
1192 TXT( "\nExtSwizzleX: " );
1193 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleX
, TGSI_EXTSWIZZLES
);
1195 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleY
!= src
->SrcRegisterExtSwz
.ExtSwizzleY
) {
1196 TXT( "\nExtSwizzleY: " );
1197 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleY
, TGSI_EXTSWIZZLES
);
1199 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleZ
!= src
->SrcRegisterExtSwz
.ExtSwizzleZ
) {
1200 TXT( "\nExtSwizzleZ: " );
1201 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleZ
, TGSI_EXTSWIZZLES
);
1203 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtSwizzleW
!= src
->SrcRegisterExtSwz
.ExtSwizzleW
) {
1204 TXT( "\nExtSwizzleW: " );
1205 ENM( src
->SrcRegisterExtSwz
.ExtSwizzleW
, TGSI_EXTSWIZZLES
);
1207 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateX
!= src
->SrcRegisterExtSwz
.NegateX
) {
1208 TXT( "\nNegateX : " );
1209 UID( src
->SrcRegisterExtSwz
.NegateX
);
1211 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateY
!= src
->SrcRegisterExtSwz
.NegateY
) {
1212 TXT( "\nNegateY : " );
1213 UID( src
->SrcRegisterExtSwz
.NegateY
);
1215 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateZ
!= src
->SrcRegisterExtSwz
.NegateZ
) {
1216 TXT( "\nNegateZ : " );
1217 UID( src
->SrcRegisterExtSwz
.NegateZ
);
1219 if( deflt
|| fs
->SrcRegisterExtSwz
.NegateW
!= src
->SrcRegisterExtSwz
.NegateW
) {
1220 TXT( "\nNegateW : " );
1221 UID( src
->SrcRegisterExtSwz
.NegateW
);
1223 if( deflt
|| fs
->SrcRegisterExtSwz
.ExtDivide
!= src
->SrcRegisterExtSwz
.ExtDivide
) {
1224 TXT( "\nExtDivide : " );
1225 ENM( src
->SrcRegisterExtSwz
.ExtDivide
, TGSI_EXTSWIZZLES
);
1228 TXT( "\nPadding : " );
1229 UIX( src
->SrcRegisterExtSwz
.Padding
);
1230 if( deflt
|| fs
->SrcRegisterExtSwz
.Extended
!= src
->SrcRegisterExtSwz
.Extended
) {
1231 TXT( "\nExtended : " );
1232 UID( src
->SrcRegisterExtSwz
.Extended
);
1237 if( deflt
|| tgsi_compare_src_register_ext_mod( src
->SrcRegisterExtMod
, fs
->SrcRegisterExtMod
) ) {
1240 ENM( src
->SrcRegisterExtMod
.Type
, TGSI_SRC_REGISTER_EXTS
);
1241 if( deflt
|| fs
->SrcRegisterExtMod
.Complement
!= src
->SrcRegisterExtMod
.Complement
) {
1242 TXT( "\nComplement: " );
1243 UID( src
->SrcRegisterExtMod
.Complement
);
1245 if( deflt
|| fs
->SrcRegisterExtMod
.Bias
!= src
->SrcRegisterExtMod
.Bias
) {
1247 UID( src
->SrcRegisterExtMod
.Bias
);
1249 if( deflt
|| fs
->SrcRegisterExtMod
.Scale2X
!= src
->SrcRegisterExtMod
.Scale2X
) {
1250 TXT( "\nScale2X : " );
1251 UID( src
->SrcRegisterExtMod
.Scale2X
);
1253 if( deflt
|| fs
->SrcRegisterExtMod
.Absolute
!= src
->SrcRegisterExtMod
.Absolute
) {
1254 TXT( "\nAbsolute : " );
1255 UID( src
->SrcRegisterExtMod
.Absolute
);
1257 if( deflt
|| fs
->SrcRegisterExtMod
.Negate
!= src
->SrcRegisterExtMod
.Negate
) {
1258 TXT( "\nNegate : " );
1259 UID( src
->SrcRegisterExtMod
.Negate
);
1262 TXT( "\nPadding : " );
1263 UIX( src
->SrcRegisterExtMod
.Padding
);
1264 if( deflt
|| fs
->SrcRegisterExtMod
.Extended
!= src
->SrcRegisterExtMod
.Extended
) {
1265 TXT( "\nExtended : " );
1266 UID( src
->SrcRegisterExtMod
.Extended
);
1275 const struct tgsi_token
*tokens
,
1278 struct text_dump _dump
;
1279 struct text_dump
*dump
= &_dump
;
1280 struct tgsi_parse_context parse
;
1281 struct tgsi_full_instruction fi
;
1282 struct tgsi_full_declaration fd
;
1283 unsigned verbose
= flags
& TGSI_DUMP_VERBOSE
;
1284 unsigned ignored
= !(flags
& TGSI_DUMP_NO_IGNORED
);
1285 unsigned deflt
= !(flags
& TGSI_DUMP_NO_DEFAULT
);
1286 unsigned instno
= 0;
1290 static unsigned counter
= 0;
1293 sprintf( buffer
, "tgsi-dump-%.4u.txt", counter
++ );
1294 dump
->file
= fopen( buffer
, "wt" );
1296 dump
->file
= stderr
;
1302 assert(strcmp(TGSI_OPCODES
[TGSI_OPCODE_CONT
], "OPCODE_CONT") == 0);
1304 tgsi_parse_init( &parse
, tokens
);
1306 TXT( "tgsi-dump begin -----------------" );
1309 ENM( parse
.FullHeader
.Processor
.Processor
, TGSI_PROCESSOR_TYPES_SHORT
);
1311 UID( parse
.FullVersion
.Version
.MajorVersion
);
1313 UID( parse
.FullVersion
.Version
.MinorVersion
);
1316 TXT( "\nMajorVersion: " );
1317 UID( parse
.FullVersion
.Version
.MajorVersion
);
1318 TXT( "\nMinorVersion: " );
1319 UID( parse
.FullVersion
.Version
.MinorVersion
);
1322 TXT( "\nHeaderSize: " );
1323 UID( parse
.FullHeader
.Header
.HeaderSize
);
1324 TXT( "\nBodySize : " );
1325 UID( parse
.FullHeader
.Header
.BodySize
);
1326 TXT( "\nProcessor : " );
1327 ENM( parse
.FullHeader
.Processor
.Processor
, TGSI_PROCESSOR_TYPES
);
1331 fi
= tgsi_default_full_instruction();
1332 fd
= tgsi_default_full_declaration();
1334 while( !tgsi_parse_end_of_tokens( &parse
) ) {
1335 tgsi_parse_token( &parse
);
1337 switch( parse
.FullToken
.Token
.Type
) {
1338 case TGSI_TOKEN_TYPE_DECLARATION
:
1339 dump_declaration_short(
1341 &parse
.FullToken
.FullDeclaration
);
1344 case TGSI_TOKEN_TYPE_IMMEDIATE
:
1345 dump_immediate_short(
1347 &parse
.FullToken
.FullImmediate
);
1350 case TGSI_TOKEN_TYPE_INSTRUCTION
:
1351 dump_instruction_short(
1353 &parse
.FullToken
.FullInstruction
,
1364 ENM( parse
.FullToken
.Token
.Type
, TGSI_TOKEN_TYPES
);
1367 UID( parse
.FullToken
.Token
.Size
);
1368 if( deflt
|| parse
.FullToken
.Token
.Extended
) {
1369 TXT( "\nExtended : " );
1370 UID( parse
.FullToken
.Token
.Extended
);
1374 switch( parse
.FullToken
.Token
.Type
) {
1375 case TGSI_TOKEN_TYPE_DECLARATION
:
1376 dump_declaration_verbose(
1378 &parse
.FullToken
.FullDeclaration
,
1384 case TGSI_TOKEN_TYPE_IMMEDIATE
:
1385 dump_immediate_verbose(
1387 &parse
.FullToken
.FullImmediate
,
1391 case TGSI_TOKEN_TYPE_INSTRUCTION
:
1392 dump_instruction_verbose(
1394 &parse
.FullToken
.FullInstruction
,
1408 TXT( "\ntgsi-dump end -------------------\n" );
1410 tgsi_parse_free( &parse
);
1412 if (dump
->file
!= stderr
&&
1413 dump
->file
!= stdout
)
1414 fclose( dump
->file
);