nir: Add a new memory_barrier_tcs_patch intrinsic

[mesa.git] / src / compiler / nir / nir_search_helpers.h

diff --git a/src/compiler/nir/nir_search_helpers.h b/src/compiler/nir/nir_search_helpers.h
index acd53a4960d12017522e5aaebfea349073b717fb..0c2f631ac39029026a45127801bd907af610cd8b 100644 (file)
--- a/src/compiler/nir/nir_search_helpers.h
+++ b/src/compiler/nir/nir_search_helpers.h
@@ -29,10 +29,12 @@
 
 #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: */
@@ -40,7 +42,8 @@ is_pos_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
       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))
@@ -62,7 +65,8 @@ is_pos_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
 }
 
 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: */
@@ -70,7 +74,8 @@ is_neg_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
       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))
@@ -86,7 +91,8 @@ is_neg_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components,
 }
 
 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: */
@@ -116,7 +122,8 @@ is_zero_to_one(nir_alu_instr *instr, unsigned src, unsigned num_components,
  * 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: */
@@ -140,14 +147,16 @@ is_gt_0_and_lt_1(nir_alu_instr *instr, unsigned src, unsigned num_components,
 }
 
 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;
@@ -167,14 +176,15 @@ is_not_const_zero(nir_alu_instr *instr, unsigned src, unsigned num_components,
 }
 
 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(nir_alu_instr *instr, unsigned src,
+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 =
@@ -184,16 +194,40 @@ is_not_fmul(nir_alu_instr *instr, unsigned src,
       return true;
 
    if (src_alu->op == nir_op_fneg)
-      return is_not_fmul(src_alu, 0, 0, NULL);
+      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;
@@ -214,13 +248,13 @@ is_used_once(nir_alu_instr *instr)
 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
@@ -248,7 +282,8 @@ is_used_by_non_fsat(nir_alu_instr *instr)
  * of all its components is zero.
  */
 static inline bool
-is_upper_half_zero(nir_alu_instr *instr, unsigned src,
+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)
@@ -272,7 +307,8 @@ is_upper_half_zero(nir_alu_instr *instr, unsigned src,
  * of all its components is zero.
  */
 static inline bool
-is_lower_half_zero(nir_alu_instr *instr, unsigned src,
+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)
@@ -288,4 +324,64 @@ is_lower_half_zero(nir_alu_instr *instr, unsigned src,
    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_ */