X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=cdefab67ab27d960f20d0066e513e58a89dd6f91;hb=b6ab0207b1b18a9a8eebffcfab5c61d7302b027d;hp=65c6934b000d2ce65dec16a0ffed4a0f897a7d80;hpb=ae251d391464763fd8293efd65627f9f9fd56572;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index 65c6934..cdefab6 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); @@ -225,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) { @@ -298,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); @@ -445,11 +557,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) { @@ -460,6 +582,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); } @@ -580,7 +705,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; @@ -602,9 +727,21 @@ 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) { - printf("ir_builder_create_global failed\n"); + asterror(ast_ctx(self), "ir_builder_create_global failed\n"); return false; } @@ -624,13 +761,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; } } @@ -678,7 +815,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; } } @@ -701,7 +838,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; } @@ -722,6 +859,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; @@ -743,6 +885,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; } } @@ -764,6 +907,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 @@ -787,6 +934,8 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu return false; } + self->expression.outr = *out; + return true; } @@ -795,10 +944,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! */ @@ -807,6 +967,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 @@ -828,7 +989,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! */ @@ -844,6 +1009,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; } @@ -857,6 +1077,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! */ @@ -867,6 +1091,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; } @@ -880,6 +1105,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! */ @@ -902,6 +1132,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; @@ -918,13 +1158,50 @@ bool ast_entfield_codegen(ast_entfield *self, ast_function *func, bool lvalue, i *out = ir_block_create_load_from_ent(func->curblock, ast_function_label(func, "efv"), ent, field, self->expression.vtype); } - if (!*out) + if (!*out) { + asterror(ast_ctx(self), "failed to create %s instruction (output type %s)", + (lvalue ? "ADDRESS" : "FIELD"), + type_name[self->expression.vtype]); 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; @@ -941,6 +1218,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; @@ -1021,6 +1304,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 @@ -1031,10 +1318,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 */ @@ -1146,6 +1429,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 @@ -1350,9 +1639,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; @@ -1386,6 +1680,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;