return build_addr_for_var(b, deref->var, addr_format);
case nir_deref_type_array: {
- nir_deref_instr *parent = nir_deref_instr_parent(deref);
-
- unsigned stride = glsl_get_explicit_stride(parent->type);
- if ((glsl_type_is_matrix(parent->type) &&
- glsl_matrix_type_is_row_major(parent->type)) ||
- (glsl_type_is_vector(parent->type) && stride == 0))
- stride = type_scalar_size_bytes(parent->type);
-
+ unsigned stride = nir_deref_instr_array_stride(deref);
assert(stride > 0);
nir_ssa_def *index = nir_ssa_for_src(b, deref->arr.index, 1);
case nir_deref_type_ptr_as_array: {
nir_ssa_def *index = nir_ssa_for_src(b, deref->arr.index, 1);
index = nir_i2i(b, index, addr_get_offset_bit_size(base_addr, addr_format));
- unsigned stride = nir_deref_instr_ptr_as_array_stride(deref);
+ unsigned stride = nir_deref_instr_array_stride(deref);
return build_addr_iadd(b, base_addr, addr_format,
nir_amul_imm(b, index, stride));
}
nir_instr_remove(&intrin->instr);
}
+bool
+nir_get_explicit_deref_align(nir_deref_instr *deref,
+ bool default_to_type_align,
+ uint32_t *align_mul,
+ uint32_t *align_offset)
+{
+ if (deref->deref_type == nir_deref_type_var) {
+ /* If we see a variable, align_mul is effectively infinite because we
+ * know the offset exactly (up to the offset of the base pointer for the
+ * given variable mode). We have to pick something so we choose 256B
+ * as an arbitrary alignment which seems high enough for any reasonable
+ * wide-load use-case. Back-ends should clamp alignments down if 256B
+ * is too large for some reason.
+ */
+ *align_mul = 256;
+ *align_offset = deref->var->data.driver_location % 256;
+ return true;
+ }
+
+ /* If we're a cast deref that has an alignment, use that. */
+ if (deref->deref_type == nir_deref_type_cast && deref->cast.align_mul > 0) {
+ *align_mul = deref->cast.align_mul;
+ *align_offset = deref->cast.align_offset;
+ return true;
+ }
+
+ /* Otherwise, we need to compute the alignment based on the parent */
+ nir_deref_instr *parent = nir_deref_instr_parent(deref);
+ if (parent == NULL) {
+ assert(deref->deref_type == nir_deref_type_cast);
+ if (default_to_type_align) {
+ /* If we don't have a parent, assume the type's alignment, if any. */
+ unsigned type_align = glsl_get_explicit_alignment(deref->type);
+ if (type_align == 0)
+ return false;
+
+ *align_mul = type_align;
+ *align_offset = 0;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ uint32_t parent_mul, parent_offset;
+ if (!nir_get_explicit_deref_align(parent, default_to_type_align,
+ &parent_mul, &parent_offset))
+ return false;
+
+ switch (deref->deref_type) {
+ case nir_deref_type_var:
+ unreachable("Handled above");
+
+ case nir_deref_type_array:
+ case nir_deref_type_array_wildcard:
+ case nir_deref_type_ptr_as_array: {
+ const unsigned stride = nir_deref_instr_array_stride(deref);
+ if (stride == 0)
+ return false;
+
+ if (deref->deref_type != nir_deref_type_array_wildcard &&
+ nir_src_is_const(deref->arr.index)) {
+ unsigned offset = nir_src_as_uint(deref->arr.index) * stride;
+ *align_mul = parent_mul;
+ *align_offset = (parent_offset + offset) % parent_mul;
+ } else {
+ /* If this is a wildcard or an indirect deref, we have to go with the
+ * power-of-two gcd.
+ */
+ *align_mul = MIN3(parent_mul,
+ 1 << (ffs(parent_offset) - 1),
+ 1 << (ffs(stride) - 1));
+ *align_offset = 0;
+ }
+ return true;
+ }
+
+ case nir_deref_type_struct: {
+ const int offset = glsl_get_struct_field_offset(parent->type,
+ deref->strct.index);
+ if (offset < 0)
+ return false;
+
+ *align_mul = parent_mul;
+ *align_offset = (parent_offset + offset) % parent_mul;
+ return true;
+ }
+
+ case nir_deref_type_cast:
+ /* We handled the explicit alignment case above. */
+ assert(deref->cast.align_mul == 0);
+ *align_mul = parent_mul;
+ *align_offset = parent_offset;
+ return true;
+ }
+
+ unreachable("Invalid deref_instr_type");
+}
+
static void
lower_explicit_io_deref(nir_builder *b, nir_deref_instr *deref,
nir_address_format addr_format)
nir_ssa_def *addr = nir_explicit_io_address_from_deref(b, deref, base_addr,
addr_format);
+ assert(addr->bit_size == deref->dest.ssa.bit_size);
+ assert(addr->num_components == deref->dest.ssa.num_components);
nir_instr_remove(&deref->instr);
nir_ssa_def_rewrite_uses(&deref->dest.ssa, nir_src_for_ssa(addr));
nir_lower_mem_constant_vars(nir_shader *shader,
glsl_type_size_align_func type_info)
{
- unsigned old_constant_data_size = shader->constant_data_size;
- if (!lower_vars_to_explicit(shader, &shader->variables,
- nir_var_mem_constant, type_info)) {
- nir_shader_preserve_all_metadata(shader);
- return false;
- }
-
- shader->constant_data = rerzalloc_size(shader, shader->constant_data,
- old_constant_data_size,
- shader->constant_data_size);
+ bool progress = false;
- nir_foreach_variable_with_modes(var, shader, nir_var_mem_constant) {
- write_constant((char *)shader->constant_data + var->data.driver_location,
- var->constant_initializer, var->type);
+ unsigned old_constant_data_size = shader->constant_data_size;
+ if (lower_vars_to_explicit(shader, &shader->variables,
+ nir_var_mem_constant, type_info)) {
+ assert(shader->constant_data_size > old_constant_data_size);
+ shader->constant_data = rerzalloc_size(shader, shader->constant_data,
+ old_constant_data_size,
+ shader->constant_data_size);
+
+ nir_foreach_variable_with_modes(var, shader, nir_var_mem_constant) {
+ write_constant((char *)shader->constant_data +
+ var->data.driver_location,
+ var->constant_initializer, var->type);
+ }
+ progress = true;
}
nir_foreach_function(function, shader) {
if (!function->impl)
continue;
- nir_lower_vars_to_explicit_types_impl(function->impl,
- nir_var_mem_constant,
- type_info);
+ if (nir_lower_vars_to_explicit_types_impl(function->impl,
+ nir_var_mem_constant,
+ type_info))
+ progress = true;
}
- return true;
+ return progress;
}
/**
nir_src_num_components(intrin->src[0]) >= 3;
}
- return nir_dest_bit_size(intrin->dest) &&
+ return nir_dest_bit_size(intrin->dest) == 64 &&
nir_dest_num_components(intrin->dest) >= 3;
}
projects / mesa.git / blobdiff