From 406a32bea6ee2b6925a40b6020c135de459697c8 Mon Sep 17 00:00:00 2001 From: "Wolfgang (Blub) Bumiller" Date: Mon, 13 Aug 2012 19:39:35 +0200 Subject: [PATCH 1/4] prototypes for ast_binstore, and storing outl/outr in ast_expression_common, TODO: let ast_codegen functions reuse previous results so that binstore can call codegen twice --- ast.h | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/ast.h b/ast.h index 29f3061..780f6a9 100644 --- a/ast.h +++ b/ast.h @@ -36,6 +36,7 @@ typedef struct ast_function_s ast_function; typedef struct ast_block_s ast_block; typedef struct ast_binary_s ast_binary; typedef struct ast_store_s ast_store; +typedef struct ast_binstore_s ast_binstore; typedef struct ast_entfield_s ast_entfield; typedef struct ast_ifthen_s ast_ifthen; typedef struct ast_ternary_s ast_ternary; @@ -53,6 +54,7 @@ enum { TYPE_ast_block, TYPE_ast_binary, TYPE_ast_store, + TYPE_ast_binstore, TYPE_ast_entfield, TYPE_ast_ifthen, TYPE_ast_ternary, @@ -104,6 +106,13 @@ typedef struct int vtype; ast_expression *next; MEM_VECTOR_MAKE(ast_value*, params); + /* The codegen functions should store their output values + * so we can call it multiple times without re-evaluating. + * Store lvalue and rvalue seperately though. So that + * ast_entfield for example can generate both if required. + */ + ir_value *outl; + ir_value *outr; } ast_expression_common; MEM_VECTOR_PROTO(ast_expression_common, ast_value*, params); @@ -170,6 +179,28 @@ void ast_binary_delete(ast_binary*); bool ast_binary_codegen(ast_binary*, ast_function*, bool lvalue, ir_value**); +/* Binstore + * + * An assignment including a binary expression with the source as left operand. + * Eg. a += b; is a binstore { INSTR_STORE, INSTR_ADD, a, b } + */ +struct ast_binstore_s +{ + ast_expression_common expression; + + int opstore; + int opbin; + ast_expression *left; + ast_expression *right; +}; +ast_binstore* ast_binstore_new(lex_ctx ctx, + int op, + ast_expression *left, + ast_expression *right); +void ast_binstore_delete(ast_binstore*); + +bool ast_binstore_codegen(ast_binstore*, ast_function*, bool lvalue, ir_value**); + /* Unary * * Regular unary expressions: not,neg From 862b506dcdcc03c4f6251a343488c2fdecbc000d Mon Sep 17 00:00:00 2001 From: "Wolfgang (Blub) Bumiller" Date: Mon, 13 Aug 2012 19:40:06 +0200 Subject: [PATCH 2/4] initialize ast_expression_common.outl/outr --- ast.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ast.c b/ast.c index 5dfad22..ffefb3f 100644 --- a/ast.c +++ b/ast.c @@ -58,6 +58,8 @@ static void ast_expression_init(ast_expression *self, self->expression.codegen = codegen; self->expression.vtype = TYPE_VOID; self->expression.next = NULL; + self->expression.outl = NULL; + self->expression.outr = NULL; MEM_VECTOR_INIT(&self->expression, params); } From 3fd7a64b45347f934c0944051beb7fb841bf97cb Mon Sep 17 00:00:00 2001 From: "Wolfgang (Blub) Bumiller" Date: Mon, 13 Aug 2012 19:54:53 +0200 Subject: [PATCH 3/4] storing generated values and returning them early if they exist - will error when that doesn't make sense eg when trying to call codegen ast_ifthen more than once --- ast.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 80 insertions(+), 6 deletions(-) diff --git a/ast.c b/ast.c index ffefb3f..1186c81 100644 --- a/ast.c +++ b/ast.c @@ -825,6 +825,10 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu * of the form: (a, b, c) = x should not assign to c... */ (void)lvalue; + if (self->expression.outr) { + *out = self->expression.outr; + return true; + } /* output is NULL at first, we'll have each expression * assign to out output, thus, a comma-operator represention @@ -848,6 +852,8 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu return false; } + self->expression.outr = *out; + return true; } @@ -856,10 +862,21 @@ bool ast_store_codegen(ast_store *self, ast_function *func, bool lvalue, ir_valu ast_expression_codegen *cgen; ir_value *left, *right; + if (lvalue && self->expression.outl) { + *out = self->expression.outl; + return true; + } + + if (!lvalue && self->expression.outr) { + *out = self->expression.outr; + return true; + } + cgen = self->dest->expression.codegen; /* lvalue! */ if (!(*cgen)((ast_expression*)(self->dest), func, true, &left)) return false; + self->expression.outl = left; cgen = self->source->expression.codegen; /* rvalue! */ @@ -868,6 +885,7 @@ bool ast_store_codegen(ast_store *self, ast_function *func, bool lvalue, ir_valu if (!ir_block_create_store_op(func->curblock, self->op, left, right)) return false; + self->expression.outr = right; /* Theoretically, an assinment returns its left side as an * lvalue, if we don't need an lvalue though, we return @@ -889,7 +907,11 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va /* In the context of a binary operation, we can disregard * the lvalue flag. */ - (void)lvalue; + (void)lvalue; + if (self->expression.outr) { + *out = self->expression.outr; + return true; + } cgen = self->left->expression.codegen; /* lvalue! */ @@ -905,6 +927,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va self->op, left, right); if (!*out) return false; + self->expression.outr = *out; return true; } @@ -918,6 +941,10 @@ bool ast_unary_codegen(ast_unary *self, ast_function *func, bool lvalue, ir_valu * the lvalue flag. */ (void)lvalue; + if (self->expression.outr) { + *out = self->expression.outr; + return true; + } cgen = self->operand->expression.codegen; /* lvalue! */ @@ -928,6 +955,7 @@ bool ast_unary_codegen(ast_unary *self, ast_function *func, bool lvalue, ir_valu self->op, operand); if (!*out) return false; + self->expression.outr = *out; return true; } @@ -941,6 +969,11 @@ bool ast_return_codegen(ast_return *self, ast_function *func, bool lvalue, ir_va * the lvalue flag. */ (void)lvalue; + if (self->expression.outr) { + printf("internal error: ast_return cannot be reused, it bears no result!\n"); + return false; + } + self->expression.outr = (ir_value*)1; cgen = self->operand->expression.codegen; /* lvalue! */ @@ -963,6 +996,16 @@ bool ast_entfield_codegen(ast_entfield *self, ast_function *func, bool lvalue, i * value in a temp. */ + if (lvalue && self->expression.outl) { + *out = self->expression.outl; + return true; + } + + if (!lvalue && self->expression.outr) { + *out = self->expression.outr; + return true; + } + cgen = self->entity->expression.codegen; if (!(*cgen)((ast_expression*)(self->entity), func, false, &ent)) return false; @@ -982,6 +1025,11 @@ bool ast_entfield_codegen(ast_entfield *self, ast_function *func, bool lvalue, i if (!*out) return false; + if (lvalue) + self->expression.outl = *out; + else + self->expression.outr = *out; + /* Hm that should be it... */ return true; } @@ -991,6 +1039,13 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va ast_expression_codegen *cgen; ir_value *vec; + /* in QC this is always an lvalue */ + (void)lvalue; + if (self->expression.outl) { + *out = self->expression.outl; + return true; + } + cgen = self->owner->expression.codegen; if (!(*cgen)((ast_expression*)(self->owner), func, true, &vec)) return false; @@ -1002,6 +1057,7 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va } *out = ir_value_vector_member(vec, self->field); + self->expression.outl = *out; return (*out != NULL); } @@ -1022,6 +1078,12 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va (void)out; (void)lvalue; + if (self->expression.outr) { + printf("internal error: ast_ifthen cannot be reused, it bears no result!\n"); + return false; + } + self->expression.outr = (ir_value*)1; + /* generate the condition */ func->curblock = cond; cgen = self->cond->expression.codegen; @@ -1102,6 +1164,10 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ ir_block *onfalse; ir_block *merge; + /* Ternary can never create an lvalue... */ + if (lvalue) + return false; + /* In theory it shouldn't be possible to pass through a node twice, but * in case we add any kind of optimization pass for the AST itself, it * may still happen, thus we remember a created ir_value and simply return one @@ -1112,10 +1178,6 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ return true; } - /* Ternary can never create an lvalue... */ - if (lvalue) - return false; - /* In the following, contraty to ast_ifthen, we assume both paths exist. */ /* generate the condition */ @@ -1227,6 +1289,12 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value (void)lvalue; (void)out; + if (self->expression.outr) { + printf("internal error: ast_loop cannot be reused, it bears no result!\n"); + return false; + } + self->expression.outr = (ir_value*)1; + /* NOTE: * Should we ever need some kind of block ordering, better make this function * move blocks around than write a block ordering algorithm later... after all @@ -1431,9 +1499,14 @@ bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value ir_value *funval = NULL; - /* return values are never rvalues */ + /* return values are never lvalues */ (void)lvalue; + if (self->expression.outr) { + *out = self->expression.outr; + return true; + } + cgen = self->func->expression.codegen; if (!(*cgen)((ast_expression*)(self->func), func, false, &funval)) return false; @@ -1467,6 +1540,7 @@ bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value } *out = ir_call_value(callinstr); + self->expression.outr = *out; MEM_VECTOR_CLEAR(¶ms, v); return true; From cfdf915b25352648748095685e00af917549639d Mon Sep 17 00:00:00 2001 From: "Wolfgang (Blub) Bumiller" Date: Tue, 14 Aug 2012 10:40:48 +0200 Subject: [PATCH 4/4] ast_binstore, used for +=, -=, ++, -- etc --- ast.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ast.h | 5 ++-- 2 files changed, 90 insertions(+), 2 deletions(-) diff --git a/ast.c b/ast.c index 1186c81..71c4ae6 100644 --- a/ast.c +++ b/ast.c @@ -236,6 +236,39 @@ void ast_binary_delete(ast_binary *self) mem_d(self); } +ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op, + ast_expression* left, ast_expression* right) +{ + ast_instantiate(ast_binstore, ctx, ast_binstore_delete); + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binstore_codegen); + + self->opstore = storop; + self->opbin = op; + self->dest = left; + self->source = right; + + self->expression.vtype = left->expression.vtype; + if (left->expression.next) { + self->expression.next = ast_type_copy(ctx, left); + if (!self->expression.next) { + ast_delete(self); + return NULL; + } + } + else + self->expression.next = NULL; + + return self; +} + +void ast_binstore_delete(ast_binstore *self) +{ + ast_unref(self->dest); + ast_unref(self->source); + ast_expression_delete((ast_expression*)self); + mem_d(self); +} + ast_unary* ast_unary_new(lex_ctx ctx, int op, ast_expression *expr) { @@ -932,6 +965,60 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va return true; } +bool ast_binstore_codegen(ast_binstore *self, ast_function *func, bool lvalue, ir_value **out) +{ + ast_expression_codegen *cgen; + ir_value *leftl, *leftr, *right, *bin; + + if (lvalue && self->expression.outl) { + *out = self->expression.outl; + return true; + } + + if (!lvalue && self->expression.outr) { + *out = self->expression.outr; + return true; + } + + /* for a binstore we need both an lvalue and an rvalue for the left side */ + /* rvalue of destination! */ + cgen = self->dest->expression.codegen; + if (!(*cgen)((ast_expression*)(self->dest), func, true, &leftr)) + return false; + + /* source as rvalue only */ + cgen = self->source->expression.codegen; + if (!(*cgen)((ast_expression*)(self->source), func, false, &right)) + return false; + + /* now the binary */ + bin = ir_block_create_binop(func->curblock, ast_function_label(func, "binst"), + self->opbin, leftr, right); + self->expression.outr = bin; + + /* now store them */ + cgen = self->dest->expression.codegen; + /* lvalue of destination */ + if (!(*cgen)((ast_expression*)(self->dest), func, true, &leftl)) + return false; + self->expression.outl = leftl; + + if (!ir_block_create_store_op(func->curblock, self->opstore, leftl, bin)) + return false; + self->expression.outr = bin; + + /* Theoretically, an assinment returns its left side as an + * lvalue, if we don't need an lvalue though, we return + * the right side as an rvalue, otherwise we have to + * somehow know whether or not we need to dereference the pointer + * on the left side - that is: OP_LOAD if it was an address. + * Also: in original QC we cannot OP_LOADP *anyway*. + */ + *out = (lvalue ? leftl : bin); + + return true; +} + bool ast_unary_codegen(ast_unary *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen; diff --git a/ast.h b/ast.h index 780f6a9..55f4427 100644 --- a/ast.h +++ b/ast.h @@ -190,10 +190,11 @@ struct ast_binstore_s int opstore; int opbin; - ast_expression *left; - ast_expression *right; + ast_expression *dest; + ast_expression *source; }; ast_binstore* ast_binstore_new(lex_ctx ctx, + int storeop, int op, ast_expression *left, ast_expression *right);