Lines Matching defs:var
39 get_variable_io_mask(nir_variable *var, gl_shader_stage stage)
41 if (var->data.location < 0)
44 unsigned location = var->data.patch ?
45 var->data.location - VARYING_SLOT_PATCH0 : var->data.location;
47 assert(var->data.mode == nir_var_shader_in ||
48 var->data.mode == nir_var_shader_out);
49 assert(var->data.location >= 0);
52 const struct glsl_type *type = var->type;
53 if (nir_is_arrayed_io(var, stage) || var->data.per_view) {
63 is_non_generic_patch_var(nir_variable *var)
65 return var->data.location == VARYING_SLOT_TESS_LEVEL_INNER ||
66 var->data.location == VARYING_SLOT_TESS_LEVEL_OUTER ||
67 var->data.location == VARYING_SLOT_BOUNDING_BOX0 ||
68 var->data.location == VARYING_SLOT_BOUNDING_BOX1;
72 get_num_components(nir_variable *var)
74 if (glsl_type_is_struct_or_ifc(glsl_without_array(var->type)))
77 return glsl_get_vector_elements(glsl_without_array(var->type));
100 nir_variable *var = nir_deref_instr_get_variable(deref);
101 for (unsigned i = 0; i < get_num_components(var); i++) {
102 if (var->data.patch) {
103 if (is_non_generic_patch_var(var))
106 patches_read[var->data.location_frac + i] |=
107 get_variable_io_mask(var, shader->info.stage);
109 read[var->data.location_frac + i] |=
110 get_variable_io_mask(var, shader->info.stage);
144 nir_foreach_variable_with_modes_safe(var, shader, mode) {
145 if (var->data.patch)
150 if (var->data.location < VARYING_SLOT_VAR0 && var->data.location >= 0)
151 if (shader->info.stage != MESA_SHADER_MESH || var->data.location != VARYING_SLOT_PRIMITIVE_ID)
154 if (var->data.always_active_io)
157 if (var->data.explicit_xfb_buffer)
160 uint64_t other_stage = used[var->data.location_frac];
162 if (!(other_stage & get_variable_io_mask(var, shader->info.stage))) {
165 (shader->info.outputs_read & BITFIELD64_BIT(var->data.location)))
166 var->data.mode = nir_var_mem_shared;
168 var->data.mode = nir_var_shader_temp;
169 var->data.location = 0;
196 nir_foreach_shader_out_variable(var, producer) {
197 for (unsigned i = 0; i < get_num_components(var); i++) {
198 if (var->data.patch) {
199 if (is_non_generic_patch_var(var))
202 patches_written[var->data.location_frac + i] |=
203 get_variable_io_mask(var, producer->info.stage);
205 written[var->data.location_frac + i] |=
206 get_variable_io_mask(var, producer->info.stage);
211 nir_foreach_shader_in_variable(var, consumer) {
212 for (unsigned i = 0; i < get_num_components(var); i++) {
213 if (var->data.patch) {
214 if (is_non_generic_patch_var(var))
217 patches_read[var->data.location_frac + i] |=
218 get_variable_io_mask(var, consumer->info.stage);
220 read[var->data.location_frac + i] |=
221 get_variable_io_mask(var, consumer->info.stage);
244 get_interp_type(nir_variable *var, const struct glsl_type *type,
247 if (var->data.per_primitive)
251 else if (var->data.interpolation != INTERP_MODE_NONE)
252 return var->data.interpolation;
264 get_interp_loc(nir_variable *var)
266 if (var->data.sample)
268 else if (var->data.centroid)
307 nir_foreach_variable_with_modes_safe(var, shader, mode) {
308 assert(var->data.location >= 0);
311 if (var->data.location >= VARYING_SLOT_VAR0 &&
312 var->data.location - VARYING_SLOT_VAR0 < MAX_VARYINGS_INCL_PATCH) {
314 const struct glsl_type *type = var->type;
315 if (nir_is_arrayed_io(var, stage) || var->data.per_view) {
324 !var->data.always_active_io)
327 unsigned location = var->data.location - VARYING_SLOT_VAR0;
342 unsigned num_comps = 4 - var->data.location_frac;
346 assert(var->data.location_frac == 0 ||
347 var->data.location_frac == 2);
351 ((1 << num_comps) - 1) << var->data.location_frac;
355 ((1 << (elements * dmul)) - 1) << var->data.location_frac;
359 get_interp_type(var, type, default_to_smooth_interp);
360 comps[location + i].interp_loc = get_interp_loc(var);
364 var->data.precision == GLSL_PRECISION_MEDIUM ||
365 var->data.precision == GLSL_PRECISION_LOW;
366 comps[location + i].is_per_primitive = var->data.per_primitive;
379 mark_all_used_slots(nir_variable *var, uint64_t *slots_used,
382 unsigned loc_offset = var->data.patch ? VARYING_SLOT_PATCH0 : 0;
384 slots_used[var->data.patch ? 1 : 0] |= slots_used_mask &
385 BITFIELD64_RANGE(var->data.location - loc_offset, num_slots);
389 mark_used_slot(nir_variable *var, uint64_t *slots_used, unsigned offset)
391 unsigned loc_offset = var->data.patch ? VARYING_SLOT_PATCH0 : 0;
393 slots_used[var->data.patch ? 1 : 0] |=
394 BITFIELD64_BIT(var->data.location - loc_offset + offset);
410 nir_foreach_variable_with_modes(var, shader, mode) {
411 assert(var->data.location >= 0);
414 if (var->data.location >= VARYING_SLOT_VAR0 &&
415 var->data.location - VARYING_SLOT_VAR0 < MAX_VARYINGS_INCL_PATCH) {
417 const struct glsl_type *type = var->type;
418 if (nir_is_arrayed_io(var, stage) || var->data.per_view) {
427 unsigned location = var->data.location - VARYING_SLOT_VAR0;
428 struct varying_loc *new_loc = &remap[location][var->data.location_frac];
430 unsigned loc_offset = var->data.patch ? VARYING_SLOT_PATCH0 : 0;
431 uint64_t used = var->data.patch ? *p_slots_used : *slots_used;
433 var->data.patch ? *p_out_slots_read : *out_slots_read;
435 BITFIELD64_RANGE(var->data.location - loc_offset, num_slots);
444 var->data.location = new_loc->location;
445 var->data.location_frac = new_loc->component;
448 if (var->data.always_active_io) {
455 mark_all_used_slots(var, slots_used_tmp, used, num_slots);
458 mark_all_used_slots(var, out_slots_read_tmp, outs_used,
464 mark_used_slot(var, slots_used_tmp, i);
467 mark_used_slot(var, out_slots_read_tmp, i);
480 nir_variable *var;
528 const struct nir_variable_data *const data1 = &comp1->var->data;
529 const struct nir_variable_data *const data2 = &comp2->var->data;
547 nir_foreach_shader_out_variable(var, producer) {
550 if (var->data.location >= VARYING_SLOT_VAR0 &&
551 var->data.location - VARYING_SLOT_VAR0 < MAX_VARYINGS_INCL_PATCH) {
554 if (var->data.always_active_io)
557 const struct glsl_type *type = var->type;
558 if (nir_is_arrayed_io(var, producer->info.stage) || var->data.per_view) {
566 unsigned loc = var->data.location - VARYING_SLOT_VAR0;
567 store_varying_info_idx[loc][var->data.location_frac] =
621 vc_info->var = in_var;
687 vc_info->var = out_var;
829 unsigned location = info->var->data.location - VARYING_SLOT_VAR0;
840 remap[location][info->var->data.location_frac].component = tmp_comp++;
841 remap[location][info->var->data.location_frac].location =
973 nir_foreach_shader_in_variable(var, consumer) {
974 if (var->data.location >= VARYING_SLOT_VAR0 &&
975 var->data.location - VARYING_SLOT_VAR0 < MAX_VARYING) {
977 unsigned location = var->data.location - VARYING_SLOT_VAR0;
978 input_vars[location][var->data.location_frac] = var;
982 nir_foreach_shader_out_variable(var, producer) {
983 if (var->data.location >= VARYING_SLOT_VAR0 &&
984 var->data.location - VARYING_SLOT_VAR0 < MAX_VARYING) {
986 if (!var->data.always_active_io)
989 unsigned location = var->data.location - VARYING_SLOT_VAR0;
990 if (input_vars[location][var->data.location_frac]) {
991 input_vars[location][var->data.location_frac]->data.always_active_io = true;
1007 nir_foreach_shader_in_variable(var, consumer) {
1008 if (does_varying_match(out_var, var))
1009 return var;
1194 clone_deref_instr(nir_builder *b, nir_variable *var, nir_deref_instr *deref)
1197 return nir_build_deref_var(b, var);
1200 nir_deref_instr *parent = clone_deref_instr(b, var, parent_deref);
1436 nir_foreach_variable_in_list(var, var_list) {
1445 if (new_var->data.per_primitive < var->data.per_primitive ||
1446 (new_var->data.per_primitive == var->data.per_primitive &&
1447 (var->data.location > new_var->data.location ||
1448 (var->data.location == new_var->data.location &&
1449 var->data.location_frac > new_var->data.location_frac)))) {
1450 exec_node_insert_node_before(&var->node, &new_var->node);
1462 nir_foreach_variable_with_modes_safe(var, shader, mode) {
1463 exec_node_remove(&var->node);
1464 insert_sorted(sorted_list, var);
1482 nir_foreach_variable_in_list(var, &io_vars) {
1483 const struct glsl_type *type = var->type;
1484 if (nir_is_arrayed_io(var, stage)) {
1490 if (var->data.mode == nir_var_shader_in && stage == MESA_SHADER_VERTEX)
1492 else if (var->data.mode == nir_var_shader_out &&
1499 if (var->data.compact) {
1504 if (last_partial && var->data.location_frac == 0) {
1509 assert(!var->data.per_view);
1512 unsigned start = 4 * location + var->data.location_frac;
1528 * when counting user-facing slots (var->data.location), but *not*
1529 * with driver slots (var->data.driver_location). That is, each user
1533 if (var->data.per_view) {
1546 if (var->data.location >= base) {
1547 unsigned glsl_location = var->data.location - base;
1550 if (processed_locs[var->data.index] &
1554 processed_locs[var->data.index] |=
1564 assert(!var->data.per_view);
1565 unsigned driver_location = assigned_locations[var->data.location];
1566 var->data.driver_location = driver_location;
1570 * consecutively if the previously proccessed var was shorter than
1573 * NOTE: The code below assumes the var list is ordered in ascending
1577 assert(last_loc <= var->data.location ||
1578 last_per_prim != var->data.per_primitive);
1579 last_loc = var->data.location;
1580 last_per_prim = var->data.per_primitive;
1586 assigned_locations[var->data.location + i] = location;
1594 assigned_locations[var->data.location + i] = location + i;
1597 var->data.driver_location = location;