[PATCH v3 0/7] MR153: hlsl: Return hlsl_ir_node pointers from instruction constructors, part 1.

[Zebediah Figura (＠zfigura)]

The motivation for this is twofold.

Firstly, this makes code a little nicer to read, by virtue of removing a
ubiquitous &(...)->node.

Secondly, and more importantly, this allows for the possibility of constructors
returning a different instruction type than intended. The ultimate goal here is
to return a preallocated "error" instruction when allocation fails, instead of
returning NULL and propagating out-of-memory handling to the caller.

--
  v3: vkd3d-shader/hlsl: Return an hlsl_ir_node pointer from hlsl_new_if().
      vkd3d-shader/hlsl: Pass hlsl_block pointers to hlsl_new_if().
      vkd3d-shader/hlsl: Initialize the block in clone_block().
      vkd3d-shader/hlsl: Introduce a hlsl_block_cleanup() helper.
 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153

[PATCH v3 1/7] vkd3d-shader/hlsl: Return an hlsl_ir_node pointer from hlsl_new_bool_constant().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         | 10 +++++-----
 libs/vkd3d-shader/hlsl.h         |  2 +-
 libs/vkd3d-shader/hlsl.y         |  6 +++---
 libs/vkd3d-shader/hlsl_codegen.c |  8 ++++----
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 869638a6..2ec04ef4 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -1128,14 +1128,14 @@ struct hlsl_ir_constant *hlsl_new_constant(struct hlsl_ctx *ctx, struct hlsl_typ
     return c;
 }
 
-struct hlsl_ir_constant *hlsl_new_bool_constant(struct hlsl_ctx *ctx, bool b, const struct vkd3d_shader_location *loc)
+struct hlsl_ir_node *hlsl_new_bool_constant(struct hlsl_ctx *ctx, bool b, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_constant *c;
 
     if ((c = hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_BOOL), loc)))
         c->value[0].u = b ? ~0u : 0;
 
-    return c;
+    return &c->node;
 }
 
 struct hlsl_ir_constant *hlsl_new_float_constant(struct hlsl_ctx *ctx, float f,
@@ -1711,7 +1711,7 @@ struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx,
         const struct hlsl_semantic *semantic, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_function_decl *decl;
-    struct hlsl_ir_constant *constant;
+    struct hlsl_ir_node *constant;
     struct hlsl_ir_store *store;
 
     if (!(decl = hlsl_alloc(ctx, sizeof(*decl))))
@@ -1737,9 +1737,9 @@ struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx,
 
     if (!(constant = hlsl_new_bool_constant(ctx, false, loc)))
         return decl;
-    hlsl_block_add_instr(&decl->body, &constant->node);
+    hlsl_block_add_instr(&decl->body, constant);
 
-    if (!(store = hlsl_new_simple_store(ctx, decl->early_return_var, &constant->node)))
+    if (!(store = hlsl_new_simple_store(ctx, decl->early_return_var, constant)))
         return decl;
     hlsl_block_add_instr(&decl->body, &store->node);
 
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index b38fba1c..68f27abc 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -1048,7 +1048,7 @@ const char *hlsl_jump_type_to_string(enum hlsl_ir_jump_type type);
 struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, unsigned int array_size);
 struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1,
         struct hlsl_ir_node *arg2);
-struct hlsl_ir_constant *hlsl_new_bool_constant(struct hlsl_ctx *ctx, bool b, const struct vkd3d_shader_location *loc);
+struct hlsl_ir_node *hlsl_new_bool_constant(struct hlsl_ctx *ctx, bool b, const struct vkd3d_shader_location *loc);
 struct hlsl_buffer *hlsl_new_buffer(struct hlsl_ctx *ctx, enum hlsl_buffer_type type, const char *name,
         const struct hlsl_reg_reservation *reservation, struct vkd3d_shader_location loc);
 struct hlsl_ir_node *hlsl_new_call(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *decl,
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 0ddae6ee..ad0a784c 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -5350,13 +5350,13 @@ primary_expr:
         }
     | boolean
         {
-            struct hlsl_ir_constant *c;
+            struct hlsl_ir_node *c;
 
             if (!(c = hlsl_new_bool_constant(ctx, $1, &@1)))
                 YYABORT;
-            if (!($$ = make_list(ctx, &c->node)))
+            if (!($$ = make_list(ctx, c)))
             {
-                hlsl_free_instr(&c->node);
+                hlsl_free_instr(c);
                 YYABORT;
             }
         }
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index c8130a3f..eebc69a3 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -628,18 +628,18 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
         else if (instr->type == HLSL_IR_JUMP)
         {
             struct hlsl_ir_jump *jump = hlsl_ir_jump(instr);
-            struct hlsl_ir_constant *constant;
+            struct hlsl_ir_node *constant;
             struct hlsl_ir_store *store;
 
             if (jump->type == HLSL_IR_JUMP_RETURN)
             {
                 if (!(constant = hlsl_new_bool_constant(ctx, true, &jump->node.loc)))
                     return false;
-                list_add_before(&jump->node.entry, &constant->node.entry);
+                list_add_before(&jump->node.entry, &constant->entry);
 
-                if (!(store = hlsl_new_simple_store(ctx, func->early_return_var, &constant->node)))
+                if (!(store = hlsl_new_simple_store(ctx, func->early_return_var, constant)))
                     return false;
-                list_add_after(&constant->node.entry, &store->node.entry);
+                list_add_after(&constant->entry, &store->node.entry);
 
                 has_early_return = true;
                 if (in_loop)
-- 
GitLab


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

[PATCH v3 2/7] vkd3d-shader/hlsl: Return an hlsl_ir_node pointer from hlsl_new_cast() and hlsl_new_copy().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         |  6 ++--
 libs/vkd3d-shader/hlsl.h         |  4 +--
 libs/vkd3d-shader/hlsl.y         | 29 ++++++++++----------
 libs/vkd3d-shader/hlsl_codegen.c | 47 +++++++++++++++-----------------
 4 files changed, 41 insertions(+), 45 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 2ec04ef4..412bc738 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -916,7 +916,7 @@ bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type)
     return true;
 }
 
-struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
+struct hlsl_ir_node *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
         const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_node *cast;
@@ -924,10 +924,10 @@ struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *no
     cast = hlsl_new_unary_expr(ctx, HLSL_OP1_CAST, node, *loc);
     if (cast)
         cast->data_type = type;
-    return hlsl_ir_expr(cast);
+    return cast;
 }
 
-struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node)
+struct hlsl_ir_node *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node)
 {
     /* Use a cast to the same type as a makeshift identity expression. */
     return hlsl_new_cast(ctx, node, node->data_type, &node->loc);
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 68f27abc..ebccfd58 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -1053,11 +1053,11 @@ struct hlsl_buffer *hlsl_new_buffer(struct hlsl_ctx *ctx, enum hlsl_buffer_type
         const struct hlsl_reg_reservation *reservation, struct vkd3d_shader_location loc);
 struct hlsl_ir_node *hlsl_new_call(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *decl,
         const struct vkd3d_shader_location *loc);
-struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
+struct hlsl_ir_node *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
         const struct vkd3d_shader_location *loc);
 struct hlsl_ir_constant *hlsl_new_constant(struct hlsl_ctx *ctx, struct hlsl_type *type,
         const struct vkd3d_shader_location *loc);
-struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node);
+struct hlsl_ir_node *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node);
 struct hlsl_ir_node *hlsl_new_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op,
         struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS],
         struct hlsl_type *data_type, const struct vkd3d_shader_location *loc);
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index ad0a784c..261b28f5 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -280,7 +280,7 @@ static struct hlsl_ir_node *add_cast(struct hlsl_ctx *ctx, struct list *instrs,
         struct hlsl_ir_node *node, struct hlsl_type *dst_type, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_type *src_type = node->data_type;
-    struct hlsl_ir_expr *cast;
+    struct hlsl_ir_node *cast;
 
     if (hlsl_types_are_equal(src_type, dst_type))
         return node;
@@ -338,9 +338,9 @@ static struct hlsl_ir_node *add_cast(struct hlsl_ctx *ctx, struct list *instrs,
 
             if (!(cast = hlsl_new_cast(ctx, &load->node, dst_comp_type, loc)))
                 return NULL;
-            list_add_tail(instrs, &cast->node.entry);
+            list_add_tail(instrs, &cast->entry);
 
-            if (!(store = hlsl_new_store_component(ctx, &block, &var_deref, dst_idx, &cast->node)))
+            if (!(store = hlsl_new_store_component(ctx, &block, &var_deref, dst_idx, cast)))
                 return NULL;
             list_move_tail(instrs, &block.instrs);
         }
@@ -355,8 +355,8 @@ static struct hlsl_ir_node *add_cast(struct hlsl_ctx *ctx, struct list *instrs,
     {
         if (!(cast = hlsl_new_cast(ctx, node, dst_type, loc)))
             return NULL;
-        list_add_tail(instrs, &cast->node.entry);
-        return &cast->node;
+        list_add_tail(instrs, &cast->entry);
+        return cast;
     }
 }
 
@@ -705,8 +705,7 @@ static bool add_array_access(struct hlsl_ctx *ctx, struct list *instrs, struct h
         struct hlsl_ir_node *index, const struct vkd3d_shader_location *loc)
 {
     const struct hlsl_type *expr_type = array->data_type, *index_type = index->data_type;
-    struct hlsl_ir_node *return_index;
-    struct hlsl_ir_expr *cast;
+    struct hlsl_ir_node *return_index, *cast;
 
     if (expr_type->class == HLSL_CLASS_OBJECT
             && (expr_type->base_type == HLSL_TYPE_TEXTURE || expr_type->base_type == HLSL_TYPE_UAV)
@@ -752,8 +751,8 @@ static bool add_array_access(struct hlsl_ctx *ctx, struct list *instrs, struct h
 
     if (!(cast = hlsl_new_cast(ctx, index, hlsl_get_scalar_type(ctx, HLSL_TYPE_UINT), &index->loc)))
         return false;
-    list_add_tail(instrs, &cast->node.entry);
-    index = &cast->node;
+    list_add_tail(instrs, &cast->entry);
+    index = cast;
 
     if (expr_type->class != HLSL_CLASS_ARRAY && expr_type->class != HLSL_CLASS_VECTOR && expr_type->class != HLSL_CLASS_MATRIX)
     {
@@ -1670,7 +1669,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in
         enum parse_assign_op assign_op, struct hlsl_ir_node *rhs)
 {
     struct hlsl_type *lhs_type = lhs->data_type;
-    struct hlsl_ir_expr *copy;
+    struct hlsl_ir_node *copy;
     unsigned int writemask = 0;
 
     if (assign_op == ASSIGN_OP_SUB)
@@ -1829,8 +1828,8 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in
      * the last instruction in the list, we do need to copy. */
     if (!(copy = hlsl_new_copy(ctx, rhs)))
         return NULL;
-    list_add_tail(instrs, ©->node.entry);
-    return ©->node;
+    list_add_tail(instrs, ©->entry);
+    return copy;
 }
 
 static bool add_increment(struct hlsl_ctx *ctx, struct list *instrs, bool decrement, bool post,
@@ -1852,14 +1851,14 @@ static bool add_increment(struct hlsl_ctx *ctx, struct list *instrs, bool decrem
 
     if (post)
     {
-        struct hlsl_ir_expr *copy;
+        struct hlsl_ir_node *copy;
 
         if (!(copy = hlsl_new_copy(ctx, lhs)))
             return false;
-        list_add_tail(instrs, ©->node.entry);
+        list_add_tail(instrs, ©->entry);
 
         /* Post increment/decrement expressions are considered const. */
-        if (!(copy->node.data_type = hlsl_type_clone(ctx, copy->node.data_type, 0, HLSL_MODIFIER_CONST)))
+        if (!(copy->data_type = hlsl_type_clone(ctx, copy->data_type, 0, HLSL_MODIFIER_CONST)))
             return false;
     }
 
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index eebc69a3..1d628047 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -823,23 +823,22 @@ static bool lower_broadcasts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, v
 
     if (src_type->class <= HLSL_CLASS_VECTOR && dst_type->class <= HLSL_CLASS_VECTOR && src_type->dimx == 1)
     {
-        struct hlsl_ir_node *replacement;
+        struct hlsl_ir_node *replacement, *new_cast;
         struct hlsl_ir_swizzle *swizzle;
-        struct hlsl_ir_expr *new_cast;
 
         dst_scalar_type = hlsl_get_scalar_type(ctx, dst_type->base_type);
         /* We need to preserve the cast since it might be doing more than just
          * turning the scalar into a vector. */
         if (!(new_cast = hlsl_new_cast(ctx, cast->operands[0].node, dst_scalar_type, &cast->node.loc)))
             return false;
-        list_add_after(&cast->node.entry, &new_cast->node.entry);
-        replacement = &new_cast->node;
+        list_add_after(&cast->node.entry, &new_cast->entry);
+        replacement = new_cast;
 
         if (dst_type->dimx != 1)
         {
             if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, X, X, X), dst_type->dimx, replacement, &cast->node.loc)))
                 return false;
-            list_add_after(&new_cast->node.entry, &swizzle->node.entry);
+            list_add_after(&new_cast->entry, &swizzle->node.entry);
             replacement = &swizzle->node;
         }
 
@@ -1727,17 +1726,17 @@ static bool lower_narrowing_casts(struct hlsl_ctx *ctx, struct hlsl_ir_node *ins
     if (src_type->class <= HLSL_CLASS_VECTOR && dst_type->class <= HLSL_CLASS_VECTOR && dst_type->dimx < src_type->dimx)
     {
         struct hlsl_ir_swizzle *swizzle;
-        struct hlsl_ir_expr *new_cast;
+        struct hlsl_ir_node *new_cast;
 
         dst_vector_type = hlsl_get_vector_type(ctx, dst_type->base_type, src_type->dimx);
         /* We need to preserve the cast since it might be doing more than just
          * narrowing the vector. */
         if (!(new_cast = hlsl_new_cast(ctx, cast->operands[0].node, dst_vector_type, &cast->node.loc)))
             return false;
-        list_add_after(&cast->node.entry, &new_cast->node.entry);
-        if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, Y, Z, W), dst_type->dimx, &new_cast->node, &cast->node.loc)))
+        list_add_after(&cast->node.entry, &new_cast->entry);
+        if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, Y, Z, W), dst_type->dimx, new_cast, &cast->node.loc)))
             return false;
-        list_add_after(&new_cast->node.entry, &swizzle->node.entry);
+        list_add_after(&new_cast->entry, &swizzle->node.entry);
 
         hlsl_replace_node(&cast->node, &swizzle->node);
         return true;
@@ -2033,9 +2032,8 @@ struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *ins
 
 static bool lower_int_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context)
 {
-    struct hlsl_ir_node *arg1, *arg2, *xor, *and, *abs1, *abs2, *div, *neg;
+    struct hlsl_ir_node *arg1, *arg2, *xor, *and, *abs1, *abs2, *div, *neg, *cast1, *cast2, *cast3;
     struct hlsl_type *type = instr->data_type, *utype;
-    struct hlsl_ir_expr *cast1, *cast2, *cast3;
     struct hlsl_ir_constant *high_bit;
     struct hlsl_ir_expr *expr;
     struct hlsl_ir_load *cond;
@@ -2074,7 +2072,7 @@ static bool lower_int_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
 
     if (!(cast1 = hlsl_new_cast(ctx, abs1, utype, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast1->node.entry);
+    list_add_before(&instr->entry, &cast1->entry);
 
     if (!(abs2 = hlsl_new_unary_expr(ctx, HLSL_OP1_ABS, arg2, instr->loc)))
         return false;
@@ -2082,21 +2080,21 @@ static bool lower_int_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
 
     if (!(cast2 = hlsl_new_cast(ctx, abs2, utype, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast2->node.entry);
+    list_add_before(&instr->entry, &cast2->entry);
 
-    if (!(div = hlsl_new_binary_expr(ctx, HLSL_OP2_DIV, &cast1->node, &cast2->node)))
+    if (!(div = hlsl_new_binary_expr(ctx, HLSL_OP2_DIV, cast1, cast2)))
         return false;
     list_add_before(&instr->entry, &div->entry);
 
     if (!(cast3 = hlsl_new_cast(ctx, div, type, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast3->node.entry);
+    list_add_before(&instr->entry, &cast3->entry);
 
-    if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, &cast3->node, instr->loc)))
+    if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, cast3, instr->loc)))
         return false;
     list_add_before(&instr->entry, &neg->entry);
 
-    if (!(cond = hlsl_add_conditional(ctx, &instr->entry, and, neg, &cast3->node)))
+    if (!(cond = hlsl_add_conditional(ctx, &instr->entry, and, neg, cast3)))
         return false;
     hlsl_replace_node(instr, &cond->node);
 
@@ -2105,9 +2103,8 @@ static bool lower_int_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
 
 static bool lower_int_modulus(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context)
 {
-    struct hlsl_ir_node *arg1, *arg2, *and, *abs1, *abs2, *div, *neg;
+    struct hlsl_ir_node *arg1, *arg2, *and, *abs1, *abs2, *div, *neg, *cast1, *cast2, *cast3;
     struct hlsl_type *type = instr->data_type, *utype;
-    struct hlsl_ir_expr *cast1, *cast2, *cast3;
     struct hlsl_ir_constant *high_bit;
     struct hlsl_ir_expr *expr;
     struct hlsl_ir_load *cond;
@@ -2142,7 +2139,7 @@ static bool lower_int_modulus(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
 
     if (!(cast1 = hlsl_new_cast(ctx, abs1, utype, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast1->node.entry);
+    list_add_before(&instr->entry, &cast1->entry);
 
     if (!(abs2 = hlsl_new_unary_expr(ctx, HLSL_OP1_ABS, arg2, instr->loc)))
         return false;
@@ -2150,21 +2147,21 @@ static bool lower_int_modulus(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
 
     if (!(cast2 = hlsl_new_cast(ctx, abs2, utype, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast2->node.entry);
+    list_add_before(&instr->entry, &cast2->entry);
 
-    if (!(div = hlsl_new_binary_expr(ctx, HLSL_OP2_MOD, &cast1->node, &cast2->node)))
+    if (!(div = hlsl_new_binary_expr(ctx, HLSL_OP2_MOD, cast1, cast2)))
         return false;
     list_add_before(&instr->entry, &div->entry);
 
     if (!(cast3 = hlsl_new_cast(ctx, div, type, &instr->loc)))
         return false;
-    list_add_before(&instr->entry, &cast3->node.entry);
+    list_add_before(&instr->entry, &cast3->entry);
 
-    if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, &cast3->node, instr->loc)))
+    if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, cast3, instr->loc)))
         return false;
     list_add_before(&instr->entry, &neg->entry);
 
-    if (!(cond = hlsl_add_conditional(ctx, &instr->entry, and, neg, &cast3->node)))
+    if (!(cond = hlsl_add_conditional(ctx, &instr->entry, and, neg, cast3)))
         return false;
     hlsl_replace_node(instr, &cond->node);
 
-- 
GitLab


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

[PATCH v3 3/7] vkd3d-shader/hlsl: Return an hlsl_ir_node pointer from hlsl_new_float_constant().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         |  4 +-
 libs/vkd3d-shader/hlsl.h         |  2 +-
 libs/vkd3d-shader/hlsl.y         | 64 ++++++++++++++------------------
 libs/vkd3d-shader/hlsl_codegen.c |  7 ++--
 4 files changed, 34 insertions(+), 43 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 412bc738..449a22e4 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -1138,7 +1138,7 @@ struct hlsl_ir_node *hlsl_new_bool_constant(struct hlsl_ctx *ctx, bool b, const
     return &c->node;
 }
 
-struct hlsl_ir_constant *hlsl_new_float_constant(struct hlsl_ctx *ctx, float f,
+struct hlsl_ir_node *hlsl_new_float_constant(struct hlsl_ctx *ctx, float f,
         const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_constant *c;
@@ -1146,7 +1146,7 @@ struct hlsl_ir_constant *hlsl_new_float_constant(struct hlsl_ctx *ctx, float f,
     if ((c = hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_FLOAT), loc)))
         c->value[0].f = f;
 
-    return c;
+    return &c->node;
 }
 
 struct hlsl_ir_constant *hlsl_new_int_constant(struct hlsl_ctx *ctx, int n,
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index ebccfd58..cabbf1de 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -1061,7 +1061,7 @@ struct hlsl_ir_node *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *no
 struct hlsl_ir_node *hlsl_new_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op,
         struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS],
         struct hlsl_type *data_type, const struct vkd3d_shader_location *loc);
-struct hlsl_ir_constant *hlsl_new_float_constant(struct hlsl_ctx *ctx,
+struct hlsl_ir_node *hlsl_new_float_constant(struct hlsl_ctx *ctx,
         float f, const struct vkd3d_shader_location *loc);
 struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx,
         struct hlsl_type *return_type, const struct hlsl_func_parameters *parameters,
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 261b28f5..719dfc62 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -2405,20 +2405,19 @@ static bool intrinsic_abs(struct hlsl_ctx *ctx,
 static bool intrinsic_all(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
-    struct hlsl_ir_node *arg = params->args[0], *mul;
-    struct hlsl_ir_constant *one, *zero;
+    struct hlsl_ir_node *arg = params->args[0], *mul, *one, *zero;
     struct hlsl_ir_load *load;
     unsigned int i, count;
 
     if (!(one = hlsl_new_float_constant(ctx, 1.0f, loc)))
         return false;
-    list_add_tail(params->instrs, &one->node.entry);
+    list_add_tail(params->instrs, &one->entry);
 
     if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc)))
         return false;
-    list_add_tail(params->instrs, &zero->node.entry);
+    list_add_tail(params->instrs, &zero->entry);
 
-    mul = &one->node;
+    mul = one;
 
     count = hlsl_type_component_count(arg->data_type);
     for (i = 0; i < count; ++i)
@@ -2430,7 +2429,7 @@ static bool intrinsic_all(struct hlsl_ctx *ctx,
             return false;
     }
 
-    return !!add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_NEQUAL, mul, &zero->node, loc);
+    return !!add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_NEQUAL, mul, zero, loc);
 }
 
 /* Find the type corresponding to the given source type, with the same
@@ -2587,8 +2586,7 @@ static bool intrinsic_dot(struct hlsl_ctx *ctx,
 static bool intrinsic_exp(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
-    struct hlsl_ir_constant *coeff;
-    struct hlsl_ir_node *arg, *mul;
+    struct hlsl_ir_node *arg, *mul, *coeff;
 
     if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc)))
         return false;
@@ -2596,9 +2594,9 @@ static bool intrinsic_exp(struct hlsl_ctx *ctx,
     /* 1/ln(2) */
     if (!(coeff = hlsl_new_float_constant(ctx, 1.442695f, loc)))
         return false;
-    list_add_tail(params->instrs, &coeff->node.entry);
+    list_add_tail(params->instrs, &coeff->entry);
 
-    if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, &coeff->node, params->args[0], loc)))
+    if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, coeff, params->args[0], loc)))
         return false;
 
     return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_EXP2, mul, loc);
@@ -2715,9 +2713,8 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_node *n_l_neg, *n_h_neg, *specular_or, *specular_pow;
-    struct hlsl_ir_constant *init, *zero;
-    struct hlsl_ir_node *n_l, *n_h, *m;
-    struct hlsl_ir_node *diffuse;
+    struct hlsl_ir_node *n_l, *n_h, *m, *diffuse, *zero;
+    struct hlsl_ir_constant *init;
     struct hlsl_ir_store *store;
     struct hlsl_deref var_deref;
     struct hlsl_type *ret_type;
@@ -2762,10 +2759,10 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
 
     if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc)))
         return false;
-    list_add_tail(params->instrs, &zero->node.entry);
+    list_add_tail(params->instrs, &zero->entry);
 
     /* Diffuse component. */
-    if (!(diffuse = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MAX, n_l, &zero->node, loc)))
+    if (!(diffuse = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MAX, n_l, zero, loc)))
         return false;
 
     if (!(store = hlsl_new_store_component(ctx, &block, &var_deref, 1, diffuse)))
@@ -2773,12 +2770,10 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
     list_move_tail(params->instrs, &block.instrs);
 
     /* Specular component. */
-    if (!(n_h_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS,
-            n_h, &zero->node, loc)))
+    if (!(n_h_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, n_h, zero, loc)))
         return false;
 
-    if (!(n_l_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS,
-            n_l, &zero->node, loc)))
+    if (!(n_l_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, n_l, zero, loc)))
         return false;
 
     if (!(specular_or = add_binary_logical_expr(ctx, params->instrs, HLSL_OP2_LOGIC_OR, n_l_neg, n_h_neg, loc)))
@@ -2787,7 +2782,7 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
     if (!(specular_pow = add_pow_expr(ctx, params->instrs, n_h, m, loc)))
         return false;
 
-    if (!(load = hlsl_add_conditional(ctx, params->instrs, specular_or, &zero->node, specular_pow)))
+    if (!(load = hlsl_add_conditional(ctx, params->instrs, specular_or, zero, specular_pow)))
         return false;
 
     if (!(store = hlsl_new_store_component(ctx, &block, &var_deref, 2, &load->node)))
@@ -2804,8 +2799,7 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
 static bool intrinsic_log(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
-    struct hlsl_ir_constant *coeff;
-    struct hlsl_ir_node *log, *arg;
+    struct hlsl_ir_node *log, *arg, *coeff;
 
     if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc)))
         return false;
@@ -2817,14 +2811,13 @@ static bool intrinsic_log(struct hlsl_ctx *ctx,
     if (!(coeff = hlsl_new_float_constant(ctx, 0.69314718055f, loc)))
         return false;
 
-    return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, &coeff->node, loc);
+    return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, coeff, loc);
 }
 
 static bool intrinsic_log10(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
-    struct hlsl_ir_constant *coeff;
-    struct hlsl_ir_node *log, *arg;
+    struct hlsl_ir_node *log, *arg, *coeff;
 
     if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc)))
         return false;
@@ -2836,7 +2829,7 @@ static bool intrinsic_log10(struct hlsl_ctx *ctx,
     if (!(coeff = hlsl_new_float_constant(ctx, 0.301029996f, loc)))
         return false;
 
-    return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, &coeff->node, loc);
+    return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, coeff, loc);
 }
 
 static bool intrinsic_log2(struct hlsl_ctx *ctx,
@@ -3072,8 +3065,7 @@ static bool intrinsic_sin(struct hlsl_ctx *ctx,
 static bool intrinsic_smoothstep(struct hlsl_ctx *ctx,
         const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
-    struct hlsl_ir_node *min_arg, *max_arg, *x_arg, *p, *p_num, *p_denom, *res;
-    struct hlsl_ir_constant *one, *minus_two, *three;
+    struct hlsl_ir_node *min_arg, *max_arg, *x_arg, *p, *p_num, *p_denom, *res, *one, *minus_two, *three;
 
     if (!elementwise_intrinsic_float_convert_args(ctx, params, loc))
         return false;
@@ -3093,9 +3085,9 @@ static bool intrinsic_smoothstep(struct hlsl_ctx *ctx,
 
     if (!(one = hlsl_new_float_constant(ctx, 1.0, loc)))
         return false;
-    list_add_tail(params->instrs, &one->node.entry);
+    list_add_tail(params->instrs, &one->entry);
 
-    if (!(p_denom = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, &one->node, p_denom, loc)))
+    if (!(p_denom = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, one, p_denom, loc)))
         return false;
 
     if (!(p = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, p_num, p_denom, loc)))
@@ -3106,16 +3098,16 @@ static bool intrinsic_smoothstep(struct hlsl_ctx *ctx,
 
     if (!(minus_two = hlsl_new_float_constant(ctx, -2.0, loc)))
         return false;
-    list_add_tail(params->instrs, &minus_two->node.entry);
+    list_add_tail(params->instrs, &minus_two->entry);
 
     if (!(three = hlsl_new_float_constant(ctx, 3.0, loc)))
         return false;
-    list_add_tail(params->instrs, &three->node.entry);
+    list_add_tail(params->instrs, &three->entry);
 
-    if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, &minus_two->node, p, loc)))
+    if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, minus_two, p, loc)))
         return false;
 
-    if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_ADD, &three->node, res, loc)))
+    if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_ADD, three, res, loc)))
         return false;
 
     if (!(p = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, p, p, loc)))
@@ -5331,11 +5323,11 @@ func_arguments:
 primary_expr:
       C_FLOAT
         {
-            struct hlsl_ir_constant *c;
+            struct hlsl_ir_node *c;
 
             if (!(c = hlsl_new_float_constant(ctx, $1, &@1)))
                 YYABORT;
-            if (!($$ = make_list(ctx, &c->node)))
+            if (!($$ = make_list(ctx, c)))
                 YYABORT;
         }
     | C_INTEGER
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 1d628047..3fd5c968 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1844,9 +1844,8 @@ static bool lower_sqrt(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *c
 /* Lower DP2 to MUL + ADD */
 static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context)
 {
-    struct hlsl_ir_node *arg1, *arg2, *mul, *replacement;
+    struct hlsl_ir_node *arg1, *arg2, *mul, *replacement, *zero;
     struct hlsl_ir_swizzle *add_x, *add_y;
-    struct hlsl_ir_constant *zero;
     struct hlsl_ir_expr *expr;
 
     if (instr->type != HLSL_IR_EXPR)
@@ -1865,11 +1864,11 @@ static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *co
 
         if (!(zero = hlsl_new_float_constant(ctx, 0.0f, &expr->node.loc)))
             return false;
-        list_add_before(&instr->entry, &zero->node.entry);
+        list_add_before(&instr->entry, &zero->entry);
 
         operands[0] = arg1;
         operands[1] = arg2;
-        operands[2] = &zero->node;
+        operands[2] = zero;
 
         if (!(replacement = hlsl_new_expr(ctx, HLSL_OP3_DP2ADD, operands, instr->data_type, &expr->node.loc)))
             return false;
-- 
GitLab


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

[PATCH v3 4/7] vkd3d-shader/hlsl: Introduce a hlsl_block_cleanup() helper.

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c | 19 ++++++++++++-------
 libs/vkd3d-shader/hlsl.h |  1 +
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 449a22e4..7f71b565 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -553,7 +553,7 @@ static bool init_deref_from_component_index(struct hlsl_ctx *ctx, struct hlsl_bl
 
         if (!(c = hlsl_new_uint_constant(ctx, next_index, loc)))
         {
-            hlsl_free_instr_list(&block->instrs);
+            hlsl_block_cleanup(block);
             return false;
         }
         hlsl_block_add_instr(block, &c->node);
@@ -1426,7 +1426,7 @@ static bool clone_block(struct hlsl_ctx *ctx, struct hlsl_block *dst_block,
     {
         if (!(dst = clone_instr(ctx, map, src)))
         {
-            hlsl_free_instr_list(&dst_block->instrs);
+            hlsl_block_cleanup(dst_block);
             return false;
         }
         list_add_tail(&dst_block->instrs, &dst->entry);
@@ -1435,7 +1435,7 @@ static bool clone_block(struct hlsl_ctx *ctx, struct hlsl_block *dst_block,
         {
             if (!vkd3d_array_reserve((void **)&map->instrs, &map->capacity, map->count + 1, sizeof(*map->instrs)))
             {
-                hlsl_free_instr_list(&dst_block->instrs);
+                hlsl_block_cleanup(dst_block);
                 return false;
             }
 
@@ -2577,6 +2577,11 @@ void hlsl_free_instr_list(struct list *list)
         hlsl_free_instr(node);
 }
 
+void hlsl_block_cleanup(struct hlsl_block *block)
+{
+    hlsl_free_instr_list(&block->instrs);
+}
+
 static void free_ir_call(struct hlsl_ir_call *call)
 {
     vkd3d_free(call);
@@ -2598,8 +2603,8 @@ static void free_ir_expr(struct hlsl_ir_expr *expr)
 
 static void free_ir_if(struct hlsl_ir_if *if_node)
 {
-    hlsl_free_instr_list(&if_node->then_instrs.instrs);
-    hlsl_free_instr_list(&if_node->else_instrs.instrs);
+    hlsl_block_cleanup(&if_node->then_instrs);
+    hlsl_block_cleanup(&if_node->else_instrs);
     hlsl_src_remove(&if_node->condition);
     vkd3d_free(if_node);
 }
@@ -2617,7 +2622,7 @@ static void free_ir_load(struct hlsl_ir_load *load)
 
 static void free_ir_loop(struct hlsl_ir_loop *loop)
 {
-    hlsl_free_instr_list(&loop->body.instrs);
+    hlsl_block_cleanup(&loop->body);
     vkd3d_free(loop);
 }
 
@@ -2741,7 +2746,7 @@ static void free_function_decl(struct hlsl_ir_function_decl *decl)
     vkd3d_free((void *)decl->attrs);
 
     vkd3d_free(decl->parameters.vars);
-    hlsl_free_instr_list(&decl->body.instrs);
+    hlsl_block_cleanup(&decl->body);
     vkd3d_free(decl);
 }
 
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index cabbf1de..0016da76 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -1014,6 +1014,7 @@ struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *ins
 void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function_decl *decl);
 bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var);
 
+void hlsl_block_cleanup(struct hlsl_block *block);
 bool hlsl_clone_block(struct hlsl_ctx *ctx, struct hlsl_block *dst_block, const struct hlsl_block *src_block);
 
 void hlsl_dump_function(struct hlsl_ctx *ctx, const struct hlsl_ir_function_decl *func);
-- 
GitLab


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

[PATCH v3 5/7] vkd3d-shader/hlsl: Initialize the block in clone_block().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         | 2 ++
 libs/vkd3d-shader/hlsl_codegen.c | 1 -
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 7f71b565..3ee97ca6 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -1422,6 +1422,8 @@ static bool clone_block(struct hlsl_ctx *ctx, struct hlsl_block *dst_block,
     const struct hlsl_ir_node *src;
     struct hlsl_ir_node *dst;
 
+    hlsl_block_init(dst_block);
+
     LIST_FOR_EACH_ENTRY(src, &src_block->instrs, struct hlsl_ir_node, entry)
     {
         if (!(dst = clone_instr(ctx, map, src)))
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 3fd5c968..7e51abde 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -721,7 +721,6 @@ static bool lower_calls(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *
         hlsl_error(ctx, &call->node.loc, VKD3D_SHADER_ERROR_HLSL_NOT_DEFINED,
                 "Function \"%s\" is not defined.", decl->func->name);
 
-    hlsl_block_init(&block);
     if (!hlsl_clone_block(ctx, &block, &decl->body))
         return false;
     list_move_before(&call->node.entry, &block.instrs);
-- 
GitLab


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

[PATCH v3 6/7] vkd3d-shader/hlsl: Pass hlsl_block pointers to hlsl_new_if().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         | 35 +++++++++------
 libs/vkd3d-shader/hlsl.h         |  7 +--
 libs/vkd3d-shader/hlsl.y         | 39 ++++++++++-------
 libs/vkd3d-shader/hlsl_codegen.c | 74 ++++++++++++++++++--------------
 libs/vkd3d-shader/hlsl_sm4.c     |  6 +--
 5 files changed, 94 insertions(+), 67 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 3ee97ca6..9eccdd0e 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -1208,16 +1208,20 @@ struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_exp
     return hlsl_new_expr(ctx, op, operands, arg1->data_type, &arg1->loc);
 }
 
-struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, struct vkd3d_shader_location loc)
+struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
+        struct hlsl_block *then_block, struct hlsl_block *else_block, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_if *iff;
 
     if (!(iff = hlsl_alloc(ctx, sizeof(*iff))))
         return NULL;
-    init_node(&iff->node, HLSL_IR_IF, NULL, &loc);
+    init_node(&iff->node, HLSL_IR_IF, NULL, loc);
     hlsl_src_from_node(&iff->condition, condition);
-    hlsl_block_init(&iff->then_instrs);
-    hlsl_block_init(&iff->else_instrs);
+    hlsl_block_init(&iff->then_block);
+    hlsl_block_add_block(&iff->then_block, then_block);
+    hlsl_block_init(&iff->else_block);
+    if (else_block)
+        hlsl_block_add_block(&iff->else_block, else_block);
     return iff;
 }
 
@@ -1516,17 +1520,24 @@ static struct hlsl_ir_node *clone_expr(struct hlsl_ctx *ctx, struct clone_instr_
 
 static struct hlsl_ir_node *clone_if(struct hlsl_ctx *ctx, struct clone_instr_map *map, struct hlsl_ir_if *src)
 {
+    struct hlsl_block then_block, else_block;
     struct hlsl_ir_if *dst;
 
-    if (!(dst = hlsl_new_if(ctx, map_instr(map, src->condition.node), src->node.loc)))
+    if (!clone_block(ctx, &then_block, &src->then_block, map))
         return NULL;
+    if (!clone_block(ctx, &else_block, &src->else_block, map))
+    {
+        hlsl_block_cleanup(&then_block);
+        return NULL;
+    }
 
-    if (!clone_block(ctx, &dst->then_instrs, &src->then_instrs, map)
-            || !clone_block(ctx, &dst->else_instrs, &src->else_instrs, map))
+    if (!(dst = hlsl_new_if(ctx, map_instr(map, src->condition.node), &then_block, &else_block, &src->node.loc)))
     {
-        hlsl_free_instr(&dst->node);
+        hlsl_block_cleanup(&then_block);
+        hlsl_block_cleanup(&else_block);
         return NULL;
     }
+
     return &dst->node;
 }
 
@@ -2334,9 +2345,9 @@ static void dump_ir_if(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer,
     vkd3d_string_buffer_printf(buffer, "if (");
     dump_src(buffer, &if_node->condition);
     vkd3d_string_buffer_printf(buffer, ") {\n");
-    dump_instr_list(ctx, buffer, &if_node->then_instrs.instrs);
+    dump_instr_list(ctx, buffer, &if_node->then_block.instrs);
     vkd3d_string_buffer_printf(buffer, "      %10s   } else {\n", "");
-    dump_instr_list(ctx, buffer, &if_node->else_instrs.instrs);
+    dump_instr_list(ctx, buffer, &if_node->else_block.instrs);
     vkd3d_string_buffer_printf(buffer, "      %10s   }", "");
 }
 
@@ -2605,8 +2616,8 @@ static void free_ir_expr(struct hlsl_ir_expr *expr)
 
 static void free_ir_if(struct hlsl_ir_if *if_node)
 {
-    hlsl_block_cleanup(&if_node->then_instrs);
-    hlsl_block_cleanup(&if_node->else_instrs);
+    hlsl_block_cleanup(&if_node->then_block);
+    hlsl_block_cleanup(&if_node->else_block);
     hlsl_src_remove(&if_node->condition);
     vkd3d_free(if_node);
 }
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 0016da76..16dcdb29 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -451,8 +451,8 @@ struct hlsl_ir_if
 {
     struct hlsl_ir_node node;
     struct hlsl_src condition;
-    struct hlsl_block then_instrs;
-    struct hlsl_block else_instrs;
+    struct hlsl_block then_block;
+    struct hlsl_block else_block;
 };
 
 struct hlsl_ir_loop
@@ -1067,7 +1067,8 @@ struct hlsl_ir_node *hlsl_new_float_constant(struct hlsl_ctx *ctx,
 struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx,
         struct hlsl_type *return_type, const struct hlsl_func_parameters *parameters,
         const struct hlsl_semantic *semantic, const struct vkd3d_shader_location *loc);
-struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, struct vkd3d_shader_location loc);
+struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
+        struct hlsl_block *then_block, struct hlsl_block *else_block, const struct vkd3d_shader_location *loc);
 struct hlsl_ir_constant *hlsl_new_int_constant(struct hlsl_ctx *ctx, int n,
         const struct vkd3d_shader_location *loc);
 struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc);
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 719dfc62..4e7a4baa 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -85,8 +85,8 @@ struct parse_function
 
 struct parse_if_body
 {
-    struct list *then_instrs;
-    struct list *else_instrs;
+    struct list *then_block;
+    struct list *else_block;
 };
 
 enum parse_assign_op
@@ -407,6 +407,7 @@ static DWORD add_modifiers(struct hlsl_ctx *ctx, DWORD modifiers, DWORD mod, con
 static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_list)
 {
     struct hlsl_ir_node *condition, *not;
+    struct hlsl_block then_block;
     struct hlsl_ir_jump *jump;
     struct hlsl_ir_if *iff;
 
@@ -419,13 +420,15 @@ static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_lis
         return false;
     list_add_tail(cond_list, ¬->entry);
 
-    if (!(iff = hlsl_new_if(ctx, not, condition->loc)))
-        return false;
-    list_add_tail(cond_list, &iff->node.entry);
+    hlsl_block_init(&then_block);
 
     if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, condition->loc)))
         return false;
-    hlsl_block_add_instr(&iff->then_instrs, &jump->node);
+    hlsl_block_add_instr(&then_block, &jump->node);
+
+    if (!(iff = hlsl_new_if(ctx, not, &then_block, NULL, &condition->loc)))
+        return false;
+    list_add_tail(cond_list, &iff->node.entry);
     return true;
 }
 
@@ -5241,15 +5244,19 @@ selection_statement:
       KW_IF '(' expr ')' if_body
         {
             struct hlsl_ir_node *condition = node_from_list($3);
+            struct hlsl_block then_block, else_block;
             struct hlsl_ir_if *instr;
 
-            if (!(instr = hlsl_new_if(ctx, condition, @1)))
+            hlsl_block_init(&then_block);
+            list_move_tail(&then_block.instrs, $5.then_block);
+            hlsl_block_init(&else_block);
+            if ($5.else_block)
+                list_move_tail(&else_block.instrs, $5.else_block);
+            vkd3d_free($5.then_block);
+            vkd3d_free($5.else_block);
+
+            if (!(instr = hlsl_new_if(ctx, condition, &then_block, &else_block, &@1)))
                 YYABORT;
-            list_move_tail(&instr->then_instrs.instrs, $5.then_instrs);
-            if ($5.else_instrs)
-                list_move_tail(&instr->else_instrs.instrs, $5.else_instrs);
-            vkd3d_free($5.then_instrs);
-            vkd3d_free($5.else_instrs);
             if (condition->data_type->dimx > 1 || condition->data_type->dimy > 1)
             {
                 struct vkd3d_string_buffer *string;
@@ -5266,13 +5273,13 @@ selection_statement:
 if_body:
       statement
         {
-            $$.then_instrs = $1;
-            $$.else_instrs = NULL;
+            $$.then_block = $1;
+            $$.else_block = NULL;
         }
     | statement KW_ELSE statement
         {
-            $$.then_instrs = $1;
-            $$.else_instrs = $3;
+            $$.then_block = $1;
+            $$.else_block = $3;
         }
 
 loop_statement:
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 7e51abde..7420b1fb 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -459,8 +459,8 @@ static bool transform_ir(struct hlsl_ctx *ctx, bool (*func)(struct hlsl_ctx *ctx
         {
             struct hlsl_ir_if *iff = hlsl_ir_if(instr);
 
-            progress |= transform_ir(ctx, func, &iff->then_instrs, context);
-            progress |= transform_ir(ctx, func, &iff->else_instrs, context);
+            progress |= transform_ir(ctx, func, &iff->then_block, context);
+            progress |= transform_ir(ctx, func, &iff->else_block, context);
         }
         else if (instr->type == HLSL_IR_LOOP)
             progress |= transform_ir(ctx, func, &hlsl_ir_loop(instr)->body, context);
@@ -516,21 +516,24 @@ static bool find_recursive_calls(struct hlsl_ctx *ctx, struct hlsl_ir_node *inst
 static void insert_early_return_break(struct hlsl_ctx *ctx,
         struct hlsl_ir_function_decl *func, struct hlsl_ir_node *cf_instr)
 {
+    struct hlsl_block then_block;
     struct hlsl_ir_jump *jump;
     struct hlsl_ir_load *load;
     struct hlsl_ir_if *iff;
 
+    hlsl_block_init(&then_block);
+
     if (!(load = hlsl_new_var_load(ctx, func->early_return_var, cf_instr->loc)))
         return;
     list_add_after(&cf_instr->entry, &load->node.entry);
 
-    if (!(iff = hlsl_new_if(ctx, &load->node, cf_instr->loc)))
+    if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, cf_instr->loc)))
         return;
-    list_add_after(&load->node.entry, &iff->node.entry);
+    hlsl_block_add_instr(&then_block, &jump->node);
 
-    if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, cf_instr->loc)))
+    if (!(iff = hlsl_new_if(ctx, &load->node, &then_block, NULL, &cf_instr->loc)))
         return;
-    hlsl_block_add_instr(&iff->then_instrs, &jump->node);
+    list_add_after(&load->node.entry, &iff->node.entry);
 }
 
 /* Remove HLSL_IR_JUMP_RETURN calls by altering subsequent control flow. */
@@ -591,8 +594,8 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
         {
             struct hlsl_ir_if *iff = hlsl_ir_if(instr);
 
-            has_early_return |= lower_return(ctx, func, &iff->then_instrs, in_loop);
-            has_early_return |= lower_return(ctx, func, &iff->else_instrs, in_loop);
+            has_early_return |= lower_return(ctx, func, &iff->then_block, in_loop);
+            has_early_return |= lower_return(ctx, func, &iff->else_block, in_loop);
 
             if (has_early_return)
             {
@@ -675,6 +678,7 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
     else if (cf_instr)
     {
         struct list *tail = list_tail(&block->instrs);
+        struct hlsl_block then_block;
         struct hlsl_ir_load *load;
         struct hlsl_ir_node *not;
         struct hlsl_ir_if *iff;
@@ -685,6 +689,10 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
         if (tail == &cf_instr->entry)
             return has_early_return;
 
+        hlsl_block_init(&then_block);
+        list_move_slice_tail(&then_block.instrs, list_next(&block->instrs, &cf_instr->entry), tail);
+        lower_return(ctx, func, &then_block, in_loop);
+
         if (!(load = hlsl_new_var_load(ctx, func->early_return_var, cf_instr->loc)))
             return false;
         hlsl_block_add_instr(block, &load->node);
@@ -693,13 +701,9 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
             return false;
         hlsl_block_add_instr(block, not);
 
-        if (!(iff = hlsl_new_if(ctx, not, cf_instr->loc)))
+        if (!(iff = hlsl_new_if(ctx, not, &then_block, NULL, &cf_instr->loc)))
             return false;
-        hlsl_block_add_instr(block, &iff->node);
-
-        list_move_slice_tail(&iff->then_instrs.instrs, list_next(&block->instrs, &cf_instr->entry), tail);
-
-        lower_return(ctx, func, &iff->then_instrs, in_loop);
+        list_add_tail(&block->instrs, &iff->node.entry);
     }
 
     return has_early_return;
@@ -1343,8 +1347,8 @@ static void copy_propagation_invalidate_from_block(struct hlsl_ctx *ctx, struct
             {
                 struct hlsl_ir_if *iff = hlsl_ir_if(instr);
 
-                copy_propagation_invalidate_from_block(ctx, state, &iff->then_instrs);
-                copy_propagation_invalidate_from_block(ctx, state, &iff->else_instrs);
+                copy_propagation_invalidate_from_block(ctx, state, &iff->then_block);
+                copy_propagation_invalidate_from_block(ctx, state, &iff->else_block);
 
                 break;
             }
@@ -1374,19 +1378,19 @@ static bool copy_propagation_process_if(struct hlsl_ctx *ctx, struct hlsl_ir_if
     bool progress = false;
 
     copy_propagation_state_init(ctx, &inner_state, state);
-    progress |= copy_propagation_transform_block(ctx, &iff->then_instrs, &inner_state);
+    progress |= copy_propagation_transform_block(ctx, &iff->then_block, &inner_state);
     copy_propagation_state_destroy(&inner_state);
 
     copy_propagation_state_init(ctx, &inner_state, state);
-    progress |= copy_propagation_transform_block(ctx, &iff->else_instrs, &inner_state);
+    progress |= copy_propagation_transform_block(ctx, &iff->else_block, &inner_state);
     copy_propagation_state_destroy(&inner_state);
 
     /* Ideally we'd invalidate the outer state looking at what was
      * touched in the two inner states, but this doesn't work for
      * loops (because we need to know what is invalidated in advance),
      * so we need copy_propagation_invalidate_from_block() anyway. */
-    copy_propagation_invalidate_from_block(ctx, state, &iff->then_instrs);
-    copy_propagation_invalidate_from_block(ctx, state, &iff->else_instrs);
+    copy_propagation_invalidate_from_block(ctx, state, &iff->then_block);
+    copy_propagation_invalidate_from_block(ctx, state, &iff->else_block);
 
     return progress;
 }
@@ -1999,6 +2003,7 @@ static bool lower_casts_to_bool(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr
 struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *instrs,
         struct hlsl_ir_node *condition, struct hlsl_ir_node *if_true, struct hlsl_ir_node *if_false)
 {
+    struct hlsl_block then_block, else_block;
     struct hlsl_ir_store *store;
     struct hlsl_ir_load *load;
     struct hlsl_ir_var *var;
@@ -2009,17 +2014,20 @@ struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *ins
     if (!(var = hlsl_new_synthetic_var(ctx, "conditional", if_true->data_type, &condition->loc)))
         return NULL;
 
-    if (!(iff = hlsl_new_if(ctx, condition, condition->loc)))
-        return NULL;
-    list_add_tail(instrs, &iff->node.entry);
+    hlsl_block_init(&then_block);
+    hlsl_block_init(&else_block);
 
     if (!(store = hlsl_new_simple_store(ctx, var, if_true)))
         return NULL;
-    hlsl_block_add_instr(&iff->then_instrs, &store->node);
+    hlsl_block_add_instr(&then_block, &store->node);
 
     if (!(store = hlsl_new_simple_store(ctx, var, if_false)))
         return NULL;
-    hlsl_block_add_instr(&iff->else_instrs, &store->node);
+    hlsl_block_add_instr(&else_block, &store->node);
+
+    if (!(iff = hlsl_new_if(ctx, condition, &then_block, &else_block, &condition->loc)))
+        return NULL;
+    list_add_tail(instrs, &iff->node.entry);
 
     if (!(load = hlsl_new_var_load(ctx, var, condition->loc)))
         return NULL;
@@ -2320,8 +2328,8 @@ static unsigned int index_instructions(struct hlsl_block *block, unsigned int in
         if (instr->type == HLSL_IR_IF)
         {
             struct hlsl_ir_if *iff = hlsl_ir_if(instr);
-            index = index_instructions(&iff->then_instrs, index);
-            index = index_instructions(&iff->else_instrs, index);
+            index = index_instructions(&iff->then_block, index);
+            index = index_instructions(&iff->else_block, index);
         }
         else if (instr->type == HLSL_IR_LOOP)
         {
@@ -2446,8 +2454,8 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop
         {
             struct hlsl_ir_if *iff = hlsl_ir_if(instr);
 
-            compute_liveness_recurse(&iff->then_instrs, loop_first, loop_last);
-            compute_liveness_recurse(&iff->else_instrs, loop_first, loop_last);
+            compute_liveness_recurse(&iff->then_block, loop_first, loop_last);
+            compute_liveness_recurse(&iff->else_block, loop_first, loop_last);
             iff->condition.node->last_read = instr->index;
             break;
         }
@@ -2724,8 +2732,8 @@ static void allocate_temp_registers_recurse(struct hlsl_ctx *ctx, struct hlsl_bl
             case HLSL_IR_IF:
             {
                 struct hlsl_ir_if *iff = hlsl_ir_if(instr);
-                allocate_temp_registers_recurse(ctx, &iff->then_instrs, liveness);
-                allocate_temp_registers_recurse(ctx, &iff->else_instrs, liveness);
+                allocate_temp_registers_recurse(ctx, &iff->then_block, liveness);
+                allocate_temp_registers_recurse(ctx, &iff->else_block, liveness);
                 break;
             }
 
@@ -2839,8 +2847,8 @@ static void allocate_const_registers_recurse(struct hlsl_ctx *ctx, struct hlsl_b
             case HLSL_IR_IF:
             {
                 struct hlsl_ir_if *iff = hlsl_ir_if(instr);
-                allocate_const_registers_recurse(ctx, &iff->then_instrs, liveness);
-                allocate_const_registers_recurse(ctx, &iff->else_instrs, liveness);
+                allocate_const_registers_recurse(ctx, &iff->then_block, liveness);
+                allocate_const_registers_recurse(ctx, &iff->else_block, liveness);
                 break;
             }
 
diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c
index 8be848c5..22b6f6b9 100644
--- a/libs/vkd3d-shader/hlsl_sm4.c
+++ b/libs/vkd3d-shader/hlsl_sm4.c
@@ -2118,15 +2118,15 @@ static void write_sm4_if(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buf
     sm4_src_from_node(&instr.srcs[0], iff->condition.node, VKD3DSP_WRITEMASK_ALL);
     write_sm4_instruction(buffer, &instr);
 
-    write_sm4_block(ctx, buffer, &iff->then_instrs);
+    write_sm4_block(ctx, buffer, &iff->then_block);
 
-    if (!list_empty(&iff->else_instrs.instrs))
+    if (!list_empty(&iff->else_block.instrs))
     {
         instr.opcode = VKD3D_SM4_OP_ELSE;
         instr.src_count = 0;
         write_sm4_instruction(buffer, &instr);
 
-        write_sm4_block(ctx, buffer, &iff->else_instrs);
+        write_sm4_block(ctx, buffer, &iff->else_block);
     }
 
     instr.opcode = VKD3D_SM4_OP_ENDIF;
-- 
GitLab


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

[PATCH v3 7/7] vkd3d-shader/hlsl: Return an hlsl_ir_node pointer from hlsl_new_if().

[Zebediah Figura]

From: Zebediah Figura <zfigura(a)codeweavers.com>

---
 libs/vkd3d-shader/hlsl.c         |  8 ++++----
 libs/vkd3d-shader/hlsl.h         |  2 +-
 libs/vkd3d-shader/hlsl.y         | 11 +++++------
 libs/vkd3d-shader/hlsl_codegen.c | 13 ++++++-------
 4 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 9eccdd0e..5f683767 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -1208,7 +1208,7 @@ struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_exp
     return hlsl_new_expr(ctx, op, operands, arg1->data_type, &arg1->loc);
 }
 
-struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
+struct hlsl_ir_node *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
         struct hlsl_block *then_block, struct hlsl_block *else_block, const struct vkd3d_shader_location *loc)
 {
     struct hlsl_ir_if *iff;
@@ -1222,7 +1222,7 @@ struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condit
     hlsl_block_init(&iff->else_block);
     if (else_block)
         hlsl_block_add_block(&iff->else_block, else_block);
-    return iff;
+    return &iff->node;
 }
 
 struct hlsl_ir_load *hlsl_new_load_index(struct hlsl_ctx *ctx, const struct hlsl_deref *deref,
@@ -1521,7 +1521,7 @@ static struct hlsl_ir_node *clone_expr(struct hlsl_ctx *ctx, struct clone_instr_
 static struct hlsl_ir_node *clone_if(struct hlsl_ctx *ctx, struct clone_instr_map *map, struct hlsl_ir_if *src)
 {
     struct hlsl_block then_block, else_block;
-    struct hlsl_ir_if *dst;
+    struct hlsl_ir_node *dst;
 
     if (!clone_block(ctx, &then_block, &src->then_block, map))
         return NULL;
@@ -1538,7 +1538,7 @@ static struct hlsl_ir_node *clone_if(struct hlsl_ctx *ctx, struct clone_instr_ma
         return NULL;
     }
 
-    return &dst->node;
+    return dst;
 }
 
 static struct hlsl_ir_node *clone_jump(struct hlsl_ctx *ctx, struct hlsl_ir_jump *src)
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 16dcdb29..7a13c46f 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -1067,7 +1067,7 @@ struct hlsl_ir_node *hlsl_new_float_constant(struct hlsl_ctx *ctx,
 struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx,
         struct hlsl_type *return_type, const struct hlsl_func_parameters *parameters,
         const struct hlsl_semantic *semantic, const struct vkd3d_shader_location *loc);
-struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
+struct hlsl_ir_node *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
         struct hlsl_block *then_block, struct hlsl_block *else_block, const struct vkd3d_shader_location *loc);
 struct hlsl_ir_constant *hlsl_new_int_constant(struct hlsl_ctx *ctx, int n,
         const struct vkd3d_shader_location *loc);
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 4e7a4baa..45bc545f 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -406,10 +406,9 @@ static DWORD add_modifiers(struct hlsl_ctx *ctx, DWORD modifiers, DWORD mod, con
 
 static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_list)
 {
-    struct hlsl_ir_node *condition, *not;
+    struct hlsl_ir_node *condition, *not, *iff;
     struct hlsl_block then_block;
     struct hlsl_ir_jump *jump;
-    struct hlsl_ir_if *iff;
 
     /* E.g. "for (i = 0; ; ++i)". */
     if (list_empty(cond_list))
@@ -428,7 +427,7 @@ static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_lis
 
     if (!(iff = hlsl_new_if(ctx, not, &then_block, NULL, &condition->loc)))
         return false;
-    list_add_tail(cond_list, &iff->node.entry);
+    list_add_tail(cond_list, &iff->entry);
     return true;
 }
 
@@ -5245,7 +5244,7 @@ selection_statement:
         {
             struct hlsl_ir_node *condition = node_from_list($3);
             struct hlsl_block then_block, else_block;
-            struct hlsl_ir_if *instr;
+            struct hlsl_ir_node *instr;
 
             hlsl_block_init(&then_block);
             list_move_tail(&then_block.instrs, $5.then_block);
@@ -5262,12 +5261,12 @@ selection_statement:
                 struct vkd3d_string_buffer *string;
 
                 if ((string = hlsl_type_to_string(ctx, condition->data_type)))
-                    hlsl_error(ctx, &instr->node.loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                    hlsl_error(ctx, &instr->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
                             "if condition type %s is not scalar.", string->buffer);
                 hlsl_release_string_buffer(ctx, string);
             }
             $$ = $3;
-            list_add_tail($$, &instr->node.entry);
+            list_add_tail($$, &instr->entry);
         }
 
 if_body:
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 7420b1fb..a9f1ec6c 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -519,7 +519,7 @@ static void insert_early_return_break(struct hlsl_ctx *ctx,
     struct hlsl_block then_block;
     struct hlsl_ir_jump *jump;
     struct hlsl_ir_load *load;
-    struct hlsl_ir_if *iff;
+    struct hlsl_ir_node *iff;
 
     hlsl_block_init(&then_block);
 
@@ -533,7 +533,7 @@ static void insert_early_return_break(struct hlsl_ctx *ctx,
 
     if (!(iff = hlsl_new_if(ctx, &load->node, &then_block, NULL, &cf_instr->loc)))
         return;
-    list_add_after(&load->node.entry, &iff->node.entry);
+    list_add_after(&load->node.entry, &iff->entry);
 }
 
 /* Remove HLSL_IR_JUMP_RETURN calls by altering subsequent control flow. */
@@ -678,10 +678,9 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
     else if (cf_instr)
     {
         struct list *tail = list_tail(&block->instrs);
+        struct hlsl_ir_node *not, *iff;
         struct hlsl_block then_block;
         struct hlsl_ir_load *load;
-        struct hlsl_ir_node *not;
-        struct hlsl_ir_if *iff;
 
         /* If we're in a loop, we should have used "break" instead. */
         assert(!in_loop);
@@ -703,7 +702,7 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun
 
         if (!(iff = hlsl_new_if(ctx, not, &then_block, NULL, &cf_instr->loc)))
             return false;
-        list_add_tail(&block->instrs, &iff->node.entry);
+        list_add_tail(&block->instrs, &iff->entry);
     }
 
     return has_early_return;
@@ -2006,8 +2005,8 @@ struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *ins
     struct hlsl_block then_block, else_block;
     struct hlsl_ir_store *store;
     struct hlsl_ir_load *load;
+    struct hlsl_ir_node *iff;
     struct hlsl_ir_var *var;
-    struct hlsl_ir_if *iff;
 
     assert(hlsl_types_are_equal(if_true->data_type, if_false->data_type));
 
@@ -2027,7 +2026,7 @@ struct hlsl_ir_load *hlsl_add_conditional(struct hlsl_ctx *ctx, struct list *ins
 
     if (!(iff = hlsl_new_if(ctx, condition, &then_block, &else_block, &condition->loc)))
         return NULL;
-    list_add_tail(instrs, &iff->node.entry);
+    list_add_tail(instrs, &iff->entry);
 
     if (!(load = hlsl_new_var_load(ctx, var, condition->loc)))
         return NULL;
-- 
GitLab

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

[Zebediah Figura (＠zfigura)]

On Fri Apr 14 18:07:39 2023 +0000, Zebediah Figura wrote:
> changed this line in [version 3 of the diff](/wine/vkd3d/-/merge_requests/153/diffs?diff_id=42470&start_sha=4fd616ed53ddbe33592a72429ef4e75d618250ee#c6c9a40d72060550079c91bb6dd5741748169928_1221_1221)
> Because I reordered patches :-)

-- 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153#note_30111

[Zebediah Figura (＠zfigura)]

On Fri Apr 14 18:07:40 2023 +0000, Zebediah Figura wrote:
> changed this line in [version 3 of the diff](/wine/vkd3d/-/merge_requests/153/diffs?diff_id=42470&start_sha=4fd616ed53ddbe33592a72429ef4e75d618250ee#c6c9a40d72060550079c91bb6dd5741748169928_1528_1530)
> I did have a patch for that, but it was more awkward. I've just introduced it earlier as a helper in v3.

-- 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153#note_30112

[Zebediah Figura (＠zfigura)]

On Fri Apr 14 09:51:28 2023 +0000, Giovanni Mascellani wrote:
> I get a segfault here on `function-return.shader_test`. I guess it's
> because you need to init the two blocks. It doesn't look like
> `clone_block()` does it. Or maybe `clone_block()` should do it, I don't know.
> Fixed in v3, thanks. I could have sworn I ran the tests before sending...

-- 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153#note_30113

[PATCH v3 0/7] MR153: hlsl: Return hlsl_ir_node pointers from instruction constructors, part 1. - approved

[Giovanni Mascellani (＠giomasce)]

This merge request was approved by Giovanni Mascellani.
-- 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153

[PATCH v3 0/7] MR153: hlsl: Return hlsl_ir_node pointers from instruction constructors, part 1. - approved

[Henri Verbeet (＠hverbeet)]

This merge request was approved by Henri Verbeet.
-- 
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/153