summaryrefslogtreecommitdiffstats
path: root/src/glsl/nir
diff options
context:
space:
mode:
Diffstat (limited to 'src/glsl/nir')
-rw-r--r--src/glsl/nir/spirv_to_nir.c96
-rw-r--r--src/glsl/nir/spirv_to_nir_private.h7
2 files changed, 87 insertions, 16 deletions
diff --git a/src/glsl/nir/spirv_to_nir.c b/src/glsl/nir/spirv_to_nir.c
index 740479f4d20..024988e06ef 100644
--- a/src/glsl/nir/spirv_to_nir.c
+++ b/src/glsl/nir/spirv_to_nir.c
@@ -617,6 +617,19 @@ vtn_handle_type(struct vtn_builder *b, SpvOp opcode,
val->type = vtn_value(b, w[2], vtn_value_type_type)->type;
break;
+ case SpvOpTypeSampler:
+ /* The actual sampler type here doesn't really matter. It gets
+ * thrown away the moment you combine it with an image. What really
+ * matters is that it's a sampler type as opposed to an integer type
+ * so the backend knows what to do.
+ *
+ * TODO: Eventually we should consider adding a "bare sampler" type
+ * to glsl_types.
+ */
+ val->type->type = glsl_sampler_type(GLSL_SAMPLER_DIM_2D, false, false,
+ GLSL_TYPE_FLOAT);
+ break;
+
case SpvOpTypeRuntimeArray:
case SpvOpTypeOpaque:
case SpvOpTypeEvent:
@@ -1603,12 +1616,26 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
case SpvOpAccessChain:
case SpvOpInBoundsAccessChain: {
- struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_deref);
- nir_deref_var *base = vtn_value(b, w[3], vtn_value_type_deref)->deref;
- val->deref = nir_deref_as_var(nir_copy_deref(b, &base->deref));
+ nir_deref_var *base;
+ struct vtn_value *base_val = vtn_untyped_value(b, w[3]);
+ if (base_val->value_type == vtn_value_type_sampled_image) {
+ /* This is rather insane. SPIR-V allows you to use OpSampledImage
+ * to combine an array of images with a single sampler to get an
+ * array of sampled images that all share the same sampler.
+ * Fortunately, this means that we can more-or-less ignore the
+ * sampler when crawling the access chain, but it does leave us
+ * with this rather awkward little special-case.
+ */
+ base = base_val->sampled_image->image;
+ } else {
+ assert(base_val->value_type == vtn_value_type_deref);
+ base = base_val->deref;
+ }
+
+ nir_deref_var *deref = nir_deref_as_var(nir_copy_deref(b, &base->deref));
struct vtn_type *deref_type = vtn_value(b, w[3], vtn_value_type_deref)->deref_type;
- nir_deref *tail = &val->deref->deref;
+ nir_deref *tail = &deref->deref;
while (tail->child)
tail = tail->child;
@@ -1679,29 +1706,29 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
b->shader->info.gs.vertices_in);
/* The first non-var deref should be an array deref. */
- assert(val->deref->deref.child->deref_type ==
+ assert(deref->deref.child->deref_type ==
nir_deref_type_array);
- per_vertex_deref = nir_deref_as_array(val->deref->deref.child);
+ per_vertex_deref = nir_deref_as_array(deref->deref.child);
}
nir_variable *builtin = get_builtin_variable(b,
base->var->data.mode,
builtin_type,
deref_type->builtin);
- val->deref = nir_deref_var_create(b, builtin);
+ deref = nir_deref_var_create(b, builtin);
if (per_vertex_deref) {
/* Since deref chains start at the variable, we can just
* steal that link and use it.
*/
- val->deref->deref.child = &per_vertex_deref->deref;
+ deref->deref.child = &per_vertex_deref->deref;
per_vertex_deref->deref.child = NULL;
per_vertex_deref->deref.type =
glsl_get_array_element(builtin_type);
tail = &per_vertex_deref->deref;
} else {
- tail = &val->deref->deref;
+ tail = &deref->deref;
}
} else {
tail = tail->child;
@@ -1712,12 +1739,20 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
* actually access the variable, so we need to keep around the original
* type of the variable.
*/
-
if (variable_is_external_block(base->var))
- val->deref_type = vtn_value(b, w[3], vtn_value_type_deref)->deref_type;
- else
+ deref_type = vtn_value(b, w[3], vtn_value_type_deref)->deref_type;
+
+ if (base_val->value_type == vtn_value_type_sampled_image) {
+ struct vtn_value *val =
+ vtn_push_value(b, w[2], vtn_value_type_sampled_image);
+ val->sampled_image = ralloc(b, struct vtn_sampled_image);
+ val->sampled_image->image = deref;
+ val->sampled_image->sampler = base_val->sampled_image->sampler;
+ } else {
+ struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_deref);
+ val->deref = deref;
val->deref_type = deref_type;
-
+ }
break;
}
@@ -1822,8 +1857,28 @@ static void
vtn_handle_texture(struct vtn_builder *b, SpvOp opcode,
const uint32_t *w, unsigned count)
{
+ if (opcode == SpvOpSampledImage) {
+ struct vtn_value *val =
+ vtn_push_value(b, w[2], vtn_value_type_sampled_image);
+ val->sampled_image = ralloc(b, struct vtn_sampled_image);
+ val->sampled_image->image =
+ vtn_value(b, w[3], vtn_value_type_deref)->deref;
+ val->sampled_image->sampler =
+ vtn_value(b, w[4], vtn_value_type_deref)->deref;
+ return;
+ }
+
struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
- nir_deref_var *sampler = vtn_value(b, w[3], vtn_value_type_deref)->deref;
+
+ struct vtn_sampled_image sampled;
+ struct vtn_value *sampled_val = vtn_untyped_value(b, w[3]);
+ if (sampled_val->value_type == vtn_value_type_sampled_image) {
+ sampled = *sampled_val->sampled_image;
+ } else {
+ assert(sampled_val->value_type == vtn_value_type_deref);
+ sampled.image = NULL;
+ sampled.sampler = sampled_val->deref;
+ }
nir_tex_src srcs[8]; /* 8 should be enough */
nir_tex_src *p = srcs;
@@ -1954,7 +2009,8 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp opcode,
nir_tex_instr *instr = nir_tex_instr_create(b->shader, p - srcs);
- const struct glsl_type *sampler_type = nir_deref_tail(&sampler->deref)->type;
+ const struct glsl_type *sampler_type =
+ nir_deref_tail(&sampled.sampler->deref)->type;
instr->sampler_dim = glsl_get_sampler_dim(sampler_type);
switch (glsl_get_sampler_result_type(sampler_type)) {
@@ -1972,7 +2028,14 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp opcode,
instr->is_array = glsl_sampler_type_is_array(sampler_type);
instr->is_shadow = glsl_sampler_type_is_shadow(sampler_type);
- instr->sampler = nir_deref_as_var(nir_copy_deref(instr, &sampler->deref));
+ instr->sampler =
+ nir_deref_as_var(nir_copy_deref(instr, &sampled.sampler->deref));
+ if (sampled.image) {
+ instr->texture =
+ nir_deref_as_var(nir_copy_deref(instr, &sampled.image->deref));
+ } else {
+ instr->texture = NULL;
+ }
nir_ssa_dest_init(&instr->instr, &instr->dest, 4, NULL);
val->ssa = vtn_create_ssa_value(b, glsl_vector_type(GLSL_TYPE_FLOAT, 4));
@@ -3310,6 +3373,7 @@ vtn_handle_body_instruction(struct vtn_builder *b, SpvOp opcode,
vtn_handle_function_call(b, opcode, w, count);
break;
+ case SpvOpSampledImage:
case SpvOpImageSampleImplicitLod:
case SpvOpImageSampleExplicitLod:
case SpvOpImageSampleDrefImplicitLod:
diff --git a/src/glsl/nir/spirv_to_nir_private.h b/src/glsl/nir/spirv_to_nir_private.h
index f7be166da16..40f0c78ae78 100644
--- a/src/glsl/nir/spirv_to_nir_private.h
+++ b/src/glsl/nir/spirv_to_nir_private.h
@@ -46,6 +46,7 @@ enum vtn_value_type {
vtn_value_type_ssa,
vtn_value_type_extension,
vtn_value_type_image_pointer,
+ vtn_value_type_sampled_image,
};
struct vtn_block {
@@ -127,6 +128,11 @@ struct vtn_image_pointer {
nir_ssa_def *sample;
};
+struct vtn_sampled_image {
+ nir_deref_var *image; /* Image or array of images */
+ nir_deref_var *sampler; /* Sampler */
+};
+
struct vtn_value {
enum vtn_value_type value_type;
const char *name;
@@ -144,6 +150,7 @@ struct vtn_value {
struct vtn_type *deref_type;
};
struct vtn_image_pointer *image;
+ struct vtn_sampled_image *sampled_image;
struct vtn_function *func;
struct vtn_block *block;
struct vtn_ssa_value *ssa;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-12 15:30:41 +0000