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

nir: Rework nir_src_as_alu_instr to not take a pointer

Browse Source 
Other nir_src_as_* functions just take a nir_src.  It's not that much
more memory copying and the constness preserving really isn't worth the
cognitive dissonance.

Reviewed-by: Eric Anholt <eric@anholt.net>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@intel.com>
This commit is contained in:
Jason Ekstrand
2019-04-17 17:10:18 -05:00
parent eee994e769
commit 85c35885b3
4 changed files with 18 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/compiler/nir/nir.h
View File

@@ -2756,16 +2756,10 @@ nir_src_instr(const struct nir_src *src)
#define NIR_SRC_AS_(name, c_type, type_enum, cast_macro) \ #define NIR_SRC_AS_(name, c_type, type_enum, cast_macro) \
static inline c_type * \ static inline c_type * \
nir_src_as_ ## name (nir_src *src) \ nir_src_as_ ## name (nir_src src) \
{ \ { \
return src->is_ssa && src->ssa->parent_instr->type == type_enum \ return src.is_ssa && src.ssa->parent_instr->type == type_enum \
? cast_macro(src->ssa->parent_instr) : NULL; \ ? cast_macro(src.ssa->parent_instr) : NULL; \
} \
static inline const c_type * \
nir_src_as_ ## name ## _const(const nir_src *src) \
{ \
return src->is_ssa && src->ssa->parent_instr->type == type_enum \
? cast_macro(src->ssa->parent_instr) : NULL; \
} }
NIR_SRC_AS_(alu_instr, nir_alu_instr, nir_instr_type_alu, nir_instr_as_alu) NIR_SRC_AS_(alu_instr, nir_alu_instr, nir_instr_type_alu, nir_instr_as_alu)

10
src/compiler/nir/nir_instr_set.c
View File

@@ -281,10 +281,10 @@ nir_srcs_equal(nir_src src1, nir_src src2)
* that instruction is returned as a \c nir_alu_instr. Otherwise \c NULL is * that instruction is returned as a \c nir_alu_instr. Otherwise \c NULL is
* returned. * returned.
*/ */
static const nir_alu_instr * static nir_alu_instr *
get_neg_instr(const nir_src *s) get_neg_instr(nir_src s)
{ {
const nir_alu_instr *const alu = nir_src_as_alu_instr_const(s); nir_alu_instr *alu = nir_src_as_alu_instr(s);
return alu != NULL && (alu->op == nir_op_fneg || alu->op == nir_op_ineg) return alu != NULL && (alu->op == nir_op_fneg || alu->op == nir_op_ineg)
? alu : NULL; ? alu : NULL;
@@ -440,7 +440,7 @@ nir_alu_srcs_negative_equal(const nir_alu_instr *alu1,
uint8_t alu1_swizzle[4] = {0}; uint8_t alu1_swizzle[4] = {0};
nir_src alu1_actual_src; nir_src alu1_actual_src;
const nir_alu_instr *const neg1 = get_neg_instr(&alu1->src[src1].src); nir_alu_instr *neg1 = get_neg_instr(alu1->src[src1].src);
if (neg1) { if (neg1) {
parity = !parity; parity = !parity;
@@ -457,7 +457,7 @@ nir_alu_srcs_negative_equal(const nir_alu_instr *alu1,
uint8_t alu2_swizzle[4] = {0}; uint8_t alu2_swizzle[4] = {0};
nir_src alu2_actual_src; nir_src alu2_actual_src;
const nir_alu_instr *const neg2 = get_neg_instr(&alu2->src[src2].src); nir_alu_instr *neg2 = get_neg_instr(alu2->src[src2].src);
if (neg2) { if (neg2) {
parity = !parity; parity = !parity;

12
src/compiler/nir/tests/vars_tests.cpp
View File

@@ -509,7 +509,7 @@ TEST_F(nir_copy_prop_vars_test, load_direct_array_deref_on_vector_reuses_previou
ASSERT_TRUE(store->src[1].is_ssa); ASSERT_TRUE(store->src[1].is_ssa);
/* NOTE: The ALU instruction is how we get the vec.y. */ /* NOTE: The ALU instruction is how we get the vec.y. */
ASSERT_TRUE(nir_src_as_alu_instr(&store->src[1])); ASSERT_TRUE(nir_src_as_alu_instr(store->src[1]));
} }
TEST_F(nir_copy_prop_vars_test, load_direct_array_deref_on_vector_reuses_previous_copy) TEST_F(nir_copy_prop_vars_test, load_direct_array_deref_on_vector_reuses_previous_copy)
@@ -567,7 +567,7 @@ TEST_F(nir_copy_prop_vars_test, load_direct_array_deref_on_vector_gets_reused)
nir_intrinsic_instr *store = get_intrinsic(nir_intrinsic_store_deref, 1); nir_intrinsic_instr *store = get_intrinsic(nir_intrinsic_store_deref, 1);
ASSERT_TRUE(store->src[1].is_ssa); ASSERT_TRUE(store->src[1].is_ssa);
ASSERT_TRUE(nir_src_as_alu_instr(&store->src[1])); ASSERT_TRUE(nir_src_as_alu_instr(store->src[1]));
} }
TEST_F(nir_copy_prop_vars_test, store_load_direct_array_deref_on_vector) TEST_F(nir_copy_prop_vars_test, store_load_direct_array_deref_on_vector)
@@ -612,7 +612,7 @@ TEST_F(nir_copy_prop_vars_test, store_load_direct_array_deref_on_vector)
/* Fourth store will compose first and second store values. */ /* Fourth store will compose first and second store values. */
nir_intrinsic_instr *fourth_store = get_intrinsic(nir_intrinsic_store_deref, 3); nir_intrinsic_instr *fourth_store = get_intrinsic(nir_intrinsic_store_deref, 3);
ASSERT_TRUE(fourth_store->src[1].is_ssa); ASSERT_TRUE(fourth_store->src[1].is_ssa);
EXPECT_TRUE(nir_src_as_alu_instr(&fourth_store->src[1])); EXPECT_TRUE(nir_src_as_alu_instr(fourth_store->src[1]));
} }
TEST_F(nir_copy_prop_vars_test, store_load_indirect_array_deref_on_vector) TEST_F(nir_copy_prop_vars_test, store_load_indirect_array_deref_on_vector)
@@ -990,7 +990,7 @@ TEST_F(nir_combine_stores_test, non_overlapping_stores)
ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf); ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf);
ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out); ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out);
nir_alu_instr *vec = nir_src_as_alu_instr(&combined->src[1]); nir_alu_instr *vec = nir_src_as_alu_instr(combined->src[1]);
ASSERT_TRUE(vec); ASSERT_TRUE(vec);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
nir_intrinsic_instr *load = nir_intrinsic_instr *load =
@@ -1030,7 +1030,7 @@ TEST_F(nir_combine_stores_test, overlapping_stores)
ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf); ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf);
ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out); ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out);
nir_alu_instr *vec = nir_src_as_alu_instr(&combined->src[1]); nir_alu_instr *vec = nir_src_as_alu_instr(combined->src[1]);
ASSERT_TRUE(vec); ASSERT_TRUE(vec);
/* Component x comes from v[0]. */ /* Component x comes from v[0]. */
@@ -1100,7 +1100,7 @@ TEST_F(nir_combine_stores_test, direct_array_derefs)
ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf); ASSERT_EQ(nir_intrinsic_write_mask(combined), 0xf);
ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out); ASSERT_EQ(nir_intrinsic_get_var(combined, 0), out);
nir_alu_instr *vec = nir_src_as_alu_instr(&combined->src[1]); nir_alu_instr *vec = nir_src_as_alu_instr(combined->src[1]);
ASSERT_TRUE(vec); ASSERT_TRUE(vec);
/* Component x comes from v[0]. */ /* Component x comes from v[0]. */

10
src/intel/compiler/brw_fs_nir.cpp
View File

@@ -387,7 +387,7 @@ fs_visitor::nir_emit_if(nir_if *if_stmt)
/* If the condition has the form !other_condition, use other_condition as /* If the condition has the form !other_condition, use other_condition as
* the source, but invert the predicate on the if instruction. * the source, but invert the predicate on the if instruction.
*/ */
nir_alu_instr *const cond = nir_src_as_alu_instr(&if_stmt->condition); nir_alu_instr *cond = nir_src_as_alu_instr(if_stmt->condition);
if (cond != NULL && cond->op == nir_op_inot) { if (cond != NULL && cond->op == nir_op_inot) {
assert(!cond->src[0].negate); assert(!cond->src[0].negate);
assert(!cond->src[0].abs); assert(!cond->src[0].abs);
@@ -754,8 +754,7 @@ fs_visitor::resolve_inot_sources(const fs_builder &bld, nir_alu_instr *instr,
fs_reg *op) fs_reg *op)
{ {
for (unsigned i = 0; i < 2; i++) { for (unsigned i = 0; i < 2; i++) {
nir_alu_instr *const inot_instr = nir_alu_instr *inot_instr = nir_src_as_alu_instr(instr->src[i].src);
nir_src_as_alu_instr(&instr->src[i].src);
if (inot_instr != NULL && inot_instr->op == nir_op_inot && if (inot_instr != NULL && inot_instr->op == nir_op_inot &&
!inot_instr->src[0].abs && !inot_instr->src[0].negate) { !inot_instr->src[0].abs && !inot_instr->src[0].negate) {
@@ -778,7 +777,7 @@ fs_visitor::try_emit_b2fi_of_inot(const fs_builder &bld,
if (devinfo->gen < 6 || devinfo->gen >= 12) if (devinfo->gen < 6 || devinfo->gen >= 12)
return false; return false;
nir_alu_instr *const inot_instr = nir_src_as_alu_instr(&instr->src[0].src); nir_alu_instr *inot_instr = nir_src_as_alu_instr(instr->src[0].src);
if (inot_instr == NULL || inot_instr->op != nir_op_inot) if (inot_instr == NULL || inot_instr->op != nir_op_inot)
return false; return false;
@@ -1242,8 +1241,7 @@ fs_visitor::nir_emit_alu(const fs_builder &bld, nir_alu_instr *instr)
case nir_op_inot: case nir_op_inot:
if (devinfo->gen >= 8) { if (devinfo->gen >= 8) {
nir_alu_instr *const inot_src_instr = nir_alu_instr *inot_src_instr = nir_src_as_alu_instr(instr->src[0].src);
nir_src_as_alu_instr(&instr->src[0].src);
if (inot_src_instr != NULL && if (inot_src_instr != NULL &&
(inot_src_instr->op == nir_op_ior || (inot_src_instr->op == nir_op_ior ||