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