summaryrefslogtreecommitdiffstats
path: root/src/compiler/nir
diff options
context:
space:
mode:
Diffstat (limited to 'src/compiler/nir')
-rw-r--r--src/compiler/nir/nir.h3
-rw-r--r--src/compiler/nir/nir_instr_set.c124
-rw-r--r--src/compiler/nir/tests/negative_equal_tests.cpp259
3 files changed, 169 insertions, 217 deletions
diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
index 92dad1c4bb3..90e35ee9205 100644
--- a/src/compiler/nir/nir.h
+++ b/src/compiler/nir/nir.h
@@ -1032,8 +1032,7 @@ nir_ssa_alu_instr_src_components(const nir_alu_instr *instr, unsigned src)
bool nir_const_value_negative_equal(const nir_const_value *c1,
const nir_const_value *c2,
unsigned components,
- nir_alu_type base_type,
- unsigned bits);
+ nir_alu_type full_type);
bool nir_alu_srcs_equal(const nir_alu_instr *alu1, const nir_alu_instr *alu2,
unsigned src1, unsigned src2);
diff --git a/src/compiler/nir/nir_instr_set.c b/src/compiler/nir/nir_instr_set.c
index a19e8467b0a..5893dc5cfe1 100644
--- a/src/compiler/nir/nir_instr_set.c
+++ b/src/compiler/nir/nir_instr_set.c
@@ -305,95 +305,73 @@ bool
nir_const_value_negative_equal(const nir_const_value *c1,
const nir_const_value *c2,
unsigned components,
- nir_alu_type base_type,
- unsigned bits)
+ nir_alu_type full_type)
{
- assert(base_type == nir_alu_type_get_base_type(base_type));
- assert(base_type != nir_type_invalid);
-
- /* This can occur for 1-bit Boolean values. */
- if (bits == 1)
- return false;
-
- switch (base_type) {
- case nir_type_float:
- switch (bits) {
- case 16:
- for (unsigned i = 0; i < components; i++) {
- if (_mesa_half_to_float(c1[i].u16) !=
- -_mesa_half_to_float(c2[i].u16)) {
- return false;
- }
- }
-
- return true;
-
- case 32:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].f32 != -c2[i].f32)
- return false;
- }
-
- return true;
-
- case 64:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].f64 != -c2[i].f64)
- return false;
+ assert(nir_alu_type_get_base_type(full_type) != nir_type_invalid);
+ assert(nir_alu_type_get_type_size(full_type) != 0);
+
+ switch (full_type) {
+ case nir_type_float16:
+ for (unsigned i = 0; i < components; i++) {
+ if (_mesa_half_to_float(c1[i].u16) !=
+ -_mesa_half_to_float(c2[i].u16)) {
+ return false;
}
+ }
- return true;
+ return true;
- default:
- unreachable("unknown bit size");
+ case nir_type_float32:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].f32 != -c2[i].f32)
+ return false;
}
- break;
+ return true;
- case nir_type_int:
- case nir_type_uint:
- switch (bits) {
- case 8:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].i8 != -c2[i].i8)
- return false;
- }
+ case nir_type_float64:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].f64 != -c2[i].f64)
+ return false;
+ }
- return true;
+ return true;
- case 16:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].i16 != -c2[i].i16)
- return false;
- }
+ case nir_type_int8:
+ case nir_type_uint8:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].i8 != -c2[i].i8)
+ return false;
+ }
- return true;
- break;
+ return true;
- case 32:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].i32 != -c2[i].i32)
- return false;
- }
+ case nir_type_int16:
+ case nir_type_uint16:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].i16 != -c2[i].i16)
+ return false;
+ }
- return true;
+ return true;
- case 64:
- for (unsigned i = 0; i < components; i++) {
- if (c1[i].i64 != -c2[i].i64)
- return false;
- }
+ case nir_type_int32:
+ case nir_type_uint32:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].i32 != -c2[i].i32)
+ return false;
+ }
- return true;
+ return true;
- default:
- unreachable("unknown bit size");
+ case nir_type_int64:
+ case nir_type_uint64:
+ for (unsigned i = 0; i < components; i++) {
+ if (c1[i].i64 != -c2[i].i64)
+ return false;
}
- break;
-
- case nir_type_bool:
- return false;
+ return true;
default:
break;
@@ -449,7 +427,7 @@ nir_alu_srcs_negative_equal(const nir_alu_instr *alu1,
return nir_const_value_negative_equal(const1,
const2,
nir_ssa_alu_instr_src_components(alu1, src1),
- nir_op_infos[alu1->op].input_types[src1],
+ nir_op_infos[alu1->op].input_types[src1] |
nir_src_bit_size(alu1->src[src1].src));
}
diff --git a/src/compiler/nir/tests/negative_equal_tests.cpp b/src/compiler/nir/tests/negative_equal_tests.cpp
index 2d3aa6a6b85..86305ceb0ba 100644
--- a/src/compiler/nir/tests/negative_equal_tests.cpp
+++ b/src/compiler/nir/tests/negative_equal_tests.cpp
@@ -26,10 +26,10 @@
#include "util/half_float.h"
static void count_sequence(nir_const_value c[NIR_MAX_VEC_COMPONENTS],
- nir_alu_type base_type, unsigned bits, int first);
+ nir_alu_type full_type, int first);
static void negate(nir_const_value dst[NIR_MAX_VEC_COMPONENTS],
const nir_const_value src[NIR_MAX_VEC_COMPONENTS],
- nir_alu_type base_type, unsigned bits, unsigned components);
+ nir_alu_type full_type, unsigned components);
class const_value_negative_equal_test : public ::testing::Test {
protected:
@@ -68,89 +68,89 @@ TEST_F(const_value_negative_equal_test, float32_zero)
{
/* Verify that 0.0 negative-equals 0.0. */
EXPECT_TRUE(nir_const_value_negative_equal(c1, c1, NIR_MAX_VEC_COMPONENTS,
- nir_type_float, 32));
+ nir_type_float32));
}
TEST_F(const_value_negative_equal_test, float64_zero)
{
/* Verify that 0.0 negative-equals 0.0. */
EXPECT_TRUE(nir_const_value_negative_equal(c1, c1, NIR_MAX_VEC_COMPONENTS,
- nir_type_float, 64));
+ nir_type_float64));
}
/* Compare an object with non-zero values to itself. This should always be
* false.
*/
-#define compare_with_self(base_type, bits) \
-TEST_F(const_value_negative_equal_test, base_type ## bits ## _self) \
+#define compare_with_self(full_type) \
+TEST_F(const_value_negative_equal_test, full_type ## _self) \
{ \
- count_sequence(c1, base_type, bits, 1); \
+ count_sequence(c1, full_type, 1); \
EXPECT_FALSE(nir_const_value_negative_equal(c1, c1, \
NIR_MAX_VEC_COMPONENTS, \
- base_type, bits)); \
+ full_type)); \
}
-compare_with_self(nir_type_float, 16)
-compare_with_self(nir_type_float, 32)
-compare_with_self(nir_type_float, 64)
-compare_with_self(nir_type_int, 8)
-compare_with_self(nir_type_uint, 8)
-compare_with_self(nir_type_int, 16)
-compare_with_self(nir_type_uint, 16)
-compare_with_self(nir_type_int, 32)
-compare_with_self(nir_type_uint, 32)
-compare_with_self(nir_type_int, 64)
-compare_with_self(nir_type_uint, 64)
+compare_with_self(nir_type_float16)
+compare_with_self(nir_type_float32)
+compare_with_self(nir_type_float64)
+compare_with_self(nir_type_int8)
+compare_with_self(nir_type_uint8)
+compare_with_self(nir_type_int16)
+compare_with_self(nir_type_uint16)
+compare_with_self(nir_type_int32)
+compare_with_self(nir_type_uint32)
+compare_with_self(nir_type_int64)
+compare_with_self(nir_type_uint64)
/* Compare an object with the negation of itself. This should always be true.
*/
-#define compare_with_negation(base_type, bits) \
-TEST_F(const_value_negative_equal_test, base_type ## bits ## _trivially_true) \
+#define compare_with_negation(full_type) \
+TEST_F(const_value_negative_equal_test, full_type ## _trivially_true) \
{ \
- count_sequence(c1, base_type, bits, 1); \
- negate(c2, c1, base_type, bits, NIR_MAX_VEC_COMPONENTS); \
+ count_sequence(c1, full_type, 1); \
+ negate(c2, c1, full_type, NIR_MAX_VEC_COMPONENTS); \
EXPECT_TRUE(nir_const_value_negative_equal(c1, c2, \
NIR_MAX_VEC_COMPONENTS, \
- base_type, bits)); \
+ full_type)); \
}
-compare_with_negation(nir_type_float, 16)
-compare_with_negation(nir_type_float, 32)
-compare_with_negation(nir_type_float, 64)
-compare_with_negation(nir_type_int, 8)
-compare_with_negation(nir_type_uint, 8)
-compare_with_negation(nir_type_int, 16)
-compare_with_negation(nir_type_uint, 16)
-compare_with_negation(nir_type_int, 32)
-compare_with_negation(nir_type_uint, 32)
-compare_with_negation(nir_type_int, 64)
-compare_with_negation(nir_type_uint, 64)
+compare_with_negation(nir_type_float16)
+compare_with_negation(nir_type_float32)
+compare_with_negation(nir_type_float64)
+compare_with_negation(nir_type_int8)
+compare_with_negation(nir_type_uint8)
+compare_with_negation(nir_type_int16)
+compare_with_negation(nir_type_uint16)
+compare_with_negation(nir_type_int32)
+compare_with_negation(nir_type_uint32)
+compare_with_negation(nir_type_int64)
+compare_with_negation(nir_type_uint64)
/* Compare fewer than the maximum possible components. All of the components
* that are compared a negative-equal, but the extra components are not.
*/
-#define compare_fewer_components(base_type, bits) \
-TEST_F(const_value_negative_equal_test, base_type ## bits ## _fewer_components) \
+#define compare_fewer_components(full_type) \
+TEST_F(const_value_negative_equal_test, full_type ## _fewer_components) \
{ \
- count_sequence(c1, base_type, bits, 1); \
- negate(c2, c1, base_type, bits, 3); \
- EXPECT_TRUE(nir_const_value_negative_equal(c1, c2, 3, base_type, bits)); \
+ count_sequence(c1, full_type, 1); \
+ negate(c2, c1, full_type, 3); \
+ EXPECT_TRUE(nir_const_value_negative_equal(c1, c2, 3, full_type)); \
EXPECT_FALSE(nir_const_value_negative_equal(c1, c2, \
NIR_MAX_VEC_COMPONENTS, \
- base_type, bits)); \
+ full_type)); \
}
-compare_fewer_components(nir_type_float, 16)
-compare_fewer_components(nir_type_float, 32)
-compare_fewer_components(nir_type_float, 64)
-compare_fewer_components(nir_type_int, 8)
-compare_fewer_components(nir_type_uint, 8)
-compare_fewer_components(nir_type_int, 16)
-compare_fewer_components(nir_type_uint, 16)
-compare_fewer_components(nir_type_int, 32)
-compare_fewer_components(nir_type_uint, 32)
-compare_fewer_components(nir_type_int, 64)
-compare_fewer_components(nir_type_uint, 64)
+compare_fewer_components(nir_type_float16)
+compare_fewer_components(nir_type_float32)
+compare_fewer_components(nir_type_float64)
+compare_fewer_components(nir_type_int8)
+compare_fewer_components(nir_type_uint8)
+compare_fewer_components(nir_type_int16)
+compare_fewer_components(nir_type_uint16)
+compare_fewer_components(nir_type_int32)
+compare_fewer_components(nir_type_uint32)
+compare_fewer_components(nir_type_int64)
+compare_fewer_components(nir_type_uint64)
TEST_F(alu_srcs_negative_equal_test, trivial_float)
{
@@ -221,65 +221,53 @@ TEST_F(alu_srcs_negative_equal_test, trivial_negation_int)
}
static void
-count_sequence(nir_const_value c[NIR_MAX_VEC_COMPONENTS], nir_alu_type base_type, unsigned bits, int first)
+count_sequence(nir_const_value c[NIR_MAX_VEC_COMPONENTS],
+ nir_alu_type full_type, int first)
{
- switch (base_type) {
- case nir_type_float:
- switch (bits) {
- case 16:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].u16 = _mesa_float_to_half(float(i + first));
+ switch (full_type) {
+ case nir_type_float16:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].u16 = _mesa_float_to_half(float(i + first));
- break;
-
- case 32:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].f32 = float(i + first);
-
- break;
-
- case 64:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].f64 = double(i + first);
-
- break;
+ break;
- default:
- unreachable("unknown bit size");
- }
+ case nir_type_float32:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].f32 = float(i + first);
break;
- case nir_type_int:
- case nir_type_uint:
- switch (bits) {
- case 8:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].i8 = i + first;
+ case nir_type_float64:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].f64 = double(i + first);
- break;
+ break;
- case 16:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].i16 = i + first;
+ case nir_type_int8:
+ case nir_type_uint8:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].i8 = i + first;
- break;
+ break;
- case 32:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].i32 = i + first;
+ case nir_type_int16:
+ case nir_type_uint16:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].i16 = i + first;
- break;
+ break;
- case 64:
- for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
- c[i].i64 = i + first;
+ case nir_type_int32:
+ case nir_type_uint32:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].i32 = i + first;
- break;
+ break;
- default:
- unreachable("unknown bit size");
- }
+ case nir_type_int64:
+ case nir_type_uint64:
+ for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
+ c[i].i64 = i + first;
break;
@@ -292,65 +280,52 @@ count_sequence(nir_const_value c[NIR_MAX_VEC_COMPONENTS], nir_alu_type base_type
static void
negate(nir_const_value dst[NIR_MAX_VEC_COMPONENTS],
const nir_const_value src[NIR_MAX_VEC_COMPONENTS],
- nir_alu_type base_type, unsigned bits, unsigned components)
+ nir_alu_type full_type, unsigned components)
{
- switch (base_type) {
- case nir_type_float:
- switch (bits) {
- case 16:
- for (unsigned i = 0; i < components; i++)
- dst[i].u16 = _mesa_float_to_half(-_mesa_half_to_float(src[i].u16));
+ switch (full_type) {
+ case nir_type_float16:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].u16 = _mesa_float_to_half(-_mesa_half_to_float(src[i].u16));
- break;
-
- case 32:
- for (unsigned i = 0; i < components; i++)
- dst[i].f32 = -src[i].f32;
-
- break;
-
- case 64:
- for (unsigned i = 0; i < components; i++)
- dst[i].f64 = -src[i].f64;
-
- break;
+ break;
- default:
- unreachable("unknown bit size");
- }
+ case nir_type_float32:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].f32 = -src[i].f32;
break;
- case nir_type_int:
- case nir_type_uint:
- switch (bits) {
- case 8:
- for (unsigned i = 0; i < components; i++)
- dst[i].i8 = -src[i].i8;
+ case nir_type_float64:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].f64 = -src[i].f64;
- break;
+ break;
- case 16:
- for (unsigned i = 0; i < components; i++)
- dst[i].i16 = -src[i].i16;
+ case nir_type_int8:
+ case nir_type_uint8:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].i8 = -src[i].i8;
- break;
+ break;
- case 32:
- for (unsigned i = 0; i < components; i++)
- dst[i].i32 = -src[i].i32;
+ case nir_type_int16:
+ case nir_type_uint16:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].i16 = -src[i].i16;
- break;
+ break;
- case 64:
- for (unsigned i = 0; i < components; i++)
- dst[i].i64 = -src[i].i64;
+ case nir_type_int32:
+ case nir_type_uint32:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].i32 = -src[i].i32;
- break;
+ break;
- default:
- unreachable("unknown bit size");
- }
+ case nir_type_int64:
+ case nir_type_uint64:
+ for (unsigned i = 0; i < components; i++)
+ dst[i].i64 = -src[i].i64;
break;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-27 02:39:02 +0000