wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader/hlsl: Store the "instrs" field of struct parse_initializer as a hlsl_block pointer.

Browse Source
This commit is contained in:
Zebediah Figura 2022-11-12 23:04:17 -06:00 committed by Alexandre Julliard
parent 7d521db3db
commit 8fa1750206
Notes: Alexandre Julliard 2023-06-28 23:03:54 +02:00 
Approved-by: Giovanni Mascellani (@giomasce)
Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/230
1 changed files with 139 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
libs/vkd3d-shader/hlsl.y
View File

@ -53,7 +53,7 @@ struct parse_initializer
{ {
struct hlsl_ir_node **args; struct hlsl_ir_node **args;
unsigned int args_count; unsigned int args_count;
struct list *instrs; struct hlsl_block *instrs;
bool braces; bool braces;
}; };
@ -134,6 +134,31 @@ static struct hlsl_ir_node *node_from_list(struct list *list)
return LIST_ENTRY(list_tail(list), struct hlsl_ir_node, entry); return LIST_ENTRY(list_tail(list), struct hlsl_ir_node, entry);
} }
static struct list *block_to_list(struct hlsl_block *block)
{
/* This is a temporary hack to ease the transition from lists to blocks.
* It takes advantage of the fact that an allocated hlsl_block pointer is
* byte-compatible with an allocated list pointer. */
return &block->instrs;
}
static struct hlsl_block *list_to_block(struct list *list)
{
/* This is a temporary hack to ease the transition from lists to blocks.
* It takes advantage of the fact that an allocated hlsl_block pointer is
* byte-compatible with an allocated list pointer. */
return CONTAINING_RECORD(list, struct hlsl_block, instrs);
}
static struct hlsl_block *make_empty_block(struct hlsl_ctx *ctx)
{
struct hlsl_block *block;
if ((block = hlsl_alloc(ctx, sizeof(*block))))
hlsl_block_init(block);
return block;
}
static struct list *make_empty_list(struct hlsl_ctx *ctx) static struct list *make_empty_list(struct hlsl_ctx *ctx)
{ {
struct list *list; struct list *list;
@ -149,6 +174,12 @@ static void destroy_instr_list(struct list *list)
vkd3d_free(list); vkd3d_free(list);
} }
static void destroy_block(struct hlsl_block *block)
{
hlsl_block_cleanup(block);
vkd3d_free(block);
}
static bool hlsl_types_are_componentwise_compatible(struct hlsl_ctx *ctx, struct hlsl_type *src, static bool hlsl_types_are_componentwise_compatible(struct hlsl_ctx *ctx, struct hlsl_type *src,
struct hlsl_type *dst) struct hlsl_type *dst)
{ {
@ -536,7 +567,7 @@ static unsigned int initializer_size(const struct parse_initializer *initializer
static void free_parse_initializer(struct parse_initializer *initializer) static void free_parse_initializer(struct parse_initializer *initializer)
{ {
destroy_instr_list(initializer->instrs); destroy_block(initializer->instrs);
vkd3d_free(initializer->args); vkd3d_free(initializer->args);
} }
@ -701,7 +732,7 @@ static bool add_record_access(struct hlsl_ctx *ctx, struct list *instrs, struct
return true; return true;
} }
static struct hlsl_ir_node *add_binary_arithmetic_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_binary_arithmetic_expr(struct hlsl_ctx *ctx, struct hlsl_block *block,
enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2,
const struct vkd3d_shader_location *loc); const struct vkd3d_shader_location *loc);
@ -1341,12 +1372,12 @@ static void check_integer_type(struct hlsl_ctx *ctx, const struct hlsl_ir_node *
} }
} }
static struct hlsl_ir_node *add_unary_arithmetic_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_unary_arithmetic_expr(struct hlsl_ctx *ctx, struct hlsl_block *block,
enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, const struct vkd3d_shader_location *loc) enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, const struct vkd3d_shader_location *loc)
{ {
struct hlsl_ir_node *args[HLSL_MAX_OPERANDS] = {arg}; struct hlsl_ir_node *args[HLSL_MAX_OPERANDS] = {arg};
return add_expr(ctx, instrs, op, args, arg->data_type, loc); return add_expr(ctx, block_to_list(block), op, args, arg->data_type, loc);
} }
static struct hlsl_ir_node *add_unary_bitwise_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_unary_bitwise_expr(struct hlsl_ctx *ctx, struct list *instrs,
@ -1354,7 +1385,7 @@ static struct hlsl_ir_node *add_unary_bitwise_expr(struct hlsl_ctx *ctx, struct
{ {
check_integer_type(ctx, arg); check_integer_type(ctx, arg);
return add_unary_arithmetic_expr(ctx, instrs, op, arg, loc); return add_unary_arithmetic_expr(ctx, list_to_block(instrs), op, arg, loc);
} }
static struct hlsl_ir_node *add_unary_logical_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_unary_logical_expr(struct hlsl_ctx *ctx, struct list *instrs,
@ -1385,7 +1416,7 @@ static struct hlsl_type *get_common_numeric_type(struct hlsl_ctx *ctx, const str
return hlsl_get_numeric_type(ctx, type, base, dimx, dimy); return hlsl_get_numeric_type(ctx, type, base, dimx, dimy);
} }
static struct hlsl_ir_node *add_binary_arithmetic_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_binary_arithmetic_expr(struct hlsl_ctx *ctx, struct hlsl_block *block,
enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2,
const struct vkd3d_shader_location *loc) const struct vkd3d_shader_location *loc)
{ {
@ -1394,13 +1425,13 @@ static struct hlsl_ir_node *add_binary_arithmetic_expr(struct hlsl_ctx *ctx, str
common_type = get_common_numeric_type(ctx, arg1, arg2, loc); common_type = get_common_numeric_type(ctx, arg1, arg2, loc);
if (!(args[0] = add_implicit_conversion(ctx, instrs, arg1, common_type, loc))) if (!(args[0] = add_implicit_conversion(ctx, block_to_list(block), arg1, common_type, loc)))
return NULL; return NULL;
if (!(args[1] = add_implicit_conversion(ctx, instrs, arg2, common_type, loc))) if (!(args[1] = add_implicit_conversion(ctx, block_to_list(block), arg2, common_type, loc)))
return NULL; return NULL;
return add_expr(ctx, instrs, op, args, common_type, loc); return add_expr(ctx, block_to_list(block), op, args, common_type, loc);
} }
static struct hlsl_ir_node *add_binary_bitwise_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_binary_bitwise_expr(struct hlsl_ctx *ctx, struct list *instrs,
@ -1410,7 +1441,7 @@ static struct hlsl_ir_node *add_binary_bitwise_expr(struct hlsl_ctx *ctx, struct
check_integer_type(ctx, arg1); check_integer_type(ctx, arg1);
check_integer_type(ctx, arg2); check_integer_type(ctx, arg2);
return add_binary_arithmetic_expr(ctx, instrs, op, arg1, arg2, loc); return add_binary_arithmetic_expr(ctx, list_to_block(instrs), op, arg1, arg2, loc);
} }
static struct hlsl_ir_node *add_binary_comparison_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_binary_comparison_expr(struct hlsl_ctx *ctx, struct list *instrs,
@ -1492,7 +1523,7 @@ static struct hlsl_ir_node *add_binary_shift_expr(struct hlsl_ctx *ctx, struct l
return add_expr(ctx, instrs, op, args, return_type, loc); return add_expr(ctx, instrs, op, args, return_type, loc);
} }
static struct hlsl_ir_node *add_binary_dot_expr(struct hlsl_ctx *ctx, struct list *instrs, static struct hlsl_ir_node *add_binary_dot_expr(struct hlsl_ctx *ctx, struct hlsl_block *instrs,
struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, const struct vkd3d_shader_location *loc) struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, const struct vkd3d_shader_location *loc)
{ {
enum hlsl_base_type base = expr_common_base_type(arg1->data_type->base_type, arg2->data_type->base_type); enum hlsl_base_type base = expr_common_base_type(arg1->data_type->base_type, arg2->data_type->base_type);
@ -1536,13 +1567,13 @@ static struct hlsl_ir_node *add_binary_dot_expr(struct hlsl_ctx *ctx, struct lis
common_type = hlsl_get_vector_type(ctx, base, dim); common_type = hlsl_get_vector_type(ctx, base, dim);
ret_type = hlsl_get_scalar_type(ctx, base); ret_type = hlsl_get_scalar_type(ctx, base);
if (!(args[0] = add_implicit_conversion(ctx, instrs, arg1, common_type, loc))) if (!(args[0] = add_implicit_conversion(ctx, block_to_list(instrs), arg1, common_type, loc)))
return NULL; return NULL;
if (!(args[1] = add_implicit_conversion(ctx, instrs, arg2, common_type, loc))) if (!(args[1] = add_implicit_conversion(ctx, block_to_list(instrs), arg2, common_type, loc)))
return NULL; return NULL;
return add_expr(ctx, instrs, op, args, ret_type, loc); return add_expr(ctx, block_to_list(instrs), op, args, ret_type, loc);
} }
static struct list *add_binary_expr_merge(struct hlsl_ctx *ctx, struct list *list1, struct list *list2, static struct list *add_binary_expr_merge(struct hlsl_ctx *ctx, struct list *list1, struct list *list2,
@ -1559,7 +1590,7 @@ static struct list *add_binary_expr_merge(struct hlsl_ctx *ctx, struct list *lis
case HLSL_OP2_DIV: case HLSL_OP2_DIV:
case HLSL_OP2_MOD: case HLSL_OP2_MOD:
case HLSL_OP2_MUL: case HLSL_OP2_MUL:
add_binary_arithmetic_expr(ctx, list1, op, arg1, arg2, loc); add_binary_arithmetic_expr(ctx, list_to_block(list1), op, arg1, arg2, loc);
break; break;
case HLSL_OP2_BIT_AND: case HLSL_OP2_BIT_AND:
@ -1657,7 +1688,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in
if (assign_op == ASSIGN_OP_SUB) if (assign_op == ASSIGN_OP_SUB)
{ {
if (!(rhs = add_unary_arithmetic_expr(ctx, instrs, HLSL_OP1_NEG, rhs, &rhs->loc))) if (!(rhs = add_unary_arithmetic_expr(ctx, list_to_block(instrs), HLSL_OP1_NEG, rhs, &rhs->loc)))
return NULL; return NULL;
assign_op = ASSIGN_OP_ADD; assign_op = ASSIGN_OP_ADD;
} }
@ -1666,7 +1697,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in
enum hlsl_ir_expr_op op = op_from_assignment(assign_op); enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
assert(op); assert(op);
if (!(rhs = add_binary_arithmetic_expr(ctx, instrs, op, lhs, rhs, &rhs->loc))) if (!(rhs = add_binary_arithmetic_expr(ctx, list_to_block(instrs), op, lhs, rhs, &rhs->loc)))
return NULL; return NULL;
} }
@ -1847,7 +1878,7 @@ static bool add_increment(struct hlsl_ctx *ctx, struct list *instrs, bool decrem
return true; return true;
} }
static void initialize_var_components(struct hlsl_ctx *ctx, struct list *instrs, static void initialize_var_components(struct hlsl_ctx *ctx, struct hlsl_block *instrs,
struct hlsl_ir_var *dst, unsigned int *store_index, struct hlsl_ir_node *src) struct hlsl_ir_var *dst, unsigned int *store_index, struct hlsl_ir_node *src)
{ {
unsigned int src_comp_count = hlsl_type_component_count(src->data_type); unsigned int src_comp_count = hlsl_type_component_count(src->data_type);
@ -1862,17 +1893,17 @@ static void initialize_var_components(struct hlsl_ctx *ctx, struct list *instrs,
struct hlsl_type *dst_comp_type; struct hlsl_type *dst_comp_type;
struct hlsl_block block; struct hlsl_block block;
if (!(load = hlsl_add_load_component(ctx, instrs, src, k, &src->loc))) if (!(load = hlsl_add_load_component(ctx, block_to_list(instrs), src, k, &src->loc)))
return; return;
dst_comp_type = hlsl_type_get_component_type(ctx, dst->data_type, *store_index); dst_comp_type = hlsl_type_get_component_type(ctx, dst->data_type, *store_index);
if (!(conv = add_implicit_conversion(ctx, instrs, load, dst_comp_type, &src->loc))) if (!(conv = add_implicit_conversion(ctx, block_to_list(instrs), load, dst_comp_type, &src->loc)))
return; return;
if (!hlsl_new_store_component(ctx, &block, &dst_deref, *store_index, conv)) if (!hlsl_new_store_component(ctx, &block, &dst_deref, *store_index, conv))
return; return;
list_move_tail(instrs, &block.instrs); hlsl_block_add_block(instrs, &block);
++*store_index; ++*store_index;
} }
@ -2153,14 +2184,14 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t
struct hlsl_ir_load *load = hlsl_new_var_load(ctx, var, &var->loc); struct hlsl_ir_load *load = hlsl_new_var_load(ctx, var, &var->loc);
assert(v->initializer.args_count == 1); assert(v->initializer.args_count == 1);
list_add_tail(v->initializer.instrs, &load->node.entry); hlsl_block_add_instr(v->initializer.instrs, &load->node);
add_assignment(ctx, v->initializer.instrs, &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]); add_assignment(ctx, block_to_list(v->initializer.instrs), &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]);
} }
if (modifiers & HLSL_STORAGE_STATIC) if (modifiers & HLSL_STORAGE_STATIC)
list_move_tail(&ctx->static_initializers.instrs, v->initializer.instrs); hlsl_block_add_block(&ctx->static_initializers, v->initializer.instrs);
else else
list_move_tail(statements_list, v->initializer.instrs); list_move_tail(statements_list, &v->initializer.instrs->instrs);
vkd3d_free(v->initializer.args); vkd3d_free(v->initializer.args);
vkd3d_free(v->initializer.instrs); vkd3d_free(v->initializer.instrs);
} }
@ -2280,7 +2311,7 @@ static struct hlsl_ir_node *intrinsic_float_convert_arg(struct hlsl_ctx *ctx,
return arg; return arg;
type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_FLOAT, type->dimx, type->dimy); type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_FLOAT, type->dimx, type->dimy);
return add_implicit_conversion(ctx, params->instrs, arg, type, loc); return add_implicit_conversion(ctx, block_to_list(params->instrs), arg, type, loc);
} }
static bool convert_args(struct hlsl_ctx *ctx, const struct parse_initializer *params, static bool convert_args(struct hlsl_ctx *ctx, const struct parse_initializer *params,
@ -2292,7 +2323,7 @@ static bool convert_args(struct hlsl_ctx *ctx, const struct parse_initializer *p
{ {
struct hlsl_ir_node *new_arg; struct hlsl_ir_node *new_arg;
if (!(new_arg = add_implicit_conversion(ctx, params->instrs, params->args[i], type, loc))) if (!(new_arg = add_implicit_conversion(ctx, block_to_list(params->instrs), params->args[i], type, loc)))
return false; return false;
params->args[i] = new_arg; params->args[i] = new_arg;
} }
@ -2388,25 +2419,25 @@ static bool intrinsic_all(struct hlsl_ctx *ctx,
if (!(one = hlsl_new_float_constant(ctx, 1.0f, loc))) if (!(one = hlsl_new_float_constant(ctx, 1.0f, loc)))
return false; return false;
list_add_tail(params->instrs, &one->entry); hlsl_block_add_instr(params->instrs, one);
if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc))) if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc)))
return false; return false;
list_add_tail(params->instrs, &zero->entry); hlsl_block_add_instr(params->instrs, zero);
mul = one; mul = one;
count = hlsl_type_component_count(arg->data_type); count = hlsl_type_component_count(arg->data_type);
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
if (!(load = hlsl_add_load_component(ctx, params->instrs, arg, i, loc))) if (!(load = hlsl_add_load_component(ctx, block_to_list(params->instrs), arg, i, loc)))
return false; return false;
if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, load, mul, loc))) if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, load, mul, loc)))
return false; return false;
} }
return !!add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_NEQUAL, mul, zero, loc); return !!add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_NEQUAL, mul, zero, loc);
} }
static bool intrinsic_any(struct hlsl_ctx *ctx, static bool intrinsic_any(struct hlsl_ctx *ctx,
@ -2425,28 +2456,28 @@ static bool intrinsic_any(struct hlsl_ctx *ctx,
{ {
if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc))) if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc)))
return false; return false;
list_add_tail(params->instrs, &zero->entry); hlsl_block_add_instr(params->instrs, zero);
if (!(dot = add_binary_dot_expr(ctx, params->instrs, arg, arg, loc))) if (!(dot = add_binary_dot_expr(ctx, params->instrs, arg, arg, loc)))
return false; return false;
return !!add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_NEQUAL, dot, zero, loc); return !!add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_NEQUAL, dot, zero, loc);
} }
else if (arg->data_type->base_type == HLSL_TYPE_BOOL) else if (arg->data_type->base_type == HLSL_TYPE_BOOL)
{ {
if (!(bfalse = hlsl_new_bool_constant(ctx, false, loc))) if (!(bfalse = hlsl_new_bool_constant(ctx, false, loc)))
return false; return false;
list_add_tail(params->instrs, &bfalse->entry); hlsl_block_add_instr(params->instrs, bfalse);
or = bfalse; or = bfalse;
count = hlsl_type_component_count(arg->data_type); count = hlsl_type_component_count(arg->data_type);
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
if (!(load = hlsl_add_load_component(ctx, params->instrs, arg, i, loc))) if (!(load = hlsl_add_load_component(ctx, block_to_list(params->instrs), arg, i, loc)))
return false; return false;
if (!(or = add_binary_bitwise_expr(ctx, params->instrs, HLSL_OP2_BIT_OR, or, load, loc))) if (!(or = add_binary_bitwise_expr(ctx, block_to_list(params->instrs), HLSL_OP2_BIT_OR, or, load, loc)))
return false; return false;
} }
@ -2485,7 +2516,7 @@ static bool intrinsic_asfloat(struct hlsl_ctx *ctx,
data_type = convert_numeric_type(ctx, data_type, HLSL_TYPE_FLOAT); data_type = convert_numeric_type(ctx, data_type, HLSL_TYPE_FLOAT);
operands[0] = params->args[0]; operands[0] = params->args[0];
return add_expr(ctx, params->instrs, HLSL_OP1_REINTERPRET, operands, data_type, loc); return add_expr(ctx, block_to_list(params->instrs), HLSL_OP1_REINTERPRET, operands, data_type, loc);
} }
static bool intrinsic_asuint(struct hlsl_ctx *ctx, static bool intrinsic_asuint(struct hlsl_ctx *ctx,
@ -2521,7 +2552,7 @@ static bool intrinsic_asuint(struct hlsl_ctx *ctx,
data_type = convert_numeric_type(ctx, data_type, HLSL_TYPE_UINT); data_type = convert_numeric_type(ctx, data_type, HLSL_TYPE_UINT);
operands[0] = params->args[0]; operands[0] = params->args[0];
return add_expr(ctx, params->instrs, HLSL_OP1_REINTERPRET, operands, data_type, loc); return add_expr(ctx, block_to_list(params->instrs), HLSL_OP1_REINTERPRET, operands, data_type, loc);
} }
static bool intrinsic_clamp(struct hlsl_ctx *ctx, static bool intrinsic_clamp(struct hlsl_ctx *ctx,
@ -2561,7 +2592,7 @@ static bool intrinsic_clip(struct hlsl_ctx *ctx,
if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_DISCARD_NEG, condition, loc))) if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_DISCARD_NEG, condition, loc)))
return false; return false;
list_add_tail(params->instrs, &jump->entry); hlsl_block_add_instr(params->instrs, jump);
return true; return true;
} }
@ -2593,34 +2624,34 @@ static bool intrinsic_cross(struct hlsl_ctx *ctx,
cast_type = hlsl_get_vector_type(ctx, base, 3); cast_type = hlsl_get_vector_type(ctx, base, 3);
if (!(arg1_cast = add_implicit_conversion(ctx, params->instrs, arg1, cast_type, loc))) if (!(arg1_cast = add_implicit_conversion(ctx, block_to_list(params->instrs), arg1, cast_type, loc)))
return false; return false;
if (!(arg2_cast = add_implicit_conversion(ctx, params->instrs, arg2, cast_type, loc))) if (!(arg2_cast = add_implicit_conversion(ctx, block_to_list(params->instrs), arg2, cast_type, loc)))
return false; return false;
if (!(arg1_swzl1 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, X, Y, Z), 3, arg1_cast, loc))) if (!(arg1_swzl1 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, X, Y, Z), 3, arg1_cast, loc)))
return false; return false;
list_add_tail(params->instrs, &arg1_swzl1->entry); hlsl_block_add_instr(params->instrs, arg1_swzl1);
if (!(arg2_swzl1 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Y, Z, X, Y), 3, arg2_cast, loc))) if (!(arg2_swzl1 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Y, Z, X, Y), 3, arg2_cast, loc)))
return false; return false;
list_add_tail(params->instrs, &arg2_swzl1->entry); hlsl_block_add_instr(params->instrs, arg2_swzl1);
if (!(mul1 = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg1_swzl1, arg2_swzl1, loc))) if (!(mul1 = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg1_swzl1, arg2_swzl1, loc)))
return false; return false;
if (!(mul1_neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, mul1, loc))) if (!(mul1_neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, mul1, loc)))
return false; return false;
list_add_tail(params->instrs, &mul1_neg->entry); hlsl_block_add_instr(params->instrs, mul1_neg);
if (!(arg1_swzl2 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Y, Z, X, Y), 3, arg1_cast, loc))) if (!(arg1_swzl2 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Y, Z, X, Y), 3, arg1_cast, loc)))
return false; return false;
list_add_tail(params->instrs, &arg1_swzl2->entry); hlsl_block_add_instr(params->instrs, arg1_swzl2);
if (!(arg2_swzl2 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, X, Y, Z), 3, arg2_cast, loc))) if (!(arg2_swzl2 = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, X, Y, Z), 3, arg2_cast, loc)))
return false; return false;
list_add_tail(params->instrs, &arg2_swzl2->entry); hlsl_block_add_instr(params->instrs, arg2_swzl2);
if (!(mul2 = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg1_swzl2, arg2_swzl2, loc))) if (!(mul2 = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg1_swzl2, arg2_swzl2, loc)))
return false; return false;
@ -2690,7 +2721,7 @@ static bool intrinsic_exp(struct hlsl_ctx *ctx,
/* 1/ln(2) */ /* 1/ln(2) */
if (!(coeff = hlsl_new_float_constant(ctx, 1.442695f, loc))) if (!(coeff = hlsl_new_float_constant(ctx, 1.442695f, loc)))
return false; return false;
list_add_tail(params->instrs, &coeff->entry); hlsl_block_add_instr(params->instrs, coeff);
if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, coeff, params->args[0], loc))) if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, coeff, params->args[0], loc)))
return false; return false;
@ -2737,7 +2768,7 @@ static bool intrinsic_fmod(struct hlsl_ctx *ctx, const struct parse_initializer
if (!(zero = hlsl_new_constant(ctx, div->data_type, &zero_value, loc))) if (!(zero = hlsl_new_constant(ctx, div->data_type, &zero_value, loc)))
return false; return false;
list_add_tail(params->instrs, &zero->entry); hlsl_block_add_instr(params->instrs, zero);
if (!(abs = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_ABS, div, loc))) if (!(abs = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_ABS, div, loc)))
return false; return false;
@ -2748,10 +2779,10 @@ static bool intrinsic_fmod(struct hlsl_ctx *ctx, const struct parse_initializer
if (!(neg_frac = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_NEG, frac, loc))) if (!(neg_frac = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_NEG, frac, loc)))
return false; return false;
if (!(ge = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_GEQUAL, div, zero, loc))) if (!(ge = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_GEQUAL, div, zero, loc)))
return false; return false;
if (!(select = hlsl_add_conditional(ctx, params->instrs, ge, frac, neg_frac))) if (!(select = hlsl_add_conditional(ctx, block_to_list(params->instrs), ge, frac, neg_frac)))
return false; return false;
return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, select, y, loc); return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, select, y, loc);
@ -2828,7 +2859,7 @@ static bool intrinsic_lerp(struct hlsl_ctx *ctx,
} }
static struct hlsl_ir_node * add_pow_expr(struct hlsl_ctx *ctx, static struct hlsl_ir_node * add_pow_expr(struct hlsl_ctx *ctx,
struct list *instrs, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, struct hlsl_block *instrs, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2,
const struct vkd3d_shader_location *loc) const struct vkd3d_shader_location *loc)
{ {
struct hlsl_ir_node *log, *mul; struct hlsl_ir_node *log, *mul;
@ -2883,15 +2914,15 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
init_value.u[3].f = 1.0f; init_value.u[3].f = 1.0f;
if (!(init = hlsl_new_constant(ctx, ret_type, &init_value, loc))) if (!(init = hlsl_new_constant(ctx, ret_type, &init_value, loc)))
return false; return false;
list_add_tail(params->instrs, &init->entry); hlsl_block_add_instr(params->instrs, init);
if (!(store = hlsl_new_simple_store(ctx, var, init))) if (!(store = hlsl_new_simple_store(ctx, var, init)))
return false; return false;
list_add_tail(params->instrs, &store->entry); hlsl_block_add_instr(params->instrs, store);
if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc))) if (!(zero = hlsl_new_float_constant(ctx, 0.0f, loc)))
return false; return false;
list_add_tail(params->instrs, &zero->entry); hlsl_block_add_instr(params->instrs, zero);
/* Diffuse component. */ /* Diffuse component. */
if (!(diffuse = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MAX, n_l, zero, loc))) if (!(diffuse = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MAX, n_l, zero, loc)))
@ -2899,31 +2930,31 @@ static bool intrinsic_lit(struct hlsl_ctx *ctx,
if (!hlsl_new_store_component(ctx, &block, &var_deref, 1, diffuse)) if (!hlsl_new_store_component(ctx, &block, &var_deref, 1, diffuse))
return false; return false;
list_move_tail(params->instrs, &block.instrs); hlsl_block_add_block(params->instrs, &block);
/* Specular component. */ /* Specular component. */
if (!(n_h_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, n_h, zero, loc))) if (!(n_h_neg = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_LESS, n_h, zero, loc)))
return false; return false;
if (!(n_l_neg = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, n_l, zero, loc))) if (!(n_l_neg = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_LESS, n_l, zero, loc)))
return false; return false;
if (!(specular_or = add_binary_logical_expr(ctx, params->instrs, HLSL_OP2_LOGIC_OR, n_l_neg, n_h_neg, loc))) if (!(specular_or = add_binary_logical_expr(ctx, block_to_list(params->instrs), HLSL_OP2_LOGIC_OR, n_l_neg, n_h_neg, loc)))
return false; return false;
if (!(specular_pow = add_pow_expr(ctx, params->instrs, n_h, m, loc))) if (!(specular_pow = add_pow_expr(ctx, params->instrs, n_h, m, loc)))
return false; return false;
if (!(load = hlsl_add_conditional(ctx, params->instrs, specular_or, zero, specular_pow))) if (!(load = hlsl_add_conditional(ctx, block_to_list(params->instrs), specular_or, zero, specular_pow)))
return false; return false;
if (!hlsl_new_store_component(ctx, &block, &var_deref, 2, load)) if (!hlsl_new_store_component(ctx, &block, &var_deref, 2, load))
return false; return false;
list_move_tail(params->instrs, &block.instrs); hlsl_block_add_block(params->instrs, &block);
if (!(var_load = hlsl_new_var_load(ctx, var, loc))) if (!(var_load = hlsl_new_var_load(ctx, var, loc)))
return false; return false;
list_add_tail(params->instrs, &var_load->node.entry); hlsl_block_add_instr(params->instrs, &var_load->node);
return true; return true;
} }
@ -3035,10 +3066,10 @@ static bool intrinsic_mul(struct hlsl_ctx *ctx,
ret_type = hlsl_get_scalar_type(ctx, base); ret_type = hlsl_get_scalar_type(ctx, base);
} }
if (!(cast1 = add_implicit_conversion(ctx, params->instrs, arg1, cast_type1, loc))) if (!(cast1 = add_implicit_conversion(ctx, block_to_list(params->instrs), arg1, cast_type1, loc)))
return false; return false;
if (!(cast2 = add_implicit_conversion(ctx, params->instrs, arg2, cast_type2, loc))) if (!(cast2 = add_implicit_conversion(ctx, block_to_list(params->instrs), arg2, cast_type2, loc)))
return false; return false;
if (!(var = hlsl_new_synthetic_var(ctx, "mul", matrix_type, loc))) if (!(var = hlsl_new_synthetic_var(ctx, "mul", matrix_type, loc)))
@ -3056,10 +3087,12 @@ static bool intrinsic_mul(struct hlsl_ctx *ctx,
{ {
struct hlsl_ir_node *value1, *value2, *mul; struct hlsl_ir_node *value1, *value2, *mul;
if (!(value1 = hlsl_add_load_component(ctx, params->instrs, cast1, j * cast1->data_type->dimx + k, loc))) if (!(value1 = hlsl_add_load_component(ctx, block_to_list(params->instrs),
cast1, j * cast1->data_type->dimx + k, loc)))
return false; return false;
if (!(value2 = hlsl_add_load_component(ctx, params->instrs, cast2, k * cast2->data_type->dimx + i, loc))) if (!(value2 = hlsl_add_load_component(ctx, block_to_list(params->instrs),
cast2, k * cast2->data_type->dimx + i, loc)))
return false; return false;
if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, value1, value2, loc))) if (!(mul = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, value1, value2, loc)))
@ -3078,15 +3111,15 @@ static bool intrinsic_mul(struct hlsl_ctx *ctx,
if (!hlsl_new_store_component(ctx, &block, &var_deref, j * matrix_type->dimx + i, instr)) if (!hlsl_new_store_component(ctx, &block, &var_deref, j * matrix_type->dimx + i, instr))
return false; return false;
list_move_tail(params->instrs, &block.instrs); hlsl_block_add_block(params->instrs, &block);
} }
} }
if (!(load = hlsl_new_var_load(ctx, var, loc))) if (!(load = hlsl_new_var_load(ctx, var, loc)))
return false; return false;
list_add_tail(params->instrs, &load->node.entry); hlsl_block_add_instr(params->instrs, &load->node);
return !!add_implicit_conversion(ctx, params->instrs, &load->node, ret_type, loc); return !!add_implicit_conversion(ctx, block_to_list(params->instrs), &load->node, ret_type, loc);
} }
static bool intrinsic_normalize(struct hlsl_ctx *ctx, static bool intrinsic_normalize(struct hlsl_ctx *ctx,
@ -3191,22 +3224,22 @@ static bool intrinsic_sign(struct hlsl_ctx *ctx,
if (!(zero = hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, arg->data_type->base_type), &zero_value, loc))) if (!(zero = hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, arg->data_type->base_type), &zero_value, loc)))
return false; return false;
list_add_tail(params->instrs, &zero->entry); hlsl_block_add_instr(params->instrs, zero);
/* Check if 0 < arg, cast bool to int */ /* Check if 0 < arg, cast bool to int */
if (!(lt = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, zero, arg, loc))) if (!(lt = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_LESS, zero, arg, loc)))
return false; return false;
if (!(op1 = add_implicit_conversion(ctx, params->instrs, lt, int_type, loc))) if (!(op1 = add_implicit_conversion(ctx, block_to_list(params->instrs), lt, int_type, loc)))
return false; return false;
/* Check if arg < 0, cast bool to int and invert (meaning true is -1) */ /* Check if arg < 0, cast bool to int and invert (meaning true is -1) */
if (!(lt = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_LESS, arg, zero, loc))) if (!(lt = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_LESS, arg, zero, loc)))
return false; return false;
if (!(op2 = add_implicit_conversion(ctx, params->instrs, lt, int_type, loc))) if (!(op2 = add_implicit_conversion(ctx, block_to_list(params->instrs), lt, int_type, loc)))
return false; return false;
if (!(neg = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_NEG, op2, loc))) if (!(neg = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_NEG, op2, loc)))
@ -3251,7 +3284,7 @@ static bool intrinsic_smoothstep(struct hlsl_ctx *ctx,
if (!(one = hlsl_new_float_constant(ctx, 1.0, loc))) if (!(one = hlsl_new_float_constant(ctx, 1.0, loc)))
return false; return false;
list_add_tail(params->instrs, &one->entry); hlsl_block_add_instr(params->instrs, one);
if (!(p_denom = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, one, p_denom, loc))) if (!(p_denom = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, one, p_denom, loc)))
return false; return false;
@ -3264,11 +3297,11 @@ static bool intrinsic_smoothstep(struct hlsl_ctx *ctx,
if (!(minus_two = hlsl_new_float_constant(ctx, -2.0, loc))) if (!(minus_two = hlsl_new_float_constant(ctx, -2.0, loc)))
return false; return false;
list_add_tail(params->instrs, &minus_two->entry); hlsl_block_add_instr(params->instrs, minus_two);
if (!(three = hlsl_new_float_constant(ctx, 3.0, loc))) if (!(three = hlsl_new_float_constant(ctx, 3.0, loc)))
return false; return false;
list_add_tail(params->instrs, &three->entry); hlsl_block_add_instr(params->instrs, three);
if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, minus_two, p, loc))) if (!(res = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, minus_two, p, loc)))
return false; return false;
@ -3305,13 +3338,13 @@ static bool intrinsic_step(struct hlsl_ctx *ctx,
if (!elementwise_intrinsic_float_convert_args(ctx, params, loc)) if (!elementwise_intrinsic_float_convert_args(ctx, params, loc))
return false; return false;
if (!(ge = add_binary_comparison_expr(ctx, params->instrs, HLSL_OP2_GEQUAL, if (!(ge = add_binary_comparison_expr(ctx, block_to_list(params->instrs), HLSL_OP2_GEQUAL,
params->args[1], params->args[0], loc))) params->args[1], params->args[0], loc)))
return false; return false;
type = ge->data_type; type = ge->data_type;
type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_FLOAT, type->dimx, type->dimy); type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_FLOAT, type->dimx, type->dimy);
return !!add_implicit_conversion(ctx, params->instrs, ge, type, loc); return !!add_implicit_conversion(ctx, block_to_list(params->instrs), ge, type, loc);
} }
static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer *params, static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer *params,
@ -3346,7 +3379,7 @@ static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer *
hlsl_release_string_buffer(ctx, string); hlsl_release_string_buffer(ctx, string);
} }
if (!(coords = add_implicit_conversion(ctx, params->instrs, params->args[1], if (!(coords = add_implicit_conversion(ctx, block_to_list(params->instrs), params->args[1],
hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, hlsl_sampler_dim_count(dim)), loc))) hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, hlsl_sampler_dim_count(dim)), loc)))
coords = params->args[1]; coords = params->args[1];
@ -3357,7 +3390,7 @@ static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer *
if (!(load = hlsl_new_resource_load(ctx, &load_params, loc))) if (!(load = hlsl_new_resource_load(ctx, &load_params, loc)))
return false; return false;
list_add_tail(params->instrs, &load->entry); hlsl_block_add_instr(params->instrs, load);
return true; return true;
} }
@ -3399,7 +3432,7 @@ static bool intrinsic_transpose(struct hlsl_ctx *ctx,
if (arg_type->class == HLSL_CLASS_SCALAR) if (arg_type->class == HLSL_CLASS_SCALAR)
{ {
list_add_tail(params->instrs, &arg->entry); hlsl_block_add_instr(params->instrs, arg);
return true; return true;
} }
@ -3415,18 +3448,18 @@ static bool intrinsic_transpose(struct hlsl_ctx *ctx,
{ {
struct hlsl_block block; struct hlsl_block block;
if (!(load = hlsl_add_load_component(ctx, params->instrs, arg, j * arg->data_type->dimx + i, loc))) if (!(load = hlsl_add_load_component(ctx, block_to_list(params->instrs), arg, j * arg->data_type->dimx + i, loc)))
return false; return false;
if (!hlsl_new_store_component(ctx, &block, &var_deref, i * var->data_type->dimx + j, load)) if (!hlsl_new_store_component(ctx, &block, &var_deref, i * var->data_type->dimx + j, load))
return false; return false;
list_move_tail(params->instrs, &block.instrs); hlsl_block_add_block(params->instrs, &block);
} }
} }
if (!(var_load = hlsl_new_var_load(ctx, var, loc))) if (!(var_load = hlsl_new_var_load(ctx, var, loc)))
return false; return false;
list_add_tail(params->instrs, &var_load->node.entry); hlsl_block_add_instr(params->instrs, &var_load->node);
return true; return true;
} }
@ -3466,13 +3499,13 @@ static bool intrinsic_d3dcolor_to_ubyte4(struct hlsl_ctx *ctx,
if (!(c = hlsl_new_float_constant(ctx, 255.0f + (0.5f / 256.0f), loc))) if (!(c = hlsl_new_float_constant(ctx, 255.0f + (0.5f / 256.0f), loc)))
return false; return false;
list_add_tail(params->instrs, &c->entry); hlsl_block_add_instr(params->instrs, c);
if (arg_type->class == HLSL_CLASS_VECTOR) if (arg_type->class == HLSL_CLASS_VECTOR)
{ {
if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, Y, X, W), 4, arg, loc))) if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Z, Y, X, W), 4, arg, loc)))
return false; return false;
list_add_tail(params->instrs, &swizzle->entry); hlsl_block_add_instr(params->instrs, swizzle);
arg = swizzle; arg = swizzle;
} }
@ -3572,7 +3605,7 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
{ {
struct hlsl_ir_node *cast; struct hlsl_ir_node *cast;
if (!(cast = add_cast(ctx, args->instrs, arg, param->data_type, &arg->loc))) if (!(cast = add_cast(ctx, block_to_list(args->instrs), arg, param->data_type, &arg->loc)))
goto fail; goto fail;
args->args[i] = cast; args->args[i] = cast;
arg = cast; arg = cast;
@ -3584,13 +3617,13 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
if (!(store = hlsl_new_simple_store(ctx, param, arg))) if (!(store = hlsl_new_simple_store(ctx, param, arg)))
goto fail; goto fail;
list_add_tail(args->instrs, &store->entry); hlsl_block_add_instr(args->instrs, store);
} }
} }
if (!(call = hlsl_new_call(ctx, decl, loc))) if (!(call = hlsl_new_call(ctx, decl, loc)))
goto fail; goto fail;
list_add_tail(args->instrs, &call->entry); hlsl_block_add_instr(args->instrs, call);
for (i = 0; i < decl->parameters.count; ++i) for (i = 0; i < decl->parameters.count; ++i)
{ {
@ -3607,9 +3640,9 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
if (!(load = hlsl_new_var_load(ctx, param, &arg->loc))) if (!(load = hlsl_new_var_load(ctx, param, &arg->loc)))
goto fail; goto fail;
list_add_tail(args->instrs, &load->node.entry); hlsl_block_add_instr(args->instrs, &load->node);
if (!add_assignment(ctx, args->instrs, arg, ASSIGN_OP_ASSIGN, &load->node)) if (!add_assignment(ctx, block_to_list(args->instrs), arg, ASSIGN_OP_ASSIGN, &load->node))
goto fail; goto fail;
} }
} }
@ -3620,7 +3653,7 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
if (!(load = hlsl_new_var_load(ctx, decl->return_var, loc))) if (!(load = hlsl_new_var_load(ctx, decl->return_var, loc)))
goto fail; goto fail;
list_add_tail(args->instrs, &load->node.entry); hlsl_block_add_instr(args->instrs, &load->node);
} }
else else
{ {
@ -3629,7 +3662,7 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
if (!(expr = hlsl_new_expr(ctx, HLSL_OP0_VOID, operands, ctx->builtin_types.Void, loc))) if (!(expr = hlsl_new_expr(ctx, HLSL_OP0_VOID, operands, ctx->builtin_types.Void, loc)))
goto fail; goto fail;
list_add_tail(args->instrs, &expr->entry); hlsl_block_add_instr(args->instrs, expr);
} }
} }
else if ((intrinsic = bsearch(name, intrinsic_functions, ARRAY_SIZE(intrinsic_functions), else if ((intrinsic = bsearch(name, intrinsic_functions, ARRAY_SIZE(intrinsic_functions),
@ -3678,7 +3711,7 @@ static struct list *add_call(struct hlsl_ctx *ctx, const char *name,
goto fail; goto fail;
} }
vkd3d_free(args->args); vkd3d_free(args->args);
return args->instrs; return block_to_list(args->instrs);
fail: fail:
free_parse_initializer(args); free_parse_initializer(args);
@ -3715,10 +3748,10 @@ static struct list *add_constructor(struct hlsl_ctx *ctx, struct hlsl_type *type
if (!(load = hlsl_new_var_load(ctx, var, loc))) if (!(load = hlsl_new_var_load(ctx, var, loc)))
return NULL; return NULL;
list_add_tail(params->instrs, &load->node.entry); hlsl_block_add_instr(params->instrs, &load->node);
vkd3d_free(params->args); vkd3d_free(params->args);
return params->instrs; return block_to_list(params->instrs);
} }
static unsigned int hlsl_offset_dim_count(enum hlsl_sampler_dim dim) static unsigned int hlsl_offset_dim_count(enum hlsl_sampler_dim dim)
@ -4724,7 +4757,7 @@ attribute:
} }
$$->name = $2; $$->name = $2;
list_init(&$$->instrs); list_init(&$$->instrs);
list_move_tail(&$$->instrs, $4.instrs); list_move_tail(&$$->instrs, &$4.instrs->instrs);
vkd3d_free($4.instrs); vkd3d_free($4.instrs);
$$->loc = @$; $$->loc = @$;
$$->args_count = $4.args_count; $$->args_count = $4.args_count;
@ -5649,7 +5682,7 @@ complex_initializer:
YYABORT; YYABORT;
} }
$$.args[0] = node_from_list($1); $$.args[0] = node_from_list($1);
$$.instrs = $1; $$.instrs = list_to_block($1);
$$.braces = false; $$.braces = false;
} }
| '{' complex_initializer_list '}' | '{' complex_initializer_list '}'
@ -5680,7 +5713,7 @@ complex_initializer_list:
$$.args = new_args; $$.args = new_args;
for (i = 0; i < $3.args_count; ++i) for (i = 0; i < $3.args_count; ++i)
$$.args[$$.args_count++] = $3.args[i]; $$.args[$$.args_count++] = $3.args[i];
list_move_tail($$.instrs, $3.instrs); hlsl_block_add_block($$.instrs, $3.instrs);
free_parse_initializer(&$3); free_parse_initializer(&$3);
} }
@ -5697,7 +5730,7 @@ initializer_expr_list:
YYABORT; YYABORT;
} }
$$.args[0] = node_from_list($1); $$.args[0] = node_from_list($1);
$$.instrs = $1; $$.instrs = list_to_block($1);
$$.braces = false; $$.braces = false;
} }
| initializer_expr_list ',' initializer_expr | initializer_expr_list ',' initializer_expr
@ -5713,7 +5746,7 @@ initializer_expr_list:
} }
$$.args = new_args; $$.args = new_args;
$$.args[$$.args_count++] = node_from_list($3); $$.args[$$.args_count++] = node_from_list($3);
list_move_tail($$.instrs, $3); list_move_tail(&$$.instrs->instrs, $3);
vkd3d_free($3); vkd3d_free($3);
} }
@ -5855,7 +5888,7 @@ func_arguments:
{ {
$$.args = NULL; $$.args = NULL;
$$.args_count = 0; $$.args_count = 0;
if (!($$.instrs = make_empty_list(ctx))) if (!($$.instrs = make_empty_block(ctx)))
YYABORT; YYABORT;
$$.braces = false; $$.braces = false;
} }
@ -6056,7 +6089,7 @@ postfix_expr:
{ {
struct hlsl_ir_node *object = node_from_list($1); struct hlsl_ir_node *object = node_from_list($1);
list_move_tail($1, $5.instrs); list_move_tail($1, &$5.instrs->instrs);
vkd3d_free($5.instrs); vkd3d_free($5.instrs);
if (!add_method_call(ctx, $1, object, $3, &$5, &@3)) if (!add_method_call(ctx, $1, object, $3, &$5, &@3))
@ -6095,7 +6128,7 @@ unary_expr:
} }
| '-' unary_expr | '-' unary_expr
{ {
add_unary_arithmetic_expr(ctx, $2, HLSL_OP1_NEG, node_from_list($2), &@1); add_unary_arithmetic_expr(ctx, list_to_block($2), HLSL_OP1_NEG, node_from_list($2), &@1);
$$ = $2; $$ = $2;
} }
| '~' unary_expr | '~' unary_expr
@ -6180,7 +6213,7 @@ add_expr:
{ {
struct hlsl_ir_node *neg; struct hlsl_ir_node *neg;
if (!(neg = add_unary_arithmetic_expr(ctx, $3, HLSL_OP1_NEG, node_from_list($3), &@2))) if (!(neg = add_unary_arithmetic_expr(ctx, list_to_block($3), HLSL_OP1_NEG, node_from_list($3), &@2)))
YYABORT; YYABORT;
$$ = add_binary_expr_merge(ctx, $1, $3, HLSL_OP2_ADD, &@2); $$ = add_binary_expr_merge(ctx, $1, $3, HLSL_OP2_ADD, &@2);
} }