{
nir_shader *shader = rzalloc(mem_ctx, nir_shader);
- exec_list_make_empty(&shader->uniforms);
- exec_list_make_empty(&shader->inputs);
- exec_list_make_empty(&shader->outputs);
- exec_list_make_empty(&shader->shared);
+ exec_list_make_empty(&shader->variables);
shader->options = options;
}
exec_list_make_empty(&shader->functions);
- exec_list_make_empty(&shader->globals);
- exec_list_make_empty(&shader->system_values);
shader->num_inputs = 0;
shader->num_outputs = 0;
nir_shader_add_variable(nir_shader *shader, nir_variable *var)
{
switch (var->data.mode) {
- case nir_var_all:
- assert(!"invalid mode");
- break;
-
case nir_var_function_temp:
assert(!"nir_shader_add_variable cannot be used for local variables");
- break;
+ return;
case nir_var_shader_temp:
- exec_list_push_tail(&shader->globals, &var->node);
- break;
-
case nir_var_shader_in:
- exec_list_push_tail(&shader->inputs, &var->node);
- break;
-
case nir_var_shader_out:
- exec_list_push_tail(&shader->outputs, &var->node);
- break;
-
case nir_var_uniform:
case nir_var_mem_ubo:
case nir_var_mem_ssbo:
- exec_list_push_tail(&shader->uniforms, &var->node);
- break;
-
case nir_var_mem_shared:
- assert(gl_shader_stage_is_compute(shader->info.stage));
- exec_list_push_tail(&shader->shared, &var->node);
+ case nir_var_system_value:
break;
case nir_var_mem_global:
assert(!"nir_shader_add_variable cannot be used for global memory");
- break;
+ return;
- case nir_var_system_value:
- exec_list_push_tail(&shader->system_values, &var->node);
- break;
+ case nir_var_mem_push_const:
+ assert(!"nir_var_push_constant is not supposed to be used for variables");
+ return;
+
+ default:
+ assert(!"invalid mode");
+ return;
}
+
+ exec_list_push_tail(&shader->variables, &var->node);
}
nir_variable *
return var;
}
+nir_variable *
+nir_find_variable_with_location(nir_shader *shader,
+ nir_variable_mode mode,
+ unsigned location)
+{
+ assert(util_bitcount(mode) == 1 && mode != nir_var_function_temp);
+ nir_foreach_variable_with_modes(var, shader, mode) {
+ if (var->data.location == location)
+ return var;
+ }
+ return NULL;
+}
+
+nir_variable *
+nir_find_variable_with_driver_location(nir_shader *shader,
+ nir_variable_mode mode,
+ unsigned location)
+{
+ assert(util_bitcount(mode) == 1 && mode != nir_var_function_temp);
+ nir_foreach_variable_with_modes(var, shader, mode) {
+ if (var->data.driver_location == location)
+ return var;
+ }
+ return NULL;
+}
+
nir_function *
nir_function_create(nir_shader *shader, const char *name)
{
impl->reg_alloc = 0;
impl->ssa_alloc = 0;
impl->valid_metadata = nir_metadata_none;
+ impl->structured = true;
/* create start & end blocks */
nir_block *start_block = nir_block_create(shader);
{
nir_jump_instr *instr = ralloc(shader, nir_jump_instr);
instr_init(&instr->instr, nir_instr_type_jump);
+ src_init(&instr->condition);
instr->type = type;
+ instr->target = NULL;
+ instr->else_target = NULL;
return instr;
}
src_init(&instr->src[i].src);
instr->texture_index = 0;
- instr->texture_array_size = 0;
instr->sampler_index = 0;
memcpy(instr->tg4_offsets, default_tg4_offsets, sizeof(instr->tg4_offsets));
{
switch (cursor.option) {
case nir_cursor_before_block:
- assert(nir_cf_node_prev(&cursor.block->cf_node) == NULL ||
- nir_cf_node_prev(&cursor.block->cf_node)->type != nir_cf_node_block);
if (exec_list_is_empty(&cursor.block->instr_list)) {
/* Empty block. After is as good as before. */
cursor.option = nir_cursor_after_block;
return true;
}
+static bool
+visit_jump_src(nir_jump_instr *instr, nir_foreach_src_cb cb, void *state)
+{
+ if (instr->type != nir_jump_goto_if)
+ return true;
+
+ return visit_src(&instr->condition, cb, state);
+}
+
typedef struct {
void *state;
nir_foreach_src_cb cb;
return false;
break;
case nir_instr_type_jump:
+ return visit_jump_src(nir_instr_as_jump(instr), cb, state);
case nir_instr_type_ssa_undef:
return true;
return nir_foreach_dest(instr, visit_dest_indirect, &dest_state);
}
+bool
+nir_foreach_phi_src_leaving_block(nir_block *block,
+ nir_foreach_src_cb cb,
+ void *state)
+{
+ for (unsigned i = 0; i < ARRAY_SIZE(block->successors); i++) {
+ if (block->successors[i] == NULL)
+ continue;
+
+ nir_foreach_instr(instr, block->successors[i]) {
+ if (instr->type != nir_instr_type_phi)
+ break;
+
+ nir_phi_instr *phi = nir_instr_as_phi(instr);
+ nir_foreach_phi_src(phi_src, phi) {
+ if (phi_src->pred == block) {
+ if (!cb(&phi_src->src, state))
+ return false;
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
nir_const_value
nir_const_value_for_float(double f, unsigned bit_size)
{
/* As are uniform variables */
if (src.ssa->parent_instr->type == nir_instr_type_intrinsic) {
nir_intrinsic_instr *intr = nir_instr_as_intrinsic(src.ssa->parent_instr);
-
- if (intr->intrinsic == nir_intrinsic_load_uniform)
+ if (intr->intrinsic == nir_intrinsic_load_uniform &&
+ nir_src_is_dynamically_uniform(intr->src[0]))
return true;
}
{
if (dest->is_ssa) {
/* We can only overwrite an SSA destination if it has no uses. */
- assert(list_empty(&dest->ssa.uses) && list_empty(&dest->ssa.if_uses));
+ assert(list_is_empty(&dest->ssa.uses) && list_is_empty(&dest->ssa.if_uses));
} else {
list_del(&dest->reg.def_link);
if (dest->reg.indirect)
list_inithead(&def->if_uses);
def->num_components = num_components;
def->bit_size = bit_size;
+ def->divergent = true; /* This is the safer default */
if (instr->block) {
nir_function_impl *impl =
}
}
- if (!list_empty(&def->if_uses))
+ if (!list_is_empty(&def->if_uses))
read_mask |= 1;
return read_mask;
}
+nir_block *
+nir_block_unstructured_next(nir_block *block)
+{
+ if (block == NULL) {
+ /* nir_foreach_block_unstructured_safe() will call this function on a
+ * NULL block after the last iteration, but it won't use the result so
+ * just return NULL here.
+ */
+ return NULL;
+ }
+
+ nir_cf_node *cf_next = nir_cf_node_next(&block->cf_node);
+ if (cf_next == NULL && block->cf_node.parent->type == nir_cf_node_function)
+ return NULL;
+
+ if (cf_next && cf_next->type == nir_cf_node_block)
+ return nir_cf_node_as_block(cf_next);
+
+ return nir_block_cf_tree_next(block);
+}
+
+nir_block *
+nir_unstructured_start_block(nir_function_impl *impl)
+{
+ return nir_start_block(impl);
+}
+
nir_block *
nir_block_cf_tree_next(nir_block *block)
{
return NULL;
}
+ assert(nir_cf_node_get_function(&block->cf_node)->structured);
+
nir_cf_node *cf_next = nir_cf_node_next(&block->cf_node);
if (cf_next)
return nir_cf_node_cf_tree_first(cf_next);
return nir_if_first_else_block(if_stmt);
assert(block == nir_if_last_else_block(if_stmt));
- /* fall through */
}
+ /* fallthrough */
case nir_cf_node_loop:
return nir_cf_node_as_block(nir_cf_node_next(parent));
return NULL;
}
+ assert(nir_cf_node_get_function(&block->cf_node)->structured);
+
nir_cf_node *cf_prev = nir_cf_node_prev(&block->cf_node);
if (cf_prev)
return nir_cf_node_cf_tree_last(cf_prev);
return nir_if_last_then_block(if_stmt);
assert(block == nir_if_first_then_block(if_stmt));
- /* fall through */
}
+ /* fallthrough */
case nir_cf_node_loop:
return nir_cf_node_as_block(nir_cf_node_prev(parent));
if (impl->valid_metadata & nir_metadata_block_index)
return;
- nir_foreach_block(block, impl) {
+ nir_foreach_block_unstructured(block, impl) {
block->index = index++;
}
{
unsigned index = 0;
- nir_foreach_block(block, impl) {
+ nir_foreach_block_unstructured(block, impl) {
nir_foreach_instr(instr, block)
nir_foreach_ssa_def(instr, index_ssa_def_cb, &index);
}
return index;
}
+unsigned
+nir_shader_index_vars(nir_shader *shader, nir_variable_mode modes)
+{
+ unsigned count = 0;
+ nir_foreach_variable_with_modes(var, shader, modes)
+ var->index = count++;
+ return count;
+}
+
+unsigned
+nir_function_impl_index_vars(nir_function_impl *impl)
+{
+ unsigned count = 0;
+ nir_foreach_function_temp_variable(var, impl)
+ var->index = count++;
+ return count;
+}
+
static nir_instr *
cursor_next_instr(nir_cursor cursor)
{
unreachable("Inavlid cursor option");
}
-static bool
+ASSERTED static bool
dest_is_ssa(nir_dest *dest, void *_state)
{
+ (void) _state;
return dest->is_ssa;
}
list_for_each_entry_safe(nir_src, use_src, &old_if_uses, use_link)
nir_if_rewrite_condition(use_src->parent_if, new_src);
- if (list_empty(&old_def->uses) && list_empty(&old_def->if_uses)) {
+ if (list_is_empty(&old_def->uses) && list_is_empty(&old_def->if_uses)) {
iter = nir_instr_remove(instr);
} else {
iter = nir_after_instr(instr);
if (progress) {
nir_metadata_preserve(impl, preserved);
} else {
-#ifndef NDEBUG
- impl->valid_metadata &= ~nir_metadata_not_properly_reset;
-#endif
+ nir_metadata_preserve(impl, nir_metadata_all);
}
return progress;
return nir_intrinsic_load_frag_coord;
case SYSTEM_VALUE_POINT_COORD:
return nir_intrinsic_load_point_coord;
+ case SYSTEM_VALUE_LINE_COORD:
+ return nir_intrinsic_load_line_coord;
case SYSTEM_VALUE_FRONT_FACE:
return nir_intrinsic_load_front_face;
case SYSTEM_VALUE_SAMPLE_ID:
return SYSTEM_VALUE_FRAG_COORD;
case nir_intrinsic_load_point_coord:
return SYSTEM_VALUE_POINT_COORD;
+ case nir_intrinsic_load_line_coord:
+ return SYSTEM_VALUE_LINE_COORD;
case nir_intrinsic_load_front_face:
return SYSTEM_VALUE_FRONT_FACE;
case nir_intrinsic_load_sample_id:
assert(shader->info.stage == MESA_SHADER_VERTEX);
*dual_slot = 0;
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if (glsl_type_is_dual_slot(glsl_without_array(var->type))) {
unsigned slots = glsl_count_attribute_slots(var->type, true);
*dual_slot |= BITFIELD64_MASK(slots) << var->data.location;
}
}
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
var->data.location +=
util_bitcount64(*dual_slot & BITFIELD64_MASK(var->data.location));
}
CASE(load)
CASE(store)
CASE(atomic_add)
- CASE(atomic_min)
- CASE(atomic_max)
+ CASE(atomic_imin)
+ CASE(atomic_umin)
+ CASE(atomic_imax)
+ CASE(atomic_umax)
CASE(atomic_and)
CASE(atomic_or)
CASE(atomic_xor)
CASE(atomic_exchange)
CASE(atomic_comp_swap)
CASE(atomic_fadd)
+ CASE(atomic_inc_wrap)
+ CASE(atomic_dec_wrap)
CASE(size)
CASE(samples)
CASE(load_raw_intel)
nir_intrinsic_set_image_dim(intrin, glsl_get_sampler_dim(deref->type));
nir_intrinsic_set_image_array(intrin, glsl_sampler_type_is_array(deref->type));
- nir_intrinsic_set_access(intrin, access | var->data.image.access);
+ nir_intrinsic_set_access(intrin, access | var->data.access);
nir_intrinsic_set_format(intrin, var->data.image.format);
nir_instr_rewrite_src(&intrin->instr, &intrin->src[0],
nir_src_for_ssa(src));
}
+
+unsigned
+nir_image_intrinsic_coord_components(const nir_intrinsic_instr *instr)
+{
+ enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
+ int coords = glsl_get_sampler_dim_coordinate_components(dim);
+ if (dim == GLSL_SAMPLER_DIM_CUBE)
+ return coords;
+ else
+ return coords + nir_intrinsic_image_array(instr);
+}
projects / mesa.git / blobdiff