Mesa (master): nir/constant_folding: Use the standard variable naming convention
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Tue Nov 3 23:31:09 UTC 2020
Module: Mesa
Branch: master
Commit: 9492ab286402700175331feb4511e72c9f2c9b20
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=9492ab286402700175331feb4511e72c9f2c9b20
Author: Jason Ekstrand <jason at jlekstrand.net>
Date: Thu Oct 29 10:05:21 2020 -0500
nir/constant_folding: Use the standard variable naming convention
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 at intel.com>
Reviewed-by: Ian Romanick <ian.d.romanick at intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/7366>
---
src/compiler/nir/nir_opt_constant_folding.c | 94 ++++++++++++++---------------
1 file changed, 47 insertions(+), 47 deletions(-)
diff --git a/src/compiler/nir/nir_opt_constant_folding.c b/src/compiler/nir/nir_opt_constant_folding.c
index c9f7d078481..64a5f2583cf 100644
--- a/src/compiler/nir/nir_opt_constant_folding.c
+++ b/src/compiler/nir/nir_opt_constant_folding.c
@@ -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;
}
More information about the mesa-commit
mailing list