2 * Copyright © 2010 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 * \file ir_validate.cpp
27 * Attempts to verify that various invariants of the IR tree are true.
29 * In particular, at the moment it makes sure that no single
30 * ir_instruction node except for ir_variable appears multiple times
31 * in the ir tree. ir_variable does appear multiple times: Once as a
32 * declaration in an exec_list, and multiple times as the endpoint of
33 * a dereference chain.
37 #include "ir_hierarchical_visitor.h"
38 #include "util/hash_table.h"
39 #include "util/macros.h"
41 #include "compiler/glsl_types.h"
45 class ir_validate
: public ir_hierarchical_visitor
{
49 this->ir_set
= _mesa_set_create(NULL
, _mesa_hash_pointer
,
50 _mesa_key_pointer_equal
);
52 this->current_function
= NULL
;
54 this->callback_enter
= ir_validate::validate_ir
;
55 this->data_enter
= ir_set
;
60 _mesa_set_destroy(this->ir_set
, NULL
);
63 virtual ir_visitor_status
visit(ir_variable
*v
);
64 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
);
66 virtual ir_visitor_status
visit_enter(ir_discard
*ir
);
67 virtual ir_visitor_status
visit_enter(ir_if
*ir
);
69 virtual ir_visitor_status
visit_enter(ir_function
*ir
);
70 virtual ir_visitor_status
visit_leave(ir_function
*ir
);
71 virtual ir_visitor_status
visit_enter(ir_function_signature
*ir
);
73 virtual ir_visitor_status
visit_leave(ir_expression
*ir
);
74 virtual ir_visitor_status
visit_leave(ir_swizzle
*ir
);
76 virtual ir_visitor_status
visit_enter(class ir_dereference_array
*);
78 virtual ir_visitor_status
visit_enter(ir_assignment
*ir
);
79 virtual ir_visitor_status
visit_enter(ir_call
*ir
);
81 static void validate_ir(ir_instruction
*ir
, void *data
);
83 ir_function
*current_function
;
88 } /* anonymous namespace */
91 ir_validate::visit(ir_dereference_variable
*ir
)
93 if ((ir
->var
== NULL
) || (ir
->var
->as_variable() == NULL
)) {
94 printf("ir_dereference_variable @ %p does not specify a variable %p\n",
95 (void *) ir
, (void *) ir
->var
);
99 if (_mesa_set_search(ir_set
, ir
->var
) == NULL
) {
100 printf("ir_dereference_variable @ %p specifies undeclared variable "
102 (void *) ir
, ir
->var
->name
, (void *) ir
->var
);
106 this->validate_ir(ir
, this->data_enter
);
108 return visit_continue
;
112 ir_validate::visit_enter(class ir_dereference_array
*ir
)
114 if (!ir
->array
->type
->is_array() && !ir
->array
->type
->is_matrix() &&
115 !ir
->array
->type
->is_vector()) {
116 printf("ir_dereference_array @ %p does not specify an array, a vector "
124 if (!ir
->array_index
->type
->is_scalar()) {
125 printf("ir_dereference_array @ %p does not have scalar index: %s\n",
126 (void *) ir
, ir
->array_index
->type
->name
);
130 if (!ir
->array_index
->type
->is_integer()) {
131 printf("ir_dereference_array @ %p does not have integer index: %s\n",
132 (void *) ir
, ir
->array_index
->type
->name
);
136 return visit_continue
;
140 ir_validate::visit_enter(ir_discard
*ir
)
142 if (ir
->condition
&& ir
->condition
->type
!= glsl_type::bool_type
) {
143 printf("ir_discard condition %s type instead of bool.\n",
144 ir
->condition
->type
->name
);
150 return visit_continue
;
154 ir_validate::visit_enter(ir_if
*ir
)
156 if (ir
->condition
->type
!= glsl_type::bool_type
) {
157 printf("ir_if condition %s type instead of bool.\n",
158 ir
->condition
->type
->name
);
164 return visit_continue
;
169 ir_validate::visit_enter(ir_function
*ir
)
171 /* Function definitions cannot be nested.
173 if (this->current_function
!= NULL
) {
174 printf("Function definition nested inside another function "
176 printf("%s %p inside %s %p\n",
177 ir
->name
, (void *) ir
,
178 this->current_function
->name
, (void *) this->current_function
);
182 /* Store the current function hierarchy being traversed. This is used
183 * by the function signature visitor to ensure that the signatures are
184 * linked with the correct functions.
186 this->current_function
= ir
;
188 this->validate_ir(ir
, this->data_enter
);
190 /* Verify that all of the things stored in the list of signatures are,
191 * in fact, function signatures.
193 foreach_in_list(ir_instruction
, sig
, &ir
->signatures
) {
194 if (sig
->ir_type
!= ir_type_function_signature
) {
195 printf("Non-signature in signature list of function `%s'\n",
201 return visit_continue
;
205 ir_validate::visit_leave(ir_function
*ir
)
207 assert(ralloc_parent(ir
->name
) == ir
);
209 this->current_function
= NULL
;
210 return visit_continue
;
214 ir_validate::visit_enter(ir_function_signature
*ir
)
216 if (this->current_function
!= ir
->function()) {
217 printf("Function signature nested inside wrong function "
219 printf("%p inside %s %p instead of %s %p\n",
221 this->current_function
->name
, (void *) this->current_function
,
222 ir
->function_name(), (void *) ir
->function());
226 if (ir
->return_type
== NULL
) {
227 printf("Function signature %p for function %s has NULL return type.\n",
228 (void *) ir
, ir
->function_name());
232 this->validate_ir(ir
, this->data_enter
);
234 return visit_continue
;
238 ir_validate::visit_leave(ir_expression
*ir
)
240 for (unsigned i
= ir
->num_operands
; i
< 4; i
++) {
241 assert(ir
->operands
[i
] == NULL
);
244 for (unsigned i
= 0; i
< ir
->num_operands
; i
++) {
245 assert(ir
->operands
[i
] != NULL
);
248 switch (ir
->operation
) {
249 case ir_unop_bit_not
:
250 assert(ir
->operands
[0]->type
== ir
->type
);
252 case ir_unop_logic_not
:
253 assert(ir
->type
->is_boolean());
254 assert(ir
->operands
[0]->type
->is_boolean());
258 assert(ir
->type
== ir
->operands
[0]->type
);
263 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
||
264 ir
->operands
[0]->type
->is_float() ||
265 ir
->operands
[0]->type
->is_double() ||
266 ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
267 assert(ir
->type
== ir
->operands
[0]->type
);
273 assert(ir
->type
->is_float() ||
274 ir
->type
->is_double());
275 assert(ir
->type
== ir
->operands
[0]->type
);
282 case ir_unop_saturate
:
283 assert(ir
->operands
[0]->type
->is_float());
284 assert(ir
->type
== ir
->operands
[0]->type
);
288 assert(ir
->operands
[0]->type
->is_float());
289 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
292 assert(ir
->operands
[0]->type
->is_float());
293 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
296 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
297 assert(ir
->type
->is_float());
300 assert(ir
->operands
[0]->type
->is_float());
301 assert(ir
->type
->is_boolean());
304 assert(ir
->operands
[0]->type
->is_boolean());
305 assert(ir
->type
->is_float());
308 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
309 assert(ir
->type
->is_boolean());
312 assert(ir
->operands
[0]->type
->is_boolean());
313 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
316 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
317 assert(ir
->type
->is_float());
320 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
321 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
324 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
325 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
327 case ir_unop_bitcast_i2f
:
328 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
329 assert(ir
->type
->is_float());
331 case ir_unop_bitcast_f2i
:
332 assert(ir
->operands
[0]->type
->is_float());
333 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
335 case ir_unop_bitcast_u2f
:
336 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
337 assert(ir
->type
->is_float());
339 case ir_unop_bitcast_f2u
:
340 assert(ir
->operands
[0]->type
->is_float());
341 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
344 case ir_unop_bitcast_u642d
:
345 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
346 assert(ir
->type
->is_double());
348 case ir_unop_bitcast_i642d
:
349 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
350 assert(ir
->type
->is_double());
352 case ir_unop_bitcast_d2u64
:
353 assert(ir
->operands
[0]->type
->is_double());
354 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
356 case ir_unop_bitcast_d2i64
:
357 assert(ir
->operands
[0]->type
->is_double());
358 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
361 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
362 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
365 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
366 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
369 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
370 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
373 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
374 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
377 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
378 assert(ir
->type
->is_boolean());
381 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
382 assert(ir
->type
->is_float());
385 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
386 assert(ir
->type
->is_float());
389 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
390 assert(ir
->type
->is_double());
393 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
394 assert(ir
->type
->is_double());
397 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
398 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
401 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
402 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
405 assert(ir
->operands
[0]->type
->is_boolean());
406 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
409 assert(ir
->operands
[0]->type
->is_float());
410 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
413 assert(ir
->operands
[0]->type
->is_double());
414 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
417 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
418 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
421 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
422 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
425 assert(ir
->operands
[0]->type
->is_float());
426 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
429 assert(ir
->operands
[0]->type
->is_double());
430 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
432 case ir_unop_u642i64
:
433 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT64
);
434 assert(ir
->type
->base_type
== GLSL_TYPE_INT64
);
436 case ir_unop_i642u64
:
437 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT64
);
438 assert(ir
->type
->base_type
== GLSL_TYPE_UINT64
);
441 case ir_unop_round_even
:
445 assert(ir
->operands
[0]->type
->is_float() ||
446 ir
->operands
[0]->type
->is_double());
447 assert(ir
->operands
[0]->type
== ir
->type
);
452 case ir_unop_dFdx_coarse
:
453 case ir_unop_dFdx_fine
:
455 case ir_unop_dFdy_coarse
:
456 case ir_unop_dFdy_fine
:
457 assert(ir
->operands
[0]->type
->is_float());
458 assert(ir
->operands
[0]->type
== ir
->type
);
461 case ir_unop_pack_snorm_2x16
:
462 case ir_unop_pack_unorm_2x16
:
463 case ir_unop_pack_half_2x16
:
464 assert(ir
->type
== glsl_type::uint_type
);
465 assert(ir
->operands
[0]->type
== glsl_type::vec2_type
);
468 case ir_unop_pack_snorm_4x8
:
469 case ir_unop_pack_unorm_4x8
:
470 assert(ir
->type
== glsl_type::uint_type
);
471 assert(ir
->operands
[0]->type
== glsl_type::vec4_type
);
474 case ir_unop_pack_double_2x32
:
475 assert(ir
->type
== glsl_type::double_type
);
476 assert(ir
->operands
[0]->type
== glsl_type::uvec2_type
);
479 case ir_unop_pack_int_2x32
:
480 assert(ir
->type
== glsl_type::int64_t_type
);
481 assert(ir
->operands
[0]->type
== glsl_type::ivec2_type
);
484 case ir_unop_pack_uint_2x32
:
485 assert(ir
->type
== glsl_type::uint64_t_type
);
486 assert(ir
->operands
[0]->type
== glsl_type::uvec2_type
);
489 case ir_unop_pack_sampler_2x32
:
490 assert(ir
->type
->is_sampler());
491 assert(ir
->operands
[0]->type
== glsl_type::uvec2_type
);
494 case ir_unop_pack_image_2x32
:
495 assert(ir
->type
->is_image());
496 assert(ir
->operands
[0]->type
== glsl_type::uvec2_type
);
499 case ir_unop_unpack_snorm_2x16
:
500 case ir_unop_unpack_unorm_2x16
:
501 case ir_unop_unpack_half_2x16
:
502 assert(ir
->type
== glsl_type::vec2_type
);
503 assert(ir
->operands
[0]->type
== glsl_type::uint_type
);
506 case ir_unop_unpack_snorm_4x8
:
507 case ir_unop_unpack_unorm_4x8
:
508 assert(ir
->type
== glsl_type::vec4_type
);
509 assert(ir
->operands
[0]->type
== glsl_type::uint_type
);
512 case ir_unop_unpack_double_2x32
:
513 assert(ir
->type
== glsl_type::uvec2_type
);
514 assert(ir
->operands
[0]->type
== glsl_type::double_type
);
517 case ir_unop_unpack_int_2x32
:
518 assert(ir
->type
== glsl_type::ivec2_type
);
519 assert(ir
->operands
[0]->type
== glsl_type::int64_t_type
);
522 case ir_unop_unpack_uint_2x32
:
523 assert(ir
->type
== glsl_type::uvec2_type
);
524 assert(ir
->operands
[0]->type
== glsl_type::uint64_t_type
);
527 case ir_unop_unpack_sampler_2x32
:
528 assert(ir
->type
== glsl_type::uvec2_type
);
529 assert(ir
->operands
[0]->type
->is_sampler());
532 case ir_unop_unpack_image_2x32
:
533 assert(ir
->type
== glsl_type::uvec2_type
);
534 assert(ir
->operands
[0]->type
->is_image());
537 case ir_unop_bitfield_reverse
:
538 assert(ir
->operands
[0]->type
== ir
->type
);
539 assert(ir
->type
->is_integer());
542 case ir_unop_bit_count
:
543 case ir_unop_find_msb
:
544 case ir_unop_find_lsb
:
545 assert(ir
->operands
[0]->type
->vector_elements
== ir
->type
->vector_elements
);
546 assert(ir
->operands
[0]->type
->is_integer());
547 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
551 /* XXX what can we assert here? */
554 case ir_unop_interpolate_at_centroid
:
555 assert(ir
->operands
[0]->type
== ir
->type
);
556 assert(ir
->operands
[0]->type
->is_float());
559 case ir_unop_get_buffer_size
:
560 assert(ir
->type
== glsl_type::int_type
);
561 assert(ir
->operands
[0]->type
== glsl_type::uint_type
);
564 case ir_unop_ssbo_unsized_array_length
:
565 assert(ir
->type
== glsl_type::int_type
);
566 assert(ir
->operands
[0]->type
->is_array());
567 assert(ir
->operands
[0]->type
->is_unsized_array());
571 assert(ir
->operands
[0]->type
->is_double());
572 assert(ir
->type
->is_float());
575 assert(ir
->operands
[0]->type
->is_float());
576 assert(ir
->type
->is_double());
579 assert(ir
->operands
[0]->type
->is_double());
580 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
583 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_INT
);
584 assert(ir
->type
->is_double());
587 assert(ir
->operands
[0]->type
->is_double());
588 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
591 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_UINT
);
592 assert(ir
->type
->is_double());
595 assert(ir
->operands
[0]->type
->is_double());
596 assert(ir
->type
->is_boolean());
599 case ir_unop_frexp_sig
:
600 assert(ir
->operands
[0]->type
->is_float() ||
601 ir
->operands
[0]->type
->is_double());
602 assert(ir
->type
->is_double());
604 case ir_unop_frexp_exp
:
605 assert(ir
->operands
[0]->type
->is_float() ||
606 ir
->operands
[0]->type
->is_double());
607 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
609 case ir_unop_subroutine_to_int
:
610 assert(ir
->operands
[0]->type
->base_type
== GLSL_TYPE_SUBROUTINE
);
611 assert(ir
->type
->base_type
== GLSL_TYPE_INT
);
622 assert(ir
->operands
[0]->type
->base_type
==
623 ir
->operands
[1]->type
->base_type
);
625 if (ir
->operands
[0]->type
->is_scalar())
626 assert(ir
->operands
[1]->type
== ir
->type
);
627 else if (ir
->operands
[1]->type
->is_scalar())
628 assert(ir
->operands
[0]->type
== ir
->type
);
629 else if (ir
->operands
[0]->type
->is_vector() &&
630 ir
->operands
[1]->type
->is_vector()) {
631 assert(ir
->operands
[0]->type
== ir
->operands
[1]->type
);
632 assert(ir
->operands
[0]->type
== ir
->type
);
636 case ir_binop_imul_high
:
637 assert(ir
->type
== ir
->operands
[0]->type
);
638 assert(ir
->type
== ir
->operands
[1]->type
);
639 assert(ir
->type
->is_integer());
643 case ir_binop_borrow
:
644 assert(ir
->type
== ir
->operands
[0]->type
);
645 assert(ir
->type
== ir
->operands
[1]->type
);
646 assert(ir
->type
->base_type
== GLSL_TYPE_UINT
);
650 case ir_binop_gequal
:
652 case ir_binop_nequal
:
653 /* The semantics of the IR operators differ from the GLSL <, >, <=, >=,
654 * ==, and != operators. The IR operators perform a component-wise
655 * comparison on scalar or vector types and return a boolean scalar or
656 * vector type of the same size.
658 assert(ir
->type
->is_boolean());
659 assert(ir
->operands
[0]->type
== ir
->operands
[1]->type
);
660 assert(ir
->operands
[0]->type
->is_vector()
661 || ir
->operands
[0]->type
->is_scalar());
662 assert(ir
->operands
[0]->type
->vector_elements
663 == ir
->type
->vector_elements
);
666 case ir_binop_all_equal
:
667 case ir_binop_any_nequal
:
668 /* GLSL == and != operate on scalars, vectors, matrices and arrays, and
669 * return a scalar boolean. The IR matches that.
671 assert(ir
->type
== glsl_type::bool_type
);
672 assert(ir
->operands
[0]->type
== ir
->operands
[1]->type
);
675 case ir_binop_lshift
:
676 case ir_binop_rshift
:
677 assert(ir
->operands
[0]->type
->is_integer_32_64() &&
678 ir
->operands
[1]->type
->is_integer());
679 if (ir
->operands
[0]->type
->is_scalar()) {
680 assert(ir
->operands
[1]->type
->is_scalar());
682 if (ir
->operands
[0]->type
->is_vector() &&
683 ir
->operands
[1]->type
->is_vector()) {
684 assert(ir
->operands
[0]->type
->components() ==
685 ir
->operands
[1]->type
->components());
687 assert(ir
->type
== ir
->operands
[0]->type
);
690 case ir_binop_bit_and
:
691 case ir_binop_bit_xor
:
692 case ir_binop_bit_or
:
693 assert(ir
->operands
[0]->type
->base_type
==
694 ir
->operands
[1]->type
->base_type
);
695 assert(ir
->type
->is_integer_32_64());
696 if (ir
->operands
[0]->type
->is_vector() &&
697 ir
->operands
[1]->type
->is_vector()) {
698 assert(ir
->operands
[0]->type
->vector_elements
==
699 ir
->operands
[1]->type
->vector_elements
);
703 case ir_binop_logic_and
:
704 case ir_binop_logic_xor
:
705 case ir_binop_logic_or
:
706 assert(ir
->type
->is_boolean());
707 assert(ir
->operands
[0]->type
->is_boolean());
708 assert(ir
->operands
[1]->type
->is_boolean());
712 assert(ir
->type
== glsl_type::float_type
||
713 ir
->type
== glsl_type::double_type
);
714 assert(ir
->operands
[0]->type
->is_float() ||
715 ir
->operands
[0]->type
->is_double());
716 assert(ir
->operands
[0]->type
->is_vector());
717 assert(ir
->operands
[0]->type
== ir
->operands
[1]->type
);
720 case ir_binop_ubo_load
:
721 assert(ir
->operands
[0]->type
== glsl_type::uint_type
);
723 assert(ir
->operands
[1]->type
== glsl_type::uint_type
);
727 assert(ir
->operands
[0]->type
== ir
->type
);
728 assert(ir
->operands
[0]->type
->is_float() ||
729 ir
->operands
[0]->type
->is_double());
730 assert(ir
->operands
[1]->type
->base_type
== GLSL_TYPE_INT
);
731 assert(ir
->operands
[0]->type
->components() ==
732 ir
->operands
[1]->type
->components());
735 case ir_binop_vector_extract
:
736 assert(ir
->operands
[0]->type
->is_vector());
737 assert(ir
->operands
[1]->type
->is_scalar()
738 && ir
->operands
[1]->type
->is_integer());
741 case ir_binop_interpolate_at_offset
:
742 assert(ir
->operands
[0]->type
== ir
->type
);
743 assert(ir
->operands
[0]->type
->is_float());
744 assert(ir
->operands
[1]->type
->components() == 2);
745 assert(ir
->operands
[1]->type
->is_float());
748 case ir_binop_interpolate_at_sample
:
749 assert(ir
->operands
[0]->type
== ir
->type
);
750 assert(ir
->operands
[0]->type
->is_float());
751 assert(ir
->operands
[1]->type
== glsl_type::int_type
);
755 assert(ir
->type
->is_float() ||
756 ir
->type
->is_double());
757 assert(ir
->type
== ir
->operands
[0]->type
);
758 assert(ir
->type
== ir
->operands
[1]->type
);
759 assert(ir
->type
== ir
->operands
[2]->type
);
763 assert(ir
->operands
[0]->type
->is_float() ||
764 ir
->operands
[0]->type
->is_double());
765 assert(ir
->operands
[0]->type
== ir
->operands
[1]->type
);
766 assert(ir
->operands
[2]->type
== ir
->operands
[0]->type
||
767 ir
->operands
[2]->type
== glsl_type::float_type
||
768 ir
->operands
[2]->type
== glsl_type::double_type
);
772 assert(ir
->operands
[0]->type
->is_boolean());
773 assert(ir
->type
->vector_elements
== ir
->operands
[0]->type
->vector_elements
);
774 assert(ir
->type
== ir
->operands
[1]->type
);
775 assert(ir
->type
== ir
->operands
[2]->type
);
778 case ir_triop_bitfield_extract
:
779 assert(ir
->type
->is_integer());
780 assert(ir
->operands
[0]->type
== ir
->type
);
781 assert(ir
->operands
[1]->type
== ir
->type
);
782 assert(ir
->operands
[2]->type
== ir
->type
);
785 case ir_triop_vector_insert
:
786 assert(ir
->operands
[0]->type
->is_vector());
787 assert(ir
->operands
[1]->type
->is_scalar());
788 assert(ir
->operands
[0]->type
->base_type
== ir
->operands
[1]->type
->base_type
);
789 assert(ir
->operands
[2]->type
->is_scalar()
790 && ir
->operands
[2]->type
->is_integer());
791 assert(ir
->type
== ir
->operands
[0]->type
);
794 case ir_quadop_bitfield_insert
:
795 assert(ir
->type
->is_integer());
796 assert(ir
->operands
[0]->type
== ir
->type
);
797 assert(ir
->operands
[1]->type
== ir
->type
);
798 assert(ir
->operands
[2]->type
== ir
->type
);
799 assert(ir
->operands
[3]->type
== ir
->type
);
802 case ir_quadop_vector
:
803 /* The vector operator collects some number of scalars and generates a
806 * - All of the operands must be scalar.
807 * - Number of operands must matche the size of the resulting vector.
808 * - Base type of the operands must match the base type of the result.
810 assert(ir
->type
->is_vector());
811 switch (ir
->type
->vector_elements
) {
813 assert(ir
->operands
[0]->type
->is_scalar());
814 assert(ir
->operands
[0]->type
->base_type
== ir
->type
->base_type
);
815 assert(ir
->operands
[1]->type
->is_scalar());
816 assert(ir
->operands
[1]->type
->base_type
== ir
->type
->base_type
);
817 assert(ir
->operands
[2] == NULL
);
818 assert(ir
->operands
[3] == NULL
);
821 assert(ir
->operands
[0]->type
->is_scalar());
822 assert(ir
->operands
[0]->type
->base_type
== ir
->type
->base_type
);
823 assert(ir
->operands
[1]->type
->is_scalar());
824 assert(ir
->operands
[1]->type
->base_type
== ir
->type
->base_type
);
825 assert(ir
->operands
[2]->type
->is_scalar());
826 assert(ir
->operands
[2]->type
->base_type
== ir
->type
->base_type
);
827 assert(ir
->operands
[3] == NULL
);
830 assert(ir
->operands
[0]->type
->is_scalar());
831 assert(ir
->operands
[0]->type
->base_type
== ir
->type
->base_type
);
832 assert(ir
->operands
[1]->type
->is_scalar());
833 assert(ir
->operands
[1]->type
->base_type
== ir
->type
->base_type
);
834 assert(ir
->operands
[2]->type
->is_scalar());
835 assert(ir
->operands
[2]->type
->base_type
== ir
->type
->base_type
);
836 assert(ir
->operands
[3]->type
->is_scalar());
837 assert(ir
->operands
[3]->type
->base_type
== ir
->type
->base_type
);
840 /* The is_vector assertion above should prevent execution from ever
843 assert(!"Should not get here.");
848 return visit_continue
;
852 ir_validate::visit_leave(ir_swizzle
*ir
)
854 unsigned int chans
[4] = {ir
->mask
.x
, ir
->mask
.y
, ir
->mask
.z
, ir
->mask
.w
};
856 for (unsigned int i
= 0; i
< ir
->type
->vector_elements
; i
++) {
857 if (chans
[i
] >= ir
->val
->type
->vector_elements
) {
858 printf("ir_swizzle @ %p specifies a channel not present "
859 "in the value.\n", (void *) ir
);
865 return visit_continue
;
869 ir_validate::visit(ir_variable
*ir
)
871 /* An ir_variable is the one thing that can (and will) appear multiple times
872 * in an IR tree. It is added to the hashtable so that it can be used
873 * in the ir_dereference_variable handler to ensure that a variable is
874 * declared before it is dereferenced.
876 if (ir
->name
&& ir
->is_name_ralloced())
877 assert(ralloc_parent(ir
->name
) == ir
);
879 _mesa_set_add(ir_set
, ir
);
881 /* If a variable is an array, verify that the maximum array index is in
882 * bounds. There was once an error in AST-to-HIR conversion that set this
883 * to be out of bounds.
885 if (ir
->type
->array_size() > 0) {
886 if (ir
->data
.max_array_access
>= (int)ir
->type
->length
) {
887 printf("ir_variable has maximum access out of bounds (%d vs %d)\n",
888 ir
->data
.max_array_access
, ir
->type
->length
- 1);
894 /* If a variable is an interface block (or an array of interface blocks),
895 * verify that the maximum array index for each interface member is in
898 if (ir
->is_interface_instance()) {
899 const glsl_struct_field
*fields
=
900 ir
->get_interface_type()->fields
.structure
;
901 for (unsigned i
= 0; i
< ir
->get_interface_type()->length
; i
++) {
902 if (fields
[i
].type
->array_size() > 0 &&
903 !fields
[i
].implicit_sized_array
) {
904 const int *const max_ifc_array_access
=
905 ir
->get_max_ifc_array_access();
907 assert(max_ifc_array_access
!= NULL
);
909 if (max_ifc_array_access
[i
] >= (int)fields
[i
].type
->length
) {
910 printf("ir_variable has maximum access out of bounds for "
911 "field %s (%d vs %d)\n", fields
[i
].name
,
912 max_ifc_array_access
[i
], fields
[i
].type
->length
);
920 if (ir
->constant_initializer
!= NULL
&& !ir
->data
.has_initializer
) {
921 printf("ir_variable didn't have an initializer, but has a constant "
922 "initializer value.\n");
927 if (ir
->data
.mode
== ir_var_uniform
928 && is_gl_identifier(ir
->name
)
929 && ir
->get_state_slots() == NULL
) {
930 printf("built-in uniform has no state\n");
935 return visit_continue
;
939 ir_validate::visit_enter(ir_assignment
*ir
)
941 const ir_dereference
*const lhs
= ir
->lhs
;
942 if (lhs
->type
->is_scalar() || lhs
->type
->is_vector()) {
943 if (ir
->write_mask
== 0) {
944 printf("Assignment LHS is %s, but write mask is 0:\n",
945 lhs
->type
->is_scalar() ? "scalar" : "vector");
950 int lhs_components
= 0;
951 for (int i
= 0; i
< 4; i
++) {
952 if (ir
->write_mask
& (1 << i
))
956 if (lhs_components
!= ir
->rhs
->type
->vector_elements
) {
957 printf("Assignment count of LHS write mask channels enabled not\n"
958 "matching RHS vector size (%d LHS, %d RHS).\n",
959 lhs_components
, ir
->rhs
->type
->vector_elements
);
965 this->validate_ir(ir
, this->data_enter
);
967 return visit_continue
;
971 ir_validate::visit_enter(ir_call
*ir
)
973 ir_function_signature
*const callee
= ir
->callee
;
975 if (callee
->ir_type
!= ir_type_function_signature
) {
976 printf("IR called by ir_call is not ir_function_signature!\n");
980 if (ir
->return_deref
) {
981 if (ir
->return_deref
->type
!= callee
->return_type
) {
982 printf("callee type %s does not match return storage type %s\n",
983 callee
->return_type
->name
, ir
->return_deref
->type
->name
);
986 } else if (callee
->return_type
!= glsl_type::void_type
) {
987 printf("ir_call has non-void callee but no return storage\n");
991 const exec_node
*formal_param_node
= callee
->parameters
.get_head_raw();
992 const exec_node
*actual_param_node
= ir
->actual_parameters
.get_head_raw();
994 if (formal_param_node
->is_tail_sentinel()
995 != actual_param_node
->is_tail_sentinel()) {
996 printf("ir_call has the wrong number of parameters:\n");
999 if (formal_param_node
->is_tail_sentinel()) {
1002 const ir_variable
*formal_param
1003 = (const ir_variable
*) formal_param_node
;
1004 const ir_rvalue
*actual_param
1005 = (const ir_rvalue
*) actual_param_node
;
1006 if (formal_param
->type
!= actual_param
->type
) {
1007 printf("ir_call parameter type mismatch:\n");
1010 if (formal_param
->data
.mode
== ir_var_function_out
1011 || formal_param
->data
.mode
== ir_var_function_inout
) {
1012 if (!actual_param
->is_lvalue()) {
1013 printf("ir_call out/inout parameters must be lvalues:\n");
1017 formal_param_node
= formal_param_node
->next
;
1018 actual_param_node
= actual_param_node
->next
;
1021 return visit_continue
;
1025 printf("callee:\n");
1032 ir_validate::validate_ir(ir_instruction
*ir
, void *data
)
1034 struct set
*ir_set
= (struct set
*) data
;
1036 if (_mesa_set_search(ir_set
, ir
)) {
1037 printf("Instruction node present twice in ir tree:\n");
1042 _mesa_set_add(ir_set
, ir
);
1045 MAYBE_UNUSED
static void
1046 check_node_type(ir_instruction
*ir
, void *data
)
1050 if (ir
->ir_type
>= ir_type_max
) {
1051 printf("Instruction node with unset type\n");
1052 ir
->print(); printf("\n");
1054 ir_rvalue
*value
= ir
->as_rvalue();
1056 assert(value
->type
!= glsl_type::error_type
);
1060 validate_ir_tree(exec_list
*instructions
)
1062 /* We shouldn't have any reason to validate IR in a release build,
1063 * and it's half composed of assert()s anyway which wouldn't do
1069 v
.run(instructions
);
1071 foreach_in_list(ir_instruction
, ir
, instructions
) {
1072 visit_tree(ir
, check_node_type
, NULL
);