const struct glsl_type *elem_type =
wrap_type_in_array(type, glsl_get_array_element(array_type));
- return glsl_array_type(elem_type, glsl_get_length(array_type));
+ assert(glsl_get_explicit_stride(array_type) == 0);
+ return glsl_array_type(elem_type, glsl_get_length(array_type), 0);
}
static int
};
const struct glsl_type *struct_type = glsl_without_array(type);
- if (glsl_type_is_struct(struct_type)) {
+ if (glsl_type_is_struct_or_ifc(struct_type)) {
field->num_fields = glsl_get_length(struct_type),
field->fields = ralloc_array(state->mem_ctx, struct field,
field->num_fields);
var_type = wrap_type_in_array(var_type, f->type);
nir_variable_mode mode = state->base_var->data.mode;
- if (mode == nir_var_local) {
+ if (mode == nir_var_function_temp) {
field->var = nir_local_variable_create(state->impl, var_type, name);
} else {
field->var = nir_variable_create(state->shader, mode, var_type, name);
* pull all of the variables we plan to split off of the list
*/
nir_foreach_variable_safe(var, vars) {
- if (!glsl_type_is_struct(glsl_without_array(var->type)))
+ if (!glsl_type_is_struct_or_ifc(glsl_without_array(var->type)))
continue;
exec_node_remove(&var->node);
continue;
assert(i > 0);
- assert(glsl_type_is_struct(path.path[i - 1]->type));
+ assert(glsl_type_is_struct_or_ifc(path.path[i - 1]->type));
assert(path.path[i - 1]->type ==
glsl_without_array(tail_field->type));
{
void *mem_ctx = ralloc_context(NULL);
struct hash_table *var_field_map =
- _mesa_hash_table_create(mem_ctx, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ _mesa_pointer_hash_table_create(mem_ctx);
- assert((modes & (nir_var_global | nir_var_local)) == modes);
+ assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
bool has_global_splits = false;
- if (modes & nir_var_global) {
+ if (modes & nir_var_shader_temp) {
has_global_splits = split_var_list_structs(shader, NULL,
&shader->globals,
var_field_map, mem_ctx);
continue;
bool has_local_splits = false;
- if (modes & nir_var_local) {
+ if (modes & nir_var_function_temp) {
has_local_splits = split_var_list_structs(shader, function->impl,
&function->impl->locals,
var_field_map, mem_ctx);
name = ralloc_asprintf(mem_ctx, "(%s)", name);
nir_variable_mode mode = var_info->base_var->data.mode;
- if (mode == nir_var_local) {
+ if (mode == nir_var_function_temp) {
split->var = nir_local_variable_create(impl,
var_info->split_var_type, name);
} else {
glsl_get_components(split_type),
info->levels[i].array_len);
} else {
- split_type = glsl_array_type(split_type, info->levels[i].array_len);
+ split_type = glsl_array_type(split_type, info->levels[i].array_len, 0);
}
}
exec_node_remove(&var->node);
exec_list_push_tail(&split_vars, &var->node);
} else {
- assert(split_type == var->type);
+ assert(split_type == glsl_get_bare_type(var->type));
/* If we're not modifying this variable, delete the info so we skip
* it faster in later passes.
*/
glsl_get_length(src_path->path[src_level]->type));
unsigned len = glsl_get_length(dst_path->path[dst_level]->type);
for (unsigned i = 0; i < len; i++) {
- nir_ssa_def *idx = nir_imm_int(b, i);
emit_split_copies(b, dst_info, dst_path, dst_level + 1,
- nir_build_deref_array(b, dst, idx),
+ nir_build_deref_array_imm(b, dst, i),
src_info, src_path, src_level + 1,
- nir_build_deref_array(b, src, idx));
+ nir_build_deref_array_imm(b, src, i));
}
} else {
/* Neither side is being split so we just keep going */
nir_split_array_vars(nir_shader *shader, nir_variable_mode modes)
{
void *mem_ctx = ralloc_context(NULL);
- struct hash_table *var_info_map =
- _mesa_hash_table_create(mem_ctx, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ struct hash_table *var_info_map = _mesa_pointer_hash_table_create(mem_ctx);
- assert((modes & (nir_var_global | nir_var_local)) == modes);
+ assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
bool has_global_array = false;
- if (modes & nir_var_global) {
+ if (modes & nir_var_shader_temp) {
has_global_array = init_var_list_array_infos(&shader->globals,
var_info_map, mem_ctx);
}
continue;
bool has_local_array = false;
- if (modes & nir_var_local) {
+ if (modes & nir_var_function_temp) {
has_local_array = init_var_list_array_infos(&function->impl->locals,
var_info_map, mem_ctx);
}
}
bool has_global_splits = false;
- if (modes & nir_var_global) {
+ if (modes & nir_var_shader_temp) {
has_global_splits = split_var_list_arrays(shader, NULL,
&shader->globals,
var_info_map, mem_ctx);
continue;
bool has_local_splits = false;
- if (modes & nir_var_local) {
+ if (modes & nir_var_function_temp) {
has_local_splits = split_var_list_arrays(shader, function->impl,
&function->impl->locals,
var_info_map, mem_ctx);
true, mem_ctx);
if (copy_usage) {
if (usage->vars_copied == NULL) {
- usage->vars_copied = _mesa_set_create(mem_ctx, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ usage->vars_copied = _mesa_pointer_set_create(mem_ctx);
}
_mesa_set_add(usage->vars_copied, copy_usage);
} else {
©_usage->levels[copy_i++];
if (level->levels_copied == NULL) {
- level->levels_copied =
- _mesa_set_create(mem_ctx, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ level->levels_copied = _mesa_pointer_set_create(mem_ctx);
}
_mesa_set_add(level->levels_copied, copy_level);
} else {
static bool
src_is_load_deref(nir_src src, nir_src deref_src)
{
- assert(src.is_ssa);
- assert(deref_src.is_ssa);
-
- if (src.ssa->parent_instr->type != nir_instr_type_intrinsic)
- return false;
-
- nir_intrinsic_instr *load = nir_instr_as_intrinsic(src.ssa->parent_instr);
- if (load->intrinsic != nir_intrinsic_load_deref)
+ nir_intrinsic_instr *load = nir_src_as_intrinsic(src);
+ if (load == NULL || load->intrinsic != nir_intrinsic_load_deref)
return false;
assert(load->src[0].is_ssa);
nir_alu_instr *src_alu = nir_instr_as_alu(src_instr);
- if (src_alu->op == nir_op_imov ||
- src_alu->op == nir_op_fmov) {
+ if (src_alu->op == nir_op_mov) {
/* If it's just a swizzle of a load from the same deref, discount any
* channels that don't move in the swizzle.
*/
if (!var_usage || !var_usage->vars_copied)
continue;
- struct set_entry *copy_entry;
set_foreach(var_usage->vars_copied, copy_entry) {
struct vec_var_usage *copy_usage = (void *)copy_entry->key;
if (copy_usage->comps_kept != var_usage->comps_kept) {
new_num_comps,
usage->levels[i].array_len);
} else {
- new_type = glsl_array_type(new_type, usage->levels[i].array_len);
+ new_type = glsl_array_type(new_type, usage->levels[i].array_len, 0);
}
}
var->type = new_type;
continue;
}
+ /* If we're not dropping any components, there's no need to
+ * compact vectors.
+ */
+ if (usage->comps_kept == usage->all_comps)
+ continue;
+
if (intrin->intrinsic == nir_intrinsic_load_deref) {
b.cursor = nir_after_instr(&intrin->instr);
b.cursor = nir_before_instr(&intrin->instr);
nir_ssa_def *swizzled =
- nir_swizzle(&b, intrin->src[1].ssa, swizzle, c, false);
+ nir_swizzle(&b, intrin->src[1].ssa, swizzle, c);
/* Rewrite to use the compacted source */
nir_instr_rewrite_src(&intrin->instr, &intrin->src[1],
{
nir_shader *shader = impl->function->shader;
- if ((modes & nir_var_global) && !exec_list_is_empty(&shader->globals))
+ if ((modes & nir_var_shader_temp) && !exec_list_is_empty(&shader->globals))
return true;
- if ((modes & nir_var_local) && !exec_list_is_empty(&impl->locals))
+ if ((modes & nir_var_function_temp) && !exec_list_is_empty(&impl->locals))
return true;
return false;
bool
nir_shrink_vec_array_vars(nir_shader *shader, nir_variable_mode modes)
{
- assert((modes & (nir_var_global | nir_var_local)) == modes);
+ assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
void *mem_ctx = ralloc_context(NULL);
struct hash_table *var_usage_map =
- _mesa_hash_table_create(mem_ctx, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ _mesa_pointer_hash_table_create(mem_ctx);
bool has_vars_to_shrink = false;
nir_foreach_function(function, shader) {
}
bool globals_shrunk = false;
- if (modes & nir_var_global)
+ if (modes & nir_var_shader_temp)
globals_shrunk = shrink_vec_var_list(&shader->globals, var_usage_map);
bool progress = false;
continue;
bool locals_shrunk = false;
- if (modes & nir_var_local) {
+ if (modes & nir_var_function_temp) {
locals_shrunk = shrink_vec_var_list(&function->impl->locals,
var_usage_map);
}
projects / mesa.git / blobdiff