The size of the data structure doesn't change.
Reviewed-by: Connor Abbott <cwabbott0@gmail.com>
load->operands[0] = Operand(coords);
load->operands[1] = Operand(resource);
load->definitions[0] = Definition(tmp);
- load->glc = var->data.image.access & (ACCESS_VOLATILE | ACCESS_COHERENT) ? 1 : 0;
+ load->glc = var->data.access & (ACCESS_VOLATILE | ACCESS_COHERENT) ? 1 : 0;
load->dim = ac_get_image_dim(ctx->options->chip_class, dim, is_array);
load->dmask = dmask;
load->unrm = true;
bool is_array = glsl_sampler_type_is_array(type);
Temp data = as_vgpr(ctx, get_ssa_temp(ctx, instr->src[3].ssa));
- bool glc = ctx->options->chip_class == GFX6 || var->data.image.access & (ACCESS_VOLATILE | ACCESS_COHERENT | ACCESS_NON_READABLE) ? 1 : 0;
+ bool glc = ctx->options->chip_class == GFX6 || var->data.access & (ACCESS_VOLATILE | ACCESS_COHERENT | ACCESS_NON_READABLE) ? 1 : 0;
if (dim == GLSL_SAMPLER_DIM_BUF) {
Temp rsrc = get_sampler_desc(ctx, nir_instr_as_deref(instr->src[0].ssa->parent_instr), ACO_DESC_BUFFER, nullptr, true, true);
const struct glsl_type *type = image_deref->type;
const nir_variable *var = nir_deref_instr_get_variable(image_deref);
dim = glsl_get_sampler_dim(type);
- access = var->data.image.access;
+ access = var->data.access;
is_array = glsl_sampler_type_is_array(type);
}
const struct glsl_type *type = image_deref->type;
const nir_variable *var = nir_deref_instr_get_variable(image_deref);
dim = glsl_get_sampler_dim(type);
- access = var->data.image.access;
+ access = var->data.access;
is_array = glsl_sampler_type_is_array(type);
}
img_type, "out_img");
output_img->data.descriptor_set = 0;
output_img->data.binding = 0;
- output_img->data.image.access = ACCESS_NON_READABLE;
+ output_img->data.access = ACCESS_NON_READABLE;
nir_ssa_def *invoc_id = nir_load_local_invocation_id(&b);
nir_ssa_def *wg_id = nir_load_work_group_id(&b);
/* Set image access qualifiers */
enum gl_access_qualifier image_access =
- state->current_var->data.image.access;
+ state->current_var->data.access;
const GLenum access =
(image_access & ACCESS_NON_WRITEABLE) ?
((image_access & ACCESS_NON_READABLE) ? GL_NONE :
var->data.explicit_binding = ir->data.explicit_binding;
var->data.bindless = ir->data.bindless;
var->data.offset = ir->data.offset;
+ var->data.access = (gl_access_qualifier)image_access;
if (var->type->without_array()->is_image()) {
- var->data.image.access = (gl_access_qualifier)image_access;
var->data.image.format = ir->data.image_format;
- } else {
+ } else if (var->data.mode == nir_var_shader_out) {
var->data.xfb.buffer = ir->data.xfb_buffer;
var->data.xfb.stride = ir->data.xfb_stride;
}
nir_deref_path path;
nir_deref_path_init(&path, deref, NULL);
- unsigned qualifiers = path.path[0]->var->data.image.access;
+ unsigned qualifiers = path.path[0]->var->data.access;
const glsl_type *parent_type = path.path[0]->type;
for (nir_deref_instr **cur_ptr = &path.path[1]; *cur_ptr; cur_ptr++) {
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],
unsigned stream:9;
/**
+ * Access flags for memory variables (SSBO/global), image uniforms, and
+ * bindless images in uniforms/inputs/outputs.
+ */
+ enum gl_access_qualifier access:8;
+
+ /**
* output index for dual source blending.
*/
unsigned index;
unsigned offset;
union {
- /**
- * ARB_shader_image_load_store qualifiers.
- */
struct {
- enum gl_access_qualifier access:8;
-
/** Image internal format if specified explicitly, otherwise GL_NONE. */
GLenum16 format;
} image;
{
assert(path->path[0]->deref_type == nir_deref_type_var);
- if (path->path[0]->var->data.image.access & ACCESS_COHERENT)
+ if (path->path[0]->var->data.access & ACCESS_COHERENT)
return true;
for (nir_deref_instr **p = &path->path[1]; *p; p++) {
return false;
/* Ignore variables we've already marked */
- if (var->data.image.access & ACCESS_CAN_REORDER)
+ if (var->data.access & ACCESS_CAN_REORDER)
return false;
- if (!(var->data.image.access & ACCESS_NON_WRITEABLE) &&
+ if (!(var->data.access & ACCESS_NON_WRITEABLE) &&
!_mesa_set_search(state->vars_written, var)) {
- var->data.image.access |= ACCESS_NON_WRITEABLE;
+ var->data.access |= ACCESS_NON_WRITEABLE;
return true;
}
/* Check if we were able to mark the whole variable non-writeable */
if (!(nir_intrinsic_access(instr) & ACCESS_NON_WRITEABLE) &&
- var->data.image.access & ACCESS_NON_WRITEABLE) {
+ var->data.access & ACCESS_NON_WRITEABLE) {
progress = true;
nir_intrinsic_set_access(instr,
nir_intrinsic_access(instr) |
cent, samp, patch, inv, get_variable_mode_str(var->data.mode, false),
glsl_interp_mode_name(var->data.interpolation));
- enum gl_access_qualifier access = var->data.image.access;
+ enum gl_access_qualifier access = var->data.access;
const char *const coher = (access & ACCESS_COHERENT) ? "coherent " : "";
const char *const volat = (access & ACCESS_VOLATILE) ? "volatile " : "";
const char *const restr = (access & ACCESS_RESTRICT) ? "restrict " : "";
var_data->read_only = true;
break;
case SpvDecorationNonReadable:
- var_data->image.access |= ACCESS_NON_READABLE;
+ var_data->access |= ACCESS_NON_READABLE;
break;
case SpvDecorationNonWritable:
var_data->read_only = true;
- var_data->image.access |= ACCESS_NON_WRITEABLE;
+ var_data->access |= ACCESS_NON_WRITEABLE;
break;
case SpvDecorationRestrict:
- var_data->image.access |= ACCESS_RESTRICT;
+ var_data->access |= ACCESS_RESTRICT;
break;
case SpvDecorationVolatile:
- var_data->image.access |= ACCESS_VOLATILE;
+ var_data->access |= ACCESS_VOLATILE;
break;
case SpvDecorationCoherent:
- var_data->image.access |= ACCESS_COHERENT;
+ var_data->access |= ACCESS_COHERENT;
break;
case SpvDecorationComponent:
var_data->location_frac = dec->operands[0];
var = nir_variable_create(c->build.shader, nir_var_uniform, type, "image");
var->data.binding = binding;
var->data.explicit_binding = true;
- var->data.image.access = access;
+ var->data.access = access;
var->data.image.format = format;
c->images[binding] = var;
}
nir_deref_instr *image_deref = nir_build_deref_var(b, image);
const struct glsl_type *type = image_deref->type;
- nir_intrinsic_set_access(instr, image_deref->var->data.image.access);
+ nir_intrinsic_set_access(instr, image_deref->var->data.access);
instr->src[0] = nir_src_for_ssa(&image_deref->dest.ssa);
instr->src[1] = nir_src_for_ssa(src[addr_src_index]);
CacheMode
Converter::getCacheModeFromVar(const nir_variable *var)
{
- return convert(var->data.image.access);
+ return convert(var->data.access);
}
bool
/* For write-only surfaces, we trust that the hardware can just do the
* conversion for us.
*/
- if (var->data.image.access & ACCESS_NON_READABLE)
+ if (var->data.access & ACCESS_NON_READABLE)
return false;
const enum isl_format image_fmt =
/* For write-only images, we have an actual image surface so we fall back
* and let the back-end emit a TXS for this.
*/
- if (var->data.image.access & ACCESS_NON_READABLE)
+ if (var->data.access & ACCESS_NON_READABLE)
return false;
/* If we have a matching typed format, then we have an actual image surface
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(desc));
} else if (binding_offset > MAX_BINDING_TABLE_SIZE) {
const bool write_only =
- (var->data.image.access & ACCESS_NON_READABLE) != 0;
+ (var->data.access & ACCESS_NON_READABLE) != 0;
nir_ssa_def *desc =
build_descriptor_load(deref, 0, 2, 32, state);
nir_ssa_def *handle = nir_channel(b, desc, write_only ? 1 : 0);
/* NOTE: This is a uint8_t so we really do need to != 0 here */
pipe_binding[i].write_only =
- (var->data.image.access & ACCESS_NON_READABLE) != 0;
+ (var->data.access & ACCESS_NON_READABLE) != 0;
}
}
nir_variable_create(b.shader, nir_var_uniform,
glsl_image_type(GLSL_SAMPLER_DIM_BUF, false,
GLSL_TYPE_FLOAT), "img");
- img_var->data.image.access = ACCESS_NON_READABLE;
+ img_var->data.access = ACCESS_NON_READABLE;
img_var->data.explicit_binding = true;
img_var->data.binding = 0;
nir_deref_instr *img_deref = nir_build_deref_var(&b, img_var);