X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=0faaca1996ec6faf85688d4b52ed382e2c9df032;hb=2524d9c31b624535ac5085f2ae1871a5855912f0;hp=e4d18592b8d0b6480194eefe1c1485b0d676c58a;hpb=897bd5727e61d8a7b9c3bc557818834c06fd84a4;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index e4d1859..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); } @@ -91,9 +92,11 @@ static void ast_expression_delete_full(ast_expression *self) MEM_VEC_FUNCTIONS(ast_expression_common, ast_value*, params) -static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex); -static ast_value* ast_value_copy(const ast_value *self) +ast_value* ast_value_copy(const ast_value *self) { + size_t i; + const ast_expression_common *fromex; + ast_expression_common *selfex; ast_value *cp = ast_value_new(self->expression.node.context, self->name, self->expression.vtype); if (self->expression.next) { cp->expression.next = ast_type_copy(self->expression.node.context, self->expression.next); @@ -102,19 +105,52 @@ static ast_value* ast_value_copy(const ast_value *self) return NULL; } } + 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)) { + ast_value_delete(cp); + return NULL; + } + } return cp; } +bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other) +{ + size_t i; + const ast_expression_common *fromex; + ast_expression_common *selfex; + self->expression.vtype = other->expression.vtype; + if (other->expression.next) { + self->expression.next = (ast_expression*)ast_type_copy(ast_ctx(self), other->expression.next); + if (!self->expression.next) + return false; + } + 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)) + return false; + } + return true; +} + static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); + ast_expression_init(self, NULL); 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) +ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) { size_t i; const ast_expression_common *fromex; @@ -125,6 +161,7 @@ static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) else { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); + ast_expression_init(self, NULL); fromex = &ex->expression; selfex = &self->expression; @@ -144,6 +181,7 @@ static 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)) { @@ -164,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) { @@ -188,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; @@ -308,6 +349,11 @@ ast_unary* ast_unary_new(lex_ctx ctx, int op, self->op = op; self->operand = expr; + if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) { + self->expression.vtype = TYPE_FLOAT; + } else + asterror(ctx, "cannot determine type of unary operation %s", asm_instr[op].m); + return self; } @@ -330,7 +376,8 @@ ast_return* ast_return_new(lex_ctx ctx, ast_expression *expr) void ast_return_delete(ast_return *self) { - ast_unref(self->operand); + if (self->operand) + ast_unref(self->operand); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -355,12 +402,14 @@ ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expressi ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_entfield_codegen); - self->expression.vtype = outtype->expression.vtype; - self->expression.next = ast_type_copy(ctx, outtype->expression.next); - self->entity = entity; self->field = field; + if (!ast_type_adopt(self, outtype)) { + ast_entfield_delete(self); + return NULL; + } + return self; } @@ -382,12 +431,13 @@ 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; } ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_member_codegen); + self->expression.node.keep = true; /* keep */ if (owner->expression.vtype == TYPE_VECTOR) { self->expression.vtype = TYPE_FLOAT; @@ -405,7 +455,14 @@ ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int fiel void ast_member_delete(ast_member *self) { + /* The owner is always an ast_value, which has .keep=true, + * also: ast_members are usually deleted after the owner, thus + * this will cause invalid access ast_unref(self->owner); + * once we allow (expression).x to access a vector-member, we need + * to change this: preferably by creating an alternate ast node for this + * purpose that is not garbage-collected. + */ ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -510,6 +567,10 @@ ast_call* ast_call_new(lex_ctx ctx, self->func = funcexpr; + self->expression.vtype = funcexpr->expression.next->expression.vtype; + if (funcexpr->expression.next->expression.next) + self->expression.next = ast_type_copy(ctx, funcexpr->expression.next->expression.next); + return self; } MEM_VEC_FUNCTIONS(ast_call, ast_expression*, params) @@ -557,11 +618,21 @@ ast_block* ast_block_new(lex_ctx ctx) MEM_VECTOR_INIT(self, locals); MEM_VECTOR_INIT(self, exprs); + MEM_VECTOR_INIT(self, collect); return self; } MEM_VEC_FUNCTIONS(ast_block, ast_value*, locals) MEM_VEC_FUNCTIONS(ast_block, ast_expression*, exprs) +MEM_VEC_FUNCTIONS(ast_block, ast_expression*, collect) + +bool ast_block_collect(ast_block *self, ast_expression *expr) +{ + if (!ast_block_collect_add(self, expr)) + return false; + expr->expression.node.keep = true; + return true; +} void ast_block_delete(ast_block *self) { @@ -572,6 +643,9 @@ void ast_block_delete(ast_block *self) for (i = 0; i < self->locals_count; ++i) ast_delete(self->locals[i]); MEM_VECTOR_CLEAR(self, locals); + for (i = 0; i < self->collect_count; ++i) + ast_delete(self->collect[i]); + MEM_VECTOR_CLEAR(self, collect); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -586,6 +660,8 @@ bool ast_block_set_type(ast_block *self, ast_expression *from) if (!self->expression.next) return false; } + else + self->expression.next = NULL; return true; } @@ -692,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; @@ -707,6 +783,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype); if (!func) return false; + func->context = ast_ctx(self); self->constval.vfunc->ir_func = func; self->ir_v = func->value; @@ -718,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; @@ -728,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) @@ -748,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; } } @@ -782,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 @@ -802,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; } } @@ -825,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; } @@ -852,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; @@ -864,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) { @@ -875,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; } @@ -910,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) @@ -1093,18 +1182,23 @@ 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; - cgen = self->operand->expression.codegen; - /* lvalue! */ - if (!(*cgen)((ast_expression*)(self->operand), func, false, &operand)) - return false; + if (self->operand) { + cgen = self->operand->expression.codegen; + /* lvalue! */ + if (!(*cgen)((ast_expression*)(self->operand), func, false, &operand)) + return false; - if (!ir_block_create_return(func->curblock, operand)) - return false; + if (!ir_block_create_return(func->curblock, operand)) + return false; + } else { + if (!ir_block_create_return(func->curblock, NULL)) + return false; + } return true; } @@ -1199,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 */ @@ -1206,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; @@ -1232,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; @@ -1249,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; @@ -1258,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 && !ir_block_create_jump(ontrue, merge)) + if (ontrue && !ontrue_endblock->final && !ir_block_create_jump(ontrue_endblock, merge)) return false; - if (onfalse && !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 :) @@ -1417,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; @@ -1578,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; }