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
);
273 report_error( ctx
, "%s[%d]: Undeclared %s register", file_names
[reg
->file
],
274 reg
->indices
[0], name
);
277 if (!is_register_used( ctx
, reg
))
278 cso_hash_insert(ctx
->regs_used
, scan_register_key(reg
), reg
);
287 struct tgsi_iterate_context
*iter
,
288 struct tgsi_full_instruction
*inst
)
290 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
291 const struct tgsi_opcode_info
*info
;
294 if (inst
->Instruction
.Opcode
== TGSI_OPCODE_END
) {
295 if (ctx
->index_of_END
!= ~0) {
296 report_error( ctx
, "Too many END instructions" );
298 ctx
->index_of_END
= ctx
->num_instructions
;
301 info
= tgsi_get_opcode_info( inst
->Instruction
.Opcode
);
303 report_error( ctx
, "(%u): Invalid instruction opcode", inst
->Instruction
.Opcode
);
307 if (info
->num_dst
!= inst
->Instruction
.NumDstRegs
) {
308 report_error( ctx
, "%s: Invalid number of destination operands, should be %u", info
->mnemonic
, info
->num_dst
);
310 if (info
->num_src
!= inst
->Instruction
.NumSrcRegs
) {
311 report_error( ctx
, "%s: Invalid number of source operands, should be %u", info
->mnemonic
, info
->num_src
);
314 /* Check destination and source registers' validity.
315 * Mark the registers as used.
317 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
318 scan_register
*reg
= create_scan_register_dst(&inst
->Dst
[i
]);
319 check_register_usage(
324 if (!inst
->Dst
[i
].Register
.WriteMask
) {
325 report_error(ctx
, "Destination register has empty writemask");
328 for (i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++) {
329 scan_register
*reg
= create_scan_register_src(&inst
->Src
[i
]);
330 check_register_usage(
334 (boolean
)inst
->Src
[i
].Register
.Indirect
);
335 if (inst
->Src
[i
].Register
.Indirect
) {
336 scan_register
*ind_reg
= MALLOC(sizeof(scan_register
));
338 fill_scan_register1d(ind_reg
,
339 inst
->Src
[i
].Indirect
.File
,
340 inst
->Src
[i
].Indirect
.Index
);
341 check_register_usage(
349 switch (inst
->Instruction
.Opcode
) {
350 case TGSI_OPCODE_BGNFOR
:
351 case TGSI_OPCODE_ENDFOR
:
352 if (inst
->Dst
[0].Register
.File
!= TGSI_FILE_LOOP
||
353 inst
->Dst
[0].Register
.Index
!= 0) {
354 report_error(ctx
, "Destination register must be LOOP[0]");
359 switch (inst
->Instruction
.Opcode
) {
360 case TGSI_OPCODE_BGNFOR
:
361 if (inst
->Src
[0].Register
.File
!= TGSI_FILE_CONSTANT
&&
362 inst
->Src
[0].Register
.File
!= TGSI_FILE_IMMEDIATE
) {
363 report_error(ctx
, "Source register file must be either CONST or IMM");
368 ctx
->num_instructions
++;
374 check_and_declare(struct sanity_check_ctx
*ctx
,
377 if (is_register_declared( ctx
, reg
))
378 report_error( ctx
, "%s[%u]: The same register declared more than once",
379 file_names
[reg
->file
], reg
->indices
[0] );
380 cso_hash_insert(ctx
->regs_decl
,
381 scan_register_key(reg
),
388 struct tgsi_iterate_context
*iter
,
389 struct tgsi_full_declaration
*decl
)
391 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
395 /* No declarations allowed after the first instruction.
397 if (ctx
->num_instructions
> 0)
398 report_error( ctx
, "Instruction expected but declaration found" );
400 /* Check registers' validity.
401 * Mark the registers as declared.
403 file
= decl
->Declaration
.File
;
404 if (!check_file_name( ctx
, file
))
406 for (i
= decl
->Range
.First
; i
<= decl
->Range
.Last
; i
++) {
407 /* declared TGSI_FILE_INPUT's for geometry processor
408 * have an implied second dimension */
409 if (file
== TGSI_FILE_INPUT
&&
410 ctx
->iter
.processor
.Processor
== TGSI_PROCESSOR_GEOMETRY
) {
412 for (vert
= 0; vert
< ctx
->implied_array_size
; ++vert
) {
413 scan_register
*reg
= MALLOC(sizeof(scan_register
));
414 fill_scan_register2d(reg
, file
, i
, vert
);
415 check_and_declare(ctx
, reg
);
418 scan_register
*reg
= MALLOC(sizeof(scan_register
));
419 if (decl
->Declaration
.Dimension
) {
420 fill_scan_register2d(reg
, file
, i
, decl
->Dim
.Index2D
);
422 fill_scan_register1d(reg
, file
, i
);
424 check_and_declare(ctx
, reg
);
433 struct tgsi_iterate_context
*iter
,
434 struct tgsi_full_immediate
*imm
)
436 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
439 /* No immediates allowed after the first instruction.
441 if (ctx
->num_instructions
> 0)
442 report_error( ctx
, "Instruction expected but immediate found" );
444 /* Mark the register as declared.
446 reg
= MALLOC(sizeof(scan_register
));
447 fill_scan_register1d(reg
, TGSI_FILE_IMMEDIATE
, ctx
->num_imms
);
448 cso_hash_insert(ctx
->regs_decl
, scan_register_key(reg
), reg
);
451 /* Check data type validity.
453 if (imm
->Immediate
.DataType
!= TGSI_IMM_FLOAT32
&&
454 imm
->Immediate
.DataType
!= TGSI_IMM_UINT32
&&
455 imm
->Immediate
.DataType
!= TGSI_IMM_INT32
) {
456 report_error( ctx
, "(%u): Invalid immediate data type", imm
->Immediate
.DataType
);
466 struct tgsi_iterate_context
*iter
,
467 struct tgsi_full_property
*prop
)
469 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
471 if (iter
->processor
.Processor
== TGSI_PROCESSOR_GEOMETRY
&&
472 prop
->Property
.PropertyName
== TGSI_PROPERTY_GS_INPUT_PRIM
) {
473 ctx
->implied_array_size
= u_vertices_per_prim(prop
->u
[0].Data
);
480 struct tgsi_iterate_context
*iter
)
482 struct sanity_check_ctx
*ctx
= (struct sanity_check_ctx
*) iter
;
484 /* There must be an END instruction somewhere.
486 if (ctx
->index_of_END
== ~0) {
487 report_error( ctx
, "Missing END instruction" );
490 /* Check if all declared registers were used.
493 struct cso_hash_iter iter
=
494 cso_hash_first_node(ctx
->regs_decl
);
496 while (!cso_hash_iter_is_null(iter
)) {
497 scan_register
*reg
= (scan_register
*)cso_hash_iter_data(iter
);
498 if (!is_register_used(ctx
, reg
) && !is_ind_register_used(ctx
, reg
)) {
499 report_warning( ctx
, "%s[%u]: Register never used",
500 file_names
[reg
->file
], reg
->indices
[0] );
502 iter
= cso_hash_iter_next(iter
);
506 /* Print totals, if any.
508 if (ctx
->errors
|| ctx
->warnings
)
509 debug_printf( "%u errors, %u warnings\n", ctx
->errors
, ctx
->warnings
);
515 regs_hash_destroy(struct cso_hash
*hash
)
517 struct cso_hash_iter iter
= cso_hash_first_node(hash
);
518 while (!cso_hash_iter_is_null(iter
)) {
519 scan_register
*reg
= (scan_register
*)cso_hash_iter_data(iter
);
520 iter
= cso_hash_erase(hash
, iter
);
521 assert(reg
->file
< TGSI_FILE_COUNT
);
524 cso_hash_delete(hash
);
529 const struct tgsi_token
*tokens
)
531 struct sanity_check_ctx ctx
;
533 ctx
.iter
.prolog
= NULL
;
534 ctx
.iter
.iterate_instruction
= iter_instruction
;
535 ctx
.iter
.iterate_declaration
= iter_declaration
;
536 ctx
.iter
.iterate_immediate
= iter_immediate
;
537 ctx
.iter
.iterate_property
= iter_property
;
538 ctx
.iter
.epilog
= epilog
;
540 ctx
.regs_decl
= cso_hash_create();
541 ctx
.regs_used
= cso_hash_create();
542 ctx
.regs_ind_used
= cso_hash_create();
545 ctx
.num_instructions
= 0;
546 ctx
.index_of_END
= ~0;
550 ctx
.implied_array_size
= 0;
552 if (!tgsi_iterate_shader( tokens
, &ctx
.iter
))
555 regs_hash_destroy(ctx
.regs_decl
);
556 regs_hash_destroy(ctx
.regs_used
);
557 regs_hash_destroy(ctx
.regs_ind_used
);
558 return ctx
.errors
== 0;