#include "nir_vla.h"
#include "util/half_float.h"
-#define HASH(hash, data) _mesa_fnv32_1a_accumulate((hash), (data))
+static bool
+src_is_ssa(nir_src *src, void *data)
+{
+ (void) data;
+ return src->is_ssa;
+}
+
+static bool
+dest_is_ssa(nir_dest *dest, void *data)
+{
+ (void) data;
+ return dest->is_ssa;
+}
+
+ASSERTED static inline bool
+instr_each_src_and_dest_is_ssa(const nir_instr *instr)
+{
+ if (!nir_foreach_dest((nir_instr *)instr, dest_is_ssa, NULL) ||
+ !nir_foreach_src((nir_instr *)instr, src_is_ssa, NULL))
+ return false;
+
+ return true;
+}
+
+/* This function determines if uses of an instruction can safely be rewritten
+ * to use another identical instruction instead. Note that this function must
+ * be kept in sync with hash_instr() and nir_instrs_equal() -- only
+ * instructions that pass this test will be handed on to those functions, and
+ * conversely they must handle everything that this function returns true for.
+ */
+static bool
+instr_can_rewrite(const nir_instr *instr)
+{
+ /* We only handle SSA. */
+ assert(instr_each_src_and_dest_is_ssa(instr));
+
+ switch (instr->type) {
+ case nir_instr_type_alu:
+ case nir_instr_type_deref:
+ case nir_instr_type_tex:
+ case nir_instr_type_load_const:
+ case nir_instr_type_phi:
+ return true;
+ case nir_instr_type_intrinsic:
+ return nir_intrinsic_can_reorder(nir_instr_as_intrinsic(instr));
+ case nir_instr_type_call:
+ case nir_instr_type_jump:
+ case nir_instr_type_ssa_undef:
+ return false;
+ case nir_instr_type_parallel_copy:
+ default:
+ unreachable("Invalid instruction type");
+ }
+
+ return false;
+}
+
+
+#define HASH(hash, data) XXH32(&(data), sizeof(data), hash)
static uint32_t
hash_src(uint32_t hash, const nir_src *src)
case nir_deref_type_cast:
hash = HASH(hash, instr->cast.ptr_stride);
+ hash = HASH(hash, instr->cast.align_mul);
+ hash = HASH(hash, instr->cast.align_offset);
break;
case nir_deref_type_var:
}
} else {
unsigned size = instr->def.num_components * sizeof(*instr->value);
- hash = _mesa_fnv32_1a_accumulate_block(hash, instr->value, size);
+ hash = XXH32(instr->value, size, hash);
}
return hash;
hash = HASH(hash, instr->dest.ssa.bit_size);
}
- hash = _mesa_fnv32_1a_accumulate_block(hash, instr->const_index,
- info->num_indices
- * sizeof(instr->const_index[0]));
+ hash = XXH32(instr->const_index, info->num_indices * sizeof(instr->const_index[0]), hash);
return hash;
}
for (unsigned j = 0; j < 2; ++j)
hash = HASH(hash, instr->tg4_offsets[i][j]);
hash = HASH(hash, instr->texture_index);
- hash = HASH(hash, instr->texture_array_size);
hash = HASH(hash, instr->sampler_index);
+ hash = HASH(hash, instr->texture_non_uniform);
+ hash = HASH(hash, instr->sampler_non_uniform);
return hash;
}
hash_instr(const void *data)
{
const nir_instr *instr = data;
- uint32_t hash = _mesa_fnv32_1a_offset_bias;
+ uint32_t hash = 0;
switch (instr->type) {
case nir_instr_type_alu:
* the same hash for (ignoring collisions, of course).
*/
-static bool
+bool
nir_instrs_equal(const nir_instr *instr1, const nir_instr *instr2)
{
+ assert(instr_can_rewrite(instr1) && instr_can_rewrite(instr2));
+
if (instr1->type != instr2->type)
return false;
break;
case nir_deref_type_cast:
- if (deref1->cast.ptr_stride != deref2->cast.ptr_stride)
+ if (deref1->cast.ptr_stride != deref2->cast.ptr_stride ||
+ deref1->cast.align_mul != deref2->cast.align_mul ||
+ deref1->cast.align_offset != deref2->cast.align_offset)
return false;
break;
tex1->is_new_style_shadow != tex2->is_new_style_shadow ||
tex1->component != tex2->component ||
tex1->texture_index != tex2->texture_index ||
- tex1->texture_array_size != tex2->texture_array_size ||
tex1->sampler_index != tex2->sampler_index) {
return false;
}
unreachable("All cases in the above switch should return");
}
-static bool
-src_is_ssa(nir_src *src, void *data)
-{
- (void) data;
- return src->is_ssa;
-}
-
-static bool
-dest_is_ssa(nir_dest *dest, void *data)
-{
- (void) data;
- return dest->is_ssa;
-}
-
-static inline bool
-instr_each_src_and_dest_is_ssa(nir_instr *instr)
-{
- if (!nir_foreach_dest(instr, dest_is_ssa, NULL) ||
- !nir_foreach_src(instr, src_is_ssa, NULL))
- return false;
-
- return true;
-}
-
-/* This function determines if uses of an instruction can safely be rewritten
- * to use another identical instruction instead. Note that this function must
- * be kept in sync with hash_instr() and nir_instrs_equal() -- only
- * instructions that pass this test will be handed on to those functions, and
- * conversely they must handle everything that this function returns true for.
- */
-
-static bool
-instr_can_rewrite(nir_instr *instr)
-{
- /* We only handle SSA. */
- assert(instr_each_src_and_dest_is_ssa(instr));
-
- switch (instr->type) {
- case nir_instr_type_alu:
- case nir_instr_type_deref:
- case nir_instr_type_tex:
- case nir_instr_type_load_const:
- case nir_instr_type_phi:
- return true;
- case nir_instr_type_intrinsic:
- return nir_intrinsic_can_reorder(nir_instr_as_intrinsic(instr));
- case nir_instr_type_call:
- case nir_instr_type_jump:
- case nir_instr_type_ssa_undef:
- return false;
- case nir_instr_type_parallel_copy:
- default:
- unreachable("Invalid instruction type");
- }
-
- return false;
-}
-
static nir_ssa_def *
nir_instr_get_dest_ssa_def(nir_instr *instr)
{