Perliminary stuff for any/all ranges. This doesn't do anything, important, just some...

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index ad85e4fec6bc4d38ab3a360c0254eb8f48070b82..0ee4a2148b6b4e77f8b1d6845c10930d153162e0 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -75,6 +75,8 @@ 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 void ast_range_delete(ast_range *);
+static bool ast_range_codegen(ast_range*, ast_function*, bool lvalue, ir_value**);
 
 /* It must not be possible to get here. */
 static GMQCC_NORETURN void _ast_node_destroy(ast_node *self)
@@ -441,6 +443,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;
@@ -518,8 +538,14 @@ ast_unary* ast_unary_new(lex_ctx_t ctx, int 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);
@@ -530,10 +556,10 @@ ast_unary* ast_unary_new(lex_ctx_t ctx, int op,
 
     ast_propagate_effects(self, expr);
 
-    if (op >= INSTR_NOT_F  && op <= INSTR_NOT_FNC) {
-        self->expression.vtype = TYPE_FLOAT;
-    } else if (op >= VINSTR_NEG_F && op <= VINSTR_NEG_V) {
+    if ((op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) || op == VINSTR_NEG_F) {
         self->expression.vtype = TYPE_FLOAT;
+    } 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]);
     }
@@ -894,6 +920,27 @@ void ast_switch_delete(ast_switch *self)
     mem_d(self);
 }
 
+ast_range* ast_range_new(lex_ctx_t ctx, ast_expression *lower, ast_expression *upper) {
+    ast_instantiate(ast_range, ctx, ast_range_delete);
+    ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_range_codegen);
+
+    self->lower = lower;
+    self->upper = upper;
+
+    ast_propagate_effects(self, lower);
+    ast_propagate_effects(self, upper);
+
+    return self;
+}
+
+void ast_range_delete(ast_range *self) {
+    ast_unref(self->upper);
+    ast_unref(self->lower);
+
+    ast_expression_delete((ast_expression*)self);
+    mem_d(self);
+}
+
 ast_label* ast_label_new(lex_ctx_t ctx, const char *name, bool undefined)
 {
     ast_instantiate(ast_label, ctx, ast_label_delete);
@@ -1200,6 +1247,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:
@@ -1221,6 +1271,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);
@@ -1780,6 +1833,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;
@@ -3235,6 +3289,30 @@ bool ast_switch_codegen(ast_switch *self, ast_function *func, bool lvalue, ir_va
     return true;
 }
 
+bool ast_range_codegen(ast_range *self, ast_function *func, bool lvalue, ir_value **out) {
+    ast_expression_codegen *cgen    = NULL;
+    ir_value               *irupper = NULL;
+    ir_value               *irlower = NULL;
+
+    if (lvalue) {
+        compile_error(ast_ctx(self), "range expression is not an l-value");
+        return false;
+    }
+
+    /* generate (lower .. upper) */
+    cgen = self->lower->codegen;
+    if (!(*cgen)((ast_expression*)(self->lower), func, false, &irlower))
+        return false;
+    cgen = self->upper->codegen;
+    if (!(*cgen)((ast_expression*)(self->upper), func, false, &irupper))
+        return false;
+
+    (void)lvalue;
+    (void)out;
+
+    return true;
+}
+
 bool ast_label_codegen(ast_label *self, ast_function *func, bool lvalue, ir_value **out)
 {
     size_t i;