From 9b4677981f2b34cfabdbadcd422e62c7a4ec81f6 Mon Sep 17 00:00:00 2001 From: Faith Ekstrand Date: Mon, 14 Aug 2023 09:03:07 -0500 Subject: [PATCH] nir,ntt,a2xx,lima: Stop using nir_dest directly We want to get rid of nir_dest so back-ends need to stop storing it in structs and passing it through helpers. Acked-by: Emma Anholt Part-of: --- src/compiler/nir/nir_legacy.c | 23 +++++----- src/compiler/nir/nir_legacy.h | 4 +- src/gallium/auxiliary/nir/nir_to_tgsi.c | 64 ++++++++++++++-------------- src/gallium/drivers/freedreno/a2xx/ir2_nir.c | 44 +++++++++---------- src/gallium/drivers/lima/ir/pp/nir.c | 16 +++---- 5 files changed, 74 insertions(+), 77 deletions(-) diff --git a/src/compiler/nir/nir_legacy.c b/src/compiler/nir/nir_legacy.c index 137d42d..8680003 100644 --- a/src/compiler/nir/nir_legacy.c +++ b/src/compiler/nir/nir_legacy.c @@ -122,9 +122,9 @@ nir_legacy_chase_alu_src(const nir_alu_src *src, bool fuse_fabs) } static nir_legacy_alu_dest -chase_alu_dest_helper(nir_dest *dest) +chase_alu_dest_helper(nir_def *def) { - nir_intrinsic_instr *store = nir_store_reg_for_def(&dest->ssa); + nir_intrinsic_instr *store = nir_store_reg_for_def(def); if (store) { bool indirect = (store->intrinsic == nir_intrinsic_store_reg_indirect); @@ -141,8 +141,8 @@ chase_alu_dest_helper(nir_dest *dest) } else { return (nir_legacy_alu_dest){ .dest.is_ssa = true, - .dest.ssa = &dest->ssa, - .write_mask = nir_component_mask(dest->ssa.num_components), + .dest.ssa = def, + .write_mask = nir_component_mask(def->num_components), }; } } @@ -218,10 +218,8 @@ chase_fsat(nir_def **def) } nir_legacy_alu_dest -nir_legacy_chase_alu_dest(nir_dest *dest) +nir_legacy_chase_alu_dest(nir_def *def) { - nir_def *def = &dest->ssa; - /* Try SSA fsat. No users support 64-bit modifiers. */ if (chase_fsat(&def)) { return (nir_legacy_alu_dest){ @@ -231,7 +229,7 @@ nir_legacy_chase_alu_dest(nir_dest *dest) .write_mask = nir_component_mask(def->num_components), }; } else { - return chase_alu_dest_helper(dest); + return chase_alu_dest_helper(def); } } @@ -244,12 +242,11 @@ nir_legacy_chase_src(const nir_src *src) } nir_legacy_dest -nir_legacy_chase_dest(nir_dest *dest) +nir_legacy_chase_dest(nir_def *def) { - nir_legacy_alu_dest alu_dest = chase_alu_dest_helper(dest); + nir_legacy_alu_dest alu_dest = chase_alu_dest_helper(def); assert(!alu_dest.fsat); - assert(alu_dest.write_mask == - nir_component_mask(nir_dest_num_components(*dest))); + assert(alu_dest.write_mask == nir_component_mask(def->num_components)); return alu_dest.dest; } @@ -310,7 +307,7 @@ fuse_mods_with_registers(nir_builder *b, nir_instr *instr, void *fuse_fabs_) } } - nir_legacy_alu_dest dest = nir_legacy_chase_alu_dest(&alu->dest.dest); + nir_legacy_alu_dest dest = nir_legacy_chase_alu_dest(&alu->dest.dest.ssa); if (dest.fsat) { nir_intrinsic_instr *store = nir_store_reg_for_def(dest.dest.ssa); diff --git a/src/compiler/nir/nir_legacy.h b/src/compiler/nir/nir_legacy.h index 3190d8e..3aee869 100644 --- a/src/compiler/nir/nir_legacy.h +++ b/src/compiler/nir/nir_legacy.h @@ -75,12 +75,12 @@ void nir_legacy_trivialize(nir_shader *s, bool fuse_fabs); /* Reconstruct a legacy source/destination (including registers) */ nir_legacy_src nir_legacy_chase_src(const nir_src *src); -nir_legacy_dest nir_legacy_chase_dest(nir_dest *dest); +nir_legacy_dest nir_legacy_chase_dest(nir_def *def); /* Reconstruct a legacy ALU source/destination (including float modifiers) */ nir_legacy_alu_src nir_legacy_chase_alu_src(const nir_alu_src *src, bool fuse_fabs); -nir_legacy_alu_dest nir_legacy_chase_alu_dest(nir_dest *dest); +nir_legacy_alu_dest nir_legacy_chase_alu_dest(nir_def *def); /* Check if a source modifier folds. If so, it may be skipped during instruction * selection, avoiding the need for backend dead code elimination. diff --git a/src/gallium/auxiliary/nir/nir_to_tgsi.c b/src/gallium/auxiliary/nir/nir_to_tgsi.c index b9a9aed..256f5d7 100644 --- a/src/gallium/auxiliary/nir/nir_to_tgsi.c +++ b/src/gallium/auxiliary/nir/nir_to_tgsi.c @@ -1352,16 +1352,16 @@ ntt_get_chased_dest(struct ntt_compile *c, nir_legacy_dest *dest) } static struct ureg_dst -ntt_get_dest(struct ntt_compile *c, nir_dest *dest) +ntt_get_dest(struct ntt_compile *c, nir_def *def) { - nir_legacy_dest chased = nir_legacy_chase_dest(dest); + nir_legacy_dest chased = nir_legacy_chase_dest(def); return ntt_get_chased_dest(c, &chased); } static struct ureg_dst -ntt_get_alu_dest(struct ntt_compile *c, nir_dest *dest) +ntt_get_alu_dest(struct ntt_compile *c, nir_def *def) { - nir_legacy_alu_dest chased = nir_legacy_chase_alu_dest(dest); + nir_legacy_alu_dest chased = nir_legacy_chase_alu_dest(def); struct ureg_dst dst = ntt_get_chased_dest(c, &chased.dest); if (chased.fsat) @@ -1371,7 +1371,7 @@ ntt_get_alu_dest(struct ntt_compile *c, nir_dest *dest) if (chased.dest.is_ssa) return dst; - int dst_64 = nir_dest_bit_size(*dest) == 64; + int dst_64 = def->bit_size == 64; unsigned write_mask = chased.write_mask; if (dst_64) @@ -1401,9 +1401,9 @@ ntt_store_def(struct ntt_compile *c, nir_def *def, struct ureg_src src) } static void -ntt_store(struct ntt_compile *c, nir_dest *dest, struct ureg_src src) +ntt_store(struct ntt_compile *c, nir_def *def, struct ureg_src src) { - nir_legacy_dest chased = nir_legacy_chase_dest(dest); + nir_legacy_dest chased = nir_legacy_chase_dest(def); if (chased.is_ssa) ntt_store_def(c, chased.ssa, src); @@ -1458,7 +1458,7 @@ ntt_emit_alu(struct ntt_compile *c, nir_alu_instr *instr) for (; i < ARRAY_SIZE(src); i++) src[i] = ureg_src_undef(); - dst = ntt_get_alu_dest(c, &instr->dest.dest); + dst = ntt_get_alu_dest(c, &instr->dest.dest.ssa); static enum tgsi_opcode op_map[][2] = { [nir_op_mov] = { TGSI_OPCODE_MOV, TGSI_OPCODE_MOV }, @@ -1923,14 +1923,14 @@ ntt_emit_load_ubo(struct ntt_compile *c, nir_intrinsic_instr *instr) src = ntt_shift_by_frac(src, start_component, instr->num_components * bit_size / 32); - ntt_store(c, &instr->dest, src); + ntt_store(c, &instr->dest.ssa, src); } else { /* PIPE_CAP_LOAD_CONSTBUF: Not necessarily vec4 aligned, emit a * TGSI_OPCODE_LOAD instruction from the const file. */ struct ntt_insn *insn = ntt_insn(c, TGSI_OPCODE_LOAD, - ntt_get_dest(c, &instr->dest), + ntt_get_dest(c, &instr->dest.ssa), src, ntt_get_src(c, instr->src[1]), ureg_src_undef(), ureg_src_undef()); insn->is_mem = true; @@ -2112,7 +2112,7 @@ ntt_emit_mem(struct ntt_compile *c, nir_intrinsic_instr *instr, write_mask = ntt_64bit_write_mask(write_mask); dst = ureg_writemask(dst, write_mask); } else { - dst = ntt_get_dest(c, &instr->dest); + dst = ntt_get_dest(c, &instr->dest.ssa); } struct ntt_insn *insn = ntt_insn(c, opcode, dst, src[0], src[1], src[2], src[3]); @@ -2157,7 +2157,7 @@ ntt_emit_image_load_store(struct ntt_compile *c, nir_intrinsic_instr *instr) dst = ureg_dst(resource); } else { srcs[num_src++] = resource; - dst = ntt_get_dest(c, &instr->dest); + dst = ntt_get_dest(c, &instr->dest.ssa); } struct ureg_dst opcode_dst = dst; @@ -2269,13 +2269,13 @@ ntt_emit_load_input(struct ntt_compile *c, nir_intrinsic_instr *instr) switch (instr->intrinsic) { case nir_intrinsic_load_input: input = ntt_ureg_src_indirect(c, input, instr->src[0], 0); - ntt_store(c, &instr->dest, input); + ntt_store(c, &instr->dest.ssa, input); break; case nir_intrinsic_load_per_vertex_input: input = ntt_ureg_src_indirect(c, input, instr->src[1], 0); input = ntt_ureg_src_dimension_indirect(c, input, instr->src[0]); - ntt_store(c, &instr->dest, input); + ntt_store(c, &instr->dest.ssa, input); break; case nir_intrinsic_load_interpolated_input: { @@ -2290,7 +2290,7 @@ ntt_emit_load_input(struct ntt_compile *c, nir_intrinsic_instr *instr) /* For these, we know that the barycentric load matches the * interpolation on the input declaration, so we can use it directly. */ - ntt_store(c, &instr->dest, input); + ntt_store(c, &instr->dest.ssa, input); break; case nir_intrinsic_load_barycentric_centroid: @@ -2299,21 +2299,21 @@ ntt_emit_load_input(struct ntt_compile *c, nir_intrinsic_instr *instr) * input. */ if (c->centroid_inputs & (1ull << nir_intrinsic_base(instr))) { - ntt_store(c, &instr->dest, input); + ntt_store(c, &instr->dest.ssa, input); } else { - ntt_INTERP_CENTROID(c, ntt_get_dest(c, &instr->dest), input); + ntt_INTERP_CENTROID(c, ntt_get_dest(c, &instr->dest.ssa), input); } break; case nir_intrinsic_load_barycentric_at_sample: /* We stored the sample in the fake "bary" dest. */ - ntt_INTERP_SAMPLE(c, ntt_get_dest(c, &instr->dest), input, + ntt_INTERP_SAMPLE(c, ntt_get_dest(c, &instr->dest.ssa), input, ntt_get_src(c, instr->src[0])); break; case nir_intrinsic_load_barycentric_at_offset: /* We stored the offset in the fake "bary" dest. */ - ntt_INTERP_OFFSET(c, ntt_get_dest(c, &instr->dest), input, + ntt_INTERP_OFFSET(c, ntt_get_dest(c, &instr->dest.ssa), input, ntt_get_src(c, instr->src[0])); break; @@ -2383,7 +2383,7 @@ ntt_emit_load_output(struct ntt_compile *c, nir_intrinsic_instr *instr) out = ntt_ureg_dst_indirect(c, out, instr->src[0]); } - struct ureg_dst dst = ntt_get_dest(c, &instr->dest); + struct ureg_dst dst = ntt_get_dest(c, &instr->dest.ssa); struct ureg_src out_src = ureg_src(out); /* Don't swizzling unavailable channels of the output in the writemasked-out @@ -2426,7 +2426,7 @@ ntt_emit_load_sysval(struct ntt_compile *c, nir_intrinsic_instr *instr) switch (instr->intrinsic) { case nir_intrinsic_load_vertex_id: case nir_intrinsic_load_instance_id: - ntt_U2F(c, ntt_get_dest(c, &instr->dest), sv); + ntt_U2F(c, ntt_get_dest(c, &instr->dest.ssa), sv); return; default: @@ -2434,7 +2434,7 @@ ntt_emit_load_sysval(struct ntt_compile *c, nir_intrinsic_instr *instr) } } - ntt_store(c, &instr->dest, sv); + ntt_store(c, &instr->dest.ssa, sv); } static void @@ -2563,26 +2563,26 @@ ntt_emit_intrinsic(struct ntt_compile *c, nir_intrinsic_instr *instr) } case nir_intrinsic_is_helper_invocation: - ntt_READ_HELPER(c, ntt_get_dest(c, &instr->dest)); + ntt_READ_HELPER(c, ntt_get_dest(c, &instr->dest.ssa)); break; case nir_intrinsic_vote_all: - ntt_VOTE_ALL(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c,instr->src[0])); + ntt_VOTE_ALL(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c,instr->src[0])); return; case nir_intrinsic_vote_any: - ntt_VOTE_ANY(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c, instr->src[0])); + ntt_VOTE_ANY(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c, instr->src[0])); return; case nir_intrinsic_vote_ieq: - ntt_VOTE_EQ(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c, instr->src[0])); + ntt_VOTE_EQ(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c, instr->src[0])); return; case nir_intrinsic_ballot: - ntt_BALLOT(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c, instr->src[0])); + ntt_BALLOT(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c, instr->src[0])); return; case nir_intrinsic_read_first_invocation: - ntt_READ_FIRST(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c, instr->src[0])); + ntt_READ_FIRST(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c, instr->src[0])); return; case nir_intrinsic_read_invocation: - ntt_READ_INVOC(c, ntt_get_dest(c, &instr->dest), ntt_get_src(c, instr->src[0]), ntt_get_src(c, instr->src[1])); + ntt_READ_INVOC(c, ntt_get_dest(c, &instr->dest.ssa), ntt_get_src(c, instr->src[0]), ntt_get_src(c, instr->src[1])); return; case nir_intrinsic_load_ssbo: @@ -2654,11 +2654,11 @@ ntt_emit_intrinsic(struct ntt_compile *c, nir_intrinsic_instr *instr) break; case nir_intrinsic_load_barycentric_at_sample: case nir_intrinsic_load_barycentric_at_offset: - ntt_store(c, &instr->dest, ntt_get_src(c, instr->src[0])); + ntt_store(c, &instr->dest.ssa, ntt_get_src(c, instr->src[0])); break; case nir_intrinsic_shader_clock: - ntt_CLOCK(c, ntt_get_dest(c, &instr->dest)); + ntt_CLOCK(c, ntt_get_dest(c, &instr->dest.ssa)); break; case nir_intrinsic_decl_reg: @@ -2714,7 +2714,7 @@ ntt_push_tex_arg(struct ntt_compile *c, static void ntt_emit_texture(struct ntt_compile *c, nir_tex_instr *instr) { - struct ureg_dst dst = ntt_get_dest(c, &instr->dest); + struct ureg_dst dst = ntt_get_dest(c, &instr->dest.ssa); enum tgsi_texture_type target = tgsi_texture_type_from_sampler_dim(instr->sampler_dim, instr->is_array, instr->is_shadow); unsigned tex_opcode; diff --git a/src/gallium/drivers/freedreno/a2xx/ir2_nir.c b/src/gallium/drivers/freedreno/a2xx/ir2_nir.c index 0d844d4..614da47 100644 --- a/src/gallium/drivers/freedreno/a2xx/ir2_nir.c +++ b/src/gallium/drivers/freedreno/a2xx/ir2_nir.c @@ -285,9 +285,9 @@ set_legacy_index(struct ir2_context *ctx, nir_legacy_dest dst, } static void -set_index(struct ir2_context *ctx, nir_dest *dst, struct ir2_instr *instr) +set_index(struct ir2_context *ctx, nir_def *def, struct ir2_instr *instr) { - set_legacy_index(ctx, nir_legacy_chase_dest(dst), instr); + set_legacy_index(ctx, nir_legacy_chase_dest(def), instr); } static struct ir2_instr * @@ -381,23 +381,23 @@ instr_create_alu_reg(struct ir2_context *ctx, nir_op opcode, uint8_t write_mask, } static struct ir2_instr * -instr_create_alu_dest(struct ir2_context *ctx, nir_op opcode, nir_dest *dst) +instr_create_alu_dest(struct ir2_context *ctx, nir_op opcode, nir_def *def) { struct ir2_instr *instr; - instr = instr_create_alu(ctx, opcode, nir_dest_num_components(*dst)); - set_index(ctx, dst, instr); + instr = instr_create_alu(ctx, opcode, def->num_components); + set_index(ctx, def, instr); return instr; } static struct ir2_instr * -ir2_instr_create_fetch(struct ir2_context *ctx, nir_dest *dst, +ir2_instr_create_fetch(struct ir2_context *ctx, nir_def *def, instr_fetch_opc_t opc) { struct ir2_instr *instr = ir2_instr_create(ctx, IR2_FETCH); instr->fetch.opc = opc; instr->src_count = 1; - instr->ssa.ncomp = nir_dest_num_components(*dst); - set_index(ctx, dst, instr); + instr->ssa.ncomp = def->num_components; + set_index(ctx, def, instr); return instr; } @@ -419,7 +419,7 @@ static void emit_alu(struct ir2_context *ctx, nir_alu_instr *alu) { const nir_op_info *info = &nir_op_infos[alu->op]; - nir_dest *dst = &alu->dest.dest; + nir_def *def = &alu->dest.dest.ssa; struct ir2_instr *instr; struct ir2_src tmp; unsigned ncomp; @@ -433,11 +433,12 @@ emit_alu(struct ir2_context *ctx, nir_alu_instr *alu) return; /* get the number of dst components */ - ncomp = dst->ssa.num_components; + ncomp = def->num_components; instr = instr_create_alu(ctx, alu->op, ncomp); - nir_legacy_alu_dest legacy_dest = nir_legacy_chase_alu_dest(&alu->dest.dest); + nir_legacy_alu_dest legacy_dest = + nir_legacy_chase_alu_dest(&alu->dest.dest.ssa); set_legacy_index(ctx, legacy_dest.dest, instr); instr->alu.saturate = legacy_dest.fsat; instr->alu.write_mask = legacy_dest.write_mask; @@ -512,13 +513,13 @@ emit_alu(struct ir2_context *ctx, nir_alu_instr *alu) } static void -load_input(struct ir2_context *ctx, nir_dest *dst, unsigned idx) +load_input(struct ir2_context *ctx, nir_def *def, unsigned idx) { struct ir2_instr *instr; int slot = -1; if (ctx->so->type == MESA_SHADER_VERTEX) { - instr = ir2_instr_create_fetch(ctx, dst, 0); + instr = ir2_instr_create_fetch(ctx, def, 0); instr->src[0] = ir2_src(0, 0, IR2_SRC_INPUT); instr->fetch.vtx.const_idx = 20 + (idx / 3); instr->fetch.vtx.const_idx_sel = idx % 3; @@ -554,11 +555,11 @@ load_input(struct ir2_context *ctx, nir_dest *dst, unsigned idx) instr->src[0] = ir2_src(ctx->f->fragcoord, IR2_SWIZZLE_Y, IR2_SRC_INPUT); unsigned reg_idx = instr->reg - ctx->reg; /* XXX */ - instr = instr_create_alu_dest(ctx, nir_op_mov, dst); + instr = instr_create_alu_dest(ctx, nir_op_mov, def); instr->src[0] = ir2_src(reg_idx, 0, IR2_SRC_REG); break; default: - instr = instr_create_alu_dest(ctx, nir_op_mov, dst); + instr = instr_create_alu_dest(ctx, nir_op_mov, def); instr->src[0] = ir2_src(idx, 0, IR2_SRC_INPUT); break; } @@ -629,7 +630,7 @@ emit_intrinsic(struct ir2_context *ctx, nir_intrinsic_instr *intr) break; case nir_intrinsic_load_input: - load_input(ctx, &intr->dest, nir_intrinsic_base(intr)); + load_input(ctx, &intr->dest.ssa, nir_intrinsic_base(intr)); break; case nir_intrinsic_store_output: store_output(ctx, intr->src[0], output_slot(ctx, intr), @@ -640,7 +641,7 @@ emit_intrinsic(struct ir2_context *ctx, nir_intrinsic_instr *intr) assert(const_offset); /* TODO can be false in ES2? */ idx = nir_intrinsic_base(intr); idx += (uint32_t)const_offset[0].f32; - instr = instr_create_alu_dest(ctx, nir_op_mov, &intr->dest); + instr = instr_create_alu_dest(ctx, nir_op_mov, &intr->dest.ssa); instr->src[0] = ir2_src(idx, 0, IR2_SRC_CONST); break; case nir_intrinsic_discard: @@ -667,7 +668,7 @@ emit_intrinsic(struct ir2_context *ctx, nir_intrinsic_instr *intr) struct ir2_instr *tmp = instr_create_alu(ctx, nir_op_frcp, 1); tmp->src[0] = ir2_src(ctx->f->inputs_count, 0, IR2_SRC_INPUT); - instr = instr_create_alu_dest(ctx, nir_op_sge, &intr->dest); + instr = instr_create_alu_dest(ctx, nir_op_sge, &intr->dest.ssa); instr->src[0] = ir2_src(tmp->idx, 0, IR2_SRC_SSA); instr->src[1] = ir2_zero(ctx); break; @@ -675,7 +676,7 @@ emit_intrinsic(struct ir2_context *ctx, nir_intrinsic_instr *intr) /* param.zw (note: abs might be needed like fragcoord in param.xy?) */ ctx->so->need_param = true; - instr = instr_create_alu_dest(ctx, nir_op_mov, &intr->dest); + instr = instr_create_alu_dest(ctx, nir_op_mov, &intr->dest.ssa); instr->src[0] = ir2_src(ctx->f->inputs_count, IR2_SWIZZLE_ZW, IR2_SRC_INPUT); break; @@ -768,7 +769,7 @@ emit_tex(struct ir2_context *ctx, nir_tex_instr *tex) /* TODO: lod/bias transformed by src_coord.z ? */ } - instr = ir2_instr_create_fetch(ctx, &tex->dest, TEX_FETCH); + instr = ir2_instr_create_fetch(ctx, &tex->dest.ssa, TEX_FETCH); instr->src[0] = src_coord; instr->src[0].swizzle = is_cube ? IR2_SWIZZLE_YXW : 0; instr->fetch.tex.is_cube = is_cube; @@ -824,8 +825,7 @@ emit_undef(struct ir2_context *ctx, nir_undef_instr *undef) struct ir2_instr *instr; - instr = instr_create_alu_dest( - ctx, nir_op_mov, &(nir_dest){.ssa = undef->def}); + instr = instr_create_alu_dest(ctx, nir_op_mov, &undef->def); instr->src[0] = ir2_src(0, 0, IR2_SRC_CONST); } diff --git a/src/gallium/drivers/lima/ir/pp/nir.c b/src/gallium/drivers/lima/ir/pp/nir.c index 02310df..384f344 100644 --- a/src/gallium/drivers/lima/ir/pp/nir.c +++ b/src/gallium/drivers/lima/ir/pp/nir.c @@ -159,14 +159,14 @@ static int nir_to_ppir_opcodes[nir_num_opcodes] = { static bool ppir_emit_alu(ppir_block *block, nir_instr *ni) { nir_alu_instr *instr = nir_instr_as_alu(ni); - nir_dest *dst = &instr->dest.dest; + nir_def *def = &instr->dest.dest.ssa; int op = nir_to_ppir_opcodes[instr->op]; if (op == ppir_op_unsupported) { ppir_error("unsupported nir_op: %s\n", nir_op_infos[instr->op].name); return false; } - nir_legacy_alu_dest legacy_dest = nir_legacy_chase_alu_dest(dst); + nir_legacy_alu_dest legacy_dest = nir_legacy_chase_alu_dest(def); /* Don't try to translate folded fsat since their source won't be valid */ if (instr->op == nir_op_fsat && nir_legacy_fsat_folds(instr)) @@ -180,7 +180,7 @@ static bool ppir_emit_alu(ppir_block *block, nir_instr *ni) nir_alu_src *ns = &instr->src[0]; ppir_node *parent = block->comp->var_nodes[ns->src.ssa->index]; assert(parent); - block->comp->var_nodes[dst->ssa.index] = parent; + block->comp->var_nodes[def->index] = parent; return true; } @@ -291,7 +291,7 @@ static bool ppir_emit_intrinsic(ppir_block *block, nir_instr *ni) return true; case nir_intrinsic_load_reg: { - nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest); + nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest.ssa); lnode = ppir_node_create_dest(block, ppir_op_dummy, &legacy_dest, mask); return true; } @@ -299,7 +299,7 @@ static bool ppir_emit_intrinsic(ppir_block *block, nir_instr *ni) case nir_intrinsic_load_input: { mask = u_bit_consecutive(0, instr->num_components); - nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest); + nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest.ssa); lnode = ppir_node_create_dest(block, ppir_op_load_varying, &legacy_dest, mask); if (!lnode) return false; @@ -338,7 +338,7 @@ static bool ppir_emit_intrinsic(ppir_block *block, nir_instr *ni) break; } - nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest); + nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest.ssa); lnode = ppir_node_create_dest(block, op, &legacy_dest, mask); if (!lnode) return false; @@ -351,7 +351,7 @@ static bool ppir_emit_intrinsic(ppir_block *block, nir_instr *ni) case nir_intrinsic_load_uniform: { mask = u_bit_consecutive(0, instr->num_components); - nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest); + nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest.ssa); lnode = ppir_node_create_dest(block, ppir_op_load_uniform, &legacy_dest, mask); if (!lnode) return false; @@ -517,7 +517,7 @@ static bool ppir_emit_tex(ppir_block *block, nir_instr *ni) unsigned mask = 0; mask = u_bit_consecutive(0, nir_tex_instr_dest_size(instr)); - nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest); + nir_legacy_dest legacy_dest = nir_legacy_chase_dest(&instr->dest.ssa); node = ppir_node_create_dest(block, ppir_op_load_texture, &legacy_dest, mask); if (!node) return false; -- 2.7.4