nir/range_analysis: Make sure the table validation only occurs once

[mesa.git] / src / compiler / nir / nir_range_analysis.c

diff --git a/src/compiler/nir/nir_range_analysis.c b/src/compiler/nir/nir_range_analysis.c
index 0eaa97aafc27ad4766e68ef79dab6a676a448376..df5d4dab9af756463a26c585374493b081d99c70 100644 (file)
--- a/src/compiler/nir/nir_range_analysis.c
+++ b/src/compiler/nir/nir_range_analysis.c
@@ -221,19 +221,27 @@ analyze_constant(const struct nir_alu_instr *instr, unsigned src,
 #ifndef NDEBUG
 #define ASSERT_TABLE_IS_COMMUTATIVE(t)                        \
    do {                                                       \
-      _Pragma("GCC unroll 7")                                 \
-      for (unsigned r = 0; r < ARRAY_SIZE(t); r++) {          \
+      static bool first = true;                               \
+      if (first) {                                            \
+         first = false;                                       \
          _Pragma("GCC unroll 7")                              \
-         for (unsigned c = 0; c < ARRAY_SIZE(t[0]); c++)      \
-            assert(t[r][c] == t[c][r]);                       \
+         for (unsigned r = 0; r < ARRAY_SIZE(t); r++) {       \
+            _Pragma("GCC unroll 7")                           \
+            for (unsigned c = 0; c < ARRAY_SIZE(t[0]); c++)   \
+               assert(t[r][c] == t[c][r]);                    \
+         }                                                    \
       }                                                       \
    } while (false)
 
 #define ASSERT_TABLE_IS_DIAGONAL(t)                           \
    do {                                                       \
-      _Pragma("GCC unroll 7")                                 \
-      for (unsigned r = 0; r < ARRAY_SIZE(t); r++)            \
-         assert(t[r][r] == r);                                \
+      static bool first = true;                               \
+      if (first) {                                            \
+         first = false;                                       \
+         _Pragma("GCC unroll 7")                              \
+         for (unsigned r = 0; r < ARRAY_SIZE(t); r++)         \
+            assert(t[r][r] == r);                             \
+      }                                                       \
    } while (false)
 
 static enum ssa_ranges
@@ -261,19 +269,23 @@ union_ranges(enum ssa_ranges a, enum ssa_ranges b)
  */
 #define ASSERT_UNION_OF_OTHERS_MATCHES_UNKNOWN_2_SOURCE(t)              \
    do {                                                                 \
-      _Pragma("GCC unroll 7")                                           \
-      for (unsigned i = 0; i < last_range; i++) {                       \
-         enum ssa_ranges col_range = t[i][unknown + 1];                 \
-         enum ssa_ranges row_range = t[unknown + 1][i];                 \
+      static bool first = true;                                         \
+      if (first) {                                                      \
+         first = false;                                                 \
+         _Pragma("GCC unroll 7")                                        \
+         for (unsigned i = 0; i < last_range; i++) {                    \
+            enum ssa_ranges col_range = t[i][unknown + 1];              \
+            enum ssa_ranges row_range = t[unknown + 1][i];              \
                                                                         \
-         _Pragma("GCC unroll 5")                                        \
-         for (unsigned j = unknown + 2; j < last_range; j++) {          \
-            col_range = union_ranges(col_range, t[i][j]);               \
-            row_range = union_ranges(row_range, t[j][i]);               \
-         }                                                              \
+            _Pragma("GCC unroll 5")                                     \
+            for (unsigned j = unknown + 2; j < last_range; j++) {       \
+               col_range = union_ranges(col_range, t[i][j]);            \
+               row_range = union_ranges(row_range, t[j][i]);            \
+            }                                                           \
                                                                         \
-         assert(col_range == t[i][unknown]);                            \
-         assert(row_range == t[unknown][i]);                            \
+            assert(col_range == t[i][unknown]);                         \
+            assert(row_range == t[unknown][i]);                         \
+         }                                                              \
       }                                                                 \
    } while (false)
 
@@ -291,12 +303,16 @@ union_ranges(enum ssa_ranges a, enum ssa_ranges b)
 
 #define ASSERT_UNION_OF_EQ_AND_STRICT_INEQ_MATCHES_NONSTRICT_2_SOURCE(t) \
    do {                                                                 \
-      _Pragma("GCC unroll 7")                                           \
-      for (unsigned i = 0; i < last_range; i++) {                       \
-         assert(union_ranges(t[i][lt_zero], t[i][eq_zero]) == t[i][le_zero]); \
-         assert(union_ranges(t[i][gt_zero], t[i][eq_zero]) == t[i][ge_zero]); \
-         assert(union_ranges(t[lt_zero][i], t[eq_zero][i]) == t[le_zero][i]); \
-         assert(union_ranges(t[gt_zero][i], t[eq_zero][i]) == t[ge_zero][i]); \
+      static bool first = true;                                         \
+      if (first) {                                                      \
+         first = false;                                                 \
+         _Pragma("GCC unroll 7")                                        \
+         for (unsigned i = 0; i < last_range; i++) {                    \
+            assert(union_ranges(t[i][lt_zero], t[i][eq_zero]) == t[i][le_zero]); \
+            assert(union_ranges(t[i][gt_zero], t[i][eq_zero]) == t[i][ge_zero]); \
+            assert(union_ranges(t[lt_zero][i], t[eq_zero][i]) == t[le_zero][i]); \
+            assert(union_ranges(t[gt_zero][i], t[eq_zero][i]) == t[ge_zero][i]); \
+         }                                                              \
       }                                                                 \
    } while (false)
 
@@ -322,21 +338,25 @@ union_ranges(enum ssa_ranges a, enum ssa_ranges b)
 
 #define ASSERT_UNION_OF_DISJOINT_MATCHES_UNKNOWN_2_SOURCE(t)            \
    do {                                                                 \
-      _Pragma("GCC unroll 7")                                           \
-      for (unsigned i = 0; i < last_range; i++) {                       \
-         assert(union_ranges(t[i][lt_zero], t[i][ge_zero]) ==           \
-                t[i][unknown]);                                         \
-         assert(union_ranges(t[i][le_zero], t[i][gt_zero]) ==           \
-                t[i][unknown]);                                         \
-         assert(union_ranges(t[i][eq_zero], t[i][ne_zero]) ==           \
-                t[i][unknown]);                                         \
+      static bool first = true;                                         \
+      if (first) {                                                      \
+         first = false;                                                 \
+         _Pragma("GCC unroll 7")                                        \
+         for (unsigned i = 0; i < last_range; i++) {                    \
+            assert(union_ranges(t[i][lt_zero], t[i][ge_zero]) ==        \
+                   t[i][unknown]);                                      \
+            assert(union_ranges(t[i][le_zero], t[i][gt_zero]) ==        \
+                   t[i][unknown]);                                      \
+            assert(union_ranges(t[i][eq_zero], t[i][ne_zero]) ==        \
+                   t[i][unknown]);                                      \
                                                                         \
-         assert(union_ranges(t[lt_zero][i], t[ge_zero][i]) ==           \
-                t[unknown][i]);                                         \
-         assert(union_ranges(t[le_zero][i], t[gt_zero][i]) ==           \
-                t[unknown][i]);                                         \
-         assert(union_ranges(t[eq_zero][i], t[ne_zero][i]) ==           \
-                t[unknown][i]);                                         \
+            assert(union_ranges(t[lt_zero][i], t[ge_zero][i]) ==        \
+                   t[unknown][i]);                                      \
+            assert(union_ranges(t[le_zero][i], t[gt_zero][i]) ==        \
+                   t[unknown][i]);                                      \
+            assert(union_ranges(t[eq_zero][i], t[ne_zero][i]) ==        \
+                   t[unknown][i]);                                      \
+         }                                                              \
       }                                                                 \
    } while (false)