[PATCH v3 6/9] vkd3d-shader/hlsl: Support semantics for array types.

[Francisco Casas]

From: Francisco Casas

---
 libs/vkd3d-shader/hlsl.h                |   3 +
 libs/vkd3d-shader/hlsl.y                |   7 +-
 libs/vkd3d-shader/hlsl_codegen.c        | 187 +++++++++++++-----------
 tests/entry-point-semantics.shader_test |  36 ++---
 4 files changed, 123 insertions(+), 110 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 7acbb1e7..b45cd0ae 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -207,6 +207,9 @@ struct hlsl_semantic
 {
     const char *name;
     uint32_t index;
+
+    /* If the variable or field that stores this hlsl_semantic has already reported that it is missing. */
+    bool reported_missing;
 };

/* A field within a struct type declaration, used in hlsl_type.e.fields. */
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 79ec970a..27594ebe 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -4545,7 +4545,7 @@ var_identifier:
 colon_attribute:
       %empty
         {
-            $$.semantic.name = NULL;
+            $$.semantic = (struct hlsl_semantic){0};
             $$.reg_reservation.reg_type = 0;
             $$.reg_reservation.offset_type = 0;
         }
@@ -4557,12 +4557,12 @@ colon_attribute:
         }
     | register_opt
         {
-            $$.semantic.name = NULL;
+            $$.semantic = (struct hlsl_semantic){0};
             $$.reg_reservation = $1;
         }
     | packoffset_opt
         {
-            $$.semantic.name = NULL;
+            $$.semantic = (struct hlsl_semantic){0};
             $$.reg_reservation = $1;
         }

@@ -4575,6 +4575,7 @@ semantic:
                 ;
             $$.name = $2;
             $$.index = atoi(p);
+            $$.reported_missing = false;
             *p = 0;
         }

diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index e250dd0b..ffb80aa5 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -221,8 +221,20 @@ static void prepend_uniform_copy(struct hlsl_ctx *ctx, struct list *instrs, stru
     list_add_after(&load->node.entry, &store->node.entry);
 }

+static void validate_field_semantic(struct hlsl_ctx *ctx, struct hlsl_struct_field *field)
+{
+    if (!field->semantic.name && hlsl_get_multiarray_element_type(field->type)->class <= HLSL_CLASS_LAST_NUMERIC
+            && !field->semantic.reported_missing)
+    {
+        hlsl_error(ctx, &field->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_SEMANTIC,
+                "Field '%s' is missing a semantic.", field->name);
+        field->semantic.reported_missing = true;
+    }
+}
+
 static struct hlsl_ir_var *add_semantic_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *var,
-        struct hlsl_type *type, unsigned int modifiers, const struct hlsl_semantic *semantic, bool output)
+        struct hlsl_type *type, unsigned int modifiers, const struct hlsl_semantic *semantic,
+        uint32_t index, bool output)
 {
     struct hlsl_semantic new_semantic;
     struct vkd3d_string_buffer *name;
@@ -230,13 +242,13 @@ static struct hlsl_ir_var *add_semantic_var(struct hlsl_ctx *ctx, struct hlsl_ir

if (!(name = hlsl_get_string_buffer(ctx)))
         return NULL;
-    vkd3d_string_buffer_printf(name, "<%s-%s%u>", output ? "output" : "input", semantic->name, semantic->index);
+    vkd3d_string_buffer_printf(name, "<%s-%s%u>", output ? "output" : "input", semantic->name, index);
     if (!(new_semantic.name = hlsl_strdup(ctx, semantic->name)))
     {
         hlsl_release_string_buffer(ctx, name);
         return NULL;
     }
-    new_semantic.index = semantic->index;
+    new_semantic.index = index;
     if (!(ext_var = hlsl_new_var(ctx, hlsl_strdup(ctx, name->buffer),
             type, var->loc, &new_semantic, modifiers, NULL)))
     {
@@ -257,12 +269,44 @@ static struct hlsl_ir_var *add_semantic_var(struct hlsl_ctx *ctx, struct hlsl_ir
 }

static void prepend_input_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_load *lhs,
-        unsigned int modifiers, const struct hlsl_semantic *semantic)
+        unsigned int modifiers, const struct hlsl_semantic *semantic, uint32_t *semantic_index)
 {
     struct hlsl_type *type = lhs->node.data_type, *vector_type;
     struct hlsl_ir_var *var = lhs->src.var;
+    struct hlsl_ir_constant *c;
     unsigned int i;

+    if (type->class == HLSL_CLASS_ARRAY || type->class == HLSL_CLASS_STRUCT)
+    {
+        struct hlsl_ir_load *element_load;
+        struct hlsl_struct_field *field;
+        uint32_t field_semantic_index;
+
+        for (i = 0; i < hlsl_type_element_count(type); ++i)
+        {
+            if (type->class == HLSL_CLASS_STRUCT)
+            {
+                field = &type->e.record.fields[i];
+                validate_field_semantic(ctx, field);
+                semantic = &field->semantic;
+                field_semantic_index = semantic->index;
+                semantic_index = &field_semantic_index;
+            }
+
+            if (!(c = hlsl_new_uint_constant(ctx, i, &var->loc)))
+                return;
+            list_add_after(&lhs->node.entry, &c->node.entry);
+
+            /* This redundant load is expected to be deleted later by DCE. */
+            if (!(element_load = hlsl_new_load_index(ctx, &lhs->src, &c->node, &var->loc)))
+                return;
+            list_add_after(&c->node.entry, &element_load->node.entry);
+
+            prepend_input_copy(ctx, instrs, element_load, modifiers, semantic, semantic_index);
+        }
+        return;
+    }
+
     if (type->class > HLSL_CLASS_LAST_NUMERIC)
     {
         struct vkd3d_string_buffer *string;
@@ -270,23 +314,21 @@ static void prepend_input_copy(struct hlsl_ctx *ctx, struct list *instrs, struct
             return;
         hlsl_fixme(ctx, &var->loc, "Input semantics for type %s.", string->buffer);
         hlsl_release_string_buffer(ctx, string);
-        return;
     }
+    if (!semantic->name)
+        return;

vector_type = hlsl_get_vector_type(ctx, type->base_type, hlsl_type_minor_size(type));

for (i = 0; i < hlsl_type_major_size(type); ++i)
     {
-        struct hlsl_semantic semantic_copy = *semantic;
         struct hlsl_ir_store *store;
-        struct hlsl_ir_constant *c;
         struct hlsl_ir_var *input;
         struct hlsl_ir_load *load;

-        semantic_copy.index = semantic->index + i;
-
-        if (!(input = add_semantic_var(ctx, var, vector_type, modifiers, &semantic_copy, false)))
+        if (!(input = add_semantic_var(ctx, var, vector_type, modifiers, semantic, *semantic_index, false)))
             return;
+        ++*semantic_index;

if (!(load = hlsl_new_var_load(ctx, input, var->loc)))
             return;
@@ -313,41 +355,11 @@ static void prepend_input_copy(struct hlsl_ctx *ctx, struct list *instrs, struct
     }
 }

-static void prepend_input_struct_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_load *lhs)
-{
-    struct hlsl_type *type = lhs->node.data_type;
-    struct hlsl_ir_var *var = lhs->src.var;
-    size_t i;
-
-    for (i = 0; i < type->e.record.field_count; ++i)
-    {
-        const struct hlsl_struct_field *field = &type->e.record.fields[i];
-        struct hlsl_ir_load *field_load;
-        struct hlsl_ir_constant *c;
-
-        if (!(c = hlsl_new_uint_constant(ctx, i, &var->loc)))
-            return;
-        list_add_after(&lhs->node.entry, &c->node.entry);
-
-        /* This redundant load is expected to be deleted later by DCE. */
-        if (!(field_load = hlsl_new_load_index(ctx, &lhs->src, &c->node, &var->loc)))
-            return;
-        list_add_after(&c->node.entry, &field_load->node.entry);
-
-        if (field->type->class == HLSL_CLASS_STRUCT)
-            prepend_input_struct_copy(ctx, instrs, field_load);
-        else if (field->semantic.name)
-            prepend_input_copy(ctx, instrs, field_load, field->storage_modifiers, &field->semantic);
-        else
-            hlsl_error(ctx, &field->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_SEMANTIC,
-                    "Field '%s' is missing a semantic.", field->name);
-    }
-}
-
 /* Split inputs into two variables representing the semantic and temp registers,
  * and copy the former to the latter, so that writes to input variables work. */
 static void prepend_input_var_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_var *var)
 {
+    uint32_t semantic_index = var->semantic.index;
     struct hlsl_ir_load *load;

/* This redundant load is expected to be deleted later by DCE. */
@@ -355,19 +367,47 @@ static void prepend_input_var_copy(struct hlsl_ctx *ctx, struct list *instrs, st
         return;
     list_add_head(instrs, &load->node.entry);

-    if (var->data_type->class == HLSL_CLASS_STRUCT)
-        prepend_input_struct_copy(ctx, instrs, load);
-    else if (var->semantic.name)
-        prepend_input_copy(ctx, instrs, load, var->storage_modifiers, &var->semantic);
+    prepend_input_copy(ctx, instrs, load, var->storage_modifiers, &var->semantic, &semantic_index);
 }

static void append_output_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_load *rhs,
-        unsigned int modifiers, const struct hlsl_semantic *semantic)
+        unsigned int modifiers, const struct hlsl_semantic *semantic, uint32_t *semantic_index)
 {
     struct hlsl_type *type = rhs->node.data_type, *vector_type;
     struct hlsl_ir_var *var = rhs->src.var;
+    struct hlsl_ir_constant *c;
     unsigned int i;

+    if (type->class == HLSL_CLASS_ARRAY || type->class == HLSL_CLASS_STRUCT)
+    {
+        struct hlsl_ir_load *element_load;
+        struct hlsl_struct_field *field;
+        uint32_t field_semantic_index;
+
+        for (i = 0; i < hlsl_type_element_count(type); ++i)
+        {
+            if (type->class == HLSL_CLASS_STRUCT)
+            {
+                field = &type->e.record.fields[i];
+                validate_field_semantic(ctx, field);
+                semantic = &field->semantic;
+                field_semantic_index = semantic->index;
+                semantic_index = &field_semantic_index;
+            }
+
+            if (!(c = hlsl_new_uint_constant(ctx, i, &var->loc)))
+                return;
+            list_add_tail(instrs, &c->node.entry);
+
+            if (!(element_load = hlsl_new_load_index(ctx, &rhs->src, &c->node, &var->loc)))
+                return;
+            list_add_tail(instrs, &element_load->node.entry);
+
+            append_output_copy(ctx, instrs, element_load, modifiers, semantic, semantic_index);
+        }
+        return;
+    }
+
     if (type->class > HLSL_CLASS_LAST_NUMERIC)
     {
         struct vkd3d_string_buffer *string;
@@ -375,23 +415,21 @@ static void append_output_copy(struct hlsl_ctx *ctx, struct list *instrs, struct
             return;
         hlsl_fixme(ctx, &var->loc, "Output semantics for type %s.", string->buffer);
         hlsl_release_string_buffer(ctx, string);
-        return;
     }
+    if (!semantic->name)
+        return;

vector_type = hlsl_get_vector_type(ctx, type->base_type, hlsl_type_minor_size(type));

for (i = 0; i < hlsl_type_major_size(type); ++i)
     {
-        struct hlsl_semantic semantic_copy = *semantic;
         struct hlsl_ir_store *store;
-        struct hlsl_ir_constant *c;
         struct hlsl_ir_var *output;
         struct hlsl_ir_load *load;

-        semantic_copy.index = semantic->index + i;
-
-        if (!(output = add_semantic_var(ctx, var, vector_type, modifiers, &semantic_copy, true)))
+        if (!(output = add_semantic_var(ctx, var, vector_type, modifiers, semantic, *semantic_index, true)))
             return;
+        ++*semantic_index;

if (type->class == HLSL_CLASS_MATRIX)
         {
@@ -418,42 +456,12 @@ static void append_output_copy(struct hlsl_ctx *ctx, struct list *instrs, struct
     }
 }

-static void append_output_struct_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_load *rhs)
-{
-    struct hlsl_type *type = rhs->node.data_type;
-    struct hlsl_ir_var *var = rhs->src.var;
-    size_t i;
-
-    for (i = 0; i < type->e.record.field_count; ++i)
-    {
-        const struct hlsl_struct_field *field = &type->e.record.fields[i];
-        struct hlsl_ir_load *field_load;
-        struct hlsl_ir_constant *c;
-
-        if (!(c = hlsl_new_uint_constant(ctx, i, &var->loc)))
-            return;
-        list_add_tail(instrs, &c->node.entry);
-
-        /* This redundant load is expected to be deleted later by DCE. */
-        if (!(field_load = hlsl_new_load_index(ctx, &rhs->src, &c->node, &var->loc)))
-            return;
-        list_add_tail(instrs, &field_load->node.entry);
-
-        if (field->type->class == HLSL_CLASS_STRUCT)
-            append_output_struct_copy(ctx, instrs, field_load);
-        else if (field->semantic.name)
-            append_output_copy(ctx, instrs, field_load, field->storage_modifiers, &field->semantic);
-        else
-            hlsl_error(ctx, &field->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_SEMANTIC,
-                    "Field '%s' is missing a semantic.", field->name);
-    }
-}
-
 /* Split outputs into two variables representing the temp and semantic
  * registers, and copy the former to the latter, so that reads from output
  * variables work. */
 static void append_output_var_copy(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_var *var)
 {
+    uint32_t semantic_index = var->semantic.index;
     struct hlsl_ir_load *load;

/* This redundant load is expected to be deleted later by DCE. */
@@ -461,10 +469,7 @@ static void append_output_var_copy(struct hlsl_ctx *ctx, struct list *instrs, st
         return;
     list_add_tail(instrs, &load->node.entry);

-    if (var->data_type->class == HLSL_CLASS_STRUCT)
-        append_output_struct_copy(ctx, instrs, load);
-    else if (var->semantic.name)
-        append_output_copy(ctx, instrs, load, var->storage_modifiers, &var->semantic);
+    append_output_copy(ctx, instrs, load, var->storage_modifiers, &var->semantic, &semantic_index);
 }

static bool transform_ir(struct hlsl_ctx *ctx, bool (*func)(struct hlsl_ctx *ctx, struct hlsl_ir_node *, void *),
@@ -3396,15 +3401,19 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry
     {
         var = entry_func->parameters.vars[i];

-        if (var->data_type->class == HLSL_CLASS_OBJECT || (var->storage_modifiers & HLSL_STORAGE_UNIFORM))
+        if (hlsl_type_is_resource(var->data_type) || (var->storage_modifiers & HLSL_STORAGE_UNIFORM))
         {
             prepend_uniform_copy(ctx, &body->instrs, var);
         }
         else
         {
-            if (var->data_type->class != HLSL_CLASS_STRUCT && !var->semantic.name)
+            if (hlsl_get_multiarray_element_type(var->data_type)->class != HLSL_CLASS_STRUCT
+                    && !var->semantic.name)
+            {
                 hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_SEMANTIC,
                         "Parameter "%s" is missing a semantic.", var->name);
+                var->semantic.reported_missing = true;
+            }

if (var->storage_modifiers & HLSL_STORAGE_IN)
                 prepend_input_var_copy(ctx, &body->instrs, var);
diff --git a/tests/entry-point-semantics.shader_test b/tests/entry-point-semantics.shader_test
index e1080955..460e64b2 100644
--- a/tests/entry-point-semantics.shader_test
+++ b/tests/entry-point-semantics.shader_test
@@ -51,7 +51,7 @@ float4 main(float tex : bogus) : bogus;
 draw quad
 probe (0, 0) rgba (0.2, 0.2, 0.2, 0.2)

-[vertex shader todo]
+[vertex shader]
 void main(out float2 tex[4] : texcoord, inout float4 pos : sv_position)
 {
     tex[0] = float2(1.0, 2.0);
@@ -70,7 +70,7 @@ float4 main(in float2 arr[2]) : sv_target

% Array elements with a semantic get successive indexes.
-[pixel shader todo]
+[pixel shader]
 struct apple
 {
     float2 tp[4] : TEXCOORD0;
@@ -82,12 +82,12 @@ float4 main(in apple a) : sv_target
 }

[test]
-todo draw quad
-todo probe (0, 0) rgba (1.0, 3.0, 5.0, 7.0)
+draw quad
+probe (0, 0) rgba (1.0, 3.0, 5.0, 7.0)

% Arrays of matrices get successive indexes.
-[pixel shader todo]
+[pixel shader]
 struct apple
 {
     float2x2 tp[2] : TEXCOORD0;
@@ -99,13 +99,13 @@ float4 main(in apple a) : sv_target
 }

[test]
-todo draw quad
-todo probe (0, 0) rgba (1.0, 2.0, 5.0, 6.0)
+draw quad
+probe (0, 0) rgba (1.0, 2.0, 5.0, 6.0)

% Arrays (even multi-dimensional) of struct elements are allowed. The fields in the different struct
 % elements get the same indexes.
-[pixel shader todo]
+[pixel shader]
 struct apple {
     float2 texcoord : TEXCOORD0;
     float4 arb : UNUSED;
@@ -117,11 +117,11 @@ float4 main(in apple aps[2][2]) : sv_target
 }

[test]
-todo draw quad
+draw quad
 todo probe (0, 0) rgba (1.0, 2.0, 1.0, 2.0)

-[pixel shader todo]
+[pixel shader]
 struct apple {
     float2 texcoord : TEXCOORD0;
 };
@@ -137,7 +137,7 @@ float4 main(in banana bans[2]) : sv_target
 }

[test]
-todo draw quad
+draw quad
 todo probe (0, 0) rgba (1.0, 2.0, 1.0, 2.0)

@@ -150,7 +150,7 @@ float4 main(in float2 t1 : TEXCOORD0, in float2 t2 : TEXCOORD0) : sv_target
 }

[test]
-todo draw quad
+draw quad
 todo probe (0, 0) rgba (10.0, 20.0, 1.0, 2.0)

@@ -178,8 +178,8 @@ float4 main(in float2 a : TEXCOORD0, in float b : TEXCOORD1) : sv_target
 }

[test]
-todo draw quad
-todo probe (0, 0) rgba (1.0, 2.0, 3.0, 0.0)
+draw quad
+probe (0, 0) rgba (1.0, 2.0, 3.0, 0.0)

% Duplicated input semantics can only have different types if they have the same layout and register types.
@@ -249,7 +249,7 @@ void main(out banana bans[2])

% Output semantics cannot be mapped to more than one value.
-[vertex shader fail]
+[vertex shader fail todo]
 struct apple {
     float2 tex : TEXCOORD0;
 };
@@ -270,7 +270,7 @@ void main(out float2 a : sem0, out float2 b : SEM, inout float4 pos : sv_positio
 }

-[vertex shader todo]
+[vertex shader]
 struct apple {
     float2 tex[2] : TEXCOORD0;
 };
@@ -288,5 +288,5 @@ float4 main(in float2 tex0 : TEXCOORD0, in float2 tex1 : TEXCOORD1) : sv_target
 }

[test]
-todo draw quad
-todo probe (0, 0) rgba (1.0, 2.0, 10.0, 20.0)
+draw quad
+probe (0, 0) rgba (1.0, 2.0, 10.0, 20.0)