X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=4a07cc2f43131b934526f3f2496f1abe7e1c23d4;hp=66b78ebd1440d04ec27243268592d9c692711413;hb=783b7b6594cb3fde2b9bf945df7a68cb3afa2d5f;hpb=12a864abf5a5cc79f0a8f11535c26bb2009c0ad9 diff --git a/ast.c b/ast.c index 66b78eb..4a07cc2 100644 --- a/ast.c +++ b/ast.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012, 2013 + * Copyright (C) 2012, 2013, 2014, 2015 * Wolfgang Bumiller * Dale Weiler * @@ -27,7 +27,6 @@ #include "gmqcc.h" #include "ast.h" #include "parser.h" -#include "platform.h" #define ast_instantiate(T, ctx, destroyfn) \ T* self = (T*)mem_a(sizeof(T)); \ @@ -76,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) @@ -114,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) @@ -260,7 +262,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi if (!e) { if (pos + 6 >= bufsize) goto full; - platform_strncpy(buf + pos, "(null)", 6); + util_strncpy(buf + pos, "(null)", 6); return pos + 6; } @@ -269,7 +271,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi switch (e->vtype) { case TYPE_VARIANT: - platform_strncpy(buf + pos, "(variant)", 9); + util_strncpy(buf + pos, "(variant)", 9); return pos + 9; case TYPE_FIELD: @@ -315,7 +317,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi if (pos + 1 >= bufsize) goto full; buf[pos++] = '['; - pos += platform_snprintf(buf + pos, bufsize - pos - 1, "%i", (int)e->count); + pos += util_snprintf(buf + pos, bufsize - pos - 1, "%i", (int)e->count); if (pos + 1 >= bufsize) goto full; buf[pos++] = ']'; @@ -326,7 +328,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi typelen = strlen(typestr); if (pos + typelen >= bufsize) goto full; - platform_strncpy(buf + pos, typestr, typelen); + util_strncpy(buf + pos, typestr, typelen); return pos + typelen; } @@ -358,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; @@ -439,10 +442,27 @@ bool ast_value_set_name(ast_value *self, const char *name) ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_expression* left, ast_expression* right) { - ast_binary *fold; 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; @@ -451,11 +471,6 @@ ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_propagate_effects(self, left); ast_propagate_effects(self, right); - if (OPTS_OPTIMIZATION(OPTIM_PEEPHOLE) && (fold = (ast_binary*)fold_superfluous(left, right, op))) { - ast_binary_delete(self); - return fold; - } - if (op >= INSTR_EQ_F && op <= INSTR_GT) self->expression.vtype = TYPE_FLOAT; else if (op == INSTR_AND || op == INSTR_OR) { @@ -530,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); @@ -961,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) { @@ -1215,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: @@ -1236,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); @@ -1414,7 +1453,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) 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; + self->ir_v->flags |= IR_FLAG_ERASABLE; + 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; } @@ -1460,16 +1501,16 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) 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; + self->ir_v->flags |= IR_FLAG_ERASABLE; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); - platform_strncpy(name, self->name, namelen); + util_strncpy(name, self->name, namelen); array->ir_values = (ir_value**)mem_a(sizeof(array->ir_values[0]) * array->expression.count); array->ir_values[0] = v; for (ai = 1; ai < array->expression.count; ++ai) { - platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); array->ir_values[ai] = ir_builder_create_field(ir, name, vtype); if (!array->ir_values[ai]) { mem_d(name); @@ -1495,7 +1536,7 @@ 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; + self->ir_v->flags |= IR_FLAG_ERASABLE; } return true; } @@ -1529,16 +1570,16 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) 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; + self->ir_v->flags |= IR_FLAG_ERASABLE; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); - platform_strncpy(name, self->name, namelen); + util_strncpy(name, self->name, namelen); self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count); self->ir_values[0] = v; for (ai = 1; ai < self->expression.count; ++ai) { - platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); self->ir_values[ai] = ir_builder_create_global(ir, name, vtype); if (!self->ir_values[ai]) { mem_d(name); @@ -1574,7 +1615,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) 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; + self->ir_v->flags |= IR_FLAG_ERASABLE; /* initialize */ if (self->hasvalue) { @@ -1678,11 +1719,11 @@ static bool ast_local_codegen(ast_value *self, ir_function *func, bool param) namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); - platform_strncpy(name, self->name, namelen); + util_strncpy(name, self->name, namelen); self->ir_values[0] = v; for (ai = 1; ai < self->expression.count; ++ai) { - platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); self->ir_values[ai] = ir_function_create_local(func, name, vtype, param); if (!self->ir_values[ai]) { compile_error(ast_ctx(self), "internal_error: ir_builder_create_global failed on `%s`", name); @@ -1795,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; @@ -3327,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;