Lines Matching refs:state
41 * Per-register validation state.
63 /* map of register -> validation state (struct above) */
107 log_error(validate_state *state, const char *cond, const char *file, int line)
111 if (state->instr)
112 obj = state->instr;
113 else if (state->var)
114 obj = state->var;
118 char *msg = ralloc_asprintf(state->errors, "error: %s (%s:%d)",
121 _mesa_hash_table_insert(state->errors, obj, msg);
124 #define validate_assert(state, cond) do { \
126 log_error(state, #cond, __FILE__, __LINE__); \
129 static void validate_src(nir_src *src, validate_state *state);
132 validate_reg_src(nir_src *src, validate_state *state)
134 validate_assert(state, src->reg.reg != NULL);
137 entry = _mesa_hash_table_search(state->regs, src->reg.reg);
138 validate_assert(state, entry);
142 if (state->instr) {
145 validate_assert(state, state->if_stmt);
150 validate_assert(state, reg_state->where_defined == state->impl &&
154 validate_assert(state, (src->reg.reg->num_array_elems == 0 ||
159 validate_assert(state, src->reg.reg->num_array_elems != 0);
160 validate_assert(state, (src->reg.indirect->is_ssa ||
163 validate_src(src->reg.indirect, state);
168 validate_ssa_src(nir_src *src, validate_state *state)
170 validate_assert(state, src->ssa != NULL);
172 struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, src->ssa);
174 validate_assert(state, entry);
181 validate_assert(state, def_state->where_defined == state->impl &&
184 if (state->instr) {
187 validate_assert(state, state->if_stmt);
195 validate_src(nir_src *src, validate_state *state)
197 if (state->instr)
198 validate_assert(state, src->parent_instr == state->instr);
200 validate_assert(state, src->parent_if == state->if_stmt);
203 validate_ssa_src(src, state);
205 validate_reg_src(src, state);
209 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
226 validate_assert(state, src->swizzle[i] < 4);
229 validate_assert(state, src->swizzle[i] < num_components);
236 validate_assert(state, src_bit_size == 16 || src_bit_size == 32 || src_bit_size == 64);
240 validate_assert(state, nir_alu_type_get_type_size(src_type) == src_bit_size);
246 validate_assert(state, dest_bit_size == src_bit_size);
250 validate_src(&src->src, state);
254 validate_reg_dest(nir_reg_dest *dest, validate_state *state)
256 validate_assert(state, dest->reg != NULL);
258 validate_assert(state, dest->parent_instr == state->instr);
261 entry2 = _mesa_hash_table_search(state->regs, dest->reg);
263 validate_assert(state, entry2);
269 validate_assert(state, reg_state->where_defined == state->impl &&
273 validate_assert(state, (dest->reg->num_array_elems == 0 ||
278 validate_assert(state, dest->reg->num_array_elems != 0);
279 validate_assert(state, (dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
281 validate_src(dest->indirect, state);
286 validate_ssa_def(nir_ssa_def *def, validate_state *state)
288 validate_assert(state, def->index < state->impl->ssa_alloc);
289 validate_assert(state, !BITSET_TEST(state->ssa_defs_found, def->index));
290 BITSET_SET(state->ssa_defs_found, def->index);
292 validate_assert(state, def->parent_instr == state->instr);
294 validate_assert(state, def->num_components <= 4);
299 ssa_def_validate_state *def_state = ralloc(state->ssa_defs,
301 def_state->where_defined = state->impl;
306 _mesa_hash_table_insert(state->ssa_defs, def, def_state);
310 validate_dest(nir_dest *dest, validate_state *state)
313 validate_ssa_def(&dest->ssa, state);
315 validate_reg_dest(&dest->reg, state);
319 validate_alu_dest(nir_alu_instr *instr, validate_state *state)
331 validate_assert(state, is_packed || !(dest->write_mask & ~((1 << dest_size) - 1)));
336 nir_alu_instr *alu = nir_instr_as_alu(state->instr);
337 validate_assert(state,
348 validate_assert(state, bit_size == 16 || bit_size == 32 || bit_size == 64);
350 validate_assert(state, nir_alu_type_get_type_size(type) == 0 ||
353 validate_dest(&dest->dest, state);
357 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
359 validate_assert(state, instr->op < nir_num_opcodes);
362 validate_alu_src(instr, i, state);
365 validate_alu_dest(instr, state);
369 validate_deref_chain(nir_deref *deref, validate_state *state)
371 validate_assert(state, deref->child == NULL || ralloc_parent(deref->child) == deref);
377 validate_assert(state, deref->type == glsl_get_array_element(parent->type));
380 validate_src(&nir_deref_as_array(deref)->indirect, state);
385 validate_assert(state, deref->type ==
394 validate_assert(state, !"Invalid deref type");
404 validate_var_use(nir_variable *var, validate_state *state)
407 struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
409 validate_assert(state, entry);
410 validate_assert(state, (nir_function_impl *) entry->data == state->impl);
415 validate_deref_var(void *parent_mem_ctx, nir_deref_var *deref, validate_state *state)
417 validate_assert(state, deref != NULL);
418 validate_assert(state, ralloc_parent(deref) == parent_mem_ctx);
419 validate_assert(state, deref->deref.type == deref->var->type);
421 validate_var_use(deref->var, state);
423 validate_deref_chain(&deref->deref, state);
427 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
436 validate_assert(state, components_read > 0);
439 validate_assert(state, components_read <= instr->src[i].ssa->num_components);
441 validate_assert(state, components_read <= instr->src[i].reg.reg->num_components);
444 validate_src(&instr->src[i], state);
449 validate_deref_var(instr, instr->variables[i], state);
458 validate_assert(state, components_written > 0);
461 validate_assert(state, components_written <= instr->dest.ssa.num_components);
463 validate_assert(state, components_written <= instr->dest.reg.reg->num_components);
466 validate_dest(&instr->dest, state);
473 validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
476 validate_assert(state, instr->num_components == glsl_get_vector_elements(type));
482 validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
485 validate_assert(state, instr->num_components == glsl_get_vector_elements(type));
486 validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
489 validate_assert(state, (nir_intrinsic_write_mask(instr) & ~((1 << instr->num_components) - 1)) == 0);
493 validate_assert(state
495 validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
505 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
512 validate_assert(state, !src_type_seen[instr->src[i].src_type]);
514 validate_src(&instr->src[i].src, state);
518 validate_deref_var(instr, instr->texture, state);
521 validate_deref_var(instr, instr->sampler, state);
523 validate_dest(&instr->dest, state);
527 validate_call_instr(nir_call_instr *instr, validate_state *state)
530 validate_assert(state, glsl_type_is_void(instr->callee->return_type));
532 validate_assert(state, instr->return_deref->deref.type == instr->callee->return_type);
533 validate_deref_var(instr, instr->return_deref, state);
536 validate_assert(state, instr->num_params == instr->callee->num_params);
539 validate_assert(state, instr->callee->params[i].type == instr->params[i]->deref.type);
540 validate_deref_var(instr, instr->params[i], state);
545 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
547 validate_ssa_def(&instr->def, state);
551 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
553 validate_ssa_def(&instr->def, state);
557 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
564 validate_dest(&instr->dest, state);
567 validate_assert(state, exec_list_length(&instr->srcs) ==
568 state->block->predecessors->entries);
572 validate_instr(nir_instr *instr, validate_state *state)
574 validate_assert(state, instr->block == state->block);
576 state->instr = instr;
580 validate_alu_instr(nir_instr_as_alu(instr), state);
584 validate_call_instr(nir_instr_as_call(instr), state);
588 validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
592 validate_tex_instr(nir_instr_as_tex(instr), state);
596 validate_load_const_instr(nir_instr_as_load_const(instr), state);
600 validate_phi_instr(nir_instr_as_phi(instr), state);
604 validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
611 validate_assert(state, !"Invalid ALU instruction type");
615 state->instr = NULL;
619 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
621 state->instr = &instr->instr;
623 validate_assert(state, instr->dest.is_ssa);
628 validate_assert(state, src->src.is_ssa);
629 validate_assert(state, src->src.ssa->num_components ==
632 validate_src(&src->src, state);
633 state->instr = NULL;
642 validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
648 validate_phi_src(nir_instr_as_phi(instr), block, state);
652 static void validate_cf_node(nir_cf_node *node, validate_state *state);
655 validate_block(nir_block *block, validate_state *state)
657 validate_assert(state, block->cf_node.parent == state->parent_node);
659 state->block = block;
664 validate_assert(state, instr == nir_block_first_instr(block) ||
669 validate_assert(state, instr == nir_block_last_instr(block));
672 validate_instr(instr, state);
675 validate_assert(state, block->successors[0] != NULL);
676 validate_assert(state, block->successors[0] != block->successors[1]);
682 validate_assert(state, entry);
684 validate_phi_srcs(block, block->successors[i], state);
691 validate_assert(state, pred->successors[0] == block ||
697 validate_assert(state, block->successors[1] == NULL);
702 nir_cf_node_as_block(nir_cf_node_next(&state->loop->cf_node));
703 validate_assert(state, block->successors[0] == after);
708 nir_block *first = nir_loop_first_block(state->loop);
709 validate_assert(state, block->successors[0] == first);
714 validate_assert(state, block->successors[0] == state->impl->end_block);
723 switch (state->parent_node->type) {
725 nir_block *first = nir_loop_first_block(state->loop);
726 validate_assert(state, block->successors[0] == first);
735 nir_cf_node_as_block(nir_cf_node_next(state->parent_node));
736 validate_assert(state, block->successors[0] == after);
737 validate_assert(state, block->successors[1] == NULL);
742 validate_assert(state, block->successors[0] == state->impl->end_block);
743 validate_assert(state, block->successors[1] == NULL);
752 validate_assert(state, block->successors[0] ==
754 validate_assert(state, block->successors[1] ==
757 validate_assert(state, next->type == nir_cf_node_loop);
759 validate_assert(state, block->successors[0] ==
761 validate_assert(state, block->successors[1] == NULL);
768 validate_if(nir_if *if_stmt, validate_state *state)
770 state->if_stmt = if_stmt;
772 validate_assert(state, !exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
774 validate_assert(state, prev_node->type == nir_cf_node_block);
776 validate_assert(state, !exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
778 validate_assert(state, next_node->type == nir_cf_node_block);
780 validate_src(&if_stmt->condition, state);
782 validate_assert(state, !exec_list_is_empty(&if_stmt->then_list));
783 validate_assert(state, !exec_list_is_empty(&if_stmt->else_list));
785 nir_cf_node *old_parent = state->parent_node;
786 state->parent_node = &if_stmt->cf_node;
790 validate_cf_node(cf_node, state);
795 validate_cf_node(cf_node, state);
798 state->parent_node = old_parent;
799 state->if_stmt = NULL;
803 validate_loop(nir_loop *loop, validate_state *state)
805 validate_assert(state, !exec_node_is_head_sentinel(loop->cf_node.node.prev));
807 validate_assert(state, prev_node->type == nir_cf_node_block);
809 validate_assert(state, !exec_node_is_tail_sentinel(loop->cf_node.node.next));
811 validate_assert(state, next_node->type == nir_cf_node_block);
813 validate_assert(state, !exec_list_is_empty(&loop->body));
815 nir_cf_node *old_parent = state->parent_node;
816 state->parent_node = &loop->cf_node;
817 nir_loop *old_loop = state->loop;
818 state->loop = loop;
822 validate_cf_node(cf_node, state);
825 state->parent_node = old_parent;
826 state->loop = old_loop;
830 validate_cf_node(nir_cf_node *node, validate_state *state)
832 validate_assert(state, node->parent == state->parent_node);
836 validate_block(nir_cf_node_as_block(node), state);
840 validate_if(nir_cf_node_as_if(node), state);
844 validate_loop(nir_cf_node_as_loop(node), state);
853 prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state)
855 validate_assert(state, reg->is_global == is_global);
858 validate_assert(state, reg->index < state->shader->reg_alloc);
860 validate_assert(state, reg->index < state->impl->reg_alloc);
861 validate_assert(state, !BITSET_TEST(state->regs_found, reg->index));
862 BITSET_SET(state->regs_found, reg->index);
868 reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
876 reg_state->where_defined = is_global ? NULL : state->impl;
878 _mesa_hash_table_insert(state->regs, reg, reg_state);
882 postvalidate_reg_decl(nir_register *reg, validate_state *state)
884 struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);
891 validate_assert(state, entry);
906 validate_assert(state, entry);
921 validate_assert(state, entry);
936 validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
938 state->var = var;
940 validate_assert(state, is_global == nir_variable_is_global(var));
943 validate_assert(state, util_bitcount(var->data.mode) == 1);
950 if (nir_is_per_vertex_io(var, state->shader->stage)) {
964 _mesa_hash_table_insert(state->var_defs, var, state->impl);
967 state->var = NULL;
973 validate_state *state = void_state;
975 struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def);
982 validate_assert(state, entry);
997 validate_assert(state, entry);
1014 validate_function_impl(nir_function_impl *impl, validate_state *state)
1016 validate_assert(state, impl->function->impl == impl);
1017 validate_assert(state, impl->cf_node.parent == NULL);
1019 validate_assert(state, impl->num_params == impl->function->num_params);
1021 validate_assert(state, impl->params[i]->type == impl->function->params[i].type);
1022 validate_assert(state, impl->params[i]->data.mode == nir_var_param);
1023 validate_assert(state, impl->params[i]->data.location == i);
1024 validate_var_decl(impl->params[i], false, state);
1028 state, impl->return_var == NULL);
1030 validate_assert(state, impl->return_var->type == impl->function->return_type);
1031 validate_assert(state, impl->return_var->data.mode == nir_var_param);
1032 validate_assert(state, impl->return_var->data.location == -1);
1033 validate_var_decl(impl->return_var, false, state);
1036 validate_assert(state, exec_list_is_empty(&impl->end_block->instr_list));
1037 validate_assert(state, impl->end_block->successors[0] == NULL);
1038 validate_assert(state, impl->end_block->successors[1] == NULL);
1040 state->impl = impl;
1041 state->parent_node = &impl->cf_node;
1045 validate_var_decl(var, false, state);
1048 state->regs_found = realloc(state->regs_found,
1051 memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) *
1055 prevalidate_reg_decl(reg, false, state);
1058 state->ssa_defs_found = realloc(state->ssa_defs_found,
1061 memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) *
1065 validate_cf_node(node, state);
1069 postvalidate_reg_decl(reg, state);
1074 nir_foreach_ssa_def(instr, postvalidate_ssa_def, state);
1079 validate_function(nir_function *func, validate_state *state)
1082 validate_assert(state, func->impl->function == func);
1083 validate_function_impl(func->impl, state);
1088 init_validate_state(validate_state *state)
1090 state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1092 state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1094 state->ssa_defs_found = NULL;
1095 state->regs_found = NULL;
1096 state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1098 state->errors = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1101 state->loop = NULL;
1102 state->instr = NULL;
1103 state->var = NULL;
1107 destroy_validate_state(validate_state *state)
1109 _mesa_hash_table_destroy(state->regs, NULL);
1110 _mesa_hash_table_destroy(state->ssa_defs, NULL);
1111 free(state->ssa_defs_found);
1112 free(state->regs_found);
1113 _mesa_hash_table_destroy(state->var_defs, NULL);
1114 _mesa_hash_table_destroy(state->errors, NULL);
1118 dump_errors(validate_state *state)
1120 struct hash_table *errors = state->errors;
1124 nir_print_shader_annotated(state->shader, stderr, errors);
1147 validate_state state;
1148 init_validate_state(&state);
1150 state.shader = shader;
1154 validate_var_decl(var, true, &state);
1159 validate_var_decl(var, true, &state);
1164 validate_var_decl(var, true, &state);
1169 validate_var_decl(var, true, &state);
1174 validate_var_decl(var, true, &state);
1179 validate_var_decl(var, true, &state);
1182 state.regs_found = realloc(state.regs_found,
1185 memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) *
1189 prevalidate_reg_decl(reg, true, &state);
1194 validate_function(func, &state);
1198 postvalidate_reg_decl(reg, &state);
1201 if (_mesa_hash_table_num_entries(state.errors) > 0)
1202 dump_errors(&state);
1204 destroy_validate_state(&state);
