#include "nir.h"
#include "util/bitscan.h"
+#include "nir_range_analysis.h"
#include <math.h>
static inline bool
-is_pos_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
+is_pos_power_of_two(UNUSED struct hash_table *ht, nir_alu_instr *instr,
+ unsigned src, unsigned num_components,
const uint8_t *swizzle)
{
/* only constant srcs: */
return false;
for (unsigned i = 0; i < num_components; i++) {
- switch (nir_op_infos[instr->op].input_types[src]) {
+ nir_alu_type type = nir_op_infos[instr->op].input_types[src];
+ switch (nir_alu_type_get_base_type(type)) {
case nir_type_int: {
int64_t val = nir_src_comp_as_int(instr->src[src].src, swizzle[i]);
if (val <= 0 || !util_is_power_of_two_or_zero64(val))
}
static inline bool
-is_neg_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
+is_neg_power_of_two(UNUSED struct hash_table *ht, nir_alu_instr *instr,
+ unsigned src, unsigned num_components,
const uint8_t *swizzle)
{
/* only constant srcs: */
return false;
for (unsigned i = 0; i < num_components; i++) {
- switch (nir_op_infos[instr->op].input_types[src]) {
+ nir_alu_type type = nir_op_infos[instr->op].input_types[src];
+ switch (nir_alu_type_get_base_type(type)) {
case nir_type_int: {
int64_t val = nir_src_comp_as_int(instr->src[src].src, swizzle[i]);
if (val >= 0 || !util_is_power_of_two_or_zero64(-val))
return true;
}
+#define MULTIPLE(test) \
+static inline bool \
+is_unsigned_multiple_of_ ## test(UNUSED struct hash_table *ht, nir_alu_instr *instr, \
+ unsigned src, unsigned num_components, \
+ const uint8_t *swizzle) \
+{ \
+ /* only constant srcs: */ \
+ if (!nir_src_is_const(instr->src[src].src)) \
+ return false; \
+ \
+ for (unsigned i = 0; i < num_components; i++) { \
+ uint64_t val = nir_src_comp_as_uint(instr->src[src].src, swizzle[i]); \
+ if (val % test != 0) \
+ return false; \
+ } \
+ \
+ return true; \
+}
+
+MULTIPLE(2)
+MULTIPLE(4)
+MULTIPLE(8)
+MULTIPLE(16)
+MULTIPLE(32)
+MULTIPLE(64)
+
static inline bool
-is_zero_to_one(nir_alu_instr *instr, unsigned src, unsigned num_components,
+is_zero_to_one(UNUSED struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ unsigned num_components,
const uint8_t *swizzle)
{
/* only constant srcs: */
* 1 while this function tests 0 < src < 1.
*/
static inline bool
-is_gt_0_and_lt_1(nir_alu_instr *instr, unsigned src, unsigned num_components,
+is_gt_0_and_lt_1(UNUSED struct hash_table *ht, nir_alu_instr *instr,
+ unsigned src, unsigned num_components,
const uint8_t *swizzle)
{
/* only constant srcs: */
}
static inline bool
-is_not_const_zero(nir_alu_instr *instr, unsigned src, unsigned num_components,
+is_not_const_zero(UNUSED struct hash_table *ht, nir_alu_instr *instr,
+ unsigned src, unsigned num_components,
const uint8_t *swizzle)
{
if (nir_src_as_const_value(instr->src[src].src) == NULL)
return true;
for (unsigned i = 0; i < num_components; i++) {
- switch (nir_op_infos[instr->op].input_types[src]) {
+ nir_alu_type type = nir_op_infos[instr->op].input_types[src];
+ switch (nir_alu_type_get_base_type(type)) {
case nir_type_float:
if (nir_src_comp_as_float(instr->src[src].src, swizzle[i]) == 0.0)
return false;
}
static inline bool
-is_not_const(nir_alu_instr *instr, unsigned src, UNUSED unsigned num_components,
+is_not_const(UNUSED struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components,
UNUSED const uint8_t *swizzle)
{
return !nir_src_is_const(instr->src[src].src);
}
+static inline bool
+is_not_fmul(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ nir_alu_instr *src_alu =
+ nir_src_as_alu_instr(instr->src[src].src);
+
+ if (src_alu == NULL)
+ return true;
+
+ if (src_alu->op == nir_op_fneg)
+ return is_not_fmul(ht, src_alu, 0, 0, NULL);
+
+ return src_alu->op != nir_op_fmul;
+}
+
+static inline bool
+is_fsign(nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ nir_alu_instr *src_alu =
+ nir_src_as_alu_instr(instr->src[src].src);
+
+ if (src_alu == NULL)
+ return false;
+
+ if (src_alu->op == nir_op_fneg)
+ src_alu = nir_src_as_alu_instr(src_alu->src[0].src);
+
+ return src_alu != NULL && src_alu->op == nir_op_fsign;
+}
+
+static inline bool
+is_not_const_and_not_fsign(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ unsigned num_components, const uint8_t *swizzle)
+{
+ return is_not_const(ht, instr, src, num_components, swizzle) &&
+ !is_fsign(instr, src, num_components, swizzle);
+}
+
static inline bool
is_used_once(nir_alu_instr *instr)
{
- bool zero_if_use = list_empty(&instr->dest.dest.ssa.if_uses);
- bool zero_use = list_empty(&instr->dest.dest.ssa.uses);
+ bool zero_if_use = list_is_empty(&instr->dest.dest.ssa.if_uses);
+ bool zero_use = list_is_empty(&instr->dest.dest.ssa.uses);
if (zero_if_use && zero_use)
return false;
static inline bool
is_used_by_if(nir_alu_instr *instr)
{
- return !list_empty(&instr->dest.dest.ssa.if_uses);
+ return !list_is_empty(&instr->dest.dest.ssa.if_uses);
}
static inline bool
is_not_used_by_if(nir_alu_instr *instr)
{
- return list_empty(&instr->dest.dest.ssa.if_uses);
+ return list_is_empty(&instr->dest.dest.ssa.if_uses);
}
static inline bool
return false;
}
+/**
+ * Returns true if a NIR ALU src represents a constant integer
+ * of either 32 or 64 bits, and the higher word (bit-size / 2)
+ * of all its components is zero.
+ */
+static inline bool
+is_upper_half_zero(UNUSED struct hash_table *ht,
+ nir_alu_instr *instr, unsigned src,
+ unsigned num_components, const uint8_t *swizzle)
+{
+ if (nir_src_as_const_value(instr->src[src].src) == NULL)
+ return false;
+
+ for (unsigned i = 0; i < num_components; i++) {
+ unsigned half_bit_size = nir_src_bit_size(instr->src[src].src) / 2;
+ uint32_t high_bits = ((1 << half_bit_size) - 1) << half_bit_size;
+ if ((nir_src_comp_as_uint(instr->src[src].src,
+ swizzle[i]) & high_bits) != 0) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/**
+ * Returns true if a NIR ALU src represents a constant integer
+ * of either 32 or 64 bits, and the lower word (bit-size / 2)
+ * of all its components is zero.
+ */
+static inline bool
+is_lower_half_zero(UNUSED struct hash_table *ht,
+ nir_alu_instr *instr, unsigned src,
+ unsigned num_components, const uint8_t *swizzle)
+{
+ if (nir_src_as_const_value(instr->src[src].src) == NULL)
+ return false;
+
+ for (unsigned i = 0; i < num_components; i++) {
+ uint32_t low_bits =
+ (1 << (nir_src_bit_size(instr->src[src].src) / 2)) - 1;
+ if ((nir_src_comp_as_int(instr->src[src].src, swizzle[i]) & low_bits) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+static inline bool
+no_signed_wrap(nir_alu_instr *instr)
+{
+ return instr->no_signed_wrap;
+}
+
+static inline bool
+no_unsigned_wrap(nir_alu_instr *instr)
+{
+ return instr->no_unsigned_wrap;
+}
+
+static inline bool
+is_integral(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ const struct ssa_result_range r = nir_analyze_range(ht, instr, src);
+
+ return r.is_integral;
+}
+
+#define RELATION(r) \
+static inline bool \
+is_ ## r (struct hash_table *ht, nir_alu_instr *instr, unsigned src, \
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle) \
+{ \
+ const struct ssa_result_range v = nir_analyze_range(ht, instr, src); \
+ return v.range == r; \
+}
+
+RELATION(lt_zero)
+RELATION(le_zero)
+RELATION(gt_zero)
+RELATION(ge_zero)
+RELATION(ne_zero)
+
+static inline bool
+is_not_negative(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ const struct ssa_result_range v = nir_analyze_range(ht, instr, src);
+ return v.range == ge_zero || v.range == gt_zero || v.range == eq_zero;
+}
+
+static inline bool
+is_not_positive(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ const struct ssa_result_range v = nir_analyze_range(ht, instr, src);
+ return v.range == le_zero || v.range == lt_zero || v.range == eq_zero;
+}
+
+static inline bool
+is_not_zero(struct hash_table *ht, nir_alu_instr *instr, unsigned src,
+ UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
+{
+ const struct ssa_result_range v = nir_analyze_range(ht, instr, src);
+ return v.range == lt_zero || v.range == gt_zero || v.range == ne_zero;
+}
+
#endif /* _NIR_SEARCH_ */
projects / mesa.git / blobdiff