X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.c;h=acdaa225264c90b0096799ec239a1343499e680f;hp=2adaa724a7007624234d7655a4f66a0a49a1294f;hb=fe3b1b2e8d5e8672e6a15ccb476a1fecc6f30ff7;hpb=387335bb4dc49892ffbabd4407342b3181b5b936

diff --git a/ir.c b/ir.c
index 2adaa72..acdaa22 100644
--- a/ir.c
+++ b/ir.c
@@ -133,6 +133,24 @@ static void irerror(lex_ctx ctx, const char *msg, ...)
     va_end(ap);
 }
 
+static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
+{
+	va_list ap;
+	int lvl = LVL_WARNING;
+
+    if (!OPTS_WARN(warntype))
+        return false;
+
+    if (opts_werror)
+	    lvl = LVL_ERROR;
+
+	va_start(ap, fmt);
+    vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap);
+	va_end(ap);
+
+	return opts_werror;
+}
+
 /***********************************************************************
  *IR Builder
  */
@@ -306,6 +324,8 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
     if (!self)
         return NULL;
 
+    memset(self, 0, sizeof(*self));
+
     self->name = NULL;
     if (!ir_function_set_name(self, "<@unnamed>")) {
         mem_d(self);
@@ -322,6 +342,9 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
     MEM_VECTOR_INIT(self, values);
     MEM_VECTOR_INIT(self, locals);
 
+    self->code_function_def = -1;
+    self->allocated_locals = 0;
+
     self->run_id = 0;
     return self;
 }
@@ -416,7 +439,7 @@ ir_value* ir_function_create_local(ir_function *self, const char *name, int vtyp
     if (param &&
         self->locals_count &&
         self->locals[self->locals_count-1]->store != store_param) {
-        irerror(self->context, "cannot add parameters after adding locals\n");
+        irerror(self->context, "cannot add parameters after adding locals");
         return NULL;
     }
 
@@ -618,6 +641,7 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
     self->members[0] = NULL;
     self->members[1] = NULL;
     self->members[2] = NULL;
+    self->memberof = NULL;
 
     MEM_VECTOR_INIT(self, life);
     return self;
@@ -657,10 +681,11 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     }
     else
     {
-        irerror(self->context, "invalid member access on %s\n", self->name);
+        irerror(self->context, "invalid member access on %s", self->name);
         return NULL;
     }
 
+    m->memberof = self;
     return m;
 }
 
@@ -744,11 +769,22 @@ bool ir_value_set_field(ir_value *self, ir_value *fld)
     return true;
 }
 
+static char *ir_strdup(const char *str)
+{
+    if (str && !*str) {
+        /* actually dup empty strings */
+        char *out = mem_a(1);
+        *out = 0;
+        return out;
+    }
+    return util_strdup(str);
+}
+
 bool ir_value_set_string(ir_value *self, const char *str)
 {
     if (self->vtype != TYPE_STRING)
         return false;
-    self->constval.vstring = util_strdup(str);
+    self->constval.vstring = ir_strdup(str);
     self->isconst = true;
     return true;
 }
@@ -954,13 +990,8 @@ bool ir_values_overlap(const ir_value *a, const ir_value *b)
         /* check if the entries overlap, for that,
          * both must start before the other one ends.
          */
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-        if (la->start <= lb->end &&
-            lb->start <= la->end)
-#else
-        if (la->start <  lb->end &&
-            lb->start <  la->end)
-#endif
+        if (la->start < lb->end &&
+            lb->start < la->end)
         {
             return true;
         }
@@ -1002,9 +1033,9 @@ bool ir_block_create_store_op(ir_block *self, int op, ir_value *target, ir_value
     if (target->store == store_value &&
         (op < INSTR_STOREP_F || op > INSTR_STOREP_FNC))
     {
-        irerror(self->context, "cannot store to an SSA value\n");
-        irerror(self->context, "trying to store: %s <- %s\n", target->name, what->name);
-        irerror(self->context, "instruction: %s\n", asm_instr[op].m);
+        irerror(self->context, "cannot store to an SSA value");
+        irerror(self->context, "trying to store: %s <- %s", target->name, what->name);
+        irerror(self->context, "instruction: %s", asm_instr[op].m);
         return false;
     }
 
@@ -1068,7 +1099,7 @@ bool ir_block_create_return(ir_block *self, ir_value *v)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1090,7 +1121,7 @@ bool ir_block_create_if(ir_block *self, ir_value *v,
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1124,7 +1155,7 @@ bool ir_block_create_jump(ir_block *self, ir_block *to)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1148,7 +1179,7 @@ bool ir_block_create_goto(ir_block *self, ir_block *to)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1206,7 +1237,7 @@ bool ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
         /* Must not be possible to cause this, otherwise the AST
          * is doing something wrong.
          */
-        irerror(self->context, "Invalid entry block for PHI\n");
+        irerror(self->context, "Invalid entry block for PHI");
         abort();
     }
 
@@ -1791,6 +1822,19 @@ bool ir_function_calculate_liferanges(ir_function *self)
             }
         }
     } while (changed);
+    if (self->blocks_count) {
+        ir_block *block = self->blocks[0];
+        for (i = 0; i < block->living_count; ++i) {
+            ir_value *v = block->living[i];
+            if (v->memberof || v->store != store_local)
+                continue;
+            if (irwarning(v->context, WARN_USED_UNINITIALIZED,
+                          "variable `%s` may be used uninitialized in this function", v->name))
+            {
+                return false;
+            }
+        }
+    }
     return true;
 }
 
@@ -1889,6 +1933,10 @@ bool ir_function_allocate_locals(ir_function *self)
         }
     }
 
+    if (!alloc.sizes) {
+        goto cleanup;
+    }
+
     /* Adjust slot positions based on sizes */
     if (!function_allocator_positions_add(&alloc, 0))
         goto error;
@@ -1973,7 +2021,7 @@ static bool ir_block_living_add_instr(ir_block *self, size_t eid)
         tempbool = ir_value_life_merge(self->living[i], eid);
         /* debug
         if (tempbool)
-            irerror(self->context, "block_living_add_instr() value instruction added %s: %i\n", self->living[i]->_name, (int)eid);
+            irerror(self->context, "block_living_add_instr() value instruction added %s: %i", self->living[i]->_name, (int)eid);
         */
         changed = changed || tempbool;
     }
@@ -2008,7 +2056,7 @@ static bool ir_block_life_prop_previous(ir_block* self, ir_block *prev, bool *ch
         if (!ir_block_living_add(self, prev->living[i]))
             return false;
         /*
-        irerror(self->contextt from prev: %s\n", self->label, prev->living[i]->_name);
+        irerror(self->contextt from prev: %s", self->label, prev->living[i]->_name);
         */
     }
     return true;
@@ -2022,17 +2070,9 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     size_t i, o, p;
     /* bitmasks which operands are read from or written to */
     size_t read, write;
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    size_t rd;
-    new_reads_t new_reads;
-#endif
     char dbg_ind[16] = { '#', '0' };
     (void)dbg_ind;
 
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    MEM_VECTOR_INIT(&new_reads, v);
-#endif
-
     if (prev)
     {
         if (!ir_block_life_prop_previous(self, prev, changed))
@@ -2048,38 +2088,26 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         for (p = 0; p < instr->phi_count; ++p)
         {
             value = instr->phi[p].value;
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
+            if (value->memberof)
+                value = value->memberof;
             if (!ir_block_living_find(self, value, NULL) &&
                 !ir_block_living_add(self, value))
             {
-                goto on_error;
-            }
-#else
-            if (!new_reads_t_v_find(&new_reads, value, NULL))
-            {
-                if (!new_reads_t_v_add(&new_reads, value))
-                    goto on_error;
+                return false;
             }
-#endif
         }
 
         /* call params are read operands too */
         for (p = 0; p < instr->params_count; ++p)
         {
             value = instr->params[p];
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
+            if (value->memberof)
+                value = value->memberof;
             if (!ir_block_living_find(self, value, NULL) &&
                 !ir_block_living_add(self, value))
             {
-                goto on_error;
-            }
-#else
-            if (!new_reads_t_v_find(&new_reads, value, NULL))
-            {
-                if (!new_reads_t_v_add(&new_reads, value))
-                    goto on_error;
+                return false;
             }
-#endif
         }
 
         /* See which operands are read and write operands */
@@ -2092,6 +2120,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                 continue;
 
             value = instr->_ops[o];
+            if (value->memberof)
+                value = value->memberof;
 
             /* We only care about locals */
             /* we also calculate parameter liferanges so that locals
@@ -2104,20 +2134,11 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             /* read operands */
             if (read & (1<<o))
             {
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
                 if (!ir_block_living_find(self, value, NULL) &&
                     !ir_block_living_add(self, value))
                 {
-                    goto on_error;
-                }
-#else
-                /* fprintf(stderr, "read: %s\n", value->_name); */
-                if (!new_reads_t_v_find(&new_reads, value, NULL))
-                {
-                    if (!new_reads_t_v_add(&new_reads, value))
-                        goto on_error;
+                    return false;
                 }
-#endif
             }
 
             /* write operands */
@@ -2129,13 +2150,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             {
                 size_t idx;
                 bool in_living = ir_block_living_find(self, value, &idx);
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-                size_t readidx;
-                bool in_reads = new_reads_t_v_find(&new_reads, value, &readidx);
-                if (!in_living && !in_reads)
-#else
                 if (!in_living)
-#endif
                 {
                     /* If the value isn't alive it hasn't been read before... */
                     /* TODO: See if the warning can be emitted during parsing or AST processing
@@ -2164,16 +2179,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                     */
                     *changed = *changed || tempbool;
                     /* Then remove */
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
                     if (!ir_block_living_remove(self, idx))
-                        goto on_error;
-#else
-                    if (in_reads)
-                    {
-                        if (!new_reads_t_v_remove(&new_reads, readidx))
-                            goto on_error;
-                    }
-#endif
+                        return false;
                 }
             }
         }
@@ -2182,21 +2189,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         /*fprintf(stderr, "living added values\n");*/
         *changed = *changed || tempbool;
 
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-        /* new reads: */
-        for (rd = 0; rd < new_reads.v_count; ++rd)
-        {
-            if (!ir_block_living_find(self, new_reads.v[rd], NULL)) {
-                if (!ir_block_living_add(self, new_reads.v[rd]))
-                    goto on_error;
-            }
-            if (!i && !self->entries_count) {
-                /* fix the top */
-                *changed = *changed || ir_value_life_merge(new_reads.v[rd], instr->eid);
-            }
-        }
-        MEM_VECTOR_CLEAR(&new_reads, v);
-#endif
     }
 
     if (self->run_id == self->owner->run_id)
@@ -2211,11 +2203,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     }
 
     return true;
-on_error:
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    MEM_VECTOR_CLEAR(&new_reads, v);
-#endif
-    return false;
 }
 
 /***********************************************************************
@@ -2241,7 +2228,7 @@ static bool gen_global_field(ir_value *global)
     {
         ir_value *fld = global->constval.vpointer;
         if (!fld) {
-            irerror(global->context, "Invalid field constant with no field: %s\n", global->name);
+            irerror(global->context, "Invalid field constant with no field: %s", global->name);
             return false;
         }
 
@@ -2254,7 +2241,7 @@ static bool gen_global_field(ir_value *global)
          * for functions... might as well support that here.
          */
         if (!fld->code.globaladdr) {
-            irerror(global->context, "FIXME: Relocation support\n");
+            irerror(global->context, "FIXME: Relocation support");
             return false;
         }
 
@@ -2284,7 +2271,7 @@ static bool gen_global_pointer(ir_value *global)
     {
         ir_value *target = global->constval.vpointer;
         if (!target) {
-            irerror(global->context, "Invalid pointer constant: %s\n", global->name);
+            irerror(global->context, "Invalid pointer constant: %s", global->name);
             /* NULL pointers are pointing to the NULL constant, which also
              * sits at address 0, but still has an ir_value for itself.
              */
@@ -2300,7 +2287,7 @@ static bool gen_global_pointer(ir_value *global)
             /* FIXME: Check for the constant nullptr ir_value!
              * because then code.globaladdr being 0 is valid.
              */
-            irerror(global->context, "FIXME: Relocation support\n");
+            irerror(global->context, "FIXME: Relocation support");
             return false;
         }
 
@@ -2333,7 +2320,7 @@ tailcall:
         instr = block->instr[i];
 
         if (instr->opcode == VINSTR_PHI) {
-            irerror(block->context, "cannot generate virtual instruction (phi)\n");
+            irerror(block->context, "cannot generate virtual instruction (phi)");
             return false;
         }
 
@@ -2474,7 +2461,7 @@ tailcall:
         }
 
         if (instr->opcode == INSTR_STATE) {
-            irerror(block->context, "TODO: state instruction\n");
+            irerror(block->context, "TODO: state instruction");
             return false;
         }
 
@@ -2523,7 +2510,7 @@ static bool gen_function_code(ir_function *self)
      * for now. Dead blocks will not be translated obviously.
      */
     if (!self->blocks_count) {
-        irerror(self->context, "Function '%s' declared without body.\n", self->name);
+        irerror(self->context, "Function '%s' declared without body.", self->name);
         return false;
     }
 
@@ -2532,7 +2519,7 @@ static bool gen_function_code(ir_function *self)
         return true;
 
     if (!gen_blocks_recursive(self, block)) {
-        irerror(self->context, "failed to generate blocks for '%s'\n", self->name);
+        irerror(self->context, "failed to generate blocks for '%s'", self->name);
         return false;
     }
 
@@ -2556,7 +2543,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
 
     if (!global->isconst || (!global->constval.vfunc))
     {
-        irerror(global->context, "Invalid state of function-global: not constant: %s\n", global->name);
+        irerror(global->context, "Invalid state of function-global: not constant: %s", global->name);
         return false;
     }
 
@@ -2580,7 +2567,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     local_var_end = fun.firstlocal;
     for (i = 0; i < irfun->locals_count; ++i) {
         if (!ir_builder_gen_global(ir, irfun->locals[i])) {
-            irerror(irfun->locals[i]->context, "Failed to generate local %s\n", irfun->locals[i]->name);
+            irerror(irfun->locals[i]->context, "Failed to generate local %s", irfun->locals[i]->name);
             return false;
         }
     }
@@ -2603,16 +2590,36 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     if (irfun->builtin)
         fun.entry = irfun->builtin;
     else {
+        irfun->code_function_def = code_functions_elements;
         fun.entry = code_statements_elements;
-        if (!gen_function_code(irfun)) {
-            irerror(irfun->context, "Failed to generate code for function %s\n", irfun->name);
-            return false;
-        }
     }
 
     return (code_functions_add(fun) >= 0);
 }
 
+static bool gen_global_function_code(ir_builder *ir, ir_value *global)
+{
+    prog_section_function *fundef;
+    ir_function           *irfun;
+
+    irfun = global->constval.vfunc;
+    if (irfun->builtin)
+        return true;
+
+    if (irfun->code_function_def < 0) {
+        irerror(irfun->context, "`%s`: IR global wasn't generated, failed to access function-def", irfun->name);
+        return false;
+    }
+    fundef = &code_functions_data[irfun->code_function_def];
+
+    fundef->entry = code_statements_elements;
+    if (!gen_function_code(irfun)) {
+        irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
+        return false;
+    }
+    return true;
+}
+
 static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
 {
     size_t           i;
@@ -2700,7 +2707,8 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
             return true;
     default:
         /* refuse to create 'void' type or any other fancy business. */
-        irerror(global->context, "Invalid type for global variable %s\n", global->name);
+        irerror(global->context, "Invalid type for global variable `%s`: %s",
+                global->name, type_name[global->vtype]);
         return false;
     }
 }
@@ -2723,7 +2731,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
          * bytes is more than enough for a variable/field name
          */
         if (len+2 >= sizeof(name)) {
-            irerror(field->context, "invalid field name size: %u\n", (unsigned int)len);
+            irerror(field->context, "invalid field name size: %u", (unsigned int)len);
             return false;
         }
 
@@ -2751,7 +2759,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
     fld.type = field->fieldtype;
 
     if (fld.type == TYPE_VOID) {
-        irerror(field->context, "field is missing a type: %s - don't know its size\n", field->name);
+        irerror(field->context, "field is missing a type: %s - don't know its size", field->name);
         return false;
     }
 
@@ -2793,6 +2801,16 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    /* generate function code */
+    for (i = 0; i < self->globals_count; ++i)
+    {
+        if (self->globals[i]->vtype == TYPE_FUNCTION) {
+            if (!gen_global_function_code(self, self->globals[i])) {
+                return false;
+            }
+        }
+    }
+
     printf("writing '%s'...\n", filename);
     return code_write(filename);
 }