X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=0faaca1996ec6faf85688d4b52ed382e2c9df032;hb=5e4b8846d1838c6c0244646b2a3f81c94a647b13;hp=d0d4334c65e1aabb0c38f85b6681198d6bb61e75;hpb=49cd86e8ed8aa2675131c6fe8d5b71b18b7aab40;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index d0d4334..0faaca1 100644 --- a/ast.c +++ b/ast.c @@ -64,11 +64,12 @@ static void ast_node_init(ast_node *self, lex_ctx ctx, int nodetype) static void ast_expression_init(ast_expression *self, ast_expression_codegen *codegen) { - self->expression.codegen = codegen; - self->expression.vtype = TYPE_VOID; - self->expression.next = NULL; - self->expression.outl = NULL; - self->expression.outr = NULL; + self->expression.codegen = codegen; + self->expression.vtype = TYPE_VOID; + self->expression.next = NULL; + self->expression.outl = NULL; + self->expression.outr = NULL; + self->expression.variadic = false; MEM_VECTOR_INIT(&self->expression, params); } @@ -106,6 +107,7 @@ ast_value* ast_value_copy(const ast_value *self) } fromex = &self->expression; selfex = &cp->expression; + selfex->variadic = fromex->variadic; for (i = 0; i < fromex->params_count; ++i) { ast_value *v = ast_value_copy(fromex->params[i]); if (!v || !ast_expression_common_params_add(selfex, v)) { @@ -129,6 +131,7 @@ bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other) } fromex = &other->expression; selfex = &self->expression; + selfex->variadic = fromex->variadic; for (i = 0; i < fromex->params_count; ++i) { ast_value *v = ast_value_copy(fromex->params[i]); if (!v || !ast_expression_common_params_add(selfex, v)) @@ -178,6 +181,7 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) else selfex->next = NULL; + selfex->variadic = fromex->variadic; for (i = 0; i < fromex->params_count; ++i) { ast_value *v = ast_value_copy(fromex->params[i]); if (!v || !ast_expression_common_params_add(selfex, v)) { @@ -198,6 +202,8 @@ bool ast_compare_type(ast_expression *a, ast_expression *b) return false; if (a->expression.params_count != b->expression.params_count) return false; + if (a->expression.variadic != b->expression.variadic) + return false; if (a->expression.params_count) { size_t i; for (i = 0; i < a->expression.params_count; ++i) { @@ -222,6 +228,7 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) self->expression.vtype = t; self->expression.next = NULL; self->isconst = false; + self->uses = 0; memset(&self->constval, 0, sizeof(self->constval)); self->ir_v = NULL; @@ -424,7 +431,7 @@ ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int fiel 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]); + asterror(ctx, "member-access on an invalid owner of type %s", type_name[owner->expression.vtype]); mem_d(self); return NULL; } @@ -761,7 +768,7 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu * on all the globals. */ if (!self->ir_v) { - asterror(ast_ctx(self), "ast_value used before generated (%s)\n", self->name); + asterror(ast_ctx(self), "ast_value used before generated (%s)", self->name); return false; } *out = self->ir_v; @@ -788,8 +795,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) v = ir_builder_create_field(ir, self->name, self->expression.next->expression.vtype); if (!v) return false; + v->context = ast_ctx(self); if (self->isconst) { - asterror(ast_ctx(self), "TODO: constant field pointers with value\n"); + asterror(ast_ctx(self), "TODO: constant field pointers with value"); goto error; } self->ir_v = v; @@ -798,9 +806,10 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) v = ir_builder_create_global(ir, self->name, self->expression.vtype); if (!v) { - asterror(ast_ctx(self), "ir_builder_create_global failed\n"); + asterror(ast_ctx(self), "ir_builder_create_global failed"); return false; } + v->context = ast_ctx(self); if (self->isconst) { switch (self->expression.vtype) @@ -818,13 +827,13 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) goto error; break; case TYPE_FUNCTION: - asterror(ast_ctx(self), "global of type function not properly generated\n"); + asterror(ast_ctx(self), "global of type function not properly generated"); goto error; /* Cannot generate an IR value for a function, * need a pointer pointing to a function rather. */ default: - asterror(ast_ctx(self), "TODO: global constant type %i\n", self->expression.vtype); + asterror(ast_ctx(self), "TODO: global constant type %i", self->expression.vtype); break; } } @@ -852,6 +861,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) v = ir_function_create_local(func, self->name, self->expression.vtype, param); if (!v) return false; + v->context = ast_ctx(self); /* A constant local... hmmm... * I suppose the IR will have to deal with this @@ -872,7 +882,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) goto error; break; default: - asterror(ast_ctx(self), "TODO: global constant type %i\n", self->expression.vtype); + asterror(ast_ctx(self), "TODO: global constant type %i", self->expression.vtype); break; } } @@ -895,7 +905,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) irf = self->ir_func; if (!irf) { - asterror(ast_ctx(self), "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"); return false; } @@ -922,8 +932,10 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) } self->curblock = ir_function_create_block(irf, "entry"); - if (!self->curblock) + if (!self->curblock) { + asterror(ast_ctx(self), "failed to allocate entry block for `%s`", self->name); return false; + } for (i = 0; i < self->blocks_count; ++i) { ast_expression_codegen *gen = self->blocks[i]->expression.codegen; @@ -934,6 +946,9 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) /* TODO: check return types */ if (!self->curblock->is_return) { + return ir_block_create_return(self->curblock, NULL); + /* From now on the parser has to handle this situation */ +#if 0 if (!self->vtype->expression.next || self->vtype->expression.next->expression.vtype == TYPE_VOID) { @@ -945,6 +960,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) asterror(ast_ctx(self), "function `%s` missing return value", self->name); return false; } +#endif } return true; } @@ -980,8 +996,11 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu /* generate locals */ for (i = 0; i < self->locals_count; ++i) { - if (!ast_local_codegen(self->locals[i], func->ir_func, false)) + if (!ast_local_codegen(self->locals[i], func->ir_func, false)) { + if (opts_debug) + asterror(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name); return false; + } } for (i = 0; i < self->exprs_count; ++i) @@ -1163,7 +1182,7 @@ bool ast_return_codegen(ast_return *self, ast_function *func, bool lvalue, ir_va */ (void)lvalue; if (self->expression.outr) { - asterror(ast_ctx(self), "internal error: ast_return cannot be reused, it bears no result!\n"); + asterror(ast_ctx(self), "internal error: ast_return cannot be reused, it bears no result!"); return false; } self->expression.outr = (ir_value*)1; @@ -1274,6 +1293,8 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va ir_block *cond = func->curblock; ir_block *ontrue; ir_block *onfalse; + ir_block *ontrue_endblock; + ir_block *onfalse_endblock; ir_block *merge; /* We don't output any value, thus also don't care about r/lvalue */ @@ -1281,7 +1302,7 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va (void)lvalue; if (self->expression.outr) { - asterror(ast_ctx(self), "internal error: ast_ifthen cannot be reused, it bears no result!\n"); + asterror(ast_ctx(self), "internal error: ast_ifthen cannot be reused, it bears no result!"); return false; } self->expression.outr = (ir_value*)1; @@ -1307,6 +1328,9 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va cgen = self->on_true->expression.codegen; if (!(*cgen)((ast_expression*)(self->on_true), func, false, &dummy)) return false; + + /* we now need to work from the current endpoint */ + ontrue_endblock = func->curblock; } else ontrue = NULL; @@ -1324,6 +1348,9 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va cgen = self->on_false->expression.codegen; if (!(*cgen)((ast_expression*)(self->on_false), func, false, &dummy)) return false; + + /* we now need to work from the current endpoint */ + onfalse_endblock = func->curblock; } else onfalse = NULL; @@ -1333,9 +1360,9 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va return false; /* add jumps ot the merge block */ - if (ontrue && !ontrue->final && !ir_block_create_jump(ontrue, merge)) + if (ontrue && !ontrue_endblock->final && !ir_block_create_jump(ontrue_endblock, merge)) return false; - if (onfalse && !onfalse->final && !ir_block_create_jump(onfalse, merge)) + if (onfalse && !onfalse_endblock->final && !ir_block_create_jump(onfalse_endblock, merge)) return false; /* we create the if here, that way all blocks are ordered :) @@ -1492,7 +1519,7 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value (void)out; if (self->expression.outr) { - asterror(ast_ctx(self), "internal error: ast_loop cannot be reused, it bears no result!\n"); + asterror(ast_ctx(self), "internal error: ast_loop cannot be reused, it bears no result!"); return false; } self->expression.outr = (ir_value*)1; @@ -1653,7 +1680,7 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value else if (bpostcond) tmpblock = bpostcond; else if (bprecond) tmpblock = bprecond; else tmpblock = bout; - if (!ir_block_create_jump(end_bbody, tmpblock)) + if (!end_bbody->final && !ir_block_create_jump(end_bbody, tmpblock)) return false; }