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 "util/u_memory.h"
30 #include "util/u_prim.h"
31 #include "cso_cache/cso_hash.h"
32 #include "tgsi_sanity.h"
33 #include "tgsi_info.h"
34 #include "tgsi_iterate.h"
38 /* max 2 dimensions */
43 struct sanity_check_ctx
45 struct tgsi_iterate_context iter
;
46 struct cso_hash
*regs_decl
;
47 struct cso_hash
*regs_used
;
48 struct cso_hash
*regs_ind_used
;
51 uint num_instructions
;
56 uint implied_array_size
;
59 static INLINE
unsigned
60 scan_register_key(const scan_register
*reg
)
62 unsigned key
= reg
->file
;
63 key
|= (reg
->indices
[0] << 4);
64 key
|= (reg
->indices
[1] << 18);
70 fill_scan_register1d(scan_register
*reg
,
71 uint file
, uint index
)
75 reg
->indices
[0] = index
;
80 fill_scan_register2d(scan_register
*reg
,
81 uint file
, uint index1
, uint index2
)
85 reg
->indices
[0] = index1
;
86 reg
->indices
[1] = index2
;
90 scan_register_dst(scan_register
*reg
,
91 struct tgsi_full_dst_register
*dst
)
93 fill_scan_register1d(reg
,
99 scan_register_src(scan_register
*reg
,
100 struct tgsi_full_src_register
*src
)
102 if (src
->Register
.Dimension
) {
103 /*FIXME: right now we don't support indirect
104 * multidimensional addressing */
105 debug_assert(!src
->Dimension
.Indirect
);
106 fill_scan_register2d(reg
,
109 src
->Dimension
.Index
);
111 fill_scan_register1d(reg
,
113 src
->Register
.Index
);
117 static scan_register
*
118 create_scan_register_src(struct tgsi_full_src_register
*src
)
120 scan_register
*reg
= MALLOC(sizeof(scan_register
));
121 scan_register_src(reg
, src
);
126 static scan_register
*
127 create_scan_register_dst(struct tgsi_full_dst_register
*dst
)
129 scan_register
*reg
= MALLOC(sizeof(scan_register
));
130 scan_register_dst(reg
, dst
);
137 struct sanity_check_ctx
*ctx
,
143 debug_printf( "Error : " );
144 va_start( args
, format
);
145 _debug_vprintf( format
, args
);
147 debug_printf( "\n" );
153 struct sanity_check_ctx
*ctx
,
159 debug_printf( "Warning: " );
160 va_start( args
, format
);
161 _debug_vprintf( format
, args
);
163 debug_printf( "\n" );
169 struct sanity_check_ctx
*ctx
,
172 if (file
<= TGSI_FILE_NULL
|| file
>= TGSI_FILE_COUNT
) {
173 report_error( ctx
, "(%u): Invalid register file name", file
);
180 is_register_declared(
181 struct sanity_check_ctx
*ctx
,
182 const scan_register
*reg
)
184 void *data
= cso_hash_find_data_from_template(
185 ctx
->regs_decl
, scan_register_key(reg
),
186 (void*)reg
, sizeof(scan_register
));
187 return data
? TRUE
: FALSE
;
191 is_any_register_declared(
192 struct sanity_check_ctx
*ctx
,
195 struct cso_hash_iter iter
=
196 cso_hash_first_node(ctx
->regs_decl
);
198 while (cso_hash_iter_is_null(iter
)) {
199 scan_register
*reg
= (scan_register
*)cso_hash_iter_data(iter
);
200 if (reg
->file
== file
)
202 iter
= cso_hash_iter_next(iter
);
210 struct sanity_check_ctx
*ctx
,
213 void *data
= cso_hash_find_data_from_template(
214 ctx
->regs_used
, scan_register_key(reg
),
215 reg
, sizeof(scan_register
));
216 return data
? TRUE
: FALSE
;
221 is_ind_register_used(
222 struct sanity_check_ctx
*ctx
,
225 return cso_hash_contains(ctx
->regs_ind_used
, reg
->file
);
228 static const char *file_names
[TGSI_FILE_COUNT
] =
243 check_register_usage(
244 struct sanity_check_ctx
*ctx
,
247 boolean indirect_access
)
249 if (!check_file_name( ctx
, reg
->file
)) {
254 if (indirect_access
) {
255 /* Note that 'index' is an offset relative to the value of the
256 * address register. No range checking done here.*/
259 if (!is_any_register_declared( ctx
, reg
->file
))
260 report_error( ctx
, "%s: Undeclared %s register", file_names
[reg
->file
], name
);
261 if (!is_ind_register_used(ctx
, reg
))
262 cso_hash_insert(ctx
->regs_ind_used
, reg
->file
, reg
);
267 if (!is_register_declared( ctx
, reg
)) {
268 if (reg
->dimensions
== 2)
269 report_error( ctx
, "%s[%d][%d]: Undeclared %s register", file_names
[reg
->file
],
270 reg
->indices
[0], reg
->indices
[1], name
);
272 report_error( ctx
, "%s[%d]: Undeclared %s register", file_names
[reg
->file
],
273 reg
->indices
[0], name
);
275 if (!is_register_used( ctx
, reg
))
276 cso_hash_insert(ctx
->regs_used
, scan_register_key(reg
), reg
);
285 struct tgsi_iterate_context
*iter
,
286 struct tgsi_full_instruction
*inst
)
288 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
289 const struct tgsi_opcode_info
*info
;
292 if (inst
->Instruction
.Opcode
== TGSI_OPCODE_END
) {
293 if (ctx
->index_of_END
!= ~0) {
294 report_error( ctx
, "Too many END instructions" );
296 ctx
->index_of_END
= ctx
->num_instructions
;
299 info
= tgsi_get_opcode_info( inst
->Instruction
.Opcode
);
301 report_error( ctx
, "(%u): Invalid instruction opcode", inst
->Instruction
.Opcode
);
305 if (info
->num_dst
!= inst
->Instruction
.NumDstRegs
) {
306 report_error( ctx
, "%s: Invalid number of destination operands, should be %u", info
->mnemonic
, info
->num_dst
);
308 if (info
->num_src
!= inst
->Instruction
.NumSrcRegs
) {
309 report_error( ctx
, "%s: Invalid number of source operands, should be %u", info
->mnemonic
, info
->num_src
);
312 /* Check destination and source registers' validity.
313 * Mark the registers as used.
315 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
316 scan_register
*reg
= create_scan_register_dst(&inst
->Dst
[i
]);
317 check_register_usage(
323 for (i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++) {
324 scan_register
*reg
= create_scan_register_src(&inst
->Src
[i
]);
325 check_register_usage(
329 (boolean
)inst
->Src
[i
].Register
.Indirect
);
330 if (inst
->Src
[i
].Register
.Indirect
) {
331 scan_register
*ind_reg
= MALLOC(sizeof(scan_register
));
333 fill_scan_register1d(ind_reg
,
334 inst
->Src
[i
].Indirect
.File
,
335 inst
->Src
[i
].Indirect
.Index
);
336 check_register_usage(
341 if (!(reg
->file
== TGSI_FILE_ADDRESS
|| reg
->file
== TGSI_FILE_LOOP
) ||
342 reg
->indices
[0] != 0) {
343 report_warning(ctx
, "Indirect register neither ADDR[0] nor LOOP[0]");
348 switch (inst
->Instruction
.Opcode
) {
349 case TGSI_OPCODE_BGNFOR
:
350 case TGSI_OPCODE_ENDFOR
:
351 if (inst
->Dst
[0].Register
.File
!= TGSI_FILE_LOOP
||
352 inst
->Dst
[0].Register
.Index
!= 0) {
353 report_error(ctx
, "Destination register must be LOOP[0]");
358 switch (inst
->Instruction
.Opcode
) {
359 case TGSI_OPCODE_BGNFOR
:
360 if (inst
->Src
[0].Register
.File
!= TGSI_FILE_CONSTANT
&&
361 inst
->Src
[0].Register
.File
!= TGSI_FILE_IMMEDIATE
) {
362 report_error(ctx
, "Source register file must be either CONST or IMM");
367 ctx
->num_instructions
++;
373 check_and_declare(struct sanity_check_ctx
*ctx
,
376 if (is_register_declared( ctx
, reg
))
377 report_error( ctx
, "%s[%u]: The same register declared more than once",
378 file_names
[reg
->file
], reg
->indices
[0] );
379 cso_hash_insert(ctx
->regs_decl
,
380 scan_register_key(reg
),
387 struct tgsi_iterate_context
*iter
,
388 struct tgsi_full_declaration
*decl
)
390 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
394 /* No declarations allowed after the first instruction.
396 if (ctx
->num_instructions
> 0)
397 report_error( ctx
, "Instruction expected but declaration found" );
399 /* Check registers' validity.
400 * Mark the registers as declared.
402 file
= decl
->Declaration
.File
;
403 if (!check_file_name( ctx
, file
))
405 for (i
= decl
->Range
.First
; i
<= decl
->Range
.Last
; i
++) {
406 /* declared TGSI_FILE_INPUT's for geometry processor
407 * have an implied second dimension */
408 if (file
== TGSI_FILE_INPUT
&&
409 ctx
->iter
.processor
.Processor
== TGSI_PROCESSOR_GEOMETRY
) {
411 for (vert
= 0; vert
< ctx
->implied_array_size
; ++vert
) {
412 scan_register
*reg
= MALLOC(sizeof(scan_register
));
413 fill_scan_register2d(reg
, file
, vert
, i
);
414 check_and_declare(ctx
, reg
);
417 scan_register
*reg
= MALLOC(sizeof(scan_register
));
418 fill_scan_register1d(reg
, file
, i
);
419 check_and_declare(ctx
, reg
);
428 struct tgsi_iterate_context
*iter
,
429 struct tgsi_full_immediate
*imm
)
431 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
434 /* No immediates allowed after the first instruction.
436 if (ctx
->num_instructions
> 0)
437 report_error( ctx
, "Instruction expected but immediate found" );
439 /* Mark the register as declared.
441 reg
= MALLOC(sizeof(scan_register
));
442 fill_scan_register1d(reg
, TGSI_FILE_IMMEDIATE
, ctx
->num_imms
);
443 cso_hash_insert(ctx
->regs_decl
, scan_register_key(reg
), reg
);
446 /* Check data type validity.
448 if (imm
->Immediate
.DataType
!= TGSI_IMM_FLOAT32
&&
449 imm
->Immediate
.DataType
!= TGSI_IMM_UINT32
&&
450 imm
->Immediate
.DataType
!= TGSI_IMM_INT32
) {
451 report_error( ctx
, "(%u): Invalid immediate data type", imm
->Immediate
.DataType
);
461 struct tgsi_iterate_context
*iter
,
462 struct tgsi_full_property
*prop
)
464 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
466 if (iter
->processor
.Processor
== TGSI_PROCESSOR_GEOMETRY
&&
467 prop
->Property
.PropertyName
== TGSI_PROPERTY_GS_INPUT_PRIM
) {
468 ctx
->implied_array_size
= u_vertices_per_prim(prop
->u
[0].Data
);
475 struct tgsi_iterate_context
*iter
)
477 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
479 /* There must be an END instruction somewhere.
481 if (ctx
->index_of_END
== ~0) {
482 report_error( ctx
, "Missing END instruction" );
485 /* Check if all declared registers were used.
488 struct cso_hash_iter iter
=
489 cso_hash_first_node(ctx
->regs_decl
);
491 while (cso_hash_iter_is_null(iter
)) {
492 scan_register
*reg
= (scan_register
*)cso_hash_iter_data(iter
);
493 if (!is_register_used(ctx
, reg
) && !is_ind_register_used(ctx
, reg
)) {
494 report_warning( ctx
, "%s[%u]: Register never used",
495 file_names
[reg
->file
], reg
->indices
[0] );
497 iter
= cso_hash_iter_next(iter
);
501 /* Print totals, if any.
503 if (ctx
->errors
|| ctx
->warnings
)
504 debug_printf( "%u errors, %u warnings\n", ctx
->errors
, ctx
->warnings
);
510 regs_hash_destroy(struct cso_hash
*hash
)
512 struct cso_hash_iter iter
= cso_hash_first_node(hash
);
513 while (!cso_hash_iter_is_null(iter
)) {
514 scan_register
*reg
= (scan_register
*)cso_hash_iter_data(iter
);
515 iter
= cso_hash_erase(hash
, iter
);
518 cso_hash_delete(hash
);
523 const struct tgsi_token
*tokens
)
525 struct sanity_check_ctx ctx
;
527 ctx
.iter
.prolog
= NULL
;
528 ctx
.iter
.iterate_instruction
= iter_instruction
;
529 ctx
.iter
.iterate_declaration
= iter_declaration
;
530 ctx
.iter
.iterate_immediate
= iter_immediate
;
531 ctx
.iter
.iterate_property
= iter_property
;
532 ctx
.iter
.epilog
= epilog
;
534 ctx
.regs_decl
= cso_hash_create();
535 ctx
.regs_used
= cso_hash_create();
536 ctx
.regs_ind_used
= cso_hash_create();
539 ctx
.num_instructions
= 0;
540 ctx
.index_of_END
= ~0;
544 ctx
.implied_array_size
= 0;
546 if (!tgsi_iterate_shader( tokens
, &ctx
.iter
))
549 regs_hash_destroy(ctx
.regs_decl
);
550 regs_hash_destroy(ctx
.regs_used
);
551 regs_hash_destroy(ctx
.regs_ind_used
);
552 return ctx
.errors
== 0;