[PATCH v4 0/5] MR250: vkd3d-shader/hlsl: Declare vars individually when parsing declarations.

[Francisco Casas (＠fcasas)]

In a declaration with multiple variables, the variables must be created
before the initializer of the next variable is parsed. This is required
for initializers such as:

```
float a = 1, b = a, c = b + 1;
```

The solution is to parse the type information in the same rule as the first variable ('a' in this case) so that it can be declared before the parser reaches the initializer for the following variables.

To initialize the following variables, the type information is passed along from the first variable's struct parse_variable_def to the next and so on.

---

Solves https://bugs.winehq.org/show_bug.cgi?id=54484, pointed out by @nsivov.

--
  v4: vkd3d-shader/hlsl: Declare vars individually when parsing struct declarations.
      vkd3d-shader/hlsl: Declare vars individually when parsing regular declarations.
      vkd3d-shader/hlsl: Split declare_vars().
      tests: Test multiple variable initializers.
      tests: Test semantics in uniform variables.

https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/250

[PATCH v4 1/5] tests: Test semantics in uniform variables.

[Francisco Casas]

From: Francisco Casas

---
 Makefile.am                              |  1 +
 tests/hlsl/uniform-semantics.shader_test | 28 ++++++++++++++++++++++++
 2 files changed, 29 insertions(+)
 create mode 100644 tests/hlsl/uniform-semantics.shader_test

diff --git a/Makefile.am b/Makefile.am
index 793c3818..d6685c43 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -174,6 +174,7 @@ vkd3d_shader_tests = \
    tests/hlsl/uav-rwbuffer.shader_test \
    tests/hlsl/uav-rwstructuredbuffer.shader_test \
    tests/hlsl/uav-rwtexture.shader_test \
+	tests/hlsl/uniform-semantics.shader_test \
    tests/hlsl/vector-indexing-uniform.shader_test \
    tests/hlsl/vector-indexing.shader_test \
    tests/hlsl/writemask-assignop-0.shader_test \
diff --git a/tests/hlsl/uniform-semantics.shader_test b/tests/hlsl/uniform-semantics.shader_test
new file mode 100644
index 00000000..1125117f
--- /dev/null
+++ b/tests/hlsl/uniform-semantics.shader_test
@@ -0,0 +1,28 @@
+% Semantics can be used in uniforms even though they are ignored.
+
+[pixel shader]
+float a : SEMANTIC;
+
+float4 main() : sv_target
+{
+    return a;
+}
+
+[test]
+uniform 0 float 3.5
+draw quad
+probe all rgba (3.5, 3.5, 3.5, 3.5)
+
+
+[pixel shader]
+float2 a : sv_position;
+
+float4 main() : sv_target
+{
+    return float4(a, a);
+}
+
+[test]
+uniform 0 float4 4.0 5.0 6.0 7.0
+draw quad
+probe all rgba (4.0, 5.0, 4.0, 5.0)

[PATCH v4 2/5] tests: Test multiple variable initializers.

[Francisco Casas]

From: Francisco Casas

---
 Makefile.am                              |  1 +
 tests/hlsl/initializer-multi.shader_test | 52 ++++++++++++++++++++++++
 2 files changed, 53 insertions(+)
 create mode 100644 tests/hlsl/initializer-multi.shader_test

diff --git a/Makefile.am b/Makefile.am
index d6685c43..cafa8f2f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -98,6 +98,7 @@ vkd3d_shader_tests = \
    tests/hlsl/initializer-invalid-arg-count.shader_test \
    tests/hlsl/initializer-local-array.shader_test \
    tests/hlsl/initializer-matrix.shader_test \
+	tests/hlsl/initializer-multi.shader_test \
    tests/hlsl/initializer-nested.shader_test \
    tests/hlsl/initializer-numeric.shader_test \
    tests/hlsl/initializer-objects.shader_test \
diff --git a/tests/hlsl/initializer-multi.shader_test b/tests/hlsl/initializer-multi.shader_test
new file mode 100644
index 00000000..9c45a533
--- /dev/null
+++ b/tests/hlsl/initializer-multi.shader_test
@@ -0,0 +1,52 @@
+[pixel shader todo]
+float4 main() : sv_target
+{
+    float a = 2.0, b = a + 1.0, c = b;
+
+    return float4(a, b, c, 0);
+}
+
+[test]
+todo draw quad
+probe all rgba (2, 3, 3, 0)
+
+
+[pixel shader fail]
+float4 main() : sv_target
+{
+    float a = 2.0, b = c + 1.0, c = b;
+
+    return float4(0);
+}
+
+
+[pixel shader todo]
+float4 main() : sv_target
+{
+    struct apple {
+        float a;
+        int b;
+    } apple1 = {7.2, 8.1}, apple2 = apple1;
+
+    return float4(apple1.a, apple1.b, apple2.a, apple2.b);
+}
+
+[test]
+todo draw quad
+probe all rgba (7.2, 8.0, 7.2, 8.0)
+
+
+[pixel shader todo]
+float4 main() : sv_target
+{
+    struct apple {
+        float a;
+        int b;
+    } apple1 = {5.2, 9.1}, apples[2] = {apple1, apple1};
+
+    return float4(apples[0].a, apples[0].b, apples[1].a, apples[1].b);
+}
+
+[test]
+todo draw quad
+probe all rgba (5.2, 9.0, 5.2, 9.0)

[PATCH v4 3/5] vkd3d-shader/hlsl: Split declare_vars().

[Francisco Casas]

From: Francisco Casas

Basically, declare_vars() is separated in three functions:

1. check_invalid_in_out_modifiers(), which is to be called once per
   declaration and emits an error when in or out modifiers are used for
   these non-parameter variables.

2. declare_var(), which now handles one variable at the time and doesn't
   free any memory.

3. initialize_vars(), which takes care of preparing the initialization
   instructions of several variables and frees their struct
   parse_variable_def, using exclusively free_parse_variable_def().

This allows to declare variables individually before the initializer of
the next variable in the same declaration is parsed, which is used in
the following patches.

Also, simplifies memory management.
---
 libs/vkd3d-shader/hlsl.y | 388 ++++++++++++++++++++++-----------------
 1 file changed, 218 insertions(+), 170 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 60d6514c..984f38cd 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -1949,211 +1949,233 @@ static bool type_has_numeric_components(struct hlsl_type *type)
     return false;
 }

-static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_type,
-        unsigned int modifiers, const struct vkd3d_shader_location *modifiers_loc, struct list *var_list)
+static void check_invalid_in_out_modifiers(struct hlsl_ctx *ctx, unsigned int modifiers,
+        const struct vkd3d_shader_location *loc)
+{
+    modifiers &= (HLSL_STORAGE_IN | HLSL_STORAGE_OUT);
+    if (modifiers)
+    {
+        struct vkd3d_string_buffer *string;
+
+        if ((string = hlsl_modifiers_to_string(ctx, modifiers)))
+            hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
+                    "Modifiers '%s' are not allowed on non-parameter variables.", string->buffer);
+        hlsl_release_string_buffer(ctx, string);
+    }
+}
+
+static void declare_var(struct hlsl_ctx *ctx, struct hlsl_type *basic_type,
+        unsigned int modifiers, const struct vkd3d_shader_location *modifiers_loc, struct parse_variable_def *v)
 {
-    struct parse_variable_def *v, *v_next;
     struct hlsl_ir_function_decl *func;
-    unsigned int invalid_modifiers;
-    struct list *statements_list;
+    struct hlsl_semantic new_semantic;
+    bool unbounded_res_array = false;
     struct hlsl_ir_var *var;
     struct hlsl_type *type;
     bool local = true;
+    char *var_name;
+    unsigned int i;
+
+    assert(basic_type);

if (basic_type->class == HLSL_CLASS_MATRIX)
         assert(basic_type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK);

-    if (!(statements_list = make_empty_list(ctx)))
-    {
-        LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
-            free_parse_variable_def(v);
-        vkd3d_free(var_list);
-        return NULL;
-    }
-
-    if (!var_list)
-        return statements_list;
+    type = basic_type;

-    invalid_modifiers = modifiers & (HLSL_STORAGE_IN | HLSL_STORAGE_OUT);
-    if (invalid_modifiers)
+    if (shader_is_sm_5_1(ctx) && type->class == HLSL_CLASS_OBJECT)
     {
-        struct vkd3d_string_buffer *string;
-
-        if ((string = hlsl_modifiers_to_string(ctx, invalid_modifiers)))
-            hlsl_error(ctx, modifiers_loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
-                    "Modifiers '%s' are not allowed on non-parameter variables.", string->buffer);
-        hlsl_release_string_buffer(ctx, string);
+        for (i = 0; i < v->arrays.count; ++i)
+            unbounded_res_array |= (v->arrays.sizes[i] == HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT);
     }

-    LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
+    if (unbounded_res_array)
     {
-        bool unbounded_res_array = false;
-        unsigned int i;
-
-        type = basic_type;
-
-        if (shader_is_sm_5_1(ctx) && type->class == HLSL_CLASS_OBJECT)
+        if (v->arrays.count == 1)
         {
-            for (i = 0; i < v->arrays.count; ++i)
-                unbounded_res_array |= (v->arrays.sizes[i] == HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT);
+            hlsl_fixme(ctx, &v->loc, "Unbounded resource arrays.");
+            return;
         }
-
-        if (unbounded_res_array)
+        else
         {
-            if (v->arrays.count == 1)
-            {
-                hlsl_fixme(ctx, &v->loc, "Unbounded resource arrays.");
-                free_parse_variable_def(v);
-                continue;
-            }
-            else
-            {
-                hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                        "Unbounded resource arrays cannot be multi-dimensional.");
-            }
+            hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                    "Unbounded resource arrays cannot be multi-dimensional.");
         }
-        else
+    }
+    else
+    {
+        for (i = 0; i < v->arrays.count; ++i)
         {
-            for (i = 0; i < v->arrays.count; ++i)
+            if (v->arrays.sizes[i] == HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT)
             {
-                if (v->arrays.sizes[i] == HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT)
-                {
-                    unsigned int size = initializer_size(&v->initializer);
-                    unsigned int elem_components = hlsl_type_component_count(type);
-
-                    if (i < v->arrays.count - 1)
-                    {
-                        hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                                "Only innermost array size can be implicit.");
-                        free_parse_initializer(&v->initializer);
-                        v->initializer.args_count = 0;
-                    }
-                    else if (elem_components == 0)
-                    {
-                        hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                                "Cannot declare an implicit size array of a size 0 type.");
-                        free_parse_initializer(&v->initializer);
-                        v->initializer.args_count = 0;
-                    }
-                    else if (size == 0)
-                    {
-                        hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                                "Implicit size arrays need to be initialized.");
-                        free_parse_initializer(&v->initializer);
-                        v->initializer.args_count = 0;
+                unsigned int size = initializer_size(&v->initializer);
+                unsigned int elem_components = hlsl_type_component_count(type);

-                    }
-                    else if (size % elem_components != 0)
-                    {
-                        hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT,
-                                "Cannot initialize implicit size array with %u components, expected a multiple of %u.",
-                                size, elem_components);
-                        free_parse_initializer(&v->initializer);
-                        v->initializer.args_count = 0;
-                    }
-                    else
-                    {
-                        v->arrays.sizes[i] = size / elem_components;
-                    }
+                if (i < v->arrays.count - 1)
+                {
+                    hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                            "Only innermost array size can be implicit.");
+                    v->initializer.args_count = 0;
+                }
+                else if (elem_components == 0)
+                {
+                    hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                            "Cannot declare an implicit size array of a size 0 type.");
+                    v->initializer.args_count = 0;
+                }
+                else if (size == 0)
+                {
+                    hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                            "Implicit size arrays need to be initialized.");
+                    v->initializer.args_count = 0;
+                }
+                else if (size % elem_components != 0)
+                {
+                    hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT,
+                            "Cannot initialize implicit size array with %u components, expected a multiple of %u.",
+                            size, elem_components);
+                    v->initializer.args_count = 0;
+                }
+                else
+                {
+                    v->arrays.sizes[i] = size / elem_components;
                 }
-                type = hlsl_new_array_type(ctx, type, v->arrays.sizes[i]);
             }
+            type = hlsl_new_array_type(ctx, type, v->arrays.sizes[i]);
         }
-        vkd3d_free(v->arrays.sizes);
-
-        if (!(var = hlsl_new_var(ctx, v->name, type, &v->loc, &v->semantic, modifiers, &v->reg_reservation)))
-        {
-            free_parse_variable_def(v);
-            continue;
-        }
+    }

-        var->buffer = ctx->cur_buffer;
+    if (!(var_name = vkd3d_strdup(v->name)))
+        return;

-        if (var->buffer == ctx->globals_buffer)
+    new_semantic = v->semantic;
+    if (v->semantic.name)
+    {
+        if (!(new_semantic.name = vkd3d_strdup(v->semantic.name)))
         {
-            if (var->reg_reservation.offset_type)
-                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_RESERVATION,
-                        "packoffset() is only allowed inside constant buffer declarations.");
+            vkd3d_free(var_name);
+            return;
         }
+    }

-        if (ctx->cur_scope == ctx->globals)
-        {
-            local = false;
+    if (!(var = hlsl_new_var(ctx, var_name, type, &v->loc, &new_semantic, modifiers, &v->reg_reservation)))
+    {
+        hlsl_cleanup_semantic(&new_semantic);
+        vkd3d_free(var_name);
+        return;
+    }

-            if ((modifiers & HLSL_STORAGE_UNIFORM) && (modifiers & HLSL_STORAGE_STATIC))
-                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
-                        "Variable '%s' is declared as both "uniform" and "static".", var->name);
+    var->buffer = ctx->cur_buffer;

-            /* Mark it as uniform. We need to do this here since synthetic
-             * variables also get put in the global scope, but shouldn't be
-             * considered uniforms, and we have no way of telling otherwise. */
-            if (!(modifiers & HLSL_STORAGE_STATIC))
-                var->storage_modifiers |= HLSL_STORAGE_UNIFORM;
+    if (var->buffer == ctx->globals_buffer)
+    {
+        if (var->reg_reservation.offset_type)
+            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_RESERVATION,
+                    "packoffset() is only allowed inside constant buffer declarations.");
+    }

-            if (ctx->profile->major_version < 5 && (var->storage_modifiers & HLSL_STORAGE_UNIFORM) &&
-                    type_has_object_components(var->data_type, true))
-            {
-                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                        "Target profile doesn't support objects as struct members in uniform variables.");
-            }
+    if (ctx->cur_scope == ctx->globals)
+    {
+        local = false;

-            if ((func = hlsl_get_func_decl(ctx, var->name)))
-            {
-                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED,
-                        "'%s' is already defined as a function.", var->name);
-                hlsl_note(ctx, &func->loc, VKD3D_SHADER_LOG_ERROR,
-                        "'%s' was previously defined here.", var->name);
-            }
-        }
-        else
-        {
-            static const unsigned int invalid = HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
-                    | HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM;
+        if ((modifiers & HLSL_STORAGE_UNIFORM) && (modifiers & HLSL_STORAGE_STATIC))
+            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
+                    "Variable '%s' is declared as both "uniform" and "static".", var->name);

-            if (modifiers & invalid)
-            {
-                struct vkd3d_string_buffer *string;
+        /* Mark it as uniform. We need to do this here since synthetic
+            * variables also get put in the global scope, but shouldn't be
+            * considered uniforms, and we have no way of telling otherwise. */
+        if (!(modifiers & HLSL_STORAGE_STATIC))
+            var->storage_modifiers |= HLSL_STORAGE_UNIFORM;

-                if ((string = hlsl_modifiers_to_string(ctx, modifiers & invalid)))
-                    hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
-                            "Modifiers '%s' are not allowed on local variables.", string->buffer);
-                hlsl_release_string_buffer(ctx, string);
-            }
-            if (var->semantic.name)
-                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC,
-                        "Semantics are not allowed on local variables.");
+        if (ctx->profile->major_version < 5 && (var->storage_modifiers & HLSL_STORAGE_UNIFORM) &&
+                type_has_object_components(var->data_type, true))
+        {
+            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                    "Target profile doesn't support objects as struct members in uniform variables.");
         }

-        if ((var->storage_modifiers & HLSL_STORAGE_STATIC) && type_has_numeric_components(var->data_type)
-                && type_has_object_components(var->data_type, false))
+        if ((func = hlsl_get_func_decl(ctx, var->name)))
         {
-            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
-                    "Static variables cannot have both numeric and resource components.");
+            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED,
+                    "'%s' is already defined as a function.", var->name);
+            hlsl_note(ctx, &func->loc, VKD3D_SHADER_LOG_ERROR,
+                    "'%s' was previously defined here.", var->name);
         }
+    }
+    else
+    {
+        static const unsigned int invalid = HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
+                | HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM;

-        if ((type->modifiers & HLSL_MODIFIER_CONST) && !v->initializer.args_count
-                && !(modifiers & (HLSL_STORAGE_STATIC | HLSL_STORAGE_UNIFORM)))
+        if (modifiers & invalid)
         {
-            hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_INITIALIZER,
-                    "Const variable "%s" is missing an initializer.", var->name);
-            hlsl_free_var(var);
-            free_parse_initializer(&v->initializer);
-            vkd3d_free(v);
-            continue;
+            struct vkd3d_string_buffer *string;
+
+            if ((string = hlsl_modifiers_to_string(ctx, modifiers & invalid)))
+                hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
+                        "Modifiers '%s' are not allowed on local variables.", string->buffer);
+            hlsl_release_string_buffer(ctx, string);
         }
+        if (var->semantic.name)
+            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC,
+                    "Semantics are not allowed on local variables.");
+    }
+
+    if ((var->storage_modifiers & HLSL_STORAGE_STATIC) && type_has_numeric_components(var->data_type)
+            && type_has_object_components(var->data_type, false))
+    {
+        hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                "Static variables cannot have both numeric and resource components.");
+    }
+
+    if ((type->modifiers & HLSL_MODIFIER_CONST) && !v->initializer.args_count
+            && !(modifiers & (HLSL_STORAGE_STATIC | HLSL_STORAGE_UNIFORM)))
+    {
+        hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_INITIALIZER,
+                "Const variable "%s" is missing an initializer.", var->name);
+        hlsl_free_var(var);
+        return;
+    }
+
+    if (!hlsl_add_var(ctx, var, local))
+    {
+        struct hlsl_ir_var *old = hlsl_get_var(ctx->cur_scope, var->name);
+
+        hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED,
+                "Variable "%s" was already declared in this scope.", var->name);
+        hlsl_note(ctx, &old->loc, VKD3D_SHADER_LOG_ERROR, ""%s" was previously declared here.", old->name);
+        hlsl_free_var(var);
+        return;
+    }
+}
+
+static struct list *initialize_vars(struct hlsl_ctx *ctx, struct list *var_list)
+{
+    struct parse_variable_def *v, *v_next;
+    struct list *statements_list;
+    struct hlsl_ir_var *var;
+    struct hlsl_type *type;

-        if (!hlsl_add_var(ctx, var, local))
+    if (!(statements_list = make_empty_list(ctx)))
+    {
+        LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
         {
-            struct hlsl_ir_var *old = hlsl_get_var(ctx->cur_scope, var->name);
+            free_parse_variable_def(v);
+        }
+        vkd3d_free(var_list);
+        return NULL;
+    }

-            hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED,
-                    "Variable "%s" was already declared in this scope.", var->name);
-            hlsl_note(ctx, &old->loc, VKD3D_SHADER_LOG_ERROR, ""%s" was previously declared here.", old->name);
-            hlsl_free_var(var);
-            free_parse_initializer(&v->initializer);
-            vkd3d_free(v);
+    LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
+    {
+        /* If this fails, the variable failed to be declared. */
+        if (!(var = hlsl_get_var(ctx->cur_scope, v->name)))
+        {
+            free_parse_variable_def(v);
             continue;
         }
+        type = var->data_type;

if (v->initializer.args_count)
         {
@@ -2168,8 +2190,7 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t
                     hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT,
                             "Expected %u components in initializer, but got %u.",
                             hlsl_type_component_count(type), size);
-                    free_parse_initializer(&v->initializer);
-                    vkd3d_free(v);
+                    free_parse_variable_def(v);
                     continue;
                 }

@@ -2188,12 +2209,10 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t
                 add_assignment(ctx, block_to_list(v->initializer.instrs), &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]);
             }

-            if (modifiers & HLSL_STORAGE_STATIC)
+            if (var->storage_modifiers & HLSL_STORAGE_STATIC)
                 hlsl_block_add_block(&ctx->static_initializers, v->initializer.instrs);
             else
                 list_move_tail(statements_list, &v->initializer.instrs->instrs);
-            vkd3d_free(v->initializer.args);
-            vkd3d_free(v->initializer.instrs);
         }
         else if (var->storage_modifiers & HLSL_STORAGE_STATIC)
         {
@@ -2203,32 +2222,33 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t

if (type_has_object_components(var->data_type, false))
             {
-                vkd3d_free(v);
+                free_parse_variable_def(v);
                 continue;
             }

if (!(zero = hlsl_new_uint_constant(ctx, 0, &var->loc)))
             {
-                vkd3d_free(v);
+                free_parse_variable_def(v);
                 continue;
             }
             hlsl_block_add_instr(&ctx->static_initializers, zero);

if (!(cast = add_cast(ctx, &ctx->static_initializers.instrs, zero, var->data_type, &var->loc)))
             {
-                vkd3d_free(v);
+                free_parse_variable_def(v);
                 continue;
             }

if (!(store = hlsl_new_simple_store(ctx, var, cast)))
             {
-                vkd3d_free(v);
+                free_parse_variable_def(v);
                 continue;
             }
             hlsl_block_add_instr(&ctx->static_initializers, store);
         }
-        vkd3d_free(v);
+        free_parse_variable_def(v);
     }
+
     vkd3d_free(var_list);
     return statements_list;
 }
@@ -4619,6 +4639,7 @@ preproc_directive:
 struct_declaration:
       var_modifiers struct_spec variables_def_optional ';'
         {
+            struct parse_variable_def *v, *v_next;
             struct hlsl_type *type;
             unsigned int modifiers = $1;

@@ -4634,7 +4655,24 @@ struct_declaration:

if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
                 YYABORT;
-            $$ = declare_vars(ctx, type, modifiers, &@1, $3);
+
+            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
+
+            if ($3)
+            {
+                LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
+                {
+                    declare_var(ctx, type, modifiers, &@1, v);
+                }
+
+                if (!($$ = initialize_vars(ctx, $3)))
+                    YYABORT;
+            }
+            else
+            {
+                if (!($$ = make_empty_list(ctx)))
+                    YYABORT;
+            }
         }

struct_spec:
@@ -5478,12 +5516,22 @@ type_spec:
 declaration:
       var_modifiers type variables_def ';'
         {
+            struct parse_variable_def *v, *v_next;
             struct hlsl_type *type;
             unsigned int modifiers = $1;

if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
                 YYABORT;
-            $$ = declare_vars(ctx, type, modifiers, &@1, $3);
+
+            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
+
+            LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
+            {
+                declare_var(ctx, type, modifiers, &@1, v);
+            }
+
+            if (!($$ = initialize_vars(ctx, $3)))
+                YYABORT;
         }

variables_def_optional:

[PATCH v4 4/5] vkd3d-shader/hlsl: Declare vars individually when parsing regular declarations.

[Francisco Casas]

From: Francisco Casas

In a declaration with multiple variables, the variables must be created
before the initializer of the next variable is parsed. This is required
for initializers such as:

float a = 1, b = a, c = b + 1;

A requisite for this is that the type information is parsed in the same
rule as the first variable (as a variable_def_typed) so it is
immediately available to declare the first variable. Then, the next
untyped variable declaration is parsed, and the type from the first
variable can be used to declare the second, before the third is parsed,
and so on.
---
 libs/vkd3d-shader/hlsl.y                 | 79 ++++++++++++++++++------
 tests/hlsl/initializer-multi.shader_test |  4 +-
 2 files changed, 62 insertions(+), 21 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 984f38cd..c2c8b3db 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -73,6 +73,10 @@ struct parse_variable_def
     struct hlsl_semantic semantic;
     struct hlsl_reg_reservation reg_reservation;
     struct parse_initializer initializer;
+
+    struct hlsl_type *basic_type;
+    unsigned int modifiers;
+    struct vkd3d_shader_location modifiers_loc;
 };

struct parse_function
@@ -1964,11 +1968,12 @@ static void check_invalid_in_out_modifiers(struct hlsl_ctx *ctx, unsigned int mo
     }
 }

-static void declare_var(struct hlsl_ctx *ctx, struct hlsl_type *basic_type,
-        unsigned int modifiers, const struct vkd3d_shader_location *modifiers_loc, struct parse_variable_def *v)
+static void declare_var(struct hlsl_ctx *ctx, struct parse_variable_def *v)
 {
+    struct hlsl_type *basic_type = v->basic_type;
     struct hlsl_ir_function_decl *func;
     struct hlsl_semantic new_semantic;
+    uint32_t modifiers = v->modifiers;
     bool unbounded_res_array = false;
     struct hlsl_ir_var *var;
     struct hlsl_type *type;
@@ -4506,6 +4511,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type
 %type <list> unary_expr
 %type <list> variables_def
 %type <list> variables_def_optional
+%type <list> variables_def_typed

%token <name> VAR_IDENTIFIER
 %token <name> NEW_IDENTIFIER
@@ -4568,6 +4574,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type
 %type <variable_def> type_spec
 %type <variable_def> variable_decl
 %type <variable_def> variable_def
+%type <variable_def> variable_def_typed

%%

@@ -4662,7 +4669,11 @@ struct_declaration:
             {
                 LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
                 {
-                    declare_var(ctx, type, modifiers, &@1, v);
+                    v->basic_type = type;
+                    v->modifiers = modifiers;
+                    v->modifiers_loc = @1;
+
+                    declare_var(ctx, v);
                 }

if (!($$ = initialize_vars(ctx, $3)))
@@ -5514,23 +5525,9 @@ type_spec:
         }

declaration:
-      var_modifiers type variables_def ';'
+      variables_def_typed ';'
         {
-            struct parse_variable_def *v, *v_next;
-            struct hlsl_type *type;
-            unsigned int modifiers = $1;
-
-            if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
-                YYABORT;
-
-            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
-
-            LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
-            {
-                declare_var(ctx, type, modifiers, &@1, v);
-            }
-
-            if (!($$ = initialize_vars(ctx, $3)))
+            if (!($$ = initialize_vars(ctx, $1)))
                 YYABORT;
         }

@@ -5554,6 +5551,33 @@ variables_def:
             list_add_tail($$, &$3->entry);
         }

+variables_def_typed:
+      variable_def_typed
+        {
+            if (!($$ = make_empty_list(ctx)))
+                YYABORT;
+            list_add_head($$, &$1->entry);
+
+            declare_var(ctx, $1);
+        }
+    | variables_def_typed ',' variable_def
+        {
+            struct parse_variable_def *head_def;
+
+            assert(!list_empty($1));
+            head_def = LIST_ENTRY(list_head($1), struct parse_variable_def, entry);
+
+            assert(head_def->basic_type);
+            $3->basic_type = head_def->basic_type;
+            $3->modifiers = head_def->modifiers;
+            $3->modifiers_loc = head_def->modifiers_loc;
+
+            declare_var(ctx, $3);
+
+            $$ = $1;
+            list_add_tail($$, &$3->entry);
+        }
+
 variable_decl:
       any_identifier arrays colon_attribute
         {
@@ -5595,6 +5619,23 @@ variable_def:
             ctx->in_state_block = 0;
         }

+variable_def_typed:
+      var_modifiers type variable_def
+        {
+            unsigned int modifiers = $1;
+            struct hlsl_type *type;
+
+            if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
+                YYABORT;
+
+            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
+
+            $$ = $3;
+            $$->basic_type = type;
+            $$->modifiers = modifiers;
+            $$->modifiers_loc = @1;
+        }
+
 arrays:
       %empty
         {
diff --git a/tests/hlsl/initializer-multi.shader_test b/tests/hlsl/initializer-multi.shader_test
index 9c45a533..73dd9f2f 100644
--- a/tests/hlsl/initializer-multi.shader_test
+++ b/tests/hlsl/initializer-multi.shader_test
@@ -1,4 +1,4 @@
-[pixel shader todo]
+[pixel shader]
 float4 main() : sv_target
 {
     float a = 2.0, b = a + 1.0, c = b;
@@ -7,7 +7,7 @@ float4 main() : sv_target
 }

[test]
-todo draw quad
+draw quad
 probe all rgba (2, 3, 3, 0)

[PATCH v4 5/5] vkd3d-shader/hlsl: Declare vars individually when parsing struct declarations.

[Francisco Casas]

From: Francisco Casas

A struct declaration with variables is now absorbed into the 'declaration'
rule, like any other variable declaration.

A struct declaration without variables is now reduced to the
'struct_declaration_without_vars' rule.

They both are reduced to a 'declaration_statement' in the end.
---
 libs/vkd3d-shader/hlsl.y                 | 75 +++++++++---------------
 tests/hlsl/initializer-multi.shader_test |  8 +--
 2 files changed, 31 insertions(+), 52 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index c2c8b3db..ea81ee9f 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -4506,11 +4506,10 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type
 %type <list> shift_expr
 %type <list> statement
 %type <list> statement_list
-%type <list> struct_declaration
+%type <list> struct_declaration_without_vars
 %type <list> type_specs
 %type <list> unary_expr
 %type <list> variables_def
-%type <list> variables_def_optional
 %type <list> variables_def_typed

%token <name> VAR_IDENTIFIER
@@ -4643,47 +4642,19 @@ preproc_directive:
             }
         }

-struct_declaration:
-      var_modifiers struct_spec variables_def_optional ';'
+struct_declaration_without_vars:
+      var_modifiers struct_spec ';'
         {
-            struct parse_variable_def *v, *v_next;
-            struct hlsl_type *type;
-            unsigned int modifiers = $1;
+            if (!$2->name)
+                hlsl_error(ctx, &@2, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX,
+                    "Anonymous struct type must declare a variable.");

-            if (!$3)
-            {
-                if (!$2->name)
-                    hlsl_error(ctx, &@2, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX,
-                            "Anonymous struct type must declare a variable.");
-                if (modifiers)
-                    hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
-                            "Modifiers are not allowed on struct type declarations.");
-            }
+            if ($1)
+                hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
+                        "Modifiers are not allowed on struct type declarations.");

-            if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
+            if (!($$ = make_empty_list(ctx)))
                 YYABORT;
-
-            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
-
-            if ($3)
-            {
-                LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
-                {
-                    v->basic_type = type;
-                    v->modifiers = modifiers;
-                    v->modifiers_loc = @1;
-
-                    declare_var(ctx, v);
-                }
-
-                if (!($$ = initialize_vars(ctx, $3)))
-                    YYABORT;
-            }
-            else
-            {
-                if (!($$ = make_empty_list(ctx)))
-                    YYABORT;
-            }
         }

struct_spec:
@@ -5463,7 +5434,7 @@ type:

declaration_statement:
       declaration
-    | struct_declaration
+    | struct_declaration_without_vars
     | typedef
         {
             if (!($$ = make_empty_list(ctx)))
@@ -5531,13 +5502,6 @@ declaration:
                 YYABORT;
         }

-variables_def_optional:
-      %empty
-        {
-            $$ = NULL;
-        }
-    | variables_def
-
 variables_def:
       variable_def
         {
@@ -5620,7 +5584,22 @@ variable_def:
         }

variable_def_typed:
-      var_modifiers type variable_def
+      var_modifiers struct_spec variable_def
+        {
+            unsigned int modifiers = $1;
+            struct hlsl_type *type;
+
+            if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1)))
+                YYABORT;
+
+            check_invalid_in_out_modifiers(ctx, modifiers, &@1);
+
+            $$ = $3;
+            $$->basic_type = type;
+            $$->modifiers = modifiers;
+            $$->modifiers_loc = @1;
+        }
+    | var_modifiers type variable_def
         {
             unsigned int modifiers = $1;
             struct hlsl_type *type;
diff --git a/tests/hlsl/initializer-multi.shader_test b/tests/hlsl/initializer-multi.shader_test
index 73dd9f2f..8f8a31e2 100644
--- a/tests/hlsl/initializer-multi.shader_test
+++ b/tests/hlsl/initializer-multi.shader_test
@@ -20,7 +20,7 @@ float4 main() : sv_target
 }

-[pixel shader todo]
+[pixel shader]
 float4 main() : sv_target
 {
     struct apple {
@@ -32,11 +32,11 @@ float4 main() : sv_target
 }

[test]
-todo draw quad
+draw quad
 probe all rgba (7.2, 8.0, 7.2, 8.0)

-[pixel shader todo]
+[pixel shader]
 float4 main() : sv_target
 {
     struct apple {
@@ -48,5 +48,5 @@ float4 main() : sv_target
 }

[test]
-todo draw quad
+draw quad
 probe all rgba (5.2, 9.0, 5.2, 9.0)

[Francisco Casas (＠fcasas)]

:arrow_up: Rebased on top of current master branch.

[PATCH v4 0/5] MR250: vkd3d-shader/hlsl: Declare vars individually when parsing declarations. - approved

[Zebediah Figura (＠zfigura)]

This merge request was approved by Zebediah Figura.

[PATCH v4 0/5] MR250: vkd3d-shader/hlsl: Declare vars individually when parsing declarations. - approved

[Henri Verbeet (＠hverbeet)]

This merge request was approved by Henri Verbeet.