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

nir/constant_folding: Use the standard variable naming convention

Browse Source 
Typically, if we have one alu instruction, we call it "alu" and if we
have one intrinsic we call it "intrin".

Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@intel.com>
Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/7366>
This commit is contained in:
Jason Ekstrand
2020-10-29 10:05:21 -05:00
parent 9d2ccbfc15
commit 9492ab2864
1 changed files with 47 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
src/compiler/nir/nir_opt_constant_folding.c
View File

@@ -41,11 +41,11 @@ struct constant_fold_state {
};
static bool
try_fold_alu(nir_builder *b, nir_alu_instr *instr)
try_fold_alu(nir_builder *b, nir_alu_instr *alu)
{
nir_const_value src[NIR_MAX_VEC_COMPONENTS][NIR_MAX_VEC_COMPONENTS];
if (!instr->dest.dest.is_ssa)
if (!alu->dest.dest.is_ssa)
return false;
/* In the case that any outputs/inputs have unsized types, then we need to
@@ -58,55 +58,55 @@ try_fold_alu(nir_builder *b, nir_alu_instr *instr)
* (although it still requires to receive a valid bit-size).
*/
unsigned bit_size = 0;
if (!nir_alu_type_get_type_size(nir_op_infos[instr->op].output_type))
bit_size = instr->dest.dest.ssa.bit_size;
if (!nir_alu_type_get_type_size(nir_op_infos[alu->op].output_type))
bit_size = alu->dest.dest.ssa.bit_size;
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
if (!instr->src[i].src.is_ssa)
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
if (!alu->src[i].src.is_ssa)
return false;
if (bit_size == 0 &&
!nir_alu_type_get_type_size(nir_op_infos[instr->op].input_types[i]))
bit_size = instr->src[i].src.ssa->bit_size;
!nir_alu_type_get_type_size(nir_op_infos[alu->op].input_types[i]))
bit_size = alu->src[i].src.ssa->bit_size;
nir_instr *src_instr = instr->src[i].src.ssa->parent_instr;
nir_instr *src_instr = alu->src[i].src.ssa->parent_instr;
if (src_instr->type != nir_instr_type_load_const)
return false;
nir_load_const_instr* load_const = nir_instr_as_load_const(src_instr);
for (unsigned j = 0; j < nir_ssa_alu_instr_src_components(instr, i);
for (unsigned j = 0; j < nir_ssa_alu_instr_src_components(alu, i);
j++) {
src[i][j] = load_const->value[instr->src[i].swizzle[j]];
src[i][j] = load_const->value[alu->src[i].swizzle[j]];
}
/* We shouldn't have any source modifiers in the optimization loop. */
assert(!instr->src[i].abs && !instr->src[i].negate);
assert(!alu->src[i].abs && !alu->src[i].negate);
}
if (bit_size == 0)
bit_size = 32;
/* We shouldn't have any saturate modifiers in the optimization loop. */
assert(!instr->dest.saturate);
assert(!alu->dest.saturate);
nir_const_value dest[NIR_MAX_VEC_COMPONENTS];
nir_const_value *srcs[NIR_MAX_VEC_COMPONENTS];
memset(dest, 0, sizeof(dest));
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; ++i)
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; ++i)
srcs[i] = src[i];
nir_eval_const_opcode(instr->op, dest, instr->dest.dest.ssa.num_components,
nir_eval_const_opcode(alu->op, dest, alu->dest.dest.ssa.num_components,
bit_size, srcs,
b->shader->info.float_controls_execution_mode);
b->cursor = nir_before_instr(&instr->instr);
nir_ssa_def *imm = nir_build_imm(b, instr->dest.dest.ssa.num_components,
instr->dest.dest.ssa.bit_size,
b->cursor = nir_before_instr(&alu->instr);
nir_ssa_def *imm = nir_build_imm(b, alu->dest.dest.ssa.num_components,
alu->dest.dest.ssa.bit_size,
dest);
nir_ssa_def_rewrite_uses(&instr->dest.dest.ssa, nir_src_for_ssa(imm));
nir_instr_remove(&instr->instr);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(imm));
nir_instr_remove(&alu->instr);
ralloc_free(instr);
ralloc_free(alu);
return true;
}
@@ -180,18 +180,18 @@ fail:
}
static bool
try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *instr,
try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
struct constant_fold_state *state)
{
switch (instr->intrinsic) {
switch (intrin->intrinsic) {
case nir_intrinsic_demote_if:
case nir_intrinsic_discard_if:
case nir_intrinsic_terminate_if:
if (nir_src_is_const(instr->src[0])) {
if (nir_src_as_bool(instr->src[0])) {
b->cursor = nir_before_instr(&instr->instr);
if (nir_src_is_const(intrin->src[0])) {
if (nir_src_as_bool(intrin->src[0])) {
b->cursor = nir_before_instr(&intrin->instr);
nir_intrinsic_op op;
switch (instr->intrinsic) {
switch (intrin->intrinsic) {
case nir_intrinsic_discard_if:
op = nir_intrinsic_discard;
break;
@@ -208,20 +208,20 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *instr,
nir_intrinsic_instr_create(b->shader, op);
nir_builder_instr_insert(b, &new_instr->instr);
}
nir_instr_remove(&instr->instr);
nir_instr_remove(&intrin->instr);
return true;
}
return false;
case nir_intrinsic_load_deref: {
nir_deref_instr *deref = nir_src_as_deref(instr->src[0]);
nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
nir_const_value *v = const_value_for_deref(deref);
if (v) {
b->cursor = nir_before_instr(&instr->instr);
nir_ssa_def *val = nir_build_imm(b, instr->dest.ssa.num_components,
instr->dest.ssa.bit_size, v);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(val));
nir_instr_remove(&instr->instr);
b->cursor = nir_before_instr(&intrin->instr);
nir_ssa_def *val = nir_build_imm(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, v);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(val));
nir_instr_remove(&intrin->instr);
return true;
}
return false;
@@ -230,37 +230,37 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *instr,
case nir_intrinsic_load_constant: {
state->has_load_constant = true;
if (!nir_src_is_const(instr->src[0])) {
if (!nir_src_is_const(intrin->src[0])) {
state->has_indirect_load_const = true;
return false;
}
unsigned offset = nir_src_as_uint(instr->src[0]);
unsigned base = nir_intrinsic_base(instr);
unsigned range = nir_intrinsic_range(instr);
unsigned offset = nir_src_as_uint(intrin->src[0]);
unsigned base = nir_intrinsic_base(intrin);
unsigned range = nir_intrinsic_range(intrin);
assert(base + range <= b->shader->constant_data_size);
b->cursor = nir_before_instr(&instr->instr);
b->cursor = nir_before_instr(&intrin->instr);
nir_ssa_def *val;
if (offset >= range) {
val = nir_ssa_undef(b, instr->dest.ssa.num_components,
instr->dest.ssa.bit_size);
val = nir_ssa_undef(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size);
} else {
nir_const_value imm[NIR_MAX_VEC_COMPONENTS];
memset(imm, 0, sizeof(imm));
uint8_t *data = (uint8_t*)b->shader->constant_data + base;
for (unsigned i = 0; i < instr->num_components; i++) {
unsigned bytes = instr->dest.ssa.bit_size / 8;
for (unsigned i = 0; i < intrin->num_components; i++) {
unsigned bytes = intrin->dest.ssa.bit_size / 8;
bytes = MIN2(bytes, range - offset);
memcpy(&imm[i].u64, data + offset, bytes);
offset += bytes;
}
val = nir_build_imm(b, instr->dest.ssa.num_components,
instr->dest.ssa.bit_size, imm);
val = nir_build_imm(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, imm);
}
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(val));
nir_instr_remove(&instr->instr);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(val));
nir_instr_remove(&intrin->instr);
return true;
}