X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=dff566e94a687410840b13d557cc6368f5d54768;hb=9296257c716a7a8c35324f38f0ab5cfede7ba74d;hp=26aec5c25157f7545a827184da11314405f5078a;hpb=e1ffa04bc2c905328c621818b1c704c2738da2d7;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index 26aec5c..dff566e 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
  */
@@ -154,11 +172,6 @@ ir_builder* ir_builder_new(const char *modulename)
         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;
 }
 
@@ -306,6 +319,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 +337,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 +434,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 +636,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 +676,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 +764,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 +985,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 +1028,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 +1094,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 +1116,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 +1150,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 +1174,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 +1232,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();
     }
 
@@ -1225,7 +1251,7 @@ ir_instr* ir_block_create_call(ir_block *self, const char *label, ir_value *func
     in = ir_instr_new(self, INSTR_CALL0);
     if (!in)
         return NULL;
-    out = ir_value_out(self->owner, label, store_value, func->outtype);
+    out = ir_value_out(self->owner, label, (func->outtype == TYPE_VOID) ? store_return : store_value, func->outtype);
     if (!out) {
         ir_instr_delete(in);
         return NULL;
@@ -1786,11 +1812,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;
 }
 
@@ -1889,6 +1929,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;
@@ -1947,6 +1991,15 @@ static void ir_op_read_write(int op, size_t *read, size_t *write)
         *write = 0;
         *read = 1;
         break;
+    case INSTR_STOREP_F:
+    case INSTR_STOREP_V:
+    case INSTR_STOREP_S:
+    case INSTR_STOREP_ENT:
+    case INSTR_STOREP_FLD:
+    case INSTR_STOREP_FNC:
+        *write = 0;
+        *read  = 7;
+        break;
     default:
         *write = 1;
         *read = 6;
@@ -1964,7 +2017,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;
     }
@@ -1999,7 +2052,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;
@@ -2013,17 +2066,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))
@@ -2039,38 +2084,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 */
@@ -2083,6 +2116,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
@@ -2095,20 +2130,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 */
@@ -2120,13 +2146,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
@@ -2155,16 +2175,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;
                 }
             }
         }
@@ -2173,21 +2185,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)
@@ -2202,11 +2199,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;
 }
 
 /***********************************************************************
@@ -2232,7 +2224,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;
         }
 
@@ -2245,7 +2237,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;
         }
 
@@ -2275,7 +2267,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.
              */
@@ -2291,7 +2283,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;
         }
 
@@ -2324,7 +2316,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;
         }
 
@@ -2465,7 +2457,7 @@ tailcall:
         }
 
         if (instr->opcode == INSTR_STATE) {
-            irerror(block->context, "TODO: state instruction\n");
+            irerror(block->context, "TODO: state instruction");
             return false;
         }
 
@@ -2514,7 +2506,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;
     }
 
@@ -2523,7 +2515,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;
     }
 
@@ -2547,7 +2539,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;
     }
 
@@ -2566,12 +2558,11 @@ 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])) {
-            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;
         }
     }
@@ -2591,19 +2582,48 @@ 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 {
+        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) {
+        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;
+
+    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;
@@ -2616,6 +2636,28 @@ 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
+         */
+        ir_value_code_setaddr(global, def.offset);
+        /* Add the def */
+        if (code_defs_add(def) < 0)
+            return false;
+        return true;
     case TYPE_POINTER:
         if (code_defs_add(def) < 0)
             return false;
@@ -2680,9 +2722,14 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
     case TYPE_FUNCTION:
         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);
+        if (!global->isconst) {
+            ir_value_code_setaddr(global, code_globals_add(0));
+            return global->code.globaladdr >= 0;
+        } else {
+            ir_value_code_setaddr(global, code_globals_elements);
+            code_globals_add(code_functions_elements);
+            return gen_global_function(self, global);
+        }
     case TYPE_VARIANT:
         /* assume biggest type */
             ir_value_code_setaddr(global, code_globals_add(0));
@@ -2691,7 +2738,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;
     }
 }
@@ -2714,7 +2762,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;
         }
 
@@ -2742,7 +2790,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;
     }
 
@@ -2766,10 +2814,18 @@ 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->globals_count; ++i)
+    {
+        if (!ir_builder_gen_global(self, self->globals[i])) {
+            return false;
+        }
+    }
+
     for (i = 0; i < self->fields_count; ++i)
     {
         if (!ir_builder_gen_field(self, self->fields[i])) {
@@ -2777,13 +2833,27 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    /* generate function code */
     for (i = 0; i < self->globals_count; ++i)
     {
-        if (!ir_builder_gen_global(self, self->globals[i])) {
-            return false;
+        if (self->globals[i]->vtype == TYPE_FUNCTION) {
+            if (!gen_global_function_code(self, self->globals[i])) {
+                return false;
+            }
         }
     }
 
+    /* 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);
 }
@@ -2853,6 +2923,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);
@@ -2941,6 +3030,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;
 }
@@ -2954,7 +3049,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);