From 1a36da15afa711ff5eb9c4872f9d238bcd06ad10 Mon Sep 17 00:00:00 2001 From: Matteo Bruni Date: Fri, 20 Jul 2012 16:37:41 +0200 Subject: [PATCH] d3dcompiler: Parse assignments. --- dlls/d3dcompiler_43/d3dcompiler_private.h | 23 ++++ dlls/d3dcompiler_43/hlsl.y | 5 +- dlls/d3dcompiler_43/utils.c | 217 ++++++++++++++++++++++++++++++ 3 files changed, 244 insertions(+), 1 deletion(-) diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index efba0802f8f..05454f19da5 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -700,6 +700,7 @@ struct source_location enum hlsl_ir_node_type { HLSL_IR_VAR = 0, + HLSL_IR_ASSIGNMENT, HLSL_IR_CONSTANT, HLSL_IR_CONSTRUCTOR, HLSL_IR_DEREF, @@ -750,6 +751,14 @@ struct hlsl_ir_function_decl struct list *body; }; +struct hlsl_ir_assignment +{ + struct hlsl_ir_node node; + struct hlsl_ir_node *lhs; + struct hlsl_ir_node *rhs; + unsigned char writemask; +}; + enum hlsl_ir_expr_op { HLSL_IR_UNOP_BIT_NOT = 0, HLSL_IR_UNOP_LOGIC_NOT, @@ -960,6 +969,12 @@ void hlsl_message(const char *fmt, ...) PRINTF_ATTR(1,2) DECLSPEC_HIDDEN; void hlsl_report_message(const char *filename, DWORD line, DWORD column, enum hlsl_error_level level, const char *fmt, ...) PRINTF_ATTR(5,6) DECLSPEC_HIDDEN; +static inline struct hlsl_ir_var *var_from_node(const struct hlsl_ir_node *node) +{ + assert(node->type == HLSL_IR_VAR); + return CONTAINING_RECORD(node, struct hlsl_ir_var, node); +} + static inline struct hlsl_ir_expr *expr_from_node(const struct hlsl_ir_node *node) { assert(node->type == HLSL_IR_EXPR); @@ -978,6 +993,12 @@ static inline struct hlsl_ir_constant *constant_from_node(const struct hlsl_ir_n return CONTAINING_RECORD(node, struct hlsl_ir_constant, node); } +static inline struct hlsl_ir_assignment *assignment_from_node(const struct hlsl_ir_node *node) +{ + assert(node->type == HLSL_IR_ASSIGNMENT); + return CONTAINING_RECORD(node, struct hlsl_ir_assignment, node); +} + static inline struct hlsl_ir_constructor *constructor_from_node(const struct hlsl_ir_node *node) { assert(node->type == HLSL_IR_CONSTRUCTOR); @@ -1020,6 +1041,8 @@ struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc) DECLSPEC_HIDDEN; struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var) DECLSPEC_HIDDEN; +struct hlsl_ir_node *make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op, + DWORD writemask, struct hlsl_ir_node *right) DECLSPEC_HIDDEN; void push_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN; BOOL pop_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN; struct hlsl_ir_function_decl *new_func_decl(const char *name, struct hlsl_type *return_type, struct list *parameters) DECLSPEC_HIDDEN; diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y index 6184d6a8fbc..c67ab541bb8 100644 --- a/dlls/d3dcompiler_43/hlsl.y +++ b/dlls/d3dcompiler_43/hlsl.y @@ -1213,7 +1213,10 @@ assignment_expr: conditional_expr } | unary_expr assign_op assignment_expr { - FIXME("Assignment\n"); + $$ = make_assignment($1, $2, BWRITERSP_WRITEMASK_ALL, $3); + if (!$$) + return 1; + set_location(&$$->loc, &@2); } assign_op: '=' diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c index afb441cc804..2072a6643c6 100644 --- a/dlls/d3dcompiler_43/utils.c +++ b/dlls/d3dcompiler_43/utils.c @@ -947,6 +947,68 @@ static BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_typ return TRUE; } +static BOOL convertible_data_type(struct hlsl_type *type) +{ + return type->type != HLSL_CLASS_OBJECT; +} + +BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2) +{ + if (!convertible_data_type(t1) || !convertible_data_type(t2)) + return FALSE; + + if (t1->type <= HLSL_CLASS_LAST_NUMERIC) + { + /* Scalar vars can be converted to any other numeric data type */ + if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC) + return TRUE; + /* The other way around is true too */ + if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC) + return TRUE; + } + + if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY) + { + return components_count_type(t1) == components_count_type(t2); + } + + if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC) + || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY)) + { + /* e.g. float4[3] to float4 is allowed */ + if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2)) + return TRUE; + if (components_count_type(t1) == components_count_type(t2)) + return TRUE; + return FALSE; + } + + if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR) + { + if (t1->dimx >= t2->dimx) + return TRUE; + return FALSE; + } + + if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX) + { + if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX + && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy) + return TRUE; + + /* Matrix-vector conversion is apparently allowed if they have the same components count */ + if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR) + && components_count_type(t1) == components_count_type(t2)) + return TRUE; + return FALSE; + } + + if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT) + return compare_hlsl_types(t1, t2); + + return FALSE; +} + static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2) { if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR) @@ -1340,6 +1402,120 @@ struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var) return deref; } +static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op) +{ + static const enum hlsl_ir_expr_op ops[] = + { + 0, + HLSL_IR_BINOP_ADD, + HLSL_IR_BINOP_SUB, + HLSL_IR_BINOP_MUL, + HLSL_IR_BINOP_DIV, + HLSL_IR_BINOP_MOD, + HLSL_IR_BINOP_LSHIFT, + HLSL_IR_BINOP_RSHIFT, + HLSL_IR_BINOP_BIT_AND, + HLSL_IR_BINOP_BIT_OR, + HLSL_IR_BINOP_BIT_XOR, + }; + + return ops[op]; +} + +struct hlsl_ir_node *make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op, + DWORD writemask, struct hlsl_ir_node *right) +{ + struct hlsl_ir_expr *expr; + struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign)); + struct hlsl_type *type; + struct hlsl_ir_node *lhs, *rhs; + + if (!assign) + { + ERR("Out of memory\n"); + return NULL; + } + + TRACE("Creating proper assignment expression.\n"); + rhs = right; + if (writemask == BWRITERSP_WRITEMASK_ALL) + type = left->data_type; + else + { + FIXME("Assignments with writemasks not supported yet."); + type = NULL; + } + assign->node.type = HLSL_IR_ASSIGNMENT; + assign->node.loc = left->loc; + assign->node.data_type = type; + assign->writemask = writemask; + FIXME("Check for casts in the lhs.\n"); + + lhs = left; + if (lhs->type == HLSL_IR_VAR) + { + struct hlsl_ir_deref *lhs_deref = new_var_deref(var_from_node(lhs)); + lhs = &lhs_deref->node; + } + + if (!compare_hlsl_types(type, rhs->data_type)) + { + struct hlsl_ir_node *converted_rhs; + + if (!implicit_compatible_data_types(rhs->data_type, type)) + { + hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR, + "can't implicitly convert %s to %s", + debug_hlsl_type(rhs->data_type), debug_hlsl_type(type)); + free_instr(lhs); + free_instr(rhs); + return NULL; + } + if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy) + hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING, + "implicit truncation of vector type"); + + converted_rhs = implicit_conversion(rhs, type, &rhs->loc); + if (!converted_rhs) + { + ERR("Couldn't implicitly convert expression to %s.", debug_hlsl_type(type)); + free_instr(lhs); + free_instr(rhs); + return NULL; + } + rhs = converted_rhs; + } + + assign->lhs = lhs; + if (assign_op != ASSIGN_OP_ASSIGN) + { + struct hlsl_ir_node *operands[3]; + enum hlsl_ir_expr_op op = op_from_assignment(assign_op); + + if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR) + { + FIXME("LHS expression not supported in compound assignments yet.\n"); + assign->rhs = rhs; + } + else + { + struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref; + + TRACE("Adding an expression for the compound assignment.\n"); + new_deref = new_var_deref(lhs_deref->v.var); + operands[0] = &new_deref->node; + operands[1] = rhs; + operands[2] = NULL; + expr = new_expr(op, operands, &left->loc); + assign->rhs = &expr->node; + } + } + else + assign->rhs = rhs; + + return &assign->node; +} + void push_scope(struct hlsl_parse_ctx *ctx) { struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope)); @@ -1477,6 +1653,7 @@ static const char *debug_node_type(enum hlsl_ir_node_type type) const char *names[] = { "HLSL_IR_VAR", + "HLSL_IR_ASSIGNMENT", "HLSL_IR_CONSTANT", "HLSL_IR_CONSTRUCTOR", "HLSL_IR_DEREF", @@ -1666,6 +1843,33 @@ static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *construc TRACE(")"); } +const char *debug_writemask(DWORD writemask) +{ + char string[5], components[] = {'x', 'y', 'z', 'w'}; + unsigned int i = 0, pos = 0; + + while (writemask) + { + if (writemask & 1) + string[pos++] = components[i]; + writemask >>= 1; + i++; + } + string[pos] = '\0'; + return wine_dbg_sprintf(".%s", string); +} + +void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign) +{ + TRACE("= ("); + debug_dump_instr(assign->lhs); + if (assign->writemask != BWRITERSP_WRITEMASK_ALL) + TRACE("%s", debug_writemask(assign->writemask)); + TRACE(" "); + debug_dump_instr(assign->rhs); + TRACE(")"); +} + void debug_dump_instr(const struct hlsl_ir_node *instr) { switch (instr->type) @@ -1679,6 +1883,9 @@ void debug_dump_instr(const struct hlsl_ir_node *instr) case HLSL_IR_CONSTANT: debug_dump_ir_constant(constant_from_node(instr)); break; + case HLSL_IR_ASSIGNMENT: + debug_dump_ir_assignment(assignment_from_node(instr)); + break; case HLSL_IR_CONSTRUCTOR: debug_dump_ir_constructor(constructor_from_node(instr)); break; @@ -1806,6 +2013,13 @@ static void free_ir_expr(struct hlsl_ir_expr *expr) d3dcompiler_free(expr); } +static void free_ir_assignment(struct hlsl_ir_assignment *assignment) +{ + free_instr(assignment->lhs); + free_instr(assignment->rhs); + d3dcompiler_free(assignment); +} + void free_instr(struct hlsl_ir_node *node) { switch (node->type) @@ -1825,6 +2039,9 @@ void free_instr(struct hlsl_ir_node *node) case HLSL_IR_EXPR: free_ir_expr(expr_from_node(node)); break; + case HLSL_IR_ASSIGNMENT: + free_ir_assignment(assignment_from_node(node)); + break; default: FIXME("Unsupported node type %s\n", debug_node_type(node->type)); } -- 2.11.4.GIT