X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=7af697961edc9902d79b1d95243244e6111fee7d;hb=1fc8c2f697bb7492949eb0e1ba6703390215778d;hp=158e207f7c5936fb4d5596f2f55b05fecb762991;hpb=9aa86bee1670cdd9a6e2470a081371dee55e644c;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index 158e207..7af6979 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 (warntype && !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
  */
@@ -148,23 +166,22 @@ ir_builder* ir_builder_new(const char *modulename)
     MEM_VECTOR_INIT(self, functions);
     MEM_VECTOR_INIT(self, globals);
     MEM_VECTOR_INIT(self, fields);
+    MEM_VECTOR_INIT(self, filenames);
+    MEM_VECTOR_INIT(self, filestrings);
     self->name = NULL;
     if (!ir_builder_set_name(self, modulename)) {
         mem_d(self);
         return NULL;
     }
 
-    /* globals which always exist */
-
-    /* for now we give it a vector size */
-    ir_builder_create_global(self, "OFS_RETURN", TYPE_VARIANT);
-
     return self;
 }
 
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, fields)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*,    globals)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*,    fields)
 MEM_VEC_FUNCTIONS(ir_builder, ir_function*, functions)
+MEM_VEC_FUNCTIONS(ir_builder, const char*,  filenames)
+MEM_VEC_FUNCTIONS(ir_builder, qcint,        filestrings)
 
 void ir_builder_delete(ir_builder* self)
 {
@@ -182,6 +199,8 @@ void ir_builder_delete(ir_builder* self)
         ir_value_delete(self->fields[i]);
     }
     MEM_VECTOR_CLEAR(self, fields);
+    MEM_VECTOR_CLEAR(self, filenames);
+    MEM_VECTOR_CLEAR(self, filestrings);
     mem_d(self);
 }
 
@@ -413,15 +432,17 @@ ir_value* ir_function_get_local(ir_function *self, const char *name)
 
 ir_value* ir_function_create_local(ir_function *self, const char *name, int vtype, bool param)
 {
-    ir_value *ve = ir_function_get_local(self, name);
-    if (ve) {
+    ir_value *ve;
+
+    /*
+    if (ir_function_get_local(self, name))
         return NULL;
-    }
+    */
 
     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;
     }
 
@@ -447,7 +468,7 @@ ir_block* ir_block_new(ir_function* owner, const char *name)
     memset(self, 0, sizeof(*self));
 
     self->label = NULL;
-    if (!ir_block_set_label(self, name)) {
+    if (name && !ir_block_set_label(self, name)) {
         mem_d(self);
         return NULL;
     }
@@ -476,7 +497,7 @@ MEM_VEC_FUNCTIONS_ALL(ir_block, ir_value*, living)
 void ir_block_delete(ir_block* self)
 {
     size_t i;
-    mem_d(self->label);
+    if (self->label) mem_d(self->label);
     for (i = 0; i != self->instr_count; ++i)
         ir_instr_delete(self->instr[i]);
     MEM_VECTOR_CLEAR(self, instr);
@@ -615,7 +636,11 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
     self->context.file = "<@no context>";
     self->context.line = 0;
     self->name = NULL;
-    ir_value_set_name(self, name);
+    if (name && !ir_value_set_name(self, name)) {
+        irerror(self->context, "out of memory");
+        mem_d(self);
+        return NULL;
+    }
 
     memset(&self->constval, 0, sizeof(self->constval));
     memset(&self->code,     0, sizeof(self->code));
@@ -623,6 +648,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;
@@ -662,10 +688,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;
 }
 
@@ -706,11 +733,12 @@ void ir_value_delete(ir_value* self)
     mem_d(self);
 }
 
-void ir_value_set_name(ir_value *self, const char *name)
+bool ir_value_set_name(ir_value *self, const char *name)
 {
     if (self->name)
         mem_d((void*)self->name);
     self->name = util_strdup(name);
+    return !!self->name;
 }
 
 bool ir_value_set_float(ir_value *self, float f)
@@ -749,11 +777,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;
 }
@@ -891,14 +930,14 @@ bool ir_value_life_merge_into(ir_value *self, const ir_value *other)
             }
 
             if (life->start <  entry->start &&
-                life->end   >= entry->start)
+                life->end+1 >= entry->start)
             {
                 /* starts earlier and overlaps */
                 entry->start = life->start;
             }
 
-            if (life->end     >  entry->end &&
-                life->start-1 <= entry->end)
+            if (life->end   >  entry->end &&
+                life->start <= entry->end+1)
             {
                 /* ends later and overlaps */
                 entry->end = life->end;
@@ -959,13 +998,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;
         }
@@ -1007,9 +1041,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;
     }
 
@@ -1073,7 +1107,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;
@@ -1095,7 +1129,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;
@@ -1129,7 +1163,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;
@@ -1153,7 +1187,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;
@@ -1211,7 +1245,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,11 +1825,25 @@ bool ir_function_calculate_liferanges(ir_function *self)
         {
             if (self->blocks[i]->is_return)
             {
+                self->blocks[i]->living_count = 0;
                 if (!ir_block_life_propagate(self->blocks[i], NULL, &changed))
                     return false;
             }
         }
     } 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;
 }
 
@@ -1894,6 +1942,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;
@@ -1978,7 +2030,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;
     }
@@ -2013,7 +2065,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;
@@ -2027,17 +2079,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))
@@ -2053,43 +2097,44 @@ 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 */
         ir_op_read_write(instr->opcode, &read, &write);
 
+        if (instr->opcode == INSTR_MUL_VF)
+        {
+            /* the float source will get an additional lifetime */
+            tempbool = ir_value_life_merge(instr->_ops[2], instr->eid+1);
+            *changed = *changed || tempbool;
+        }
+        else if (instr->opcode == INSTR_MUL_FV)
+        {
+            /* the float source will get an additional lifetime */
+            tempbool = ir_value_life_merge(instr->_ops[1], instr->eid+1);
+            *changed = *changed || tempbool;
+        }
+
         /* Go through the 3 main operands */
         for (o = 0; o < 3; ++o)
         {
@@ -2097,6 +2142,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
@@ -2109,20 +2156,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 */
@@ -2134,13 +2172,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
@@ -2169,16 +2201,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;
                 }
             }
         }
@@ -2187,21 +2211,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)
@@ -2216,11 +2225,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;
 }
 
 /***********************************************************************
@@ -2238,7 +2242,7 @@ on_error:
  *
  * Breaking conventions is annoying...
  */
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global);
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
 
 static bool gen_global_field(ir_value *global)
 {
@@ -2246,7 +2250,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;
         }
 
@@ -2259,7 +2263,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;
         }
 
@@ -2289,7 +2293,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.
              */
@@ -2305,7 +2309,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;
         }
 
@@ -2338,7 +2342,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;
         }
 
@@ -2479,7 +2483,7 @@ tailcall:
         }
 
         if (instr->opcode == INSTR_STATE) {
-            irerror(block->context, "TODO: state instruction\n");
+            irerror(block->context, "TODO: state instruction");
             return false;
         }
 
@@ -2528,7 +2532,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;
     }
 
@@ -2537,7 +2541,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;
     }
 
@@ -2551,6 +2555,27 @@ static bool gen_function_code(ir_function *self)
     return true;
 }
 
+static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
+{
+    /* NOTE: filename pointers are copied, we never strdup them,
+     * thus we can use pointer-comparison to find the string.
+     */
+    size_t i;
+    qcint  str;
+
+    for (i = 0; i < ir->filenames_count; ++i) {
+        if (ir->filenames[i] == filename)
+            return ir->filestrings[i];
+    }
+
+    str = code_genstring(filename);
+    if (!ir_builder_filenames_add(ir, filename))
+        return 0;
+    if (!ir_builder_filestrings_add(ir, str))
+        ir->filenames_count--;
+    return str;
+}
+
 static bool gen_global_function(ir_builder *ir, ir_value *global)
 {
     prog_section_function fun;
@@ -2561,14 +2586,14 @@ 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;
     }
 
     irfun = global->constval.vfunc;
 
     fun.name    = global->code.name;
-    fun.file    = code_cachedstring(global->context.file);
+    fun.file    = ir_builder_filestring(ir, global->context.file);
     fun.profile = 0; /* always 0 */
     fun.nargs   = irfun->params_count;
 
@@ -2580,11 +2605,10 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     }
 
     fun.firstlocal = code_globals_elements;
-    fun.locals     = irfun->allocated_locals + irfun->locals_count;
 
     local_var_end = fun.firstlocal;
     for (i = 0; i < irfun->locals_count; ++i) {
-        if (!ir_builder_gen_global(ir, irfun->locals[i])) {
+        if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
             irerror(irfun->locals[i]->context, "Failed to generate local %s", irfun->locals[i]->name);
             return false;
         }
@@ -2605,6 +2629,8 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
         code_globals_add(0);
     }
 
+    fun.locals = code_globals_elements - fun.firstlocal;
+
     if (irfun->builtin)
         fun.entry = irfun->builtin;
     else {
@@ -2621,6 +2647,13 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
     ir_function           *irfun;
 
     irfun = global->constval.vfunc;
+    if (!irfun) {
+        irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER,
+                  "function `%s` has no body and in QC implicitly becomes a function-pointer", global->name);
+        /* this was a function pointer, don't generate code for those */
+        return true;
+    }
+
     if (irfun->builtin)
         return true;
 
@@ -2638,7 +2671,7 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
     return true;
 }
 
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
 {
     size_t           i;
     int32_t         *iptr;
@@ -2650,6 +2683,29 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
 
     switch (global->vtype)
     {
+    case TYPE_VOID:
+        if (!strcmp(global->name, "end_sys_globals")) {
+            /* TODO: remember this point... all the defs before this one
+             * should be checksummed and added to progdefs.h when we generate it.
+             */
+        }
+        else if (!strcmp(global->name, "end_sys_fields")) {
+            /* TODO: same as above but for entity-fields rather than globsl
+             */
+        }
+        else
+            irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`",
+                      global->name);
+        /* I'd argue setting it to 0 is sufficient, but maybe some depend on knowing how far
+         * the system fields actually go? Though the engine knows this anyway...
+         * Maybe this could be an -foption
+         * fteqcc creates data for end_sys_* - of size 1, so let's do the same
+         */
+        ir_value_code_setaddr(global, code_globals_add(0));
+        /* Add the def */
+        if (code_defs_add(def) < 0)
+            return false;
+        return true;
     case TYPE_POINTER:
         if (code_defs_add(def) < 0)
             return false;
@@ -2662,33 +2718,35 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
         /* fall through */
     case TYPE_FLOAT:
     {
-        if (code_defs_add(def) < 0)
-            return false;
-
         if (global->isconst) {
             iptr = (int32_t*)&global->constval.vfloat;
             ir_value_code_setaddr(global, code_globals_add(*iptr));
-        } else
+        } else {
             ir_value_code_setaddr(global, code_globals_add(0));
+            if (!islocal)
+                def.type |= DEF_SAVEGLOBAL;
+        }
+        if (code_defs_add(def) < 0)
+            return false;
 
         return global->code.globaladdr >= 0;
     }
     case TYPE_STRING:
     {
-        if (code_defs_add(def) < 0)
-            return false;
         if (global->isconst)
-            ir_value_code_setaddr(global, code_globals_add(code_cachedstring(global->constval.vstring)));
-        else
+            ir_value_code_setaddr(global, code_globals_add(code_genstring(global->constval.vstring)));
+        else {
             ir_value_code_setaddr(global, code_globals_add(0));
+            if (!islocal)
+                def.type |= DEF_SAVEGLOBAL;
+        }
+        if (code_defs_add(def) < 0)
+            return false;
         return global->code.globaladdr >= 0;
     }
     case TYPE_VECTOR:
     {
         size_t d;
-        if (code_defs_add(def) < 0)
-            return false;
-
         if (global->isconst) {
             iptr = (int32_t*)&global->constval.vvec;
             ir_value_code_setaddr(global, code_globals_add(iptr[0]));
@@ -2708,15 +2766,30 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
                 if (code_globals_add(0) < 0)
                     return false;
             }
+            if (!islocal)
+                def.type |= DEF_SAVEGLOBAL;
         }
+
+        if (code_defs_add(def) < 0)
+            return false;
         return global->code.globaladdr >= 0;
     }
     case TYPE_FUNCTION:
+        if (!global->isconst) {
+            ir_value_code_setaddr(global, code_globals_add(0));
+            if (global->code.globaladdr < 0)
+                return false;
+        } else {
+            ir_value_code_setaddr(global, code_globals_elements);
+            code_globals_add(code_functions_elements);
+            if (!gen_global_function(self, global))
+                return false;
+            if (!islocal)
+                def.type |= DEF_SAVEGLOBAL;
+        }
         if (code_defs_add(def) < 0)
             return false;
-        ir_value_code_setaddr(global, code_globals_elements);
-        code_globals_add(code_functions_elements);
-        return gen_global_function(self, global);
+        return true;
     case TYPE_VARIANT:
         /* assume biggest type */
             ir_value_code_setaddr(global, code_globals_add(0));
@@ -2725,7 +2798,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;
     }
 }
@@ -2748,7 +2822,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;
         }
 
@@ -2776,7 +2850,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;
     }
 
@@ -2800,20 +2874,21 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
 
 bool ir_builder_generate(ir_builder *self, const char *filename)
 {
+    prog_section_statement stmt;
     size_t i;
 
     code_init();
 
-    for (i = 0; i < self->fields_count; ++i)
+    for (i = 0; i < self->globals_count; ++i)
     {
-        if (!ir_builder_gen_field(self, self->fields[i])) {
+        if (!ir_builder_gen_global(self, self->globals[i], false)) {
             return false;
         }
     }
 
-    for (i = 0; i < self->globals_count; ++i)
+    for (i = 0; i < self->fields_count; ++i)
     {
-        if (!ir_builder_gen_global(self, self->globals[i])) {
+        if (!ir_builder_gen_field(self, self->fields[i])) {
             return false;
         }
     }
@@ -2828,6 +2903,17 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    /* DP errors if the last instruction is not an INSTR_DONE
+     * and for debugging purposes we add an additional AINSTR_END
+     * to the end of functions, so here it goes:
+     */
+    stmt.opcode = INSTR_DONE;
+    stmt.o1.u1 = 0;
+    stmt.o2.u1 = 0;
+    stmt.o3.u1 = 0;
+    if (code_statements_add(stmt) < 0)
+        return false;
+
     printf("writing '%s'...\n", filename);
     return code_write(filename);
 }
@@ -2897,6 +2983,25 @@ void ir_function_dump(ir_function *f, char *ind,
             oprintf("\n");
         }
     }
+    oprintf("%sliferanges:\n", ind);
+    for (i = 0; i < f->locals_count; ++i) {
+        size_t l;
+        ir_value *v = f->locals[i];
+        oprintf("%s\t%s: unique ", ind, v->name);
+        for (l = 0; l < v->life_count; ++l) {
+            oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
+        }
+        oprintf("\n");
+    }
+    for (i = 0; i < f->values_count; ++i) {
+        size_t l;
+        ir_value *v = f->values[i];
+        oprintf("%s\t%s: @%i ", ind, v->name, (int)v->code.local);
+        for (l = 0; l < v->life_count; ++l) {
+            oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
+        }
+        oprintf("\n");
+    }
     if (f->blocks_count)
     {
         oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
@@ -2985,6 +3090,12 @@ void ir_instr_dump(ir_instr *in, char *ind,
     }
     if (in->bops[1])
         oprintf("%s[%s]", comma, in->bops[1]->label);
+    if (in->params_count) {
+        oprintf("\tparams: ");
+        for (i = 0; i != in->params_count; ++i) {
+            oprintf("%s, ", in->params[i]->name);
+        }
+    }
     oprintf("\n");
     ind[strlen(ind)-1] = 0;
 }
@@ -2998,7 +3109,7 @@ void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
                 oprintf("(void)");
                 break;
             case TYPE_FUNCTION:
-                oprintf("(function)");
+                oprintf("fn:%s", v->name);
                 break;
             case TYPE_FLOAT:
                 oprintf("%g", v->constval.vfloat);
@@ -3030,10 +3141,10 @@ void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
     }
 }
 
-void ir_value_dump_life(ir_value *self, int (*oprintf)(const char*,...))
+void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...))
 {
     size_t i;
-    oprintf("Life of %s:\n", self->name);
+    oprintf("Life of %12s:", self->name);
     for (i = 0; i < self->life_count; ++i)
     {
         oprintf(" + [%i, %i]\n", self->life[i].start, self->life[i].end);