OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nir,ntt,a2xx,lima: Stop using nir_dest directly

Browse Source 
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 <emma@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24674>
This commit is contained in:
Faith Ekstrand
2023-08-14 09:03:07 -05:00
committed by Marge Bot
parent b30da1b281
commit 9b4677981f
5 changed files with 74 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/compiler/nir/nir_legacy.c
View File

@@ -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);

4
src/compiler/nir/nir_legacy.h
View File

@@ -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.

64
src/gallium/auxiliary/nir/nir_to_tgsi.c
View File

@@ -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;

44
src/gallium/drivers/freedreno/a2xx/ir2_nir.c
View File

@@ -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);
}

16
src/gallium/drivers/lima/ir/pp/nir.c
View File

@@ -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;