void
setup_vs_variables(isel_context *ctx, nir_shader *nir)
{
- nir_foreach_variable(variable, &nir->inputs)
+ nir_foreach_shader_in_variable(variable, nir)
{
variable->data.driver_location = variable->data.location * 4;
}
- nir_foreach_variable(variable, &nir->outputs)
+ nir_foreach_shader_out_variable(variable, nir)
{
if (ctx->stage == vertex_vs || ctx->stage == ngg_vertex_gs)
variable->data.driver_location = variable->data.location * 4;
if (ctx->stage == vertex_geometry_gs || ctx->stage == tess_eval_geometry_gs)
ctx->program->config->lds_size = ctx->program->info->gs_ring_info.lds_size; /* Already in units of the alloc granularity */
- nir_foreach_variable(variable, &nir->outputs) {
+ nir_foreach_shader_out_variable(variable, nir) {
variable->data.driver_location = variable->data.location * 4;
}
void
setup_tcs_variables(isel_context *ctx, nir_shader *nir)
{
- nir_foreach_variable(variable, &nir->outputs) {
+ nir_foreach_shader_out_variable(variable, nir) {
assert(variable->data.location >= 0 && variable->data.location <= UINT8_MAX);
if (variable->data.location == VARYING_SLOT_TESS_LEVEL_OUTER)
ctx->tcs_num_patches = ctx->args->options->key.tes.num_patches;
ctx->tcs_num_outputs = ctx->program->info->tes.num_linked_inputs;
- nir_foreach_variable(variable, &nir->outputs) {
+ nir_foreach_shader_out_variable(variable, nir) {
if (ctx->stage == tess_eval_vs || ctx->stage == ngg_tess_eval_gs)
variable->data.driver_location = variable->data.location * 4;
}
{
switch (nir->info.stage) {
case MESA_SHADER_FRAGMENT: {
- nir_foreach_variable(variable, &nir->outputs)
+ nir_foreach_shader_out_variable(variable, nir)
{
int idx = variable->data.location + variable->data.index;
variable->data.driver_location = idx * 4;
ctx.main_function = LLVMGetBasicBlockParent(LLVMGetInsertBlock(ctx.ac.builder));
- nir_foreach_variable(variable, &nir->outputs)
+ nir_foreach_shader_out_variable(variable, nir)
ac_handle_shader_output_decl(&ctx.ac, ctx.abi, nir, variable,
ctx.stage);
static void
handle_vs_inputs(struct radv_shader_context *ctx,
struct nir_shader *nir) {
- nir_foreach_variable(variable, &nir->inputs)
+ nir_foreach_shader_in_variable(variable, nir)
handle_vs_input_decl(ctx, variable);
}
{
bool uses_center = false;
bool uses_centroid = false;
- nir_foreach_variable(variable, &nir->inputs) {
+ nir_foreach_shader_in_variable(variable, nir) {
if (glsl_get_base_type(glsl_without_array(variable->type)) != GLSL_TYPE_FLOAT ||
variable->data.sample)
continue;
ac_emit_barrier(&ctx.ac, ctx.stage);
}
- nir_foreach_variable(variable, &shaders[i]->outputs)
+ nir_foreach_shader_out_variable(variable, shaders[i])
scan_shader_output_decl(&ctx, variable, shaders[i], shaders[i]->info.stage);
ac_setup_rings(&ctx);
ac_setup_rings(&ctx);
- nir_foreach_variable(variable, &geom_shader->outputs) {
+ nir_foreach_shader_out_variable(variable, geom_shader) {
scan_shader_output_decl(&ctx, variable, geom_shader, MESA_SHADER_VERTEX);
ac_handle_shader_output_decl(&ctx.ac, &ctx.abi, geom_shader,
variable, MESA_SHADER_VERTEX);
static nir_variable *
find_layer_in_var(nir_shader *nir)
{
- nir_foreach_variable(var, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir) {
if (var->data.location == VARYING_SLOT_LAYER) {
return var;
}
info->loads_dynamic_offsets = true;
}
- nir_foreach_variable(variable, &nir->inputs)
+ nir_foreach_shader_in_variable(variable, nir)
gather_info_input_decl(nir, variable, info, key);
nir_foreach_block(block, func->impl) {
gather_info_block(nir, block, info);
}
- nir_foreach_variable(variable, &nir->outputs)
+ nir_foreach_shader_out_variable(variable, nir)
gather_info_output_decl(nir, variable, info, key);
if (nir->info.stage == MESA_SHADER_VERTEX ||
* from the start of the attribute to the number of components we
* declare we need in c->vattr_sizes[].
*/
- nir_foreach_variable(var, &c->s->inputs) {
+ nir_foreach_shader_in_variable(var, c->s) {
/* No VS attribute array support. */
assert(MAX2(glsl_get_length(var->type), 1) == 1);
static bool
program_reads_point_coord(struct v3d_compile *c)
{
- nir_foreach_variable(var, &c->s->inputs) {
+ nir_foreach_shader_in_variable(var, c->s) {
if (util_varying_is_point_coord(var->data.location,
c->fs_key->point_sprite_mask)) {
return true;
nir_variable ***vars)
{
*num_entries = 0;
- nir_foreach_variable(var, &c->s->inputs)
+ nir_foreach_shader_in_variable(var, c->s)
(*num_entries)++;
*vars = ralloc_array(c, nir_variable *, *num_entries);
unsigned i = 0;
- nir_foreach_variable(var, &c->s->inputs)
+ nir_foreach_shader_in_variable(var, c->s)
(*vars)[i++] = var;
/* Sort the variables so that we emit the input setup in
if (c->s->info.stage != MESA_SHADER_FRAGMENT)
return;
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
unsigned array_len = MAX2(glsl_get_length(var->type), 1);
unsigned loc = var->data.driver_location * 4;
nir_ssa_def *src = nir_ssa_for_src(b, intr->src[0],
intr->num_components);
nir_variable *var = NULL;
- nir_foreach_variable(scan_var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(scan_var, c->s) {
int components = scan_var->data.compact ?
glsl_get_length(scan_var->type) :
glsl_get_components(scan_var->type);
v3d_nir_lower_io_update_output_var_base(struct v3d_compile *c,
struct v3d_nir_lower_io_state *state)
{
- nir_foreach_variable_safe(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable_safe(var, c->s) {
if (var->data.location == VARYING_SLOT_POS &&
state->pos_vpm_offset != -1) {
var->data.driver_location = state->pos_vpm_offset;
if (intr->intrinsic != nir_intrinsic_store_output)
continue;
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
const int driver_loc = var->data.driver_location;
if (driver_loc != nir_intrinsic_base(intr))
continue;
static void
v3d_fixup_fs_output_types(struct v3d_compile *c)
{
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
uint32_t mask = 0;
switch (var->data.location) {
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));
}
#define nir_foreach_variable_safe(var, var_list) \
foreach_list_typed_safe(nir_variable, var, node, var_list)
+#define nir_foreach_shader_in_variable(var, shader) \
+ nir_foreach_variable(var, &(shader)->inputs)
+
+#define nir_foreach_shader_in_variable_safe(var, shader) \
+ nir_foreach_variable_safe(var, &(shader)->inputs)
+
+#define nir_foreach_shader_out_variable(var, shader) \
+ nir_foreach_variable(var, &(shader)->outputs)
+
+#define nir_foreach_shader_out_variable_safe(var, shader) \
+ nir_foreach_variable_safe(var, &(shader)->outputs)
+
static inline bool
nir_variable_is_global(const nir_variable *var)
{
unsigned num_outputs = 0;
unsigned num_varyings = 0;
nir_xfb_varyings_info *varyings_info = NULL;
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (var->data.explicit_xfb_buffer) {
num_outputs += glsl_count_attribute_slots(var->type, false);
num_varyings += glsl_varying_count(var->type);
}
/* Walk the list of outputs and add them to the array */
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (!var->data.explicit_xfb_buffer)
continue;
uint64_t read[4] = { 0 }, written[4] = { 0 };
uint64_t patches_read[4] = { 0 }, patches_written[4] = { 0 };
- nir_foreach_variable(var, &producer->outputs) {
+ nir_foreach_shader_out_variable(var, producer) {
for (unsigned i = 0; i < get_num_components(var); i++) {
if (var->data.patch) {
patches_written[var->data.location_frac + i] |=
}
}
- nir_foreach_variable(var, &consumer->inputs) {
+ nir_foreach_shader_in_variable(var, consumer) {
for (unsigned i = 0; i < get_num_components(var); i++) {
if (var->data.patch) {
patches_read[var->data.location_frac + i] |=
/* Count the number of varying that can be packed and create a mapping
* of those varyings to the array we will pass to qsort.
*/
- nir_foreach_variable(var, &producer->outputs) {
+ nir_foreach_shader_out_variable(var, producer) {
/* Only remap things that aren't builtins. */
if (var->data.location >= VARYING_SLOT_VAR0 &&
{
nir_variable *input_vars[MAX_VARYING] = { 0 };
- nir_foreach_variable(var, &consumer->inputs) {
+ nir_foreach_shader_in_variable(var, consumer) {
if (var->data.location >= VARYING_SLOT_VAR0 &&
var->data.location - VARYING_SLOT_VAR0 < MAX_VARYING) {
}
}
- nir_foreach_variable(var, &producer->outputs) {
+ nir_foreach_shader_out_variable(var, producer) {
if (var->data.location >= VARYING_SLOT_VAR0 &&
var->data.location - VARYING_SLOT_VAR0 < MAX_VARYING) {
static nir_variable *
get_matching_input_var(nir_shader *consumer, nir_variable *out_var)
{
- nir_foreach_variable(var, &consumer->inputs) {
+ nir_foreach_shader_in_variable(var, consumer) {
if (does_varying_match(out_var, var))
return var;
}
uint64_t producer_output_mask = 0;
uint64_t producer_patch_output_mask = 0;
- nir_foreach_variable(variable, &producer->outputs) {
+ nir_foreach_shader_out_variable(variable, producer) {
uint64_t mask = get_linked_variable_io_mask(variable, producer->info.stage);
uint64_t loc = get_linked_variable_location(variable->data.location, variable->data.patch);
uint64_t consumer_input_mask = 0;
uint64_t consumer_patch_input_mask = 0;
- nir_foreach_variable(variable, &consumer->inputs) {
+ nir_foreach_shader_in_variable(variable, consumer) {
uint64_t mask = get_linked_variable_io_mask(variable, consumer->info.stage);
uint64_t loc = get_linked_variable_location(variable->data.location, variable->data.patch);
uint64_t io_mask = producer_output_mask | consumer_input_mask;
uint64_t patch_io_mask = producer_patch_output_mask | consumer_patch_input_mask;
- nir_foreach_variable(variable, &producer->outputs) {
+ nir_foreach_shader_out_variable(variable, producer) {
uint64_t loc = get_linked_variable_location(variable->data.location, variable->data.patch);
if (variable->data.patch)
variable->data.driver_location = util_bitcount64(io_mask & u_bit_consecutive64(0, loc)) * 4;
}
- nir_foreach_variable(variable, &consumer->inputs) {
+ nir_foreach_shader_in_variable(variable, consumer) {
uint64_t loc = get_linked_variable_location(variable->data.location, variable->data.patch);
if (variable->data.patch)
break;
case nir_intrinsic_store_output:
/* already had i/o lowered.. lookup the matching output var: */
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
int drvloc = var->data.driver_location;
if (nir_intrinsic_base(intr) == drvloc) {
out = var;
nir_variable *texcoord = NULL;
/* find gl_TexCoord, if it exists: */
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if (var->data.location == VARYING_SLOT_TEX0) {
texcoord = var;
break;
break;
case nir_intrinsic_store_output:
/* already had i/o lowered.. lookup the matching output var: */
- nir_foreach_variable(var, &state->shader->outputs) {
+ nir_foreach_shader_out_variable(var, state->shader) {
int drvloc = var->data.driver_location;
if (nir_intrinsic_base(intr) == drvloc) {
out = var;
nir_variable **clipvertex,
nir_variable **position)
{
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
switch (var->data.location) {
case VARYING_SLOT_POS:
*position = var;
unsigned *ucp_enables)
{
assert(shader->info.stage == MESA_SHADER_FRAGMENT);
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
switch (var->data.location) {
case VARYING_SLOT_CLIP_DIST0:
assert(var->data.compact);
{
bool progress = false;
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (var->data.location == VARYING_SLOT_CLIP_DIST0) {
unsigned size = glsl_get_length(var->type);
/* if currently-enabled planes match used planes then no-op */
nir_variable *texcoord = NULL;
/* find gl_TexCoord, if it exists: */
- nir_foreach_variable(var, &state->shader->inputs) {
+ nir_foreach_shader_in_variable(var, state->shader) {
if (var->data.location == VARYING_SLOT_TEX0) {
texcoord = var;
break;
/* The intrinsic doesn't carry the variable. We need to find it
* manually.
*/
- nir_foreach_variable(var, &state->b.shader->inputs) {
+ nir_foreach_shader_in_variable(var, state->b.shader) {
if ((var->data.driver_location == nir_intrinsic_base(intr)) &&
(nir_intrinsic_component(intr) >= var->data.location_frac &&
nir_intrinsic_component(intr) <
{
bool progress = false;
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
progress |= lower_input(shader, var);
}
static nir_ssa_def *
load_frag_coord(nir_builder *b)
{
- nir_foreach_variable(var, &b->shader->inputs) {
+ nir_foreach_shader_in_variable(var, b->shader) {
if (var->data.location == VARYING_SLOT_POS)
return nir_load_var(b, var);
}
if (intr->intrinsic != nir_intrinsic_store_output)
continue;
- nir_foreach_variable (var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
if (var->data.driver_location != nir_intrinsic_base(intr))
continue; /* not found yet */
shader->info.stage != MESA_SHADER_COMPUTE);
nir_variable *out = NULL;
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (var->data.location == VARYING_SLOT_PSIZ) {
out = var;
break;
static nir_variable *
create_face_input(nir_shader *shader)
{
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if (var->data.location == VARYING_SLOT_FACE)
return var;
}
setup_inputs(lower_2side_state *state)
{
/* find color inputs: */
- nir_foreach_variable(var, &state->shader->inputs) {
+ nir_foreach_shader_in_variable(var, state->shader) {
switch (var->data.location) {
case VARYING_SLOT_COL0:
case VARYING_SLOT_COL1:
static nir_variable *
lookup_input(nir_shader *shader, unsigned driver_location)
{
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if (driver_location == var->data.driver_location)
return var;
}
}
/* Setup inputs: */
- nir_foreach_variable (var, &ctx->s->inputs) {
+ nir_foreach_shader_in_variable (var, ctx->s) {
setup_input(ctx, var);
}
}
/* Setup outputs: */
- nir_foreach_variable (var, &ctx->s->outputs) {
+ nir_foreach_shader_out_variable (var, ctx->s) {
setup_output(ctx, var);
}
ir3_nir_lower_layer_id(nir_shader *nir)
{
unsigned layer_id_loc = ~0;
- nir_foreach_variable(var, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir) {
if (var->data.location == VARYING_SLOT_LAYER) {
layer_id_loc = var->data.driver_location;
break;
unreachable("bad shader stage");
}
- nir_foreach_variable(in_var, &consumer->shader->nir->inputs) {
- nir_foreach_variable(out_var, &producer->shader->nir->outputs) {
+ nir_foreach_shader_in_variable(in_var, consumer->shader->nir) {
+ nir_foreach_shader_out_variable(out_var, producer->shader->nir) {
if (in_var->data.location == out_var->data.location) {
locs[in_var->data.driver_location] =
producer->output_loc[out_var->data.driver_location] * factor;
nir_remove_dead_derefs(nir);
nir_remove_dead_variables(nir, nir_var_function_temp, NULL);
- nir_foreach_variable(variable, &nir->outputs)
+ nir_foreach_shader_out_variable(variable, nir)
handle_shader_output_decl(bld_base, nir, variable);
bld_base->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
static nir_ssa_def *
load_frag_coord(nir_builder *b)
{
- nir_foreach_variable(var, &b->shader->inputs) {
+ nir_foreach_shader_in_variable(var, b->shader) {
if (var->data.location == VARYING_SLOT_POS)
return nir_load_var(b, var);
}
return;
int highest_location = -1, highest_drv_location = -1;
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if ((int)var->data.location > highest_location)
highest_location = var->data.location;
if ((int)var->data.driver_location > highest_drv_location)
return;
int highest_location = -1, highest_drv_location = -1;
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
if ((int)var->data.location > highest_location)
highest_location = var->data.location;
if ((int)var->data.driver_location > highest_drv_location)
i = 0;
uint64_t processed_inputs = 0;
- nir_foreach_variable(variable, &nir->inputs) {
+ nir_foreach_shader_in_variable(variable, nir) {
unsigned semantic_name, semantic_index;
const struct glsl_type *type = variable->type;
i = 0;
uint64_t processed_outputs = 0;
unsigned num_outputs = 0;
- nir_foreach_variable(variable, &nir->outputs) {
+ nir_foreach_shader_out_variable(variable, nir) {
unsigned semantic_name, semantic_index;
i = variable->data.driver_location;
/* setup input linking */
struct etna_shader_io_file *sf = &v->infile;
if (s->info.stage == MESA_SHADER_VERTEX) {
- nir_foreach_variable(var, &s->inputs) {
+ nir_foreach_shader_in_variable(var, s) {
unsigned idx = var->data.driver_location;
sf->reg[idx].reg = idx;
sf->reg[idx].slot = var->data.location;
}
} else {
unsigned count = 0;
- nir_foreach_variable(var, &s->inputs) {
+ nir_foreach_shader_in_variable(var, s) {
unsigned idx = var->data.driver_location;
sf->reg[idx].reg = idx + 1;
sf->reg[idx].slot = var->data.location;
/* TODO we dont want to get shaders writing to depth for depth textures */
if (s->info.stage == MESA_SHADER_FRAGMENT) {
- nir_foreach_variable(var, &s->outputs) {
+ nir_foreach_shader_out_variable(var, s) {
if (var->data.location == FRAG_RESULT_DEPTH)
return -1;
}
}
/* get slot from idx */
- nir_foreach_variable(var, &ctx->nir->inputs) {
+ nir_foreach_shader_in_variable(var, ctx->nir) {
if (var->data.driver_location == idx) {
slot = var->data.location;
break;
{
int slot = -1;
unsigned idx = nir_intrinsic_base(intr);
- nir_foreach_variable(var, &ctx->nir->outputs) {
+ nir_foreach_shader_out_variable(var, ctx->nir) {
if (var->data.driver_location == idx) {
slot = var->data.location;
break;
}
/* Setup inputs: */
- nir_foreach_variable(in, &ctx->nir->inputs)
+ nir_foreach_shader_in_variable(in, ctx->nir)
setup_input(ctx, in);
if (so->type == MESA_SHADER_FRAGMENT) {
}
nir_variable *var = NULL;
- nir_foreach_variable(v, &nir->outputs) {
+ nir_foreach_shader_out_variable(v, nir) {
if (v->data.location == VARYING_SLOT_EDGE) {
var = v;
break;
if (!gpir_codegen_prog(comp))
goto err_out0;
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
bool varying = true;
switch (var->data.location) {
case VARYING_SLOT_POS:
}
/* Validate outputs, we support only gl_FragColor */
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
switch (var->data.location) {
case FRAG_RESULT_COLOR:
case FRAG_RESULT_DATA0:
if (prog->getType() == Program::TYPE_COMPUTE)
return true;
- nir_foreach_variable(var, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir) {
const glsl_type *type = var->type;
int slot = var->data.location;
uint16_t slots = calcSlots(type, prog->getType(), nir->info, true, var);
info->numInputs = std::max<uint8_t>(info->numInputs, vary);
}
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
const glsl_type *type = var->type;
int slot = var->data.location;
uint16_t slots = calcSlots(type, prog->getType(), nir->info, false, var);
bool ShaderFromNir::process_declaration()
{
// scan declarations
- nir_foreach_variable(variable, &sh->inputs) {
+ nir_foreach_shader_in_variable(variable, sh) {
if (!impl->process_inputs(variable)) {
fprintf(stderr, "R600: error parsing input varible %s\n", variable->name);
return false;
}
// scan declarations
- nir_foreach_variable(variable, &sh->outputs) {
+ nir_foreach_shader_out_variable(variable, sh) {
if (!impl->process_outputs(variable)) {
fprintf(stderr, "R600: error parsing outputs varible %s\n", variable->name);
return false;
{
uint64_t processed_inputs = 0;
- nir_foreach_variable (variable, &nir->inputs) {
+ nir_foreach_shader_in_variable (variable, nir) {
unsigned attrib_count = glsl_count_attribute_slots(variable->type, true);
unsigned input_idx = variable->data.driver_location;
unsigned loc = variable->data.location;
i = 0;
uint64_t processed_inputs = 0;
- nir_foreach_variable (variable, &nir->inputs) {
+ nir_foreach_shader_in_variable (variable, nir) {
unsigned semantic_name, semantic_index;
const struct glsl_type *type = variable->type;
}
}
- nir_foreach_variable (variable, &nir->outputs) {
+ nir_foreach_shader_out_variable (variable, nir) {
const struct glsl_type *type = variable->type;
if (nir_is_per_vertex_io(variable, nir->info.stage)) {
assert(glsl_type_is_array(type));
* as individual components.
*/
if (nir->info.stage != MESA_SHADER_FRAGMENT) {
- nir_foreach_variable (variable, &nir->inputs)
+ nir_foreach_shader_in_variable (variable, nir)
variable->data.driver_location *= 4;
}
- nir_foreach_variable (variable, &nir->outputs)
+ nir_foreach_shader_out_variable (variable, nir)
variable->data.driver_location *= 4;
}
static gl_varying_slot
v3d_get_slot_for_driver_location(nir_shader *s, uint32_t driver_location)
{
- nir_foreach_variable(var, &s->outputs) {
+ nir_foreach_shader_out_variable(var, s) {
if (var->data.driver_location == driver_location) {
return var->data.location;
}
struct v3d_varying_slot *outputs,
uint8_t *num_outputs)
{
- nir_foreach_variable(var, &s->outputs) {
+ nir_foreach_shader_out_variable(var, s) {
const int array_len = MAX2(glsl_get_length(var->type), 1);
for (int j = 0; j < array_len; j++) {
const int slot = var->data.location + j;
.base.shader_state = so,
};
- nir_foreach_variable(var, &s->outputs) {
+ nir_foreach_shader_out_variable(var, s) {
if (var->data.location == FRAG_RESULT_COLOR) {
key.cbufs |= 1 << 0;
} else if (var->data.location >= FRAG_RESULT_DATA0) {
continue;
nir_variable *output_var = NULL;
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
if (var->data.driver_location ==
nir_intrinsic_base(intr)) {
output_var = var;
}
nir_variable *input_var = NULL;
- nir_foreach_variable(var, &c->s->inputs) {
+ nir_foreach_shader_in_variable(var, c->s) {
if (var->data.driver_location == nir_intrinsic_base(intr)) {
input_var = var;
break;
nir_intrinsic_instr *intr)
{
nir_variable *output_var = NULL;
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
if (var->data.driver_location == nir_intrinsic_base(intr)) {
output_var = var;
break;
ntq_setup_inputs(struct vc4_compile *c)
{
unsigned num_entries = 0;
- nir_foreach_variable(var, &c->s->inputs)
+ nir_foreach_shader_in_variable(var, c->s)
num_entries++;
nir_variable *vars[num_entries];
unsigned i = 0;
- nir_foreach_variable(var, &c->s->inputs)
+ nir_foreach_shader_in_variable(var, c->s)
vars[i++] = var;
/* Sort the variables so that we emit the input setup in
static void
ntq_setup_outputs(struct vc4_compile *c)
{
- nir_foreach_variable(var, &c->s->outputs) {
+ nir_foreach_shader_out_variable(var, c->s) {
unsigned array_len = MAX2(glsl_get_length(var->type), 1);
unsigned loc = var->data.driver_location * 4;
ctx.so_outputs = _mesa_hash_table_create(ctx.mem_ctx, _mesa_hash_u32,
_mesa_key_u32_equal);
- nir_foreach_variable(var, &s->inputs)
+ nir_foreach_shader_in_variable(var, s)
emit_input(&ctx, var);
- nir_foreach_variable(var, &s->outputs)
+ nir_foreach_shader_out_variable(var, s)
emit_output(&ctx, var);
if (so_info)
static bool
check_psiz(struct nir_shader *s)
{
- nir_foreach_variable(var, &s->outputs) {
+ nir_foreach_shader_out_variable(var, s) {
if (var->data.location == VARYING_SLOT_PSIZ) {
/* genuine PSIZ outputs will have this set */
return !!var->data.explicit_location;
// Calculate input offsets.
unsigned offset = 0;
- nir_foreach_variable_safe(var, &nir->inputs) {
+ nir_foreach_shader_in_variable_safe(var, nir) {
offset = align(offset, glsl_get_cl_alignment(var->type));
var->data.driver_location = offset;
offset += glsl_get_cl_size(var->type);
{
prog_data->flat_inputs = 0;
- nir_foreach_variable(var, &shader->inputs) {
+ nir_foreach_shader_in_variable(var, shader) {
unsigned slots = glsl_count_attribute_slots(var->type, false);
for (unsigned s = 0; s < slots; s++) {
int input_index = prog_data->urb_setup[var->data.location + s];
* allocating them. With ARB_enhanced_layouts, multiple output variables
* may occupy the same slot, but have different type sizes.
*/
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
const int loc = var->data.driver_location;
const unsigned var_vec4s =
var->data.compact ? DIV_ROUND_UP(glsl_get_length(var->type), 4)
prog_data->contains_noperspective_varying = true;
}
- foreach_list_typed(nir_variable, var, node, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir) {
unsigned location = var->data.location;
unsigned slot_count = glsl_count_attribute_slots(var->type, false);
const uint8_t *vs_attrib_wa_flags)
{
/* Start with the location of the variable's base. */
- foreach_list_typed(nir_variable, var, node, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir)
var->data.driver_location = var->data.location;
- }
/* Now use nir_lower_io to walk dereference chains. Attribute arrays are
* loaded as one vec4 or dvec4 per element (or matrix column), depending on
brw_nir_lower_vue_inputs(nir_shader *nir,
const struct brw_vue_map *vue_map)
{
- foreach_list_typed(nir_variable, var, node, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir)
var->data.driver_location = var->data.location;
- }
/* Inputs are stored in vec4 slots, so use type_size_vec4(). */
nir_lower_io(nir, nir_var_shader_in, type_size_vec4,
void
brw_nir_lower_tes_inputs(nir_shader *nir, const struct brw_vue_map *vue_map)
{
- foreach_list_typed(nir_variable, var, node, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir)
var->data.driver_location = var->data.location;
- }
nir_lower_io(nir, nir_var_shader_in, type_size_vec4,
nir_lower_io_lower_64bit_to_32);
const struct gen_device_info *devinfo,
const struct brw_wm_prog_key *key)
{
- foreach_list_typed(nir_variable, var, node, &nir->inputs) {
+ nir_foreach_shader_in_variable(var, nir) {
var->data.driver_location = var->data.location;
/* Apply default interpolation mode.
void
brw_nir_lower_vue_outputs(nir_shader *nir)
{
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
var->data.driver_location = var->data.location;
}
brw_nir_lower_tcs_outputs(nir_shader *nir, const struct brw_vue_map *vue_map,
GLenum tes_primitive_mode)
{
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
var->data.driver_location = var->data.location;
}
void
brw_nir_lower_fs_outputs(nir_shader *nir)
{
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
var->data.driver_location =
SET_FIELD(var->data.index, BRW_NIR_FRAG_OUTPUT_INDEX) |
SET_FIELD(var->data.location, BRW_NIR_FRAG_OUTPUT_LOCATION);
/* Bail out early if we don't have gl_SampleMask */
bool is_sample_mask = false;
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (var->data.location == FRAG_RESULT_SAMPLE_MASK) {
is_sample_mask = true;
break;
switch (intr->intrinsic) {
case nir_intrinsic_store_output:
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
int drvloc = var->data.driver_location;
if (nir_intrinsic_base(intr) == drvloc) {
out = var;
/* Update position to refer to an array. */
nir_variable *pos_var = NULL;
- nir_foreach_variable(var, &shader->outputs) {
+ nir_foreach_shader_out_variable(var, shader) {
if (var->data.location == VARYING_SLOT_POS) {
assert(var->type == glsl_vec4_type());
var->type = glsl_array_type(glsl_vec4_type(), view_count, 0);
return false;
bool vs_writes_position = false;
- nir_foreach_variable(var, &shaders[MESA_SHADER_VERTEX]->outputs) {
+ nir_foreach_shader_out_variable(var, shaders[MESA_SHADER_VERTEX]) {
if (var->data.location == VARYING_SLOT_POS) {
vs_writes_position = true;
break;
*/
nir_function_impl *impl = nir_shader_get_entrypoint(stage->nir);
bool deleted_output = false;
- nir_foreach_variable_safe(var, &stage->nir->outputs) {
+ nir_foreach_shader_out_variable_safe(var, stage->nir) {
/* TODO: We don't delete depth/stencil writes. We probably could if the
* subpass doesn't have a depth/stencil attachment.
*/
{
nir_builder *b = &c->build;
- nir_foreach_variable(var, &b->shader->outputs) {
+ nir_foreach_shader_out_variable(var, b->shader) {
nir_ssa_def *src = nir_load_reg(b, c->output_regs[var->data.location]);
if (c->prog->Target == GL_FRAGMENT_PROGRAM_ARB &&
var->data.location == FRAG_RESULT_DEPTH) {
bool removed_inputs = false;
nir->num_inputs = util_bitcount64(nir->info.inputs_read);
- nir_foreach_variable_safe(var, &nir->inputs) {
+ nir_foreach_shader_in_variable_safe(var, nir) {
/* NIR already assigns dual-slot inputs to two locations so all we have
* to do is compact everything down.
*/
if (key->persample_shading) {
nir_shader *shader = state.ir.nir;
- nir_foreach_variable(var, &shader->inputs)
+ nir_foreach_shader_in_variable(var, shader)
var->data.sample = true;
finalize = true;
}
nir_variable *z_var = NULL, *s_var = NULL;
- nir_foreach_variable(var, &nir->outputs) {
+ nir_foreach_shader_out_variable(var, nir) {
if (var->data.location == FRAG_RESULT_DEPTH)
z_var = var;
else if (var->data.location == FRAG_RESULT_STENCIL)
projects / mesa.git / commitdiff