Lines Matching defs:instr
65 nir_instr *instr;
113 if (state->instr)
114 obj = state->instr;
160 if (state->instr) {
201 if (state->instr) {
224 if (state->instr)
225 validate_assert(state, src->parent_instr == state->instr);
236 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
238 nir_alu_src *src = &instr->src[index];
240 if (instr->op == nir_op_mov)
247 if (nir_alu_instr_channel_used(instr, index, i))
260 validate_assert(state, dest->parent_instr == state->instr);
297 validate_assert(state, def->parent_instr == state->instr);
338 validate_alu_dest(nir_alu_instr *instr, validate_state *state)
340 nir_alu_dest *dest = &instr->dest;
342 if (instr->op == nir_op_mov)
355 nir_alu_instr *alu = nir_instr_as_alu(state->instr);
365 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
367 validate_assert(state, instr->op < nir_num_opcodes);
370 for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
371 nir_alu_type src_type = nir_op_infos[instr->op].input_types[i];
372 unsigned src_bit_size = nir_src_bit_size(instr->src[i].src);
387 validate_alu_src(instr, i, state);
390 nir_alu_type dest_type = nir_op_infos[instr->op].output_type;
391 unsigned dest_bit_size = nir_dest_bit_size(instr->dest.dest);
406 validate_alu_dest(instr, state);
419 validate_deref_instr(nir_deref_instr *instr, validate_state *state)
421 if (instr->deref_type == nir_deref_type_var) {
423 validate_assert(state, instr->modes == instr->var->data.mode);
424 validate_assert(state, instr->type == instr->var->type);
425 validate_var_use(instr->var, state);
426 } else if (instr->deref_type == nir_deref_type_cast) {
430 validate_src(&instr->parent, state, 0, 0);
433 if (instr->modes & ~nir_var_mem_generic)
434 validate_assert(state, util_bitcount(instr->modes) == 1);
436 nir_deref_instr *parent = nir_src_as_deref(instr->parent);
441 validate_assert(state, instr->modes & parent->modes);
444 validate_assert(state, instr->modes != 0);
448 validate_assert(state, instr->type);
449 if (instr->cast.align_mul > 0) {
450 validate_assert(state, util_is_power_of_two_nonzero(instr->cast.align_mul));
451 validate_assert(state, instr->cast.align_offset < instr->cast.align_mul);
453 validate_assert(state, instr->cast.align_offset == 0);
457 validate_assert(state, instr->parent.is_ssa);
462 validate_src(&instr->parent, state, nir_dest_bit_size(instr->dest),
463 nir_dest_num_components(instr->dest));
465 nir_instr *parent_instr = instr->parent.ssa->parent_instr;
472 validate_assert(state, instr->modes == parent->modes);
474 switch (instr->deref_type) {
478 instr->strct.index < glsl_get_length(parent->type));
479 validate_assert(state, instr->type ==
480 glsl_get_struct_field(parent->type, instr->strct.index));
485 if (instr->modes & nir_var_vec_indexable_modes) {
499 instr->type == glsl_get_array_element(parent->type));
501 if (instr->deref_type == nir_deref_type_array) {
502 validate_src(&instr->arr.index, state,
503 nir_dest_bit_size(instr->dest), 1);
516 validate_src(&instr->arr.index, state,
517 nir_dest_bit_size(instr->dest), 1);
529 validate_dest(&instr->dest, state, 0, 0);
535 validate_assert(state, list_is_empty(&instr->dest.ssa.if_uses));
540 nir_foreach_use(use, &instr->dest.ssa) {
542 validate_assert(state, !(instr->modes & (nir_var_shader_in |
571 image_intrin_format(nir_intrinsic_instr *instr)
573 if (nir_intrinsic_format(instr) != PIPE_FORMAT_NONE)
574 return nir_intrinsic_format(instr);
577 if (nir_intrinsic_infos[instr->intrinsic].src_components[0] != -1)
580 nir_variable *var = nir_intrinsic_get_var(instr, 0);
588 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
592 switch (instr->intrinsic) {
594 nir_alu_type src_type = nir_intrinsic_src_type(instr);
595 nir_alu_type dest_type = nir_intrinsic_dest_type(instr);
604 unsigned param_idx = nir_intrinsic_param_idx(instr);
607 validate_assert(state, instr->num_components == param->num_components);
613 nir_deref_instr *src = nir_src_as_deref(instr->src[0]);
618 validate_assert(state, instr->num_components ==
628 nir_deref_instr *dst = nir_src_as_deref(instr->src[0]);
631 validate_assert(state, instr->num_components ==
642 nir_deref_instr *dst = nir_src_as_deref(instr->src[0]);
643 nir_deref_instr *src = nir_src_as_deref(instr->src[1]);
651 int bit_size = nir_dest_bit_size(instr->dest);
653 validate_assert(state, (nir_intrinsic_component(instr) +
654 instr->num_components) * (bit_size / 8) <= 16);
660 validate_assert(state, nir_intrinsic_range(instr) != 0);
670 util_is_power_of_two_nonzero(nir_intrinsic_align_mul(instr)));
671 validate_assert(state, nir_intrinsic_align_offset(instr) <
672 nir_intrinsic_align_mul(instr));
684 validate_assert(state, nir_dest_bit_size(instr->dest) >= 8);
693 util_is_power_of_two_nonzero(nir_intrinsic_align_mul(instr)));
694 validate_assert(state, nir_intrinsic_align_offset(instr) <
695 nir_intrinsic_align_mul(instr));
701 validate_assert(state, nir_src_bit_size(instr->src[0]) >= 8);
707 util_bitcount(nir_intrinsic_memory_modes(instr)) == 1);
737 enum pipe_format format = image_intrin_format(instr);
743 validate_assert(state, nir_dest_bit_size(instr->dest) ==
752 enum pipe_format format = image_intrin_format(instr);
759 validate_assert(state, nir_dest_bit_size(instr->dest) ==
768 enum pipe_format format = image_intrin_format(instr);
771 validate_assert(state, nir_dest_bit_size(instr->dest) == 32);
781 enum pipe_format format = image_intrin_format(instr);
786 validate_assert(state, nir_dest_bit_size(instr->dest) ==
795 if (instr->num_components > 0)
796 validate_num_components(state, instr->num_components);
798 const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
801 unsigned components_read = nir_intrinsic_src_components(instr, i);
805 validate_src(&instr->src[i], state, src_bit_sizes[i], components_read);
808 if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
809 unsigned components_written = nir_intrinsic_dest_components(instr);
812 bit_sizes = nir_src_bit_size(instr->src[info->bit_size_src]);
820 validate_dest(&instr->dest, state, dest_bit_size, components_written);
823 if (!vectorized_intrinsic(instr))
824 validate_assert(state, instr->num_components == 0);
826 if (nir_intrinsic_has_write_mask(instr)) {
827 unsigned component_mask = BITFIELD_MASK(instr->num_components);
828 validate_assert(state, (nir_intrinsic_write_mask(instr) & ~component_mask) == 0);
831 if (nir_intrinsic_has_io_xfb(instr)) {
835 nir_io_xfb xfb = i < 2 ? nir_intrinsic_io_xfb(instr) :
836 nir_intrinsic_io_xfb2(instr);
845 if (nir_intrinsic_has_io_semantics(instr) &&
846 !nir_intrinsic_infos[instr->intrinsic].has_dest) {
847 nir_io_semantics sem = nir_intrinsic_io_semantics(instr);
854 nir_instr_xfb_write_mask(instr));
859 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
865 for (unsigned i = 0; i < instr->num_srcs; i++) {
866 validate_assert(state, !src_type_seen[instr->src[i].src_type]);
867 src_type_seen[instr->src[i].src_type] = true;
868 validate_src(&instr->src[i].src, state,
869 0, nir_tex_instr_src_size(instr, i));
871 switch (instr->src[i].src_type) {
874 validate_assert(state, instr->is_shadow);
878 validate_assert(state, instr->op == nir_texop_txb ||
879 instr->op == nir_texop_tg4);
883 validate_assert(state, instr->op != nir_texop_tex &&
884 instr->op != nir_texop_txb &&
885 instr->op != nir_texop_txd &&
886 instr->op != nir_texop_lod);
891 validate_assert(state, instr->op == nir_texop_txd);
895 nir_deref_instr *deref = nir_src_as_deref(instr->src[i].src);
906 nir_deref_instr *deref = nir_src_as_deref(instr->src[i].src);
931 if (instr->op != nir_texop_tg4)
932 validate_assert(state, instr->component == 0);
934 if (nir_tex_instr_has_explicit_tg4_offsets(instr)) {
935 validate_assert(state, instr->op == nir_texop_tg4);
939 validate_dest(&instr->dest, state, 0, nir_tex_instr_dest_size(instr));
941 unsigned bit_size = nir_alu_type_get_type_size(instr->dest_type);
944 nir_dest_bit_size(instr->dest));
948 validate_call_instr(nir_call_instr *instr, validate_state *state)
950 validate_assert(state, instr->num_params == instr->callee->num_params);
952 for (unsigned i = 0; i < instr->num_params; i++) {
953 validate_src(&instr->params[i], state,
954 instr->callee->params[i].bit_size,
955 instr->callee->params[i].num_components);
992 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
994 validate_ssa_def(&instr->def, state);
996 for (unsigned i = 0; i < instr->def.num_components; i++)
997 validate_const_value(&instr->value[i], instr->def.bit_size, state);
1001 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
1003 validate_ssa_def(&instr->def, state);
1007 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
1014 validate_dest(&instr->dest, state, 0, 0);
1016 exec_list_validate(&instr->srcs);
1017 validate_assert(state, exec_list_length(&instr->srcs) ==
1022 validate_jump_instr(nir_jump_instr *instr, validate_state *state)
1025 validate_assert(state, &instr->instr == nir_block_last_instr(block));
1027 switch (instr->type) {
1032 validate_assert(state, instr->target == NULL);
1033 validate_assert(state, instr->else_target == NULL);
1045 validate_assert(state, instr->target == NULL);
1046 validate_assert(state, instr->else_target == NULL);
1057 validate_assert(state, instr->target == NULL);
1058 validate_assert(state, instr->else_target == NULL);
1063 validate_assert(state, instr->target == block->successors[0]);
1064 validate_assert(state, instr->target != NULL);
1065 validate_assert(state, instr->else_target == NULL);
1070 validate_assert(state, instr->target == block->successors[1]);
1071 validate_assert(state, instr->else_target == block->successors[0]);
1072 validate_src(&instr->condition, state, 0, 1);
1073 validate_assert(state, instr->target != NULL);
1074 validate_assert(state, instr->else_target != NULL);
1084 validate_instr(nir_instr *instr, validate_state *state)
1086 validate_assert(state, instr->block == state->block);
1088 state->instr = instr;
1091 validate_assert(state, _mesa_set_search(state->shader_gc_list, instr));
1093 switch (instr->type) {
1095 validate_alu_instr(nir_instr_as_alu(instr), state);
1099 validate_deref_instr(nir_instr_as_deref(instr), state);
1103 validate_call_instr(nir_instr_as_call(instr), state);
1107 validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
1111 validate_tex_instr(nir_instr_as_tex(instr), state);
1115 validate_load_const_instr(nir_instr_as_load_const(instr), state);
1119 validate_phi_instr(nir_instr_as_phi(instr), state);
1123 validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
1127 validate_jump_instr(nir_instr_as_jump(instr), state);
1135 state->instr = NULL;
1139 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
1141 state->instr = &instr->instr;
1143 validate_assert(state, instr->dest.is_ssa);
1145 exec_list_validate(&instr->srcs);
1146 nir_foreach_phi_src(src, instr) {
1149 validate_src(&src->src, state, instr->dest.ssa.bit_size,
1150 instr->dest.ssa.num_components);
1151 state->instr = NULL;
1162 nir_foreach_instr(instr, succ) {
1163 if (instr->type != nir_instr_type_phi)
1166 validate_phi_src(nir_instr_as_phi(instr), block, state);
1254 nir_foreach_instr(instr, block) {
1255 if (instr->type == nir_instr_type_phi) {
1256 validate_assert(state, instr == nir_block_first_instr(block) ||
1257 nir_instr_prev(instr)->type == nir_instr_type_phi);
1260 validate_instr(instr, state);
1592 nir_foreach_instr(instr, block) {
1593 state->instr = instr;
1594 if (instr->type == nir_instr_type_phi) {
1595 nir_phi_instr *phi = nir_instr_as_phi(instr);
1602 nir_foreach_src(instr, validate_src_dominance, state);
1604 nir_foreach_ssa_def(instr, validate_ssa_def_dominance, state);
1705 state->instr = NULL;
1760 list_for_each_entry(nir_instr, instr, &shader->gc_list, gc_node) {
1761 if (instr->node.prev || instr->node.next)
1762 _mesa_set_add(state.shader_gc_list, instr);