Lines Matching defs:instr
59 * (such as instr or var) to message to print.
119 print_const_from_load(nir_load_const_instr *instr, print_state *state)
131 for (unsigned i = 0; i < instr->def.num_components; i++) {
135 switch (instr->def.bit_size) {
137 fprintf(fp, "0x%016" PRIx64, instr->value[i].u64);
140 fprintf(fp, "0x%08x", instr->value[i].u32);
143 fprintf(fp, "0x%04x", instr->value[i].u16);
146 fprintf(fp, "0x%02x", instr->value[i].u8);
149 fprintf(fp, "%s", instr->value[i].b ? "true" : "false");
154 if (instr->def.bit_size > 8) {
155 if (instr->def.num_components > 1)
160 for (unsigned i = 0; i < instr->def.num_components; i++) {
164 switch (instr->def.bit_size) {
166 fprintf(fp, "%f", instr->value[i].f64);
169 fprintf(fp, "%f", instr->value[i].f32);
172 fprintf(fp, "%f", _mesa_half_to_float(instr->value[i].u16));
184 print_load_const_instr(nir_load_const_instr *instr, print_state *state)
188 print_ssa_def(&instr->def, state);
192 print_const_from_load(instr, state);
200 nir_instr *instr = def->parent_instr;
201 if (instr->type == nir_instr_type_load_const && NIR_DEBUG(PRINT_CONSTS)) {
203 print_const_from_load(nir_instr_as_load_const(instr), state);
265 print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state)
269 if (instr->src[src].negate)
271 if (instr->src[src].abs)
274 print_src(&instr->src[src].src, state);
280 if (!nir_alu_instr_channel_used(instr, src, i))
285 if (instr->src[src].swizzle[i] != i) {
291 unsigned live_channels = nir_src_num_components(instr->src[src].src);
296 if (!nir_alu_instr_channel_used(instr, src, i))
299 fprintf(fp, "%c", comp_mask_string(live_channels)[instr->src[src].swizzle[i]]);
303 if (instr->src[src].abs)
326 print_alu_instr(nir_alu_instr *instr, print_state *state)
330 print_alu_dest(&instr->dest, state);
332 fprintf(fp, " = %s", nir_op_infos[instr->op].name);
333 if (instr->exact)
335 if (instr->dest.saturate)
337 if (instr->no_signed_wrap)
339 if (instr->no_unsigned_wrap)
343 for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
347 print_alu_src(instr, i, state);
725 print_deref_link(const nir_deref_instr *instr, bool whole_chain, print_state *state)
729 if (instr->deref_type == nir_deref_type_var) {
730 fprintf(fp, "%s", get_var_name(instr->var, state));
732 } else if (instr->deref_type == nir_deref_type_cast) {
733 fprintf(fp, "(%s *)", glsl_get_type_name(instr->type));
734 print_src(&instr->parent, state);
738 assert(instr->parent.is_ssa);
740 nir_instr_as_deref(instr->parent.ssa->parent_instr);
757 is_parent_pointer && instr->deref_type != nir_deref_type_struct;
769 print_src(&instr->parent, state);
775 switch (instr->deref_type) {
778 glsl_get_struct_elem_name(parent->type, instr->strct.index));
783 if (nir_src_is_const(instr->arr.index)) {
784 fprintf(fp, "[%"PRId64"]", nir_src_as_int(instr->arr.index));
787 print_src(&instr->arr.index, state);
803 print_deref_instr(nir_deref_instr *instr, print_state *state)
807 print_dest(&instr->dest, state);
809 switch (instr->deref_type) {
831 if (instr->deref_type != nir_deref_type_cast)
834 print_deref_link(instr, false, state);
837 unsigned modes = instr->modes;
843 fprintf(fp, " %s) ", glsl_get_type_name(instr->type));
845 if (instr->deref_type != nir_deref_type_var &&
846 instr->deref_type != nir_deref_type_cast) {
849 print_deref_link(instr, true, state);
853 if (instr->deref_type == nir_deref_type_cast) {
855 instr->cast.ptr_stride,
856 instr->cast.align_mul, instr->cast.align_offset);
902 print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
904 const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
909 print_dest(&instr->dest, state);
919 print_src(&instr->src[i], state);
932 unsigned wrmask = nir_intrinsic_write_mask(instr);
934 for (unsigned i = 0; i < instr->num_components; i++)
936 fprintf(fp, "%c", comp_mask_string(instr->num_components)[i]);
941 nir_op reduction_op = nir_intrinsic_reduction_op(instr);
958 enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
965 bool array = nir_intrinsic_image_array(instr);
971 enum pipe_format format = nir_intrinsic_format(instr);
977 VkDescriptorType desc_type = nir_intrinsic_desc_type(instr);
984 print_alu_type(nir_intrinsic_src_type(instr), state);
990 print_alu_type(nir_intrinsic_dest_type(instr), state);
996 unsigned mask = nir_intrinsic_swizzle_mask(instr);
997 if (instr->intrinsic == nir_intrinsic_quad_swizzle_amd) {
1000 } else if (instr->intrinsic == nir_intrinsic_masked_swizzle_amd) {
1011 nir_memory_semantics semantics = nir_intrinsic_memory_semantics(instr);
1026 unsigned int modes = nir_intrinsic_memory_modes(instr);
1038 idx == NIR_INTRINSIC_MEMORY_SCOPE ? nir_intrinsic_memory_scope(instr)
1039 : nir_intrinsic_execution_scope(instr);
1053 struct nir_io_semantics io = nir_intrinsic_io_semantics(instr);
1079 (instr->intrinsic == nir_intrinsic_store_output ||
1080 instr->intrinsic == nir_intrinsic_store_per_primitive_output ||
1081 instr->intrinsic == nir_intrinsic_store_per_vertex_output)) {
1101 nir_io_xfb xfb = start_comp < 2 ? nir_intrinsic_io_xfb(instr) :
1102 nir_intrinsic_io_xfb2(instr);
1126 switch (nir_intrinsic_rounding_mode(instr)) {
1139 fprintf(fp, "%s=%d", nir_intrinsic_index_names[idx], instr->const_index[off]);
1145 fprintf(fp, " /*%d*/", instr->const_index[i]);
1153 switch (instr->intrinsic) {
1172 if ((var->data.driver_location == nir_intrinsic_base(instr)) &&
1173 (instr->intrinsic == nir_intrinsic_load_uniform ||
1174 (nir_intrinsic_component(instr) >= var->data.location_frac &&
1175 nir_intrinsic_component(instr) <
1185 print_tex_instr(nir_tex_instr *instr, print_state *state)
1189 print_dest(&instr->dest, state);
1192 print_alu_type(instr->dest_type, state);
1195 switch (instr->op) {
1253 for (unsigned i = 0; i < instr->num_srcs; i++) {
1258 print_src(&instr->src[i].src, state);
1261 switch(instr->src[i].src_type) {
1331 if (instr->op == nir_texop_tg4) {
1332 fprintf(fp, ", %u (gather_component)", instr->component);
1335 if (nir_tex_instr_has_explicit_tg4_offsets(instr)) {
1336 fprintf(fp, ", { (%i, %i)", instr->tg4_offsets[0][0], instr->tg4_offsets[0][1]);
1338 fprintf(fp, ", (%i, %i)", instr->tg4_offsets[i][0],
1339 instr->tg4_offsets[i][1]);
1343 if (instr->op != nir_texop_txf_ms_fb) {
1345 fprintf(fp, ", %u (texture)", instr->texture_index);
1349 fprintf(fp, ", %u (sampler)", instr->sampler_index);
1353 if (instr->texture_non_uniform) {
1357 if (instr->sampler_non_uniform) {
1361 if (instr->is_sparse) {
1367 print_call_instr(nir_call_instr *instr, print_state *state)
1371 fprintf(fp, "call %s ", instr->callee->name);
1373 for (unsigned i = 0; i < instr->num_params; i++) {
1377 print_src(&instr->params[i], state);
1382 print_jump_instr(nir_jump_instr *instr, print_state *state)
1386 switch (instr->type) {
1405 instr->target ? instr->target->index : -1);
1410 instr->target ? instr->target->index : -1);
1411 print_src(&instr->condition, state);
1413 instr->else_target ? instr->else_target->index : -1);
1419 print_ssa_undef_instr(nir_ssa_undef_instr* instr, print_state *state)
1422 print_ssa_def(&instr->def, state);
1427 print_phi_instr(nir_phi_instr *instr, print_state *state)
1430 print_dest(&instr->dest, state);
1432 nir_foreach_phi_src(src, instr) {
1433 if (&src->node != exec_list_get_head(&instr->srcs))
1442 print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state)
1445 nir_foreach_parallel_copy_entry(entry, instr) {
1446 if (&entry->node != exec_list_get_head(&instr->entries))
1456 print_instr(const nir_instr *instr, print_state *state, unsigned tabs)
1461 switch (instr->type) {
1463 print_alu_instr(nir_instr_as_alu(instr), state);
1467 print_deref_instr(nir_instr_as_deref(instr), state);
1471 print_call_instr(nir_instr_as_call(instr), state);
1475 print_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
1479 print_tex_instr(nir_instr_as_tex(instr), state);
1483 print_load_const_instr(nir_instr_as_load_const(instr), state);
1487 print_jump_instr(nir_instr_as_jump(instr), state);
1491 print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
1495 print_phi_instr(nir_instr_as_phi(instr), state);
1499 print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state);
1530 nir_foreach_instr(instr, block) {
1531 print_instr(instr, state, tabs);
1533 print_annotation(state, instr);
1793 nir_print_instr(const nir_instr *instr, FILE *fp)
1798 if (instr->block) {
1799 nir_function_impl *impl = nir_cf_node_get_function(&instr->block->cf_node);
1803 print_instr(instr, &state, 0);