nir/search: add nir_search_state

A future commit will add another hash table. Signed-off-by: Rhys Perry <pendingchaos02@gmail.com> Reviewed-by: Georg Lehmann <dadschoorse@gmail.com> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36760>
2025-08-15 10:59:12 +01:00
parent 219c53e6fc
commit 2a12624532
6 changed files with 83 additions and 72 deletions
@@ -42,7 +42,7 @@ struct match_state {
   const nir_algebraic_table *table;

   nir_alu_src variables[NIR_SEARCH_MAX_VARIABLES];
-   struct hash_table *range_ht;
+   const nir_search_state *state;
 };

 static bool
@@ -278,7 +278,7 @@ match_value(const nir_algebraic_table *table,
          instr->src[src].src.ssa->parent_instr->type != nir_instr_type_load_const)
         return false;

-      if (var->cond_index != -1 && !table->variable_cond[var->cond_index](state->range_ht, instr,
+      if (var->cond_index != -1 && !table->variable_cond[var->cond_index](state->state, instr,
                                                                          src, num_components, new_swizzle))
         return false;

@@ -678,7 +678,7 @@ nir_algebraic_update_automaton(nir_instr *new_instr,

 static nir_def *
 nir_replace_instr(nir_builder *build, nir_alu_instr *instr,
-                  struct hash_table *range_ht,
+                  const nir_search_state *search_state,
                  struct util_dynarray *states,
                  const nir_algebraic_table *table,
                  const nir_search_expression *search,
@@ -694,7 +694,7 @@ nir_replace_instr(nir_builder *build, nir_alu_instr *instr,
   struct match_state state;
   state.inexact_match = false;
   state.has_exact_alu = false;
-   state.range_ht = range_ht;
+   state.state = search_state;
   state.pass_op_table = table->pass_op_table;
   state.table = table;

@@ -854,7 +854,7 @@ nir_algebraic_automaton(nir_instr *instr, struct util_dynarray *states,

 static bool
 nir_algebraic_instr(nir_builder *build, nir_instr *instr,
-                    struct hash_table *range_ht,
+                    const nir_search_state *state,
                    const bool *condition_flags,
                    const nir_algebraic_table *table,
                    struct util_dynarray *states,
@@ -881,10 +881,10 @@ nir_algebraic_instr(nir_builder *build, nir_instr *instr,
        xform++) {
      if (condition_flags[xform->condition_offset] &&
          !(table->values[xform->search].expression.inexact && ignore_inexact) &&
-          nir_replace_instr(build, alu, range_ht, states, table,
+          nir_replace_instr(build, alu, state, states, table,
                            &table->values[xform->search].expression,
                            &table->values[xform->replace].value, worklist, dead_instrs)) {
-         _mesa_hash_table_clear(range_ht, NULL);
+         _mesa_hash_table_clear(state->range_ht, NULL);
         return true;
      }
   }
@@ -914,6 +914,9 @@ nir_algebraic_impl(nir_function_impl *impl,
   struct hash_table range_ht;
   _mesa_pointer_hash_table_init(&range_ht, NULL);

+   nir_search_state state;
+   state.range_ht = &range_ht;
+
   nir_instr_worklist worklist;
   nir_instr_worklist_init(&worklist);

@@ -949,7 +952,7 @@ nir_algebraic_impl(nir_function_impl *impl,
         continue;

      progress |= nir_algebraic_instr(&build, instr,
-                                      &range_ht, condition_flags,
+                                      &state, condition_flags,
                                      table, &states, &worklist, &dead_instrs);
   }

@@ -201,8 +201,12 @@ typedef union {
   nir_search_expression expression;
 } nir_search_value_union;

+typedef struct {
+   struct hash_table *range_ht;
+} nir_search_state;
+
 typedef bool (*nir_search_expression_cond)(const nir_alu_instr *instr);
-typedef bool (*nir_search_variable_cond)(struct hash_table *range_ht,
+typedef bool (*nir_search_variable_cond)(const nir_search_state *state,
                                         const nir_alu_instr *instr,
                                         unsigned src, unsigned num_components,
                                         const uint8_t *swizzle);
@@ -32,9 +32,10 @@
 #include "util/u_math.h"
 #include "nir.h"
 #include "nir_range_analysis.h"
+#include "nir_search.h"

 static inline bool
-is_pos_power_of_two(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_pos_power_of_two(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                    unsigned src, unsigned num_components,
                    const uint8_t *swizzle)
 {
@@ -66,7 +67,7 @@ is_pos_power_of_two(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_neg_power_of_two(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_neg_power_of_two(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                    unsigned src, unsigned num_components,
                    const uint8_t *swizzle)
 {
@@ -95,7 +96,7 @@ is_neg_power_of_two(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_bitcount2(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_bitcount2(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
             unsigned src, unsigned num_components,
             const uint8_t *swizzle)
 {
@@ -113,7 +114,7 @@ is_bitcount2(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_nan(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_nan(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
       unsigned src, unsigned num_components, const uint8_t *swizzle)
 {
   /* only constant srcs: */
@@ -129,7 +130,7 @@ is_nan(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_negative_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_negative_zero(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
       unsigned src, unsigned num_components, const uint8_t *swizzle)
 {
   /* only constant srcs: */
@@ -147,7 +148,7 @@ is_negative_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_any_comp_nan(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_any_comp_nan(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                unsigned src, unsigned num_components, const uint8_t *swizzle)
 {
   /* only constant srcs: */
@@ -164,7 +165,7 @@ is_any_comp_nan(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 #define MULTIPLE(test)                                                         \
   static inline bool                                                          \
-      is_unsigned_multiple_of_##test(UNUSED struct hash_table *ht,             \
+      is_unsigned_multiple_of_##test(UNUSED const nir_search_state *state,     \
                                     const nir_alu_instr *instr,               \
                                     unsigned src, unsigned num_components,    \
                                     const uint8_t *swizzle)                   \
@@ -190,7 +191,7 @@ MULTIPLE(32)
 MULTIPLE(64)

 static inline bool
-is_zero_to_one(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_zero_to_one(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
               unsigned src, unsigned num_components,
               const uint8_t *swizzle)
 {
@@ -222,7 +223,7 @@ is_zero_to_one(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * 1 while this function tests 0 < src < 1.
 */
 static inline bool
-is_gt_0_and_lt_1(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_gt_0_and_lt_1(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                 unsigned src, unsigned num_components,
                 const uint8_t *swizzle)
 {
@@ -251,7 +252,7 @@ is_gt_0_and_lt_1(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * x & 1 != 0
 */
 static inline bool
-is_odd(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_odd(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
       unsigned src, unsigned num_components,
       const uint8_t *swizzle)
 {
@@ -277,7 +278,7 @@ is_odd(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_not_const_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_not_const_zero(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                  unsigned src, unsigned num_components,
                  const uint8_t *swizzle)
 {
@@ -327,7 +328,7 @@ is_ult(const nir_alu_instr *instr, unsigned src, unsigned num_components, const

 /** Is value unsigned less than 32? */
 static inline bool
-is_ult_32(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_ult_32(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
          unsigned src, unsigned num_components,
          const uint8_t *swizzle)
 {
@@ -336,7 +337,7 @@ is_ult_32(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 /** Is value unsigned less than 0xfffc07fc? */
 static inline bool
-is_ult_0xfffc07fc(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_ult_0xfffc07fc(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                  unsigned src, unsigned num_components,
                  const uint8_t *swizzle)
 {
@@ -345,7 +346,7 @@ is_ult_0xfffc07fc(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 /** Is the first 5 bits of value unsigned greater than or equal 2? */
 static inline bool
-is_first_5_bits_uge_2(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_first_5_bits_uge_2(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                      unsigned src, unsigned num_components,
                      const uint8_t *swizzle)
 {
@@ -408,7 +409,7 @@ is_16_bits_with_scale(const nir_alu_instr *instr,

 /** Is this a constant that could be either int16_t or uint16_t? */
 static inline bool
-is_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_16_bits(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
           unsigned src, unsigned num_components,
           const uint8_t *swizzle)
 {
@@ -417,7 +418,7 @@ is_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 /** Like is_16_bits, but could 2 times the constant fit in 16 bits? */
 static inline bool
-is_2x_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_2x_16_bits(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
              unsigned src, unsigned num_components,
              const uint8_t *swizzle)
 {
@@ -426,7 +427,7 @@ is_2x_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 /** Like is_16_bits, but could -2 times the constant fit in 16 bits? */
 static inline bool
-is_neg2x_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_neg2x_16_bits(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                 unsigned src, unsigned num_components,
                 const uint8_t *swizzle)
 {
@@ -434,7 +435,7 @@ is_neg2x_16_bits(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_not_const(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_not_const(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
             unsigned src, UNUSED unsigned num_components,
             UNUSED const uint8_t *swizzle)
 {
@@ -442,7 +443,7 @@ is_not_const(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_not_fmul(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_not_fmul(const nir_search_state *state, const nir_alu_instr *instr, unsigned src,
            UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
 {
   nir_alu_instr *src_alu =
@@ -452,13 +453,13 @@ is_not_fmul(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
      return true;

   if (src_alu->op == nir_op_fneg)
-      return is_not_fmul(ht, src_alu, 0, 0, NULL);
+      return is_not_fmul(state, src_alu, 0, 0, NULL);

   return src_alu->op != nir_op_fmul && src_alu->op != nir_op_fmulz;
 }

 static inline bool
-is_fmul(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_fmul(const nir_search_state *state, const nir_alu_instr *instr, unsigned src,
        UNUSED unsigned num_components, UNUSED const uint8_t *swizzle)
 {
   nir_alu_instr *src_alu =
@@ -468,7 +469,7 @@ is_fmul(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
      return false;

   if (src_alu->op == nir_op_fneg)
-      return is_fmul(ht, src_alu, 0, 0, NULL);
+      return is_fmul(state, src_alu, 0, 0, NULL);

   return src_alu->op == nir_op_fmul || src_alu->op == nir_op_fmulz;
 }
@@ -490,16 +491,16 @@ is_fsign(const nir_alu_instr *instr, unsigned src,
 }

 static inline bool
-is_not_const_and_not_fsign(struct hash_table *ht, const nir_alu_instr *instr,
+is_not_const_and_not_fsign(const nir_search_state *state, const nir_alu_instr *instr,
                           unsigned src, unsigned num_components,
                           const uint8_t *swizzle)
 {
-   return is_not_const(ht, instr, src, num_components, swizzle) &&
+   return is_not_const(state, instr, src, num_components, swizzle) &&
          !is_fsign(instr, src, num_components, swizzle);
 }

 static inline bool
-has_multiple_uses(struct hash_table *ht, const nir_alu_instr *instr,
+has_multiple_uses(const nir_search_state *state, const nir_alu_instr *instr,
                  unsigned src, unsigned num_components,
                  const uint8_t *swizzle)
 {
@@ -713,7 +714,7 @@ only_lower_16_bits_used(const nir_alu_instr *instr)
 * of all its components is zero.
 */
 static inline bool
-is_upper_half_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_upper_half_zero(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                   unsigned src, unsigned num_components,
                   const uint8_t *swizzle)
 {
@@ -739,7 +740,7 @@ is_upper_half_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * of all its components is zero.
 */
 static inline bool
-is_lower_half_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_lower_half_zero(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                   unsigned src, unsigned num_components,
                   const uint8_t *swizzle)
 {
@@ -756,7 +757,7 @@ is_lower_half_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 }

 static inline bool
-is_upper_half_negative_one(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_upper_half_negative_one(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                           unsigned src, unsigned num_components,
                           const uint8_t *swizzle)
 {
@@ -777,7 +778,7 @@ is_upper_half_negative_one(UNUSED struct hash_table *ht, const nir_alu_instr *in
 }

 static inline bool
-is_lower_half_negative_one(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_lower_half_negative_one(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                           unsigned src, unsigned num_components,
                           const uint8_t *swizzle)
 {
@@ -800,7 +801,7 @@ is_lower_half_negative_one(UNUSED struct hash_table *ht, const nir_alu_instr *in
 * for the optimizations where this function is used.
 */
 static inline bool
-is_const_bitmask(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_const_bitmask(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                 unsigned src, unsigned num_components,
                 const uint8_t *swizzle)
 {
@@ -823,7 +824,7 @@ is_const_bitmask(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * that can be created by nir_op_bfm.
 */
 static inline bool
-is_const_bfm(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_const_bfm(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                 unsigned src, unsigned num_components,
                 const uint8_t *swizzle)
 {
@@ -846,7 +847,7 @@ is_const_bfm(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * Returns whether the 5 LSBs of an operand are non-zero.
 */
 static inline bool
-is_5lsb_not_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_5lsb_not_zero(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                 unsigned src, unsigned num_components,
                 const uint8_t *swizzle)
 {
@@ -866,7 +867,7 @@ is_5lsb_not_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
 * Returns whether at least one bit is 0.
 */
 static inline bool
-is_not_uint_max(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_not_uint_max(UNUSED const nir_search_state *state, const nir_alu_instr *instr,
                unsigned src, unsigned num_components,
                const uint8_t *swizzle)
 {
@@ -901,10 +902,10 @@ xz_components_unused(const nir_alu_instr *instr)
 }

 static inline bool
-is_integral(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_integral(const nir_search_state *state, const 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);
+   const struct ssa_result_range r = nir_analyze_range(state->range_ht, instr, src);

   return r.is_integral;
 }
@@ -913,21 +914,21 @@ is_integral(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
 * Is the value finite?
 */
 static inline bool
-is_finite(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_finite(UNUSED const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);

   return v.is_finite;
 }

 static inline bool
-is_finite_not_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,
+is_finite_not_zero(UNUSED const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);

   return v.is_finite &&
          (v.range == lt_zero || v.range == gt_zero || v.range == ne_zero);
@@ -935,20 +936,20 @@ is_finite_not_zero(UNUSED struct hash_table *ht, const nir_alu_instr *instr,

 #define RELATION(r)                                                        \
   static inline bool                                                      \
-      is_##r(struct hash_table *ht, const nir_alu_instr *instr,            \
+      is_##r(const nir_search_state *state, const 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); \
+      const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src); \
      return v.range == r;                                                 \
   }                                                                       \
                                                                           \
   static inline bool                                                      \
-      is_a_number_##r(struct hash_table *ht, const nir_alu_instr *instr,   \
+      is_a_number_##r(const nir_search_state *state, const 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); \
+      const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src); \
      return v.is_a_number && v.range == r;                                \
   }

@@ -959,64 +960,64 @@ RELATION(ge_zero)
 RELATION(ne_zero)

 static inline bool
-is_not_negative(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_not_negative(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.range == ge_zero || v.range == gt_zero || v.range == eq_zero;
 }

 static inline bool
-is_a_number_not_negative(struct hash_table *ht, const nir_alu_instr *instr,
+is_a_number_not_negative(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.is_a_number &&
          (v.range == ge_zero || v.range == gt_zero || v.range == eq_zero);
 }

 static inline bool
-is_not_positive(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_not_positive(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.range == le_zero || v.range == lt_zero || v.range == eq_zero;
 }

 static inline bool
-is_a_number_not_positive(struct hash_table *ht, const nir_alu_instr *instr,
+is_a_number_not_positive(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.is_a_number &&
          (v.range == le_zero || v.range == lt_zero || v.range == eq_zero);
 }

 static inline bool
-is_not_zero(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_not_zero(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.range == lt_zero || v.range == gt_zero || v.range == ne_zero;
 }

 static inline bool
-is_a_number_not_zero(struct hash_table *ht, const nir_alu_instr *instr,
+is_a_number_not_zero(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.is_a_number &&
          (v.range == lt_zero || v.range == gt_zero || v.range == ne_zero);
 }

 static inline bool
-is_a_number(struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_a_number(const nir_search_state *state, const 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);
+   const struct ssa_result_range v = nir_analyze_range(state->range_ht, instr, src);
   return v.is_a_number;
 }

@@ -108,14 +108,14 @@ nir_instr_worklist_fini(nir_instr_worklist *wl)
 static inline void
 nir_instr_worklist_push_tail(nir_instr_worklist *wl, nir_instr *instr)
 {
-   struct nir_instr **vec_instr = u_vector_add(&wl->instr_vec);
+   nir_instr **vec_instr = (nir_instr **)u_vector_add(&wl->instr_vec);
   *vec_instr = instr;
 }

 static inline nir_instr *
 nir_instr_worklist_pop_head(nir_instr_worklist *wl)
 {
-   struct nir_instr **vec_instr = u_vector_remove(&wl->instr_vec);
+   nir_instr **vec_instr = (nir_instr **)u_vector_remove(&wl->instr_vec);

   if (vec_instr == NULL)
      return NULL;
@@ -3332,11 +3332,13 @@ do_alu_action(struct lp_build_nir_soa_context *bld,
      /* If one of the sources is known to be a number (i.e., not NaN), then
       * better code can be generated by passing that information along.
       */
-      if (is_a_number(bld->range_ht, instr, 1,
+      nir_search_state search;
+      search.range_ht = bld->range_ht;
+      if (is_a_number(&search, instr, 1,
                      0 /* unused num_components */,
                      NULL /* unused swizzle */)) {
         minmax_nan = GALLIVM_NAN_RETURN_OTHER_SECOND_NONNAN;
-      } else if (is_a_number(bld->range_ht, instr, 0,
+      } else if (is_a_number(&search, instr, 0,
                             0 /* unused num_components */,
                             NULL /* unused swizzle */)) {
         first = 1;
@@ -9,11 +9,12 @@
 #include <math.h>

 #include "compiler/nir/nir.h"
+#include "compiler/nir/nir_search.h"
 #include "pipe/p_screen.h"
 #include "r300_screen.h"

 static inline bool
-is_ubo_or_input(UNUSED struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+is_ubo_or_input(UNUSED const nir_search_state *state, const nir_alu_instr *instr, unsigned src,
                unsigned num_components, const uint8_t *swizzle)
 {
   nir_instr *parent = instr->src[src].src.ssa->parent_instr;
@@ -107,7 +108,7 @@ check_instr_and_src_value(nir_op op, nir_instr **instr, double value)
 }

 static inline bool
-needs_vs_trig_input_fixup(UNUSED struct hash_table *ht, const nir_alu_instr *instr, unsigned src,
+needs_vs_trig_input_fixup(UNUSED const nir_search_state *state, const nir_alu_instr *instr, unsigned src,
                          unsigned num_components, const uint8_t *swizzle)
 {
   /* We are checking for fadd(fmul(ffract(a), 2*pi), -pi) pattern