nir_unpack_half_2x16_split_y(b, ba));
}
- nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, nir_src_for_ssa(result),
+ nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, result,
result->parent_instr);
}
intrin->dest.ssa.bit_size = 32;
nir_ssa_def *bval = nir_i2b(&b, &intrin->dest.ssa);
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(bval),
+ bval,
bval->parent_instr);
progress = true;
}
* def->parent_instr and that after_me comes after def->parent_instr.
*/
void
-nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_src new_src,
+nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_ssa_def *new_ssa,
nir_instr *after_me)
{
- if (new_src.is_ssa && def == new_src.ssa)
+ if (def == new_ssa)
return;
nir_foreach_use_safe(use_src, def) {
* the instruction list.
*/
if (!is_instr_between(def->parent_instr, after_me, use_src->parent_instr))
- nir_instr_rewrite_src(use_src->parent_instr, use_src, new_src);
+ nir_instr_rewrite_src_ssa(use_src->parent_instr, use_src, new_ssa);
}
- nir_foreach_if_use_safe(use_src, def)
- nir_if_rewrite_condition(use_src->parent_if, new_src);
+ nir_foreach_if_use_safe(use_src, def) {
+ nir_if_rewrite_condition_ssa(use_src->parent_if,
+ &use_src->parent_if->condition,
+ new_ssa);
+ }
}
nir_component_mask_t
}
void nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_ssa_def *new_ssa);
void nir_ssa_def_rewrite_uses_src(nir_ssa_def *def, nir_src new_src);
-void nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_src new_src,
+void nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_ssa_def *new_ssa,
nir_instr *after_me);
nir_component_mask_t nir_ssa_def_components_read(const nir_ssa_def *def);
data = nir_bitcast_vector(b, &load->dest.ssa, old_bit_size);
data = resize_vector(b, data, old_num_comps);
- nir_ssa_def_rewrite_uses_after(&load->dest.ssa, nir_src_for_ssa(data),
+ nir_ssa_def_rewrite_uses_after(&load->dest.ssa, data,
data->parent_instr);
return true;
}
nir_instr_remove(&intrin->instr);
} else {
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(scalar),
+ scalar,
scalar->parent_instr);
}
progress = true;
b->cursor = nir_after_instr(&last_phi->instr);
nir_ssa_def *new_dest = nir_u2u(b, &phi->dest.ssa, old_bit_size);
- nir_ssa_def_rewrite_uses_after(&phi->dest.ssa, nir_src_for_ssa(new_dest),
+ nir_ssa_def_rewrite_uses_after(&phi->dest.ssa, new_dest,
new_dest->parent_instr);
}
nir_ssa_def *new_vec = nir_channels(&b, &intrin->dest.ssa,
vec4_comp_mask >> new_frac);
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(new_vec),
+ new_vec,
new_vec->parent_instr);
progress = true;
b.cursor = nir_after_instr(instr);
nir_ssa_def *val = &intrin->dest.ssa;
nir_ssa_def *comp = nir_channel(&b, val, index);
- nir_ssa_def_rewrite_uses_after(val, nir_src_for_ssa(comp), comp->parent_instr);
+ nir_ssa_def_rewrite_uses_after(val, comp, comp->parent_instr);
}
progress = true;
nir_channel(b, pntc, 0),
nir_fadd(b, offset, scaled));
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(flipped_pntc),
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, flipped_pntc,
flipped_pntc->parent_instr);
}
unsigned swiz[4] = { 2, 3, 1, 0 };
nir_ssa_def *swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4);
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(swizzled),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, swizzled,
swizzled->parent_instr);
}
}
}
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(swizzled),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, swizzled,
swizzled->parent_instr);
}
nir_channel(b, rgb, 2),
nir_channel(b, &tex->dest.ssa, 3));
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(result),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, result,
result->parent_instr);
}
break;
}
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(color),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, color,
color->parent_instr);
}
minified = nir_vec(b, comp, dest_size);
}
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(minified),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, minified,
minified->parent_instr);
return true;
}
&intrin->dest.ssa);
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(result),
+ result,
result->parent_instr);
}
}
b.cursor = nir_after_instr(&intrin->instr);
nir_ssa_def *vec3 = nir_channels(&b, &intrin->dest.ssa, 0x7);
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(vec3),
+ vec3,
vec3->parent_instr);
progress = true;
break;
nir_imm_float(b, 0.0f)));
}
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(wpos),
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, wpos,
wpos->parent_instr);
}
nir_channel(b, wpos_temp, 3));
nir_ssa_def_rewrite_uses_after(&intr->dest.ssa,
- nir_src_for_ssa(wpos_temp),
+ wpos_temp,
wpos_temp->parent_instr);
}
nir_fmul(b, nir_channel(b, pos, 1), scale));
nir_ssa_def *flipped_pos = nir_vec2(b, nir_channel(b, pos, 0), flipped_y);
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(flipped_pos),
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, flipped_pos,
flipped_pos->parent_instr);
}
* rewrite the vecN itself.
*/
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(value.ssa.def[0]),
+ value.ssa.def[0],
value.ssa.def[0]->parent_instr);
} else {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
/* update uses */
if (first == low) {
- nir_ssa_def_rewrite_uses_after(&low->intrin->dest.ssa, nir_src_for_ssa(low_def),
+ nir_ssa_def_rewrite_uses_after(&low->intrin->dest.ssa, low_def,
high_def->parent_instr);
nir_ssa_def_rewrite_uses(&high->intrin->dest.ssa, high_def);
} else {
nir_ssa_def_rewrite_uses(&low->intrin->dest.ssa, low_def);
- nir_ssa_def_rewrite_uses_after(&high->intrin->dest.ssa, nir_src_for_ssa(high_def),
+ nir_ssa_def_rewrite_uses_after(&high->intrin->dest.ssa, high_def,
high_def->parent_instr);
}
nir_ssa_def *vec = nir_vec(&b, vec_srcs, intrin->num_components);
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
- nir_src_for_ssa(vec),
+ vec,
vec->parent_instr);
/* The SSA def is now only used by the swizzle. It's safe to
nir_ssa_def *coord = nir_vec3(b, x, y, z);
nir_ssa_def_rewrite_uses_after(&intr->dest.ssa,
- nir_src_for_ssa(coord),
+ coord,
b->cursor.instr);
break;
}
ycbcr_sampler->ycbcr_range,
&tex->dest.ssa,
bpcs);
- nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(result),
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, result,
result->parent_instr);
builder->cursor = nir_before_instr(&tex->instr);
pos = nir_vector_insert_imm(b, pos, depth, 2);
assert(intr->dest.is_ssa);
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(pos),
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, pos,
pos->parent_instr);
}
nir_instr_as_alu(ssa->parent_instr)->op = nir_op_ieq;
nir_ssa_def_rewrite_uses_after(&intr->dest.ssa,
- nir_src_for_ssa(ssa),
+ ssa,
ssa->parent_instr);
} break;
case nir_intrinsic_store_deref: {
nir_instr_insert_after(instr, &mul->instr);
- nir_ssa_def_rewrite_uses_after(ssa, nir_src_for_ssa(&mul->dest.dest.ssa), &mul->instr);
+ nir_ssa_def_rewrite_uses_after(ssa, &mul->dest.dest.ssa,
+ &mul->instr);
}
}
}
if (result != &intr->dest.ssa) {
nir_ssa_def_rewrite_uses_after(&intr->dest.ssa,
- nir_src_for_ssa(result),
+ result,
result->parent_instr);
}
}
/* now use the composite dest in all cases where the original dest (from the dynamic index)
* was used and remove the dynamically-indexed load_*bo instruction
*/
- nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, nir_src_for_ssa(new_dest), &instr->instr);
+ nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, new_dest,
+ &instr->instr);
} else
generate_store_ssbo_ssa_def(b, instr, instr->src[block_idx].ssa, first_idx, last_idx);
nir_instr_remove(&instr->instr);
def[3] = nir_vector_extract(b, &intr2->dest.ssa, nir_imm_int(b, 1));
nir_ssa_def *new_vec = nir_vec(b, def, total_num_components);
/* use the assembled dvec3/4 for all other uses of the load */
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(new_vec), new_vec->parent_instr);
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, new_vec,
+ new_vec->parent_instr);
}
return true;
nir_imm_int(b, 0),
NULL);
- nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, nir_src_for_ssa(composite), composite->parent_instr);
+ nir_ssa_def_rewrite_uses_after(&instr->dest.ssa, composite,
+ composite->parent_instr);
return true;
}
return false;
b->cursor = nir_after_instr(instr);
nir_ssa_def *def = nir_isub(b, &intr->dest.ssa, nir_load_base_instance(b));
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(def), def->parent_instr);
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, def, def->parent_instr);
return true;
}
: nir_u2f32(b, val);
}
- nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa, nir_src_for_ssa(val),
+ nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa, val,
val->parent_instr);
state->impl_progress = true;
}
b.cursor = nir_after_instr(instr);
nir_ssa_def_rewrite_uses_after(image_size,
- nir_src_for_ssa(image_size_replacement),
+ image_size_replacement,
image_size_replacement->parent_instr);
function_progress = true;
intrinsic->dest.ssa.bit_size = 32;
sysval = nir_u2u64(b, &intrinsic->dest.ssa);
nir_ssa_def_rewrite_uses_after(&intrinsic->dest.ssa,
- nir_src_for_ssa(sysval),
+ sysval,
sysval->parent_instr);
}
continue;
load_base);
nir_ssa_def_rewrite_uses_after(&load_id->dest.ssa,
- nir_src_for_ssa(id),
+ id,
id->parent_instr);
progress = true;
}
/* Rewrite uses before we insert so we don't rewrite this use */
nir_ssa_def_rewrite_uses_after(&tex->dest.ssa,
- nir_src_for_ssa(swiz_tex_res),
+ swiz_tex_res,
swiz_tex_res->parent_instr);
}
nir_ssa_def *i64 = nir_u2u64(&b, &intrinsic->dest.ssa);
nir_ssa_def_rewrite_uses_after(
&intrinsic->dest.ssa,
- nir_src_for_ssa(i64),
+ i64,
i64->parent_instr);
}
}
/* The f2f32(f2fmp(x)) will cancel by opt_algebraic */
nir_ssa_def *conv = nir_f2f32(&b, &intr->dest.ssa);
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(conv), conv->parent_instr);
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, conv,
+ conv->parent_instr);
progress |= true;
}
nir_ssa_def *conv = nir_u2u64(b, &intr->dest.ssa);
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, nir_src_for_ssa(conv), conv->parent_instr);
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, conv,
+ conv->parent_instr);
return true;
}
unpacked = nir_convert_to_bit_size(b, unpacked, src_type, bits);
unpacked = pan_extend(b, unpacked, nir_dest_num_components(intr->dest));
- nir_src rewritten = nir_src_for_ssa(unpacked);
- nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, rewritten, &intr->instr);
+ nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, unpacked, &intr->instr);
}
bool