util/hash_set: Rework the API to know about hashing
[mesa.git] / src / glsl / nir / nir_validate.c
1 /*
2 * Copyright © 2014 Intel Corporation
3 *
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:
10 *
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
13 * Software.
14 *
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 DEALINGS
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Connor Abbott (cwabbott0@gmail.com)
25 *
26 */
27
28 #include "nir.h"
29 #include <assert.h>
30
31 /*
32 * This file checks for invalid IR indicating a bug somewhere in the compiler.
33 */
34
35 /* Since this file is just a pile of asserts, don't bother compiling it if
36 * we're not building a debug build.
37 */
38 #ifdef DEBUG
39
40 /*
41 * Per-register validation state.
42 */
43
44 typedef struct {
45 /*
46 * equivalent to the uses and defs in nir_register, but built up by the
47 * validator. At the end, we verify that the sets have the same entries.
48 */
49 struct set *uses, *defs;
50 nir_function_impl *where_defined; /* NULL for global registers */
51 } reg_validate_state;
52
53 typedef struct {
54 /* map of register -> validation state (struct above) */
55 struct hash_table *regs;
56
57 /* the current shader being validated */
58 nir_shader *shader;
59
60 /* the current instruction being validated */
61 nir_instr *instr;
62
63 /* the current basic block being validated */
64 nir_block *block;
65
66 /* the current if statement being validated */
67 nir_if *if_stmt;
68
69 /* the parent of the current cf node being visited */
70 nir_cf_node *parent_node;
71
72 /* the current function implementation being validated */
73 nir_function_impl *impl;
74
75 /* map of SSA value -> function implementation where it is defined */
76 struct hash_table *ssa_defs;
77
78 /* bitset of ssa definitions we have found; used to check uniqueness */
79 BITSET_WORD *ssa_defs_found;
80
81 /* bitset of registers we have currently found; used to check uniqueness */
82 BITSET_WORD *regs_found;
83
84 /* map of local variable -> function implementation where it is defined */
85 struct hash_table *var_defs;
86 } validate_state;
87
88 static void validate_src(nir_src *src, validate_state *state);
89
90 static void
91 validate_reg_src(nir_reg_src *src, validate_state *state)
92 {
93 assert(src->reg != NULL);
94
95 struct set_entry *entry = _mesa_set_search(src->reg->uses, state->instr);
96 assert(entry && "use not in nir_register.uses");
97
98 struct hash_entry *entry2;
99 entry2 = _mesa_hash_table_search(state->regs, src->reg);
100
101 assert(entry2);
102
103 reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
104 _mesa_set_add(reg_state->uses, state->instr);
105
106 if (!src->reg->is_global) {
107 assert(reg_state->where_defined == state->impl &&
108 "using a register declared in a different function");
109 }
110
111 assert((src->reg->num_array_elems == 0 ||
112 src->base_offset < src->reg->num_array_elems) &&
113 "definitely out-of-bounds array access");
114
115 if (src->indirect) {
116 assert(src->reg->num_array_elems != 0);
117 assert((src->indirect->is_ssa || src->indirect->reg.indirect == NULL) &&
118 "only one level of indirection allowed");
119 validate_src(src->indirect, state);
120 }
121 }
122
123 static void
124 validate_ssa_src(nir_ssa_def *def, validate_state *state)
125 {
126 assert(def != NULL);
127
128 struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def);
129
130 assert(entry);
131
132 assert((nir_function_impl *) entry->data == state->impl &&
133 "using an SSA value defined in a different function");
134
135 struct set_entry *entry2;
136
137 entry2 = _mesa_set_search(def->uses, state->instr);
138
139 assert(entry2 && "SSA use missing");
140
141 /* TODO validate that the use is dominated by the definition */
142 }
143
144 static void
145 validate_src(nir_src *src, validate_state *state)
146 {
147 if (src->is_ssa)
148 validate_ssa_src(src->ssa, state);
149 else
150 validate_reg_src(&src->reg, state);
151 }
152
153 static void
154 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
155 {
156 nir_alu_src *src = &instr->src[index];
157
158 unsigned num_components;
159 if (src->src.is_ssa)
160 num_components = src->src.ssa->num_components;
161 else {
162 if (src->src.reg.reg->is_packed)
163 num_components = 4; /* can't check anything */
164 else
165 num_components = src->src.reg.reg->num_components;
166 }
167 for (unsigned i = 0; i < 4; i++) {
168 assert(src->swizzle[i] < 4);
169
170 if (nir_alu_instr_channel_used(instr, index, i))
171 assert(src->swizzle[i] < num_components);
172 }
173
174 validate_src(&src->src, state);
175 }
176
177 static void
178 validate_reg_dest(nir_reg_dest *dest, validate_state *state)
179 {
180 assert(dest->reg != NULL);
181
182 struct set_entry *entry = _mesa_set_search(dest->reg->defs, state->instr);
183 assert(entry && "definition not in nir_register.defs");
184
185 struct hash_entry *entry2;
186 entry2 = _mesa_hash_table_search(state->regs, dest->reg);
187
188 assert(entry2);
189
190 reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
191 _mesa_set_add(reg_state->defs, state->instr);
192
193 if (!dest->reg->is_global) {
194 assert(reg_state->where_defined == state->impl &&
195 "writing to a register declared in a different function");
196 }
197
198 assert((dest->reg->num_array_elems == 0 ||
199 dest->base_offset < dest->reg->num_array_elems) &&
200 "definitely out-of-bounds array access");
201
202 if (dest->indirect) {
203 assert(dest->reg->num_array_elems != 0);
204 assert((dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
205 "only one level of indirection allowed");
206 validate_src(dest->indirect, state);
207 }
208 }
209
210 static void
211 validate_ssa_def(nir_ssa_def *def, validate_state *state)
212 {
213 assert(def->index < state->impl->ssa_alloc);
214 assert(!BITSET_TEST(state->ssa_defs_found, def->index));
215 BITSET_SET(state->ssa_defs_found, def->index);
216
217 assert(def->num_components <= 4);
218 _mesa_hash_table_insert(state->ssa_defs, def, state->impl);
219 }
220
221 static void
222 validate_dest(nir_dest *dest, validate_state *state)
223 {
224 if (dest->is_ssa)
225 validate_ssa_def(&dest->ssa, state);
226 else
227 validate_reg_dest(&dest->reg, state);
228 }
229
230 static void
231 validate_alu_dest(nir_alu_dest *dest, validate_state *state)
232 {
233 unsigned dest_size =
234 dest->dest.is_ssa ? dest->dest.ssa.num_components
235 : dest->dest.reg.reg->num_components;
236 bool is_packed = !dest->dest.is_ssa && dest->dest.reg.reg->is_packed;
237 /*
238 * validate that the instruction doesn't write to components not in the
239 * register/SSA value
240 */
241 assert(is_packed || !(dest->write_mask & ~((1 << dest_size) - 1)));
242 validate_dest(&dest->dest, state);
243 }
244
245 static void
246 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
247 {
248 assert(instr->op < nir_num_opcodes);
249
250 validate_alu_dest(&instr->dest, state);
251
252 for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
253 validate_alu_src(instr, i, state);
254 }
255 }
256
257 static void
258 validate_deref_chain(nir_deref *deref, validate_state *state)
259 {
260 nir_deref *parent = NULL;
261 while (deref != NULL) {
262 switch (deref->deref_type) {
263 case nir_deref_type_array:
264 assert(deref->type == glsl_get_array_element(parent->type));
265 if (nir_deref_as_array(deref)->deref_array_type ==
266 nir_deref_array_type_indirect)
267 validate_src(&nir_deref_as_array(deref)->indirect, state);
268 break;
269
270 case nir_deref_type_struct:
271 assert(deref->type ==
272 glsl_get_struct_field(parent->type,
273 nir_deref_as_struct(deref)->index));
274 break;
275
276 case nir_deref_type_var:
277 break;
278
279 default:
280 assert(!"Invalid deref type");
281 break;
282 }
283
284 parent = deref;
285 deref = deref->child;
286 }
287 }
288
289 static void
290 validate_var_use(nir_variable *var, validate_state *state)
291 {
292 if (var->data.mode == nir_var_local) {
293 struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
294
295 assert(entry);
296 assert((nir_function_impl *) entry->data == state->impl);
297 }
298 }
299
300 static void
301 validate_deref_var(nir_deref_var *deref, validate_state *state)
302 {
303 assert(deref != NULL);
304 assert(deref->deref.type == deref->var->type);
305
306 validate_var_use(deref->var, state);
307
308 validate_deref_chain(&deref->deref, state);
309 }
310
311 static void
312 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
313 {
314 unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
315 for (unsigned i = 0; i < num_srcs; i++) {
316 unsigned components_read =
317 nir_intrinsic_infos[instr->intrinsic].src_components[i];
318 if (components_read == 0)
319 components_read = instr->num_components;
320
321 assert(components_read > 0);
322
323 if (instr->src[i].is_ssa) {
324 assert(components_read <= instr->src[i].ssa->num_components);
325 } else if (!instr->src[i].reg.reg->is_packed) {
326 assert(components_read <= instr->src[i].reg.reg->num_components);
327 }
328
329 validate_src(&instr->src[i], state);
330 }
331
332 if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
333 unsigned components_written =
334 nir_intrinsic_infos[instr->intrinsic].dest_components;
335 if (components_written == 0)
336 components_written = instr->num_components;
337
338 assert(components_written > 0);
339
340 if (instr->dest.is_ssa) {
341 assert(components_written <= instr->dest.ssa.num_components);
342 } else if (!instr->dest.reg.reg->is_packed) {
343 assert(components_written <= instr->dest.reg.reg->num_components);
344 }
345
346 validate_dest(&instr->dest, state);
347 }
348
349 unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
350 for (unsigned i = 0; i < num_vars; i++) {
351 validate_deref_var(instr->variables[i], state);
352 }
353
354 switch (instr->intrinsic) {
355 case nir_intrinsic_load_var:
356 assert(instr->variables[0]->var->data.mode != nir_var_shader_out);
357 break;
358 case nir_intrinsic_store_var:
359 assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
360 instr->variables[0]->var->data.mode != nir_var_uniform);
361 break;
362 case nir_intrinsic_copy_var:
363 assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
364 instr->variables[0]->var->data.mode != nir_var_uniform);
365 assert(instr->variables[1]->var->data.mode != nir_var_shader_out);
366 break;
367 default:
368 break;
369 }
370 }
371
372 static void
373 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
374 {
375 validate_dest(&instr->dest, state);
376
377 bool src_type_seen[nir_num_tex_src_types];
378 for (unsigned i = 0; i < nir_num_tex_src_types; i++)
379 src_type_seen[i] = false;
380
381 for (unsigned i = 0; i < instr->num_srcs; i++) {
382 assert(!src_type_seen[instr->src[i].src_type]);
383 src_type_seen[instr->src[i].src_type] = true;
384 validate_src(&instr->src[i], state);
385 }
386
387 if (instr->sampler != NULL)
388 validate_deref_var(instr->sampler, state);
389 }
390
391 static void
392 validate_call_instr(nir_call_instr *instr, validate_state *state)
393 {
394 if (instr->return_deref == NULL)
395 assert(glsl_type_is_void(instr->callee->return_type));
396 else
397 assert(instr->return_deref->deref.type == instr->callee->return_type);
398
399 assert(instr->num_params == instr->callee->num_params);
400
401 for (unsigned i = 0; i < instr->num_params; i++) {
402 assert(instr->callee->params[i].type == instr->params[i]->deref.type);
403 validate_deref_var(instr->params[i], state);
404 }
405
406 validate_deref_var(instr->return_deref, state);
407 }
408
409 static void
410 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
411 {
412 validate_ssa_def(&instr->def, state);
413 }
414
415 static void
416 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
417 {
418 validate_ssa_def(&instr->def, state);
419 }
420
421 static void
422 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
423 {
424 /*
425 * don't validate the sources until we get to them from their predecessor
426 * basic blocks, to avoid validating an SSA use before its definition.
427 */
428
429 validate_dest(&instr->dest, state);
430
431 exec_list_validate(&instr->srcs);
432 assert(exec_list_length(&instr->srcs) ==
433 state->block->predecessors->entries);
434 }
435
436 static void
437 validate_instr(nir_instr *instr, validate_state *state)
438 {
439 assert(instr->block == state->block);
440
441 state->instr = instr;
442
443 switch (instr->type) {
444 case nir_instr_type_alu:
445 validate_alu_instr(nir_instr_as_alu(instr), state);
446 break;
447
448 case nir_instr_type_call:
449 validate_call_instr(nir_instr_as_call(instr), state);
450 break;
451
452 case nir_instr_type_intrinsic:
453 validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
454 break;
455
456 case nir_instr_type_tex:
457 validate_tex_instr(nir_instr_as_tex(instr), state);
458 break;
459
460 case nir_instr_type_load_const:
461 validate_load_const_instr(nir_instr_as_load_const(instr), state);
462 break;
463
464 case nir_instr_type_phi:
465 validate_phi_instr(nir_instr_as_phi(instr), state);
466 break;
467
468 case nir_instr_type_ssa_undef:
469 validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
470 break;
471
472 case nir_instr_type_jump:
473 break;
474
475 default:
476 assert(!"Invalid ALU instruction type");
477 break;
478 }
479 }
480
481 static void
482 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
483 {
484 state->instr = &instr->instr;
485
486 assert(instr->dest.is_ssa);
487
488 exec_list_validate(&instr->srcs);
489 foreach_list_typed(nir_phi_src, src, node, &instr->srcs) {
490 if (src->pred == pred) {
491 unsigned num_components;
492 if (src->src.is_ssa)
493 num_components = src->src.ssa->num_components;
494 else {
495 if (src->src.reg.reg->is_packed)
496 num_components = 4; /* can't check anything */
497 else
498 num_components = src->src.reg.reg->num_components;
499 }
500 assert(num_components == instr->dest.ssa.num_components);
501
502 validate_src(&src->src, state);
503 return;
504 }
505 }
506
507 abort();
508 }
509
510 static void
511 validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
512 {
513 nir_foreach_instr(succ, instr) {
514 if (instr->type != nir_instr_type_phi)
515 break;
516
517 validate_phi_src(nir_instr_as_phi(instr), block, state);
518 }
519 }
520
521 static void validate_cf_node(nir_cf_node *node, validate_state *state);
522
523 static void
524 validate_block(nir_block *block, validate_state *state)
525 {
526 assert(block->cf_node.parent == state->parent_node);
527
528 state->block = block;
529
530 exec_list_validate(&block->instr_list);
531 nir_foreach_instr(block, instr) {
532 if (instr->type == nir_instr_type_phi) {
533 assert(instr == nir_block_first_instr(block) ||
534 nir_instr_prev(instr)->type == nir_instr_type_phi);
535 }
536
537 if (instr->type == nir_instr_type_jump) {
538 assert(instr == nir_block_last_instr(block));
539 }
540
541 validate_instr(instr, state);
542 }
543
544 assert(block->successors[0] != NULL);
545
546 for (unsigned i = 0; i < 2; i++) {
547 if (block->successors[i] != NULL) {
548 struct set_entry *entry =
549 _mesa_set_search(block->successors[i]->predecessors, block);
550 assert(entry);
551
552 validate_phi_srcs(block, block->successors[i], state);
553 }
554 }
555
556 if (!exec_list_is_empty(&block->instr_list) &&
557 nir_block_last_instr(block)->type == nir_instr_type_jump)
558 assert(block->successors[1] == NULL);
559 }
560
561 static void
562 validate_if(nir_if *if_stmt, validate_state *state)
563 {
564 assert(!exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
565 nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node);
566 assert(prev_node->type == nir_cf_node_block);
567
568 nir_block *prev_block = nir_cf_node_as_block(prev_node);
569 assert(&prev_block->successors[0]->cf_node ==
570 nir_if_first_then_node(if_stmt));
571 assert(&prev_block->successors[1]->cf_node ==
572 nir_if_first_else_node(if_stmt));
573
574 assert(!exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
575 nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node);
576 assert(next_node->type == nir_cf_node_block);
577
578 if (!if_stmt->condition.is_ssa) {
579 nir_register *reg = if_stmt->condition.reg.reg;
580 struct set_entry *entry = _mesa_set_search(reg->if_uses, if_stmt);
581 assert(entry);
582 } else {
583 nir_ssa_def *def = if_stmt->condition.ssa;
584 struct set_entry *entry = _mesa_set_search(def->if_uses, if_stmt);
585 assert(entry);
586 }
587
588 assert(!exec_list_is_empty(&if_stmt->then_list));
589 assert(!exec_list_is_empty(&if_stmt->else_list));
590
591 nir_cf_node *old_parent = state->parent_node;
592 state->parent_node = &if_stmt->cf_node;
593
594 exec_list_validate(&if_stmt->then_list);
595 foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) {
596 validate_cf_node(cf_node, state);
597 }
598
599 exec_list_validate(&if_stmt->else_list);
600 foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) {
601 validate_cf_node(cf_node, state);
602 }
603
604 state->parent_node = old_parent;
605 }
606
607 static void
608 validate_loop(nir_loop *loop, validate_state *state)
609 {
610 assert(!exec_node_is_head_sentinel(loop->cf_node.node.prev));
611 nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node);
612 assert(prev_node->type == nir_cf_node_block);
613
614 nir_block *prev_block = nir_cf_node_as_block(prev_node);
615 assert(&prev_block->successors[0]->cf_node == nir_loop_first_cf_node(loop));
616 assert(prev_block->successors[1] == NULL);
617
618 assert(!exec_node_is_tail_sentinel(loop->cf_node.node.next));
619 nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node);
620 assert(next_node->type == nir_cf_node_block);
621
622 assert(!exec_list_is_empty(&loop->body));
623
624 nir_cf_node *old_parent = state->parent_node;
625 state->parent_node = &loop->cf_node;
626
627 exec_list_validate(&loop->body);
628 foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) {
629 validate_cf_node(cf_node, state);
630 }
631
632 state->parent_node = old_parent;
633 }
634
635 static void
636 validate_cf_node(nir_cf_node *node, validate_state *state)
637 {
638 assert(node->parent == state->parent_node);
639
640 switch (node->type) {
641 case nir_cf_node_block:
642 validate_block(nir_cf_node_as_block(node), state);
643 break;
644
645 case nir_cf_node_if:
646 validate_if(nir_cf_node_as_if(node), state);
647 break;
648
649 case nir_cf_node_loop:
650 validate_loop(nir_cf_node_as_loop(node), state);
651 break;
652
653 default:
654 assert(!"Invalid ALU instruction type");
655 break;
656 }
657 }
658
659 static void
660 prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state)
661 {
662 assert(reg->is_global == is_global);
663
664 if (is_global)
665 assert(reg->index < state->shader->reg_alloc);
666 else
667 assert(reg->index < state->impl->reg_alloc);
668 assert(!BITSET_TEST(state->regs_found, reg->index));
669 BITSET_SET(state->regs_found, reg->index);
670
671 reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
672 reg_state->uses = _mesa_set_create(reg_state, _mesa_hash_pointer,
673 _mesa_key_pointer_equal);
674 reg_state->defs = _mesa_set_create(reg_state, _mesa_hash_pointer,
675 _mesa_key_pointer_equal);
676
677 reg_state->where_defined = is_global ? NULL : state->impl;
678
679 _mesa_hash_table_insert(state->regs, reg, reg_state);
680 }
681
682 static void
683 postvalidate_reg_decl(nir_register *reg, validate_state *state)
684 {
685 struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);
686
687 reg_validate_state *reg_state = (reg_validate_state *) entry->data;
688
689 if (reg_state->uses->entries != reg->uses->entries) {
690 printf("extra entries in register uses:\n");
691 struct set_entry *entry;
692 set_foreach(reg->uses, entry) {
693 struct set_entry *entry2 =
694 _mesa_set_search(reg_state->uses, entry->key);
695
696 if (entry2 == NULL) {
697 printf("%p\n", entry->key);
698 }
699 }
700
701 abort();
702 }
703
704 if (reg_state->defs->entries != reg->defs->entries) {
705 printf("extra entries in register defs:\n");
706 struct set_entry *entry;
707 set_foreach(reg->defs, entry) {
708 struct set_entry *entry2 =
709 _mesa_set_search(reg_state->defs, entry->key);
710
711 if (entry2 == NULL) {
712 printf("%p\n", entry->key);
713 }
714 }
715
716 abort();
717 }
718 }
719
720 static void
721 validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
722 {
723 assert(is_global != (var->data.mode == nir_var_local));
724
725 /*
726 * TODO validate some things ir_validate.cpp does (requires more GLSL type
727 * support)
728 */
729
730 if (!is_global) {
731 _mesa_hash_table_insert(state->var_defs, var, state->impl);
732 }
733 }
734
735 static void
736 validate_function_impl(nir_function_impl *impl, validate_state *state)
737 {
738 assert(impl->overload->impl == impl);
739 assert(impl->cf_node.parent == NULL);
740
741 assert(impl->num_params == impl->overload->num_params);
742 for (unsigned i = 0; i < impl->num_params; i++)
743 assert(impl->params[i]->type == impl->overload->params[i].type);
744
745 if (glsl_type_is_void(impl->overload->return_type))
746 assert(impl->return_var == NULL);
747 else
748 assert(impl->return_var->type == impl->overload->return_type);
749
750 assert(exec_list_is_empty(&impl->end_block->instr_list));
751 assert(impl->end_block->successors[0] == NULL);
752 assert(impl->end_block->successors[1] == NULL);
753
754 state->impl = impl;
755 state->parent_node = &impl->cf_node;
756
757 exec_list_validate(&impl->locals);
758 foreach_list_typed(nir_variable, var, node, &impl->locals) {
759 validate_var_decl(var, false, state);
760 }
761
762 state->regs_found = realloc(state->regs_found,
763 BITSET_WORDS(impl->reg_alloc) *
764 sizeof(BITSET_WORD));
765 memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) *
766 sizeof(BITSET_WORD));
767 exec_list_validate(&impl->registers);
768 foreach_list_typed(nir_register, reg, node, &impl->registers) {
769 prevalidate_reg_decl(reg, false, state);
770 }
771
772 state->ssa_defs_found = realloc(state->ssa_defs_found,
773 BITSET_WORDS(impl->ssa_alloc) *
774 sizeof(BITSET_WORD));
775 memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) *
776 sizeof(BITSET_WORD));
777 exec_list_validate(&impl->body);
778 foreach_list_typed(nir_cf_node, node, node, &impl->body) {
779 validate_cf_node(node, state);
780 }
781
782 foreach_list_typed(nir_register, reg, node, &impl->registers) {
783 postvalidate_reg_decl(reg, state);
784 }
785 }
786
787 static void
788 validate_function_overload(nir_function_overload *overload,
789 validate_state *state)
790 {
791 if (overload->impl != NULL)
792 validate_function_impl(overload->impl, state);
793 }
794
795 static void
796 validate_function(nir_function *func, validate_state *state)
797 {
798 exec_list_validate(&func->overload_list);
799 foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
800 assert(overload->function == func);
801 validate_function_overload(overload, state);
802 }
803 }
804
805 static void
806 init_validate_state(validate_state *state)
807 {
808 state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
809 _mesa_key_pointer_equal);
810 state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
811 _mesa_key_pointer_equal);
812 state->ssa_defs_found = NULL;
813 state->regs_found = NULL;
814 state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
815 _mesa_key_pointer_equal);
816 }
817
818 static void
819 destroy_validate_state(validate_state *state)
820 {
821 _mesa_hash_table_destroy(state->regs, NULL);
822 _mesa_hash_table_destroy(state->ssa_defs, NULL);
823 free(state->ssa_defs_found);
824 free(state->regs_found);
825 _mesa_hash_table_destroy(state->var_defs, NULL);
826 }
827
828 void
829 nir_validate_shader(nir_shader *shader)
830 {
831 validate_state state;
832 init_validate_state(&state);
833
834 state.shader = shader;
835
836 struct hash_entry *entry;
837 hash_table_foreach(shader->uniforms, entry) {
838 validate_var_decl((nir_variable *) entry->data, true, &state);
839 }
840
841 hash_table_foreach(shader->inputs, entry) {
842 validate_var_decl((nir_variable *) entry->data, true, &state);
843 }
844
845 hash_table_foreach(shader->outputs, entry) {
846 validate_var_decl((nir_variable *) entry->data, true, &state);
847 }
848
849 exec_list_validate(&shader->globals);
850 foreach_list_typed(nir_variable, var, node, &shader->globals) {
851 validate_var_decl(var, true, &state);
852 }
853
854 exec_list_validate(&shader->system_values);
855 foreach_list_typed(nir_variable, var, node, &shader->system_values) {
856 validate_var_decl(var, true, &state);
857 }
858
859 state.regs_found = realloc(state.regs_found,
860 BITSET_WORDS(shader->reg_alloc) *
861 sizeof(BITSET_WORD));
862 memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) *
863 sizeof(BITSET_WORD));
864 exec_list_validate(&shader->registers);
865 foreach_list_typed(nir_register, reg, node, &shader->registers) {
866 prevalidate_reg_decl(reg, true, &state);
867 }
868
869 exec_list_validate(&shader->functions);
870 foreach_list_typed(nir_function, func, node, &shader->functions) {
871 validate_function(func, &state);
872 }
873
874 foreach_list_typed(nir_register, reg, node, &shader->registers) {
875 postvalidate_reg_decl(reg, &state);
876 }
877
878 destroy_validate_state(&state);
879 }
880
881 #endif /* NDEBUG */