X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=ast.c;h=d8bd293d451b5e6671a495ec188190c004055237;hb=98567e20f31f4d095320269dc166c904cd3ad67a;hp=0b61fe0653afbf5b6b6701ff714d0ee98899656c;hpb=47a8a69f1ccbf9118de58d92f7174d5f65d3910c;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index 0b61fe0..d8bd293 100644 --- a/ast.c +++ b/ast.c @@ -35,6 +35,15 @@ ast_node_init((ast_node*)self, ctx, TYPE_##T); \ ( (ast_node*)self )->node.destroy = (ast_node_delete*)destroyfn +/* error handling */ +static void asterror(lex_ctx ctx, const char *msg, ...) +{ + va_list ap; + va_start(ap, msg); + cvprintmsg(ctx, LVL_ERROR, "error", msg, ap); + va_end(ap); +} + /* It must not be possible to get here. */ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self) { @@ -58,6 +67,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); } @@ -94,6 +105,15 @@ static ast_value* ast_value_copy(const ast_value *self) return cp; } +static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) +{ + ast_instantiate(ast_expression, ctx, ast_expression_delete_full); + self->expression.codegen = NULL; + self->expression.next = NULL; + self->expression.vtype = vtype; + return self; +} + static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) { size_t i; @@ -136,6 +156,27 @@ static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) } } +bool ast_compare_type(ast_expression *a, ast_expression *b) +{ + if (a->expression.vtype != b->expression.vtype) + return false; + if (!a->expression.next != !b->expression.next) + return false; + if (a->expression.params_count != b->expression.params_count) + return false; + if (a->expression.params_count) { + size_t i; + for (i = 0; i < a->expression.params_count; ++i) { + if (!ast_compare_type((ast_expression*)a->expression.params[i], + (ast_expression*)b->expression.params[i])) + return false; + } + } + if (a->expression.next) + return ast_compare_type(a->expression.next, b->expression.next); + return true; +} + ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) { ast_instantiate(ast_value, ctx, ast_value_delete); @@ -202,6 +243,18 @@ ast_binary* ast_binary_new(lex_ctx ctx, int op, self->left = left; self->right = right; + if (op >= INSTR_EQ_F && op <= INSTR_GT) + self->expression.vtype = TYPE_FLOAT; + else if (op == INSTR_AND || op == INSTR_OR || + op == INSTR_BITAND || op == INSTR_BITOR) + self->expression.vtype = TYPE_FLOAT; + else if (op == INSTR_MUL_VF || op == INSTR_MUL_FV) + self->expression.vtype = TYPE_VECTOR; + else if (op == INSTR_MUL_V) + self->expression.vtype = TYPE_FLOAT; + else + self->expression.vtype = left->expression.vtype; + return self; } @@ -213,6 +266,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) { @@ -286,6 +372,44 @@ void ast_entfield_delete(ast_entfield *self) mem_d(self); } +ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field) +{ + ast_instantiate(ast_member, ctx, ast_member_delete); + if (field >= 3) { + mem_d(self); + return NULL; + } + + if (owner->expression.vtype != TYPE_VECTOR && + owner->expression.vtype != TYPE_FIELD) { + asterror(ctx, "member-access on an invalid owner of type %s\n", type_name[owner->expression.vtype]); + mem_d(self); + return NULL; + } + + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_member_codegen); + + if (owner->expression.vtype == TYPE_VECTOR) { + self->expression.vtype = TYPE_FLOAT; + self->expression.next = NULL; + } else { + self->expression.vtype = TYPE_FIELD; + self->expression.next = ast_shallow_type(ctx, TYPE_FLOAT); + } + + self->owner = owner; + self->field = field; + + return self; +} + +void ast_member_delete(ast_member *self) +{ + ast_unref(self->owner); + ast_expression_delete((ast_expression*)self); + mem_d(self); +} + ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete); @@ -568,7 +692,7 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu * on all the globals. */ if (!self->ir_v) { - printf("ast_value used before generated (%s)\n", self->name); + asterror(ast_ctx(self), "ast_value used before generated (%s)\n", self->name); return false; } *out = self->ir_v; @@ -590,9 +714,23 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) return true; } + if (self->expression.vtype == TYPE_FIELD) { + v = ir_builder_create_field(ir, self->name, self->expression.next->expression.vtype); + if (!v) + return false; + if (self->isconst) { + asterror(ast_ctx(self), "TODO: constant field pointers with value\n"); + goto error; + } + self->ir_v = v; + return true; + } + v = ir_builder_create_global(ir, self->name, self->expression.vtype); - if (!v) + if (!v) { + asterror(ast_ctx(self), "ir_builder_create_global failed\n"); return false; + } if (self->isconst) { switch (self->expression.vtype) @@ -610,13 +748,13 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) goto error; break; case TYPE_FUNCTION: - printf("global of type function not properly generated\n"); + asterror(ast_ctx(self), "global of type function not properly generated\n"); goto error; /* Cannot generate an IR value for a function, * need a pointer pointing to a function rather. */ default: - printf("TODO: global constant type %i\n", self->expression.vtype); + asterror(ast_ctx(self), "TODO: global constant type %i\n", self->expression.vtype); break; } } @@ -664,7 +802,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) goto error; break; default: - printf("TODO: global constant type %i\n", self->expression.vtype); + asterror(ast_ctx(self), "TODO: global constant type %i\n", self->expression.vtype); break; } } @@ -687,7 +825,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) irf = self->ir_func; if (!irf) { - printf("ast_function's related ast_value was not generated yet\n"); + asterror(ast_ctx(self), "ast_function's related ast_value was not generated yet\n"); return false; } @@ -708,6 +846,11 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) return true; } + if (!self->blocks_count) { + asterror(ast_ctx(self), "function `%s` has no body", self->name); + return false; + } + self->curblock = ir_function_create_block(irf, "entry"); if (!self->curblock) return false; @@ -729,6 +872,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) else { /* error("missing return"); */ + asterror(ast_ctx(self), "function `%s` missing return value", self->name); return false; } } @@ -750,6 +894,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 @@ -773,6 +921,8 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu return false; } + self->expression.outr = *out; + return true; } @@ -781,10 +931,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! */ @@ -793,6 +954,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 @@ -814,7 +976,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! */ @@ -830,6 +996,61 @@ 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; +} + +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, false, &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; } @@ -843,6 +1064,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! */ @@ -853,6 +1078,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; } @@ -866,6 +1092,11 @@ bool ast_return_codegen(ast_return *self, ast_function *func, bool lvalue, ir_va * the lvalue flag. */ (void)lvalue; + if (self->expression.outr) { + asterror(ast_ctx(self), "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! */ @@ -888,6 +1119,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; @@ -907,10 +1148,43 @@ 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; } +bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_value **out) +{ + 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; + + if (vec->vtype != TYPE_VECTOR && + !(vec->vtype == TYPE_FIELD && self->owner->expression.next->expression.vtype == TYPE_VECTOR)) + { + return false; + } + + *out = ir_value_vector_member(vec, self->field); + self->expression.outl = *out; + + return (*out != NULL); +} + bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen; @@ -927,6 +1201,12 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va (void)out; (void)lvalue; + if (self->expression.outr) { + asterror(ast_ctx(self), "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; @@ -1007,6 +1287,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 @@ -1017,10 +1301,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 */ @@ -1132,6 +1412,12 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value (void)lvalue; (void)out; + if (self->expression.outr) { + asterror(ast_ctx(self), "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 @@ -1336,9 +1622,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; @@ -1372,6 +1663,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;