diff --git a/src/compiler/nir/nir_search.c b/src/compiler/nir/nir_search.c
index b0504a8e9cf..dec70dd18a7 100644
--- a/src/compiler/nir/nir_search.c
+++ b/src/compiler/nir/nir_search.c
@@ -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);
    }
 
diff --git a/src/compiler/nir/nir_search.h b/src/compiler/nir/nir_search.h
index 0a6160b4c83..83cc9166c59 100644
--- a/src/compiler/nir/nir_search.h
+++ b/src/compiler/nir/nir_search.h
@@ -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);
diff --git a/src/compiler/nir/nir_search_helpers.h b/src/compiler/nir/nir_search_helpers.h
index bf83badfcaa..f3d957e918f 100644
--- a/src/compiler/nir/nir_search_helpers.h
+++ b/src/compiler/nir/nir_search_helpers.h
@@ -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;
 }
 
diff --git a/src/compiler/nir/nir_worklist.h b/src/compiler/nir/nir_worklist.h
index 982f8b47ba0..63a3e224a9b 100644
--- a/src/compiler/nir/nir_worklist.h
+++ b/src/compiler/nir/nir_worklist.h
@@ -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;
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c
index 88fb2fd889d..f06e94086e9 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c
@@ -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;
diff --git a/src/gallium/drivers/r300/compiler/r300_nir.h b/src/gallium/drivers/r300/compiler/r300_nir.h
index cd971ac796e..dfc7032c816 100644
--- a/src/gallium/drivers/r300/compiler/r300_nir.h
+++ b/src/gallium/drivers/r300/compiler/r300_nir.h
@@ -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