X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=202adb64dc08e22ac87011b3920b7b485d64a70d;hb=d8b931fbcf89b6dc656d98c0c6522f879b9e1388;hp=94b254cc91f5a3ad3931fe81d9654e1d738f4047;hpb=8ce331b563e413f7d1c17bbe6bccc48657cfab90;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index 94b254c..202adb6 100644 --- a/ast.c +++ b/ast.c @@ -42,6 +42,8 @@ static bool ast_member_codegen(ast_member*, ast_function*, bool lvalue, ir_value**); static void ast_array_index_delete(ast_array_index*); static bool ast_array_index_codegen(ast_array_index*, ast_function*, bool lvalue, ir_value**); +static void ast_argpipe_delete(ast_argpipe*); +static bool ast_argpipe_codegen(ast_argpipe*, ast_function*, bool lvalue, ir_value**); static void ast_store_delete(ast_store*); static bool ast_store_codegen(ast_store*, ast_function*, bool lvalue, ir_value**); static void ast_ifthen_delete(ast_ifthen*); @@ -82,7 +84,7 @@ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self) } /* Initialize main ast node aprts */ -static void ast_node_init(ast_node *self, lex_ctx ctx, int nodetype) +static void ast_node_init(ast_node *self, lex_ctx_t ctx, int nodetype) { self->context = ctx; self->destroy = &_ast_node_destroy; @@ -172,7 +174,7 @@ void ast_type_adopt_impl(ast_expression *self, const ast_expression *other) } } -static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) +static ast_expression* ast_shallow_type(lex_ctx_t ctx, int vtype) { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); ast_expression_init(self, NULL); @@ -182,7 +184,7 @@ static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) return self; } -ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) +ast_expression* ast_type_copy(lex_ctx_t ctx, const ast_expression *ex) { size_t i; const ast_expression *fromex; @@ -340,7 +342,7 @@ void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize) } static bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out); -ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) +ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t) { ast_instantiate(ast_value, ctx, ast_value_delete); ast_expression_init((ast_expression*)self, @@ -431,7 +433,7 @@ bool ast_value_set_name(ast_value *self, const char *name) return !!self->name; } -ast_binary* ast_binary_new(lex_ctx ctx, int op, +ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binary, ctx, ast_binary_delete); @@ -476,7 +478,7 @@ void ast_binary_delete(ast_binary *self) mem_d(self); } -ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op, +ast_binstore* ast_binstore_new(lex_ctx_t ctx, int storop, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binstore, ctx, ast_binstore_delete); @@ -504,7 +506,7 @@ void ast_binstore_delete(ast_binstore *self) mem_d(self); } -ast_unary* ast_unary_new(lex_ctx ctx, int op, +ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_expression *expr) { ast_instantiate(ast_unary, ctx, ast_unary_delete); @@ -518,7 +520,7 @@ ast_unary* ast_unary_new(lex_ctx ctx, int op, if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) { self->expression.vtype = TYPE_FLOAT; } else - compile_error(ctx, "cannot determine type of unary operation %s", asm_instr[op].m); + compile_error(ctx, "cannot determine type of unary operation %s", util_instr_str[op]); return self; } @@ -530,7 +532,7 @@ void ast_unary_delete(ast_unary *self) mem_d(self); } -ast_return* ast_return_new(lex_ctx ctx, ast_expression *expr) +ast_return* ast_return_new(lex_ctx_t ctx, ast_expression *expr) { ast_instantiate(ast_return, ctx, ast_return_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_return_codegen); @@ -551,7 +553,7 @@ void ast_return_delete(ast_return *self) mem_d(self); } -ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expression *field) +ast_entfield* ast_entfield_new(lex_ctx_t ctx, ast_expression *entity, ast_expression *field) { if (field->vtype != TYPE_FIELD) { compile_error(ctx, "ast_entfield_new with expression not of type field"); @@ -560,7 +562,7 @@ ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expressi return ast_entfield_new_force(ctx, entity, field, field->next); } -ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) +ast_entfield* ast_entfield_new_force(lex_ctx_t ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) { ast_instantiate(ast_entfield, ctx, ast_entfield_delete); @@ -589,7 +591,7 @@ void ast_entfield_delete(ast_entfield *self) mem_d(self); } -ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field, const char *name) +ast_member* ast_member_new(lex_ctx_t ctx, ast_expression *owner, unsigned int field, const char *name) { ast_instantiate(ast_member, ctx, ast_member_delete); if (field >= 3) { @@ -651,7 +653,7 @@ bool ast_member_set_name(ast_member *self, const char *name) return !!self->name; } -ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index) +ast_array_index* ast_array_index_new(lex_ctx_t ctx, ast_expression *array, ast_expression *index) { ast_expression *outtype; ast_instantiate(ast_array_index, ctx, ast_array_index_delete); @@ -694,7 +696,24 @@ void ast_array_index_delete(ast_array_index *self) mem_d(self); } -ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_argpipe* ast_argpipe_new(lex_ctx_t ctx, ast_expression *index) +{ + ast_instantiate(ast_argpipe, ctx, ast_argpipe_delete); + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_argpipe_codegen); + self->index = index; + self->expression.vtype = TYPE_NOEXPR; + return self; +} + +void ast_argpipe_delete(ast_argpipe *self) +{ + if (self->index) + ast_unref(self->index); + ast_expression_delete((ast_expression*)self); + mem_d(self); +} + +ast_ifthen* ast_ifthen_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete); if (!ontrue && !onfalse) { @@ -727,7 +746,7 @@ void ast_ifthen_delete(ast_ifthen *self) mem_d(self); } -ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_ternary* ast_ternary_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_expression *exprtype = ontrue; ast_instantiate(ast_ternary, ctx, ast_ternary_delete); @@ -764,7 +783,7 @@ void ast_ternary_delete(ast_ternary *self) mem_d(self); } -ast_loop* ast_loop_new(lex_ctx ctx, +ast_loop* ast_loop_new(lex_ctx_t ctx, ast_expression *initexpr, ast_expression *precond, bool pre_not, ast_expression *postcond, bool post_not, @@ -813,7 +832,7 @@ void ast_loop_delete(ast_loop *self) mem_d(self); } -ast_breakcont* ast_breakcont_new(lex_ctx ctx, bool iscont, unsigned int levels) +ast_breakcont* ast_breakcont_new(lex_ctx_t ctx, bool iscont, unsigned int levels) { ast_instantiate(ast_breakcont, ctx, ast_breakcont_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_breakcont_codegen); @@ -830,7 +849,7 @@ void ast_breakcont_delete(ast_breakcont *self) mem_d(self); } -ast_switch* ast_switch_new(lex_ctx ctx, ast_expression *op) +ast_switch* ast_switch_new(lex_ctx_t ctx, ast_expression *op) { ast_instantiate(ast_switch, ctx, ast_switch_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_switch_codegen); @@ -859,7 +878,7 @@ void ast_switch_delete(ast_switch *self) mem_d(self); } -ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined) +ast_label* ast_label_new(lex_ctx_t 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); @@ -887,7 +906,7 @@ static void ast_label_register_goto(ast_label *self, ast_goto *g) vec_push(self->gotos, g); } -ast_goto* ast_goto_new(lex_ctx ctx, const char *name) +ast_goto* ast_goto_new(lex_ctx_t ctx, const char *name) { ast_instantiate(ast_goto, ctx, ast_goto_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_goto_codegen); @@ -911,7 +930,7 @@ void ast_goto_set_label(ast_goto *self, ast_label *label) self->target = label; } -ast_call* ast_call_new(lex_ctx ctx, +ast_call* ast_call_new(lex_ctx_t ctx, ast_expression *funcexpr) { ast_instantiate(ast_call, ctx, ast_call_delete); @@ -950,7 +969,50 @@ void ast_call_delete(ast_call *self) mem_d(self); } -bool ast_call_check_types(ast_call *self) +static bool ast_call_check_vararg(ast_call *self, ast_expression *va_type, ast_expression *exp_type) +{ + char texp[1024]; + char tgot[1024]; + if (!exp_type) + return true; + if (!va_type || !ast_compare_type(va_type, exp_type)) + { + if (va_type && exp_type) + { + ast_type_to_string(va_type, tgot, sizeof(tgot)); + ast_type_to_string(exp_type, texp, sizeof(texp)); + if (OPTS_FLAG(UNSAFE_VARARGS)) { + if (compile_warning(ast_ctx(self), WARN_UNSAFE_TYPES, + "piped variadic argument differs in type: constrained to type %s, expected type %s", + tgot, texp)) + return false; + } else { + compile_error(ast_ctx(self), + "piped variadic argument differs in type: constrained to type %s, expected type %s", + tgot, texp); + return false; + } + } + else + { + ast_type_to_string(exp_type, texp, sizeof(texp)); + if (OPTS_FLAG(UNSAFE_VARARGS)) { + if (compile_warning(ast_ctx(self), WARN_UNSAFE_TYPES, + "piped variadic argument may differ in type: expected type %s", + texp)) + return false; + } else { + compile_error(ast_ctx(self), + "piped variadic argument may differ in type: expected type %s", + texp); + return false; + } + } + } + return true; +} + +bool ast_call_check_types(ast_call *self, ast_expression *va_type) { char texp[1024]; char tgot[1024]; @@ -962,7 +1024,16 @@ bool ast_call_check_types(ast_call *self) count = vec_size(func->params); for (i = 0; i < count; ++i) { - if (!ast_compare_type(self->params[i], (ast_expression*)(func->params[i]))) + if (ast_istype(self->params[i], ast_argpipe)) { + /* warn about type safety instead */ + if (i+1 != count) { + compile_error(ast_ctx(self), "argpipe must be the last parameter to a function call"); + return false; + } + if (!ast_call_check_vararg(self, va_type, (ast_expression*)func->params[i])) + retval = false; + } + else if (!ast_compare_type(self->params[i], (ast_expression*)(func->params[i]))) { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); ast_type_to_string((ast_expression*)func->params[i], texp, sizeof(texp)); @@ -975,11 +1046,20 @@ bool ast_call_check_types(ast_call *self) count = vec_size(self->params); if (count > vec_size(func->params) && func->varparam) { for (; i < count; ++i) { - if (!ast_compare_type(self->params[i], func->varparam)) + if (ast_istype(self->params[i], ast_argpipe)) { + /* warn about type safety instead */ + if (i+1 != count) { + compile_error(ast_ctx(self), "argpipe must be the last parameter to a function call"); + return false; + } + if (!ast_call_check_vararg(self, va_type, func->varparam)) + retval = false; + } + else if (!ast_compare_type(self->params[i], func->varparam)) { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); ast_type_to_string(func->varparam, texp, sizeof(texp)); - compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s", + compile_error(ast_ctx(self), "invalid type for variadic parameter %u in function call: expected %s, got %s", (unsigned int)(i+1), texp, tgot); /* we don't immediately return */ retval = false; @@ -989,7 +1069,7 @@ bool ast_call_check_types(ast_call *self) return retval; } -ast_store* ast_store_new(lex_ctx ctx, int op, +ast_store* ast_store_new(lex_ctx_t ctx, int op, ast_expression *dest, ast_expression *source) { ast_instantiate(ast_store, ctx, ast_store_delete); @@ -1014,7 +1094,7 @@ void ast_store_delete(ast_store *self) mem_d(self); } -ast_block* ast_block_new(lex_ctx ctx) +ast_block* ast_block_new(lex_ctx_t ctx) { ast_instantiate(ast_block, ctx, ast_block_delete); ast_expression_init((ast_expression*)self, @@ -1068,20 +1148,19 @@ void ast_block_set_type(ast_block *self, ast_expression *from) ast_type_adopt(self, from); } -ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) +ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype) { ast_instantiate(ast_function, ctx, ast_function_delete); - if (!vtype || - vtype->hasvalue || - vtype->expression.vtype != TYPE_FUNCTION) - { + if (!vtype) { + compile_error(ast_ctx(self), "internal error: ast_function_new condition 0"); + goto cleanup; + } else if (vtype->hasvalue || vtype->expression.vtype != TYPE_FUNCTION) { compile_error(ast_ctx(self), "internal error: ast_function_new condition %i %i type=%i (probably 2 bodies?)", (int)!vtype, (int)vtype->hasvalue, vtype->expression.vtype); - mem_d(self); - return NULL; + goto cleanup; } self->vtype = vtype; @@ -1106,6 +1185,10 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) self->return_value = NULL; return self; + +cleanup: + mem_d(self); + return NULL; } void ast_function_delete(ast_function *self) @@ -1480,7 +1563,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) return true; error: /* clean up */ - ir_value_delete(v); + if(v) ir_value_delete(v); return false; } @@ -2404,6 +2487,19 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva return true; } +bool ast_argpipe_codegen(ast_argpipe *self, ast_function *func, bool lvalue, ir_value **out) +{ + *out = NULL; + if (lvalue) { + compile_error(ast_ctx(self), "argpipe node: not an lvalue"); + return false; + } + (void)func; + (void)out; + compile_error(ast_ctx(self), "TODO: argpipe codegen not implemented"); + return false; +} + bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen; @@ -2435,6 +2531,31 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va /* update the block which will get the jump - because short-logic or ternaries may have changed this */ cond = func->curblock; + /* eliminate branches if value is constant */ + if (condval->vtype == TYPE_FLOAT && condval->hasvalue && condval->cvq == CV_CONST) { + /* don't generate if statements */ + if (condval->constval.vfloat == 1.0f && self->on_true) { + if (!(ontrue = ir_function_create_block(ast_ctx(self), func->ir_func, ast_function_label(func, "ontrue")))) + return false; + /* generate */ + if (!(*(cgen = self->on_true->codegen))((ast_expression*)(self->on_true), func, false, &dummy)) + return false; + if (!ir_block_create_jump(func->curblock, ast_ctx(self), ontrue)) + return false; + func->curblock = ontrue; + return true; + } else if (condval->constval.vfloat == 0.0f && self->on_false) { + if (!(onfalse = ir_function_create_block(ast_ctx(self), func->ir_func, ast_function_label(func, "onfalse")))) + return false; + /* generate */ + if (!(*(cgen = self->on_false->codegen))((ast_expression*)(self->on_false), func, false, &dummy)) + return false; + if (!ir_block_create_jump(func->curblock, ast_ctx(self), onfalse)) + return false; + func->curblock = onfalse; + return true; + } + } /* on-true path */ if (self->on_true) { @@ -2787,9 +2908,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value /* Now all blocks are in place */ /* From 'bin' we jump to whatever comes first */ if (bprecond) tmpblock = bprecond; - else if (bbody) tmpblock = bbody; + else tmpblock = bbody; /* can never be null */ + + /* DEAD CODE else if (bpostcond) tmpblock = bpostcond; else tmpblock = bout; + */ + if (!ir_block_create_jump(bin, ast_ctx(self), tmpblock)) return false; @@ -2797,10 +2922,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value if (bprecond) { ir_block *ontrue, *onfalse; - if (bbody) ontrue = bbody; + ontrue = bbody; /* can never be null */ + + /* all of this is dead code else if (bincrement) ontrue = bincrement; - else if (bpostcond) ontrue = bpostcond; - else ontrue = bprecond; + else ontrue = bpostcond; + */ + onfalse = bout; if (self->pre_not) { tmpblock = ontrue; @@ -2838,9 +2966,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value { ir_block *ontrue, *onfalse; if (bprecond) ontrue = bprecond; - else if (bbody) ontrue = bbody; + else ontrue = bbody; /* can never be null */ + + /* all of this is dead code else if (bincrement) ontrue = bincrement; else ontrue = bpostcond; + */ + onfalse = bout; if (self->post_not) { tmpblock = ontrue;