X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=3c70a73721e49e726c1e010b3bbc0b77e94bc225;hb=d9572e3e303929e1b6d7267d43c0904dac3078f5;hp=2a8caf2cc2c1f263a8eeb1e85510840f729b1b5f;hpb=1b3d5157770f4faa5e1dd60250eb9f413cd9c501;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index 2a8caf2..3c70a73 100644 --- a/ast.c +++ b/ast.c @@ -369,7 +369,8 @@ ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t) self->getter = NULL; self->desc = NULL; - self->argcounter = NULL; + self->argcounter = NULL; + self->intrinsic = false; return self; } @@ -443,6 +444,7 @@ ast_binary* ast_binary_new(lex_ctx_t ctx, int op, self->op = op; self->left = left; self->right = right; + self->right_first = false; ast_propagate_effects(self, left); ast_propagate_effects(self, right); @@ -513,15 +515,34 @@ ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_instantiate(ast_unary, ctx, ast_unary_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_unary_codegen); - self->op = op; + self->op = op; self->operand = expr; + + if (ast_istype(expr, ast_unary) && OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) { + ast_unary *prev = (ast_unary*)((ast_unary*)expr)->operand; + + /* Handle for double negation */ + if (((ast_unary*)expr)->op == op) + prev = (ast_unary*)((ast_unary*)expr)->operand; + + if (ast_istype(prev, ast_unary)) { + ast_expression_delete((ast_expression*)self); + mem_d(self); + ++opts_optimizationcount[OPTIM_PEEPHOLE]; + return prev; + } + } + ast_propagate_effects(self, expr); - if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) { + if ((op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) || op == VINSTR_NEG_F) { self->expression.vtype = TYPE_FLOAT; - } else + } else if (op == VINSTR_NEG_V) { + self->expression.vtype = TYPE_VECTOR; + } else { compile_error(ctx, "cannot determine type of unary operation %s", util_instr_str[op]); + } return self; } @@ -1156,6 +1177,7 @@ ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype 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) { } 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, @@ -1383,6 +1405,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->ir_v = func->value; if (self->expression.flags & AST_FLAG_INCLUDE_DEF) self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; + if (self->expression.flags & AST_FLAG_ERASEABLE) + self->ir_v->flags |= IR_FLAG_ERASEABLE; /* The function is filled later on ast_function_codegen... */ return true; } @@ -1424,8 +1448,11 @@ 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; + if (self->expression.flags & AST_FLAG_ERASEABLE) + self->ir_v->flags |= IR_FLAG_ERASEABLE; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1458,6 +1485,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->ir_v = v; if (self->expression.flags & AST_FLAG_INCLUDE_DEF) self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; + + if (self->expression.flags & AST_FLAG_ERASEABLE) + self->ir_v->flags |= IR_FLAG_ERASEABLE; } return true; } @@ -1487,8 +1517,11 @@ 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; + if (self->expression.flags & AST_FLAG_ERASEABLE) + self->ir_v->flags |= IR_FLAG_ERASEABLE; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1529,8 +1562,11 @@ 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; + if (self->expression.flags & AST_FLAG_ERASEABLE) + self->ir_v->flags |= IR_FLAG_ERASEABLE; /* initialize */ if (self->hasvalue) { @@ -1751,6 +1787,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) ir_value *dummy; ast_expression *ec; ast_expression_codegen *cgen; + size_t i; (void)ir; @@ -1861,6 +1898,17 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) return true; } +static bool starts_a_label(ast_expression *ex) +{ + while (ex && ast_istype(ex, ast_block)) { + ast_block *b = (ast_block*)ex; + ex = b->exprs[0]; + } + if (!ex) + return false; + return ast_istype(ex, ast_label); +} + /* Note, you will not see ast_block_codegen generate ir_blocks. * To the AST and the IR, blocks are 2 different things. * In the AST it represents a block of code, usually enclosed in @@ -1906,7 +1954,7 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu for (i = 0; i < vec_size(self->exprs); ++i) { ast_expression_codegen *gen; - if (func->curblock->final && !ast_istype(self->exprs[i], ast_label)) { + if (func->curblock->final && !starts_a_label(self->exprs[i])) { if (compile_warning(ast_ctx(self->exprs[i]), WARN_UNREACHABLE_CODE, "unreachable statement")) return false; continue; @@ -2037,6 +2085,8 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va if ((OPTS_FLAG(SHORT_LOGIC) || OPTS_FLAG(PERL_LOGIC)) && (self->op == INSTR_AND || self->op == INSTR_OR)) { + /* NOTE: The short-logic path will ignore right_first */ + /* short circuit evaluation */ ir_block *other, *merge; ir_block *from_left, *from_right; @@ -2134,13 +2184,21 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va return true; } - cgen = self->left->codegen; - if (!(*cgen)((ast_expression*)(self->left), func, false, &left)) - return false; - - cgen = self->right->codegen; - if (!(*cgen)((ast_expression*)(self->right), func, false, &right)) - return false; + if (self->right_first) { + cgen = self->right->codegen; + if (!(*cgen)((ast_expression*)(self->right), func, false, &right)) + return false; + cgen = self->left->codegen; + if (!(*cgen)((ast_expression*)(self->left), func, false, &left)) + return false; + } else { + cgen = self->left->codegen; + if (!(*cgen)((ast_expression*)(self->left), func, false, &left)) + return false; + cgen = self->right->codegen; + if (!(*cgen)((ast_expression*)(self->right), func, false, &right)) + return false; + } *out = ir_block_create_binop(func->curblock, ast_ctx(self), ast_function_label(func, "bin"), self->op, left, right); @@ -2545,8 +2603,8 @@ 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; - /* try constant folding away the if */ - if ((fold = fold_cond(condval, func, self)) != -1) + /* try constant folding away the condition */ + if ((fold = fold_cond_ifthen(condval, func, self)) != -1) return fold; if (self->on_true) { @@ -2629,6 +2687,7 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ ir_block *ontrue, *ontrue_out = NULL; ir_block *onfalse, *onfalse_out = NULL; ir_block *merge; + int fold = 0; /* Ternary can never create an lvalue... */ if (lvalue) @@ -2653,6 +2712,10 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ return false; cond_out = func->curblock; + /* try constant folding away the condition */ + if ((fold = fold_cond_ternary(condval, func, self)) != -1) + return fold; + /* create on-true block */ ontrue = ir_function_create_block(ast_ctx(self), func->ir_func, ast_function_label(func, "tern_T")); if (!ontrue)