X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=41eadfa56b83fbfa8f0c9ed77d0550c682e52037;hp=89d738cd5d40cc060e9236f41f168275b7ae167a;hb=d201cfe6b49f95ba8bcaa0eebb3a6fb7e1a16913;hpb=40b2a26e896fd7a3f54c94ccb2abd9d517491822 diff --git a/ast.c b/ast.c index 89d738c..41eadfa 100644 --- a/ast.c +++ b/ast.c @@ -1,6 +1,7 @@ /* - * Copyright (C) 2012 + * Copyright (C) 2012, 2013 * Wolfgang Bumiller + * Dale Weiler * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in @@ -74,6 +75,7 @@ static void ast_expression_init(ast_expression *self, self->expression.params = NULL; self->expression.count = 0; self->expression.flags = 0; + self->expression.varparam = NULL; } static void ast_expression_delete(ast_expression *self) @@ -203,14 +205,20 @@ 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 == TYPE_NIL || + b->expression.vtype == TYPE_NIL) + return true; if (a->expression.vtype != b->expression.vtype) return false; if (!a->expression.next != !b->expression.next) return false; if (vec_size(a->expression.params) != vec_size(b->expression.params)) return false; - if (a->expression.flags != b->expression.flags) + if ((a->expression.flags & AST_FLAG_TYPE_MASK) != + (b->expression.flags & AST_FLAG_TYPE_MASK) ) + { return false; + } if (vec_size(a->expression.params)) { size_t i; for (i = 0; i < vec_size(a->expression.params); ++i) { @@ -338,6 +346,9 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) self->setter = NULL; self->getter = NULL; + self->desc = NULL; + + self->argcounter = NULL; return self; } @@ -346,6 +357,8 @@ void ast_value_delete(ast_value* self) { if (self->name) mem_d((void*)self->name); + if (self->argcounter) + mem_d((void*)self->argcounter); if (self->hasvalue) { switch (self->expression.vtype) { @@ -365,6 +378,10 @@ void ast_value_delete(ast_value* self) } if (self->ir_values) mem_d(self->ir_values); + + if (self->desc) + mem_d(self->desc); + ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -570,7 +587,8 @@ ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int fiel self->expression.next = ast_shallow_type(ctx, TYPE_FLOAT); } - self->owner = owner; + self->rvalue = false; + self->owner = owner; ast_propagate_effects(self, owner); self->field = field; @@ -683,6 +701,7 @@ void ast_ifthen_delete(ast_ifthen *self) ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { + ast_expression *exprtype = ontrue; ast_instantiate(ast_ternary, ctx, ast_ternary_delete); /* This time NEITHER must be NULL */ if (!ontrue || !onfalse) { @@ -698,7 +717,9 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression * ast_propagate_effects(self, ontrue); ast_propagate_effects(self, onfalse); - if (!ast_type_adopt(self, ontrue)) { + if (ontrue->expression.vtype == TYPE_NIL) + exprtype = onfalse; + if (!ast_type_adopt(self, exprtype)) { ast_ternary_delete(self); return NULL; } @@ -708,9 +729,12 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression * void ast_ternary_delete(ast_ternary *self) { - ast_unref(self->cond); - ast_unref(self->on_true); - ast_unref(self->on_false); + /* the if()s are only there because computed-gotos can set them + * to NULL + */ + if (self->cond) ast_unref(self->cond); + if (self->on_true) ast_unref(self->on_true); + if (self->on_false) ast_unref(self->on_false); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -810,14 +834,17 @@ void ast_switch_delete(ast_switch *self) mem_d(self); } -ast_label* ast_label_new(lex_ctx ctx, const char *name) +ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined) { ast_instantiate(ast_label, ctx, ast_label_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_label_codegen); - self->name = util_strdup(name); - self->irblock = NULL; - self->gotos = NULL; + self->expression.vtype = TYPE_NOEXPR; + + self->name = util_strdup(name); + self->irblock = NULL; + self->gotos = NULL; + self->undefined = undefined; return self; } @@ -863,12 +890,18 @@ ast_call* ast_call_new(lex_ctx ctx, ast_expression *funcexpr) { ast_instantiate(ast_call, ctx, ast_call_delete); + if (!funcexpr->expression.next) { + compile_error(ctx, "not a function"); + mem_d(self); + return NULL; + } ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_call_codegen); ast_side_effects(self) = true; - self->params = NULL; - self->func = funcexpr; + self->params = NULL; + self->func = funcexpr; + self->va_count = NULL; ast_type_adopt(self, funcexpr->expression.next); @@ -885,12 +918,17 @@ void ast_call_delete(ast_call *self) if (self->func) ast_unref(self->func); + if (self->va_count) + ast_unref(self->va_count); + ast_expression_delete((ast_expression*)self); mem_d(self); } bool ast_call_check_types(ast_call *self) { + char texp[1024]; + char tgot[1024]; size_t i; bool retval = true; const ast_expression *func = self->func; @@ -899,9 +937,8 @@ bool ast_call_check_types(ast_call *self) count = vec_size(func->expression.params); for (i = 0; i < count; ++i) { - if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) { - char texp[1024]; - char tgot[1024]; + if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) + { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); ast_type_to_string((ast_expression*)func->expression.params[i], texp, sizeof(texp)); compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s", @@ -910,6 +947,20 @@ bool ast_call_check_types(ast_call *self) retval = false; } } + count = vec_size(self->params); + if (count > vec_size(func->expression.params) && func->expression.varparam) { + for (; i < count; ++i) { + if (!ast_compare_type(self->params[i], func->expression.varparam)) + { + ast_type_to_string(self->params[i], tgot, sizeof(tgot)); + ast_type_to_string(func->expression.varparam, texp, sizeof(texp)); + compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s", + (unsigned int)(i+1), texp, tgot); + /* we don't immediately return */ + retval = false; + } + } + } return retval; } @@ -1032,6 +1083,10 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) vtype->hasvalue = true; vtype->constval.vfunc = self; + self->varargs = NULL; + self->argc = NULL; + self->fixedparams = NULL; + return self; } @@ -1054,6 +1109,12 @@ void ast_function_delete(ast_function *self) vec_free(self->blocks); vec_free(self->breakblocks); vec_free(self->continueblocks); + if (self->varargs) + ast_delete(self->varargs); + if (self->argc) + ast_delete(self->argc); + if (self->fixedparams) + ast_unref(self->fixedparams); mem_d(self); } @@ -1063,8 +1124,12 @@ const char* ast_function_label(ast_function *self, const char *prefix) size_t len; char *from; - if (!opts.dump && !opts.dumpfin && !opts.debug) + if (!OPTION_VALUE_BOOL(OPTION_DUMP) && + !OPTION_VALUE_BOOL(OPTION_DUMPFIN) && + !OPTION_VALUE_BOOL(OPTION_DEBUG)) + { return NULL; + } id = (self->labelcount++); len = strlen(prefix); @@ -1141,6 +1206,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->constval.vfunc->ir_func = func; self->ir_v = func->value; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; /* The function is filled later on ast_function_codegen... */ return true; } @@ -1168,7 +1235,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */ - if (!array->expression.count || array->expression.count > opts.max_array_size) + if (!array->expression.count || array->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count); elemtype = &array->expression.next->expression; @@ -1183,6 +1250,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) v->unique_life = true; v->locked = true; array->ir_v = self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1201,6 +1270,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) array->ir_values[ai]->context = ast_ctx(self); array->ir_values[ai]->unique_life = true; array->ir_values[ai]->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF; } mem_d(name); } @@ -1211,6 +1282,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) return false; v->context = ast_ctx(self); self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; } return true; } @@ -1224,7 +1297,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) int vtype = elemtype->vtype; /* same as with field arrays */ - if (!self->expression.count || self->expression.count > opts.max_array_size) + if (!self->expression.count || self->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); v = ir_builder_create_global(ir, self->name, vtype); @@ -1235,6 +1308,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) v->context = ast_ctx(self); v->unique_life = true; v->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + v->flags |= IR_FLAG_INCLUDE_DEF; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1253,6 +1328,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->ir_values[ai]->context = ast_ctx(self); self->ir_values[ai]->unique_life = true; self->ir_values[ai]->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF; } mem_d(name); } @@ -1315,6 +1392,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) /* link us to the ir_value */ v->cvq = self->cvq; self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; return true; error: /* clean up */ @@ -1349,13 +1428,13 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) func->flags |= IR_FLAG_HAS_ARRAYS; - if (param) { + if (param && !(self->expression.flags & AST_FLAG_IS_VARARG)) { compile_error(ast_ctx(self), "array-parameters are not supported"); return false; } /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */ - if (!self->expression.count || self->expression.count > opts.max_array_size) { + if (!self->expression.count || self->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) { compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); } @@ -1490,7 +1569,8 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) { ir_function *irf; ir_value *dummy; - ast_expression_common *ec; + ast_expression_common *ec; + ast_expression_codegen *cgen; size_t i; (void)ir; @@ -1515,6 +1595,12 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) } } + if (self->varargs) { + if (!ast_local_codegen(self->varargs, self->ir_func, true)) + return false; + irf->max_varargs = self->varargs->expression.count; + } + if (self->builtin) { irf->builtin = self->builtin; return true; @@ -1525,15 +1611,39 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) return false; } - self->curblock = ir_function_create_block(ast_ctx(self), irf, "entry"); + irf->first = self->curblock = ir_function_create_block(ast_ctx(self), irf, "entry"); if (!self->curblock) { compile_error(ast_ctx(self), "failed to allocate entry block for `%s`", self->name); return false; } + if (self->argc) { + ir_value *va_count; + ir_value *fixed; + ir_value *sub; + if (!ast_local_codegen(self->argc, self->ir_func, true)) + return false; + cgen = self->argc->expression.codegen; + if (!(*cgen)((ast_expression*)(self->argc), self, false, &va_count)) + return false; + cgen = self->fixedparams->expression.codegen; + if (!(*cgen)((ast_expression*)(self->fixedparams), self, false, &fixed)) + return false; + sub = ir_block_create_binop(self->curblock, ast_ctx(self), + ast_function_label(self, "va_count"), INSTR_SUB_F, + ir_builder_get_va_count(ir), fixed); + if (!sub) + return false; + if (!ir_block_create_store_op(self->curblock, ast_ctx(self), INSTR_STORE_F, + va_count, sub)) + { + return false; + } + } + for (i = 0; i < vec_size(self->blocks); ++i) { - ast_expression_codegen *gen = self->blocks[i]->expression.codegen; - if (!(*gen)((ast_expression*)self->blocks[i], self, false, &dummy)) + cgen = self->blocks[i]->expression.codegen; + if (!(*cgen)((ast_expression*)self->blocks[i], self, false, &dummy)) return false; } @@ -1545,7 +1655,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) { return ir_block_create_return(self->curblock, ast_ctx(self), NULL); } - else if (vec_size(self->curblock->entries)) + else if (vec_size(self->curblock->entries) || self->curblock == irf->first) { /* error("missing return"); */ if (compile_warning(ast_ctx(self), WARN_MISSING_RETURN_VALUES, @@ -1596,7 +1706,7 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu for (i = 0; i < vec_size(self->locals); ++i) { if (!ast_local_codegen(self->locals[i], func->ir_func, false)) { - if (opts.debug) + if (OPTION_VALUE_BOOL(OPTION_DEBUG)) compile_error(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name); return false; } @@ -1829,6 +1939,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va } self->expression.outr = *out; + codegen_output_type(self, *out); return true; } @@ -1845,6 +1956,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va if (!*out) return false; self->expression.outr = *out; + codegen_output_type(self, *out); return true; } @@ -2082,14 +2194,17 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va ir_value *vec; /* in QC this is always an lvalue */ - (void)lvalue; + if (lvalue && self->rvalue) { + compile_error(ast_ctx(self), "not an l-value (member access)"); + return false; + } if (self->expression.outl) { *out = self->expression.outl; return true; } cgen = self->owner->expression.codegen; - if (!(*cgen)((ast_expression*)(self->owner), func, true, &vec)) + if (!(*cgen)((ast_expression*)(self->owner), func, false, &vec)) return false; if (vec->vtype != TYPE_VECTOR && @@ -2160,6 +2275,8 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva *out = ir_call_value(call); self->expression.outr = *out; + (*out)->vtype = self->expression.vtype; + codegen_output_type(self, *out); return true; } @@ -2185,6 +2302,8 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva compile_error(ast_ctx(self), "array indexing here needs an integer constant"); return false; } + (*out)->vtype = self->expression.vtype; + codegen_output_type(self, *out); return true; } @@ -2379,15 +2498,18 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ /* Here, now, we need a PHI node * but first some sanity checking... */ - if (trueval->vtype != falseval->vtype) { + if (trueval->vtype != falseval->vtype && trueval->vtype != TYPE_NIL && falseval->vtype != TYPE_NIL) { /* error("ternary with different types on the two sides"); */ + compile_error(ast_ctx(self), "internal error: ternary operand types invalid"); return false; } /* create PHI */ - phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), trueval->vtype); - if (!phi) + phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), self->expression.vtype); + if (!phi) { + compile_error(ast_ctx(self), "internal error: failed to generate phi node"); return false; + } ir_phi_add(phi, ontrue_out, trueval); ir_phi_add(phi, onfalse_out, falseval); @@ -2843,6 +2965,11 @@ bool ast_label_codegen(ast_label *self, ast_function *func, bool lvalue, ir_valu size_t i; ir_value *dummy; + if (self->undefined) { + compile_error(ast_ctx(self), "internal error: ast_label never defined"); + return false; + } + *out = NULL; if (lvalue) { compile_error(ast_ctx(self), "internal error: ast_label cannot be an lvalue"); @@ -2952,6 +3079,20 @@ bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value vec_push(params, param); } + /* varargs counter */ + if (self->va_count) { + ir_value *va_count; + ir_builder *builder = func->curblock->owner->owner; + cgen = self->va_count->expression.codegen; + if (!(*cgen)((ast_expression*)(self->va_count), func, false, &va_count)) + return false; + if (!ir_block_create_store_op(func->curblock, ast_ctx(self), INSTR_STORE_F, + ir_builder_get_va_count(builder), va_count)) + { + return false; + } + } + callinstr = ir_block_create_call(func->curblock, ast_ctx(self), ast_function_label(func, "call"), funval, !!(self->func->expression.flags & AST_FLAG_NORETURN));