1 /**************************************************************************
3 * Copyright 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 "tgsi_sanity.h"
30 #include "tgsi_info.h"
31 #include "tgsi_iterate.h"
33 typedef uint reg_flag
;
35 #define BITS_IN_REG_FLAG (sizeof( reg_flag ) * 8)
37 #define MAX_REGISTERS 1024
38 #define MAX_REG_FLAGS ((MAX_REGISTERS + BITS_IN_REG_FLAG - 1) / BITS_IN_REG_FLAG)
40 struct sanity_check_ctx
42 struct tgsi_iterate_context iter
;
44 reg_flag regs_decl
[TGSI_FILE_COUNT
][MAX_REG_FLAGS
];
45 reg_flag regs_used
[TGSI_FILE_COUNT
][MAX_REG_FLAGS
];
46 boolean regs_ind_used
[TGSI_FILE_COUNT
];
48 uint num_instructions
;
57 struct sanity_check_ctx
*ctx
,
63 debug_printf( "Error : " );
64 va_start( args
, format
);
65 _debug_vprintf( format
, args
);
73 struct sanity_check_ctx
*ctx
,
79 debug_printf( "Warning: " );
80 va_start( args
, format
);
81 _debug_vprintf( format
, args
);
89 struct sanity_check_ctx
*ctx
,
92 if (file
<= TGSI_FILE_NULL
|| file
>= TGSI_FILE_COUNT
) {
93 report_error( ctx
, "(%u): Invalid register file name", file
);
100 is_register_declared(
101 struct sanity_check_ctx
*ctx
,
105 assert( index
>= 0 && index
< MAX_REGISTERS
);
107 return (ctx
->regs_decl
[file
][index
/ BITS_IN_REG_FLAG
] & (1 << (index
% BITS_IN_REG_FLAG
))) ? TRUE
: FALSE
;
111 is_any_register_declared(
112 struct sanity_check_ctx
*ctx
,
117 for (i
= 0; i
< MAX_REG_FLAGS
; i
++)
118 if (ctx
->regs_decl
[file
][i
])
125 struct sanity_check_ctx
*ctx
,
129 assert( index
< MAX_REGISTERS
);
131 return (ctx
->regs_used
[file
][index
/ BITS_IN_REG_FLAG
] & (1 << (index
% BITS_IN_REG_FLAG
))) ? TRUE
: FALSE
;
134 static const char *file_names
[TGSI_FILE_COUNT
] =
149 check_register_usage(
150 struct sanity_check_ctx
*ctx
,
154 boolean indirect_access
)
156 if (!check_file_name( ctx
, file
))
159 if (indirect_access
) {
160 /* Note that 'index' is an offset relative to the value of the
161 * address register. No range checking done here.
163 if (!is_any_register_declared( ctx
, file
))
164 report_error( ctx
, "%s: Undeclared %s register", file_names
[file
], name
);
165 ctx
->regs_ind_used
[file
] = TRUE
;
168 if (index
< 0 || index
>= MAX_REGISTERS
) {
169 report_error( ctx
, "%s[%d]: Invalid %s index", file_names
[file
], index
, name
);
173 if (!is_register_declared( ctx
, file
, index
))
174 report_error( ctx
, "%s[%d]: Undeclared %s register", file_names
[file
], index
, name
);
175 ctx
->regs_used
[file
][index
/ BITS_IN_REG_FLAG
] |= (1 << (index
% BITS_IN_REG_FLAG
));
182 struct tgsi_iterate_context
*iter
,
183 struct tgsi_full_instruction
*inst
)
185 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
186 const struct tgsi_opcode_info
*info
;
189 if (inst
->Instruction
.Opcode
== TGSI_OPCODE_END
) {
190 if (ctx
->index_of_END
!= ~0) {
191 report_error( ctx
, "Too many END instructions" );
193 ctx
->index_of_END
= ctx
->num_instructions
;
196 info
= tgsi_get_opcode_info( inst
->Instruction
.Opcode
);
198 report_error( ctx
, "(%u): Invalid instruction opcode", inst
->Instruction
.Opcode
);
202 if (info
->num_dst
!= inst
->Instruction
.NumDstRegs
) {
203 report_error( ctx
, "%s: Invalid number of destination operands, should be %u", info
->mnemonic
, info
->num_dst
);
205 if (info
->num_src
!= inst
->Instruction
.NumSrcRegs
) {
206 report_error( ctx
, "%s: Invalid number of source operands, should be %u", info
->mnemonic
, info
->num_src
);
209 /* Check destination and source registers' validity.
210 * Mark the registers as used.
212 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
213 check_register_usage(
215 inst
->Dst
[i
].Register
.File
,
216 inst
->Dst
[i
].Register
.Index
,
220 for (i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++) {
221 check_register_usage(
223 inst
->Src
[i
].Register
.File
,
224 inst
->Src
[i
].Register
.Index
,
226 (boolean
)inst
->Src
[i
].Register
.Indirect
);
227 if (inst
->Src
[i
].Register
.Indirect
) {
231 file
= inst
->Src
[i
].Indirect
.File
;
232 index
= inst
->Src
[i
].Indirect
.Index
;
233 check_register_usage(
239 if (!(file
== TGSI_FILE_ADDRESS
|| file
== TGSI_FILE_LOOP
) || index
!= 0) {
240 report_warning(ctx
, "Indirect register neither ADDR[0] nor LOOP[0]");
245 switch (inst
->Instruction
.Opcode
) {
246 case TGSI_OPCODE_BGNFOR
:
247 case TGSI_OPCODE_ENDFOR
:
248 if (inst
->Dst
[0].Register
.File
!= TGSI_FILE_LOOP
||
249 inst
->Dst
[0].Register
.Index
!= 0) {
250 report_error(ctx
, "Destination register must be LOOP[0]");
255 switch (inst
->Instruction
.Opcode
) {
256 case TGSI_OPCODE_BGNFOR
:
257 if (inst
->Src
[0].Register
.File
!= TGSI_FILE_CONSTANT
&&
258 inst
->Src
[0].Register
.File
!= TGSI_FILE_IMMEDIATE
) {
259 report_error(ctx
, "Source register file must be either CONST or IMM");
264 ctx
->num_instructions
++;
271 struct tgsi_iterate_context
*iter
,
272 struct tgsi_full_declaration
*decl
)
274 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
278 /* No declarations allowed after the first instruction.
280 if (ctx
->num_instructions
> 0)
281 report_error( ctx
, "Instruction expected but declaration found" );
283 /* Check registers' validity.
284 * Mark the registers as declared.
286 file
= decl
->Declaration
.File
;
287 if (!check_file_name( ctx
, file
))
289 for (i
= decl
->Range
.First
; i
<= decl
->Range
.Last
; i
++) {
290 if (is_register_declared( ctx
, file
, i
))
291 report_error( ctx
, "%s[%u]: The same register declared more than once", file_names
[file
], i
);
292 ctx
->regs_decl
[file
][i
/ BITS_IN_REG_FLAG
] |= (1 << (i
% BITS_IN_REG_FLAG
));
300 struct tgsi_iterate_context
*iter
,
301 struct tgsi_full_immediate
*imm
)
303 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
305 assert( ctx
->num_imms
< MAX_REGISTERS
);
307 /* No immediates allowed after the first instruction.
309 if (ctx
->num_instructions
> 0)
310 report_error( ctx
, "Instruction expected but immediate found" );
312 /* Mark the register as declared.
314 ctx
->regs_decl
[TGSI_FILE_IMMEDIATE
][ctx
->num_imms
/ BITS_IN_REG_FLAG
] |= (1 << (ctx
->num_imms
% BITS_IN_REG_FLAG
));
317 /* Check data type validity.
319 if (imm
->Immediate
.DataType
!= TGSI_IMM_FLOAT32
) {
320 report_error( ctx
, "(%u): Invalid immediate data type", imm
->Immediate
.DataType
);
329 struct tgsi_iterate_context
*iter
)
331 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
334 /* There must be an END instruction somewhere.
336 if (ctx
->index_of_END
== ~0) {
337 report_error( ctx
, "Missing END instruction" );
340 /* Check if all declared registers were used.
342 for (file
= TGSI_FILE_NULL
; file
< TGSI_FILE_COUNT
; file
++) {
345 for (i
= 0; i
< MAX_REGISTERS
; i
++) {
346 if (is_register_declared( ctx
, file
, i
) && !is_register_used( ctx
, file
, i
) && !ctx
->regs_ind_used
[file
]) {
347 report_warning( ctx
, "%s[%u]: Register never used", file_names
[file
], i
);
352 /* Print totals, if any.
354 if (ctx
->errors
|| ctx
->warnings
)
355 debug_printf( "%u errors, %u warnings\n", ctx
->errors
, ctx
->warnings
);
362 const struct tgsi_token
*tokens
)
364 struct sanity_check_ctx ctx
;
366 ctx
.iter
.prolog
= NULL
;
367 ctx
.iter
.iterate_instruction
= iter_instruction
;
368 ctx
.iter
.iterate_declaration
= iter_declaration
;
369 ctx
.iter
.iterate_immediate
= iter_immediate
;
370 ctx
.iter
.epilog
= epilog
;
372 memset( ctx
.regs_decl
, 0, sizeof( ctx
.regs_decl
) );
373 memset( ctx
.regs_used
, 0, sizeof( ctx
.regs_used
) );
374 memset( ctx
.regs_ind_used
, 0, sizeof( ctx
.regs_ind_used
) );
376 ctx
.num_instructions
= 0;
377 ctx
.index_of_END
= ~0;
382 if (!tgsi_iterate_shader( tokens
, &ctx
.iter
))
385 return ctx
.errors
== 0;