X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=24d0479a71f0b6ae956cce8aa3e264ebdff5cc1c;hp=dc90019c71e714dc1d8e38f6bb9fb18ea5bd885f;hb=53e9ed0d9638b911d377df28505f09c0bee62a35;hpb=08891068c89cc26d68436e75c41bfd3f0e1e4a68 diff --git a/ast.c b/ast.c index dc90019..24d0479 100644 --- a/ast.c +++ b/ast.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012, 2013 + * Copyright (C) 2012, 2013, 2014 * Wolfgang Bumiller * Dale Weiler * @@ -75,6 +75,7 @@ static void ast_binstore_delete(ast_binstore*); static bool ast_binstore_codegen(ast_binstore*, ast_function*, bool lvalue, ir_value**); static void ast_binary_delete(ast_binary*); static bool ast_binary_codegen(ast_binary*, ast_function*, bool lvalue, ir_value**); +static bool ast_state_codegen(ast_state*, ast_function*, bool lvalue, ir_value**); /* It must not be possible to get here. */ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self) @@ -113,8 +114,10 @@ static void ast_expression_init(ast_expression *self, self->outr = NULL; self->params = NULL; self->count = 0; - self->flags = 0; self->varparam = NULL; + self->flags = 0; + if (OPTS_OPTION_BOOL(OPTION_COVERAGE)) + self->flags |= AST_FLAG_BLOCK_COVERAGE; } static void ast_expression_delete(ast_expression *self) @@ -357,6 +360,7 @@ ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t) self->cvq = CV_NONE; self->hasvalue = false; self->isimm = false; + self->inexact = false; self->uses = 0; memset(&self->constval, 0, sizeof(self->constval)); self->initlist = NULL; @@ -441,6 +445,24 @@ ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_instantiate(ast_binary, ctx, ast_binary_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binary_codegen); + if (ast_istype(right, ast_unary) && OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) { + ast_unary *unary = ((ast_unary*)right); + ast_expression *normal = unary->operand; + + /* make a-(-b) => a + b */ + if (unary->op == VINSTR_NEG_F || unary->op == VINSTR_NEG_V) { + if (op == INSTR_SUB_F) { + op = INSTR_ADD_F; + right = normal; + ++opts_optimizationcount[OPTIM_PEEPHOLE]; + } else if (op == INSTR_SUB_V) { + op = INSTR_ADD_V; + right = normal; + ++opts_optimizationcount[OPTIM_PEEPHOLE]; + } + } + } + self->op = op; self->left = left; self->right = right; @@ -523,10 +545,8 @@ ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_unary *prev = (ast_unary*)((ast_unary*)expr)->operand; /* Handle for double negation */ - if ((((ast_unary*)expr)->op == VINSTR_NEG_V && op == VINSTR_NEG_V) || - (((ast_unary*)expr)->op == VINSTR_NEG_F && op == VINSTR_NEG_F)) { + 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); @@ -954,6 +974,26 @@ void ast_goto_set_label(ast_goto *self, ast_label *label) self->target = label; } +ast_state* ast_state_new(lex_ctx_t ctx, ast_expression *frame, ast_expression *think) +{ + ast_instantiate(ast_state, ctx, ast_state_delete); + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_state_codegen); + self->framenum = frame; + self->nextthink = think; + return self; +} + +void ast_state_delete(ast_state *self) +{ + if (self->framenum) + ast_unref(self->framenum); + if (self->nextthink) + ast_unref(self->nextthink); + + ast_expression_delete((ast_expression*)self); + mem_d(self); +} + ast_call* ast_call_new(lex_ctx_t ctx, ast_expression *funcexpr) { @@ -1208,6 +1248,9 @@ ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype self->fixedparams = NULL; self->return_value = NULL; + self->static_names = NULL; + self->static_count = 0; + return self; cleanup: @@ -1229,6 +1272,9 @@ void ast_function_delete(ast_function *self) */ ast_unref(self->vtype); } + for (i = 0; i < vec_size(self->static_names); ++i) + mem_d(self->static_names[i]); + vec_free(self->static_names); for (i = 0; i < vec_size(self->blocks); ++i) ast_delete(self->blocks[i]); vec_free(self->blocks); @@ -1408,6 +1454,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; if (self->expression.flags & AST_FLAG_ERASEABLE) self->ir_v->flags |= IR_FLAG_ERASEABLE; + if (self->expression.flags & AST_FLAG_BLOCK_COVERAGE) + func->flags |= IR_FLAG_BLOCK_COVERAGE; /* The function is filled later on ast_function_codegen... */ return true; } @@ -1788,6 +1836,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; @@ -3320,6 +3369,44 @@ bool ast_goto_codegen(ast_goto *self, ast_function *func, bool lvalue, ir_value return true; } +#include +bool ast_state_codegen(ast_state *self, ast_function *func, bool lvalue, ir_value **out) +{ + ast_expression_codegen *cgen; + + ir_value *frameval, *thinkval; + + if (lvalue) { + compile_error(ast_ctx(self), "not an l-value (state operation)"); + return false; + } + if (self->expression.outr) { + compile_error(ast_ctx(self), "internal error: ast_state cannot be reused!"); + return false; + } + *out = NULL; + + cgen = self->framenum->codegen; + if (!(*cgen)((ast_expression*)(self->framenum), func, false, &frameval)) + return false; + if (!frameval) + return false; + + cgen = self->nextthink->codegen; + if (!(*cgen)((ast_expression*)(self->nextthink), func, false, &thinkval)) + return false; + if (!frameval) + return false; + + if (!ir_block_create_state_op(func->curblock, ast_ctx(self), frameval, thinkval)) { + compile_error(ast_ctx(self), "failed to create STATE instruction"); + return false; + } + + self->expression.outr = (ir_value*)1; + return true; +} + bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen;