X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.c;h=4e50d7f26b31db9c477d30de31ef90a94bfb5a2a;hp=7d35e7ff1d979584bad9d42103203449b09f4365;hb=0920cb6ec4e1a00af744d1c33a4f0b44de33a3fa;hpb=710f580e1548bd7e69e39d63fd419ecae06a13d7

diff --git a/ir.c b/ir.c
index 7d35e7f..4e50d7f 100644
--- a/ir.c
+++ b/ir.c
@@ -42,7 +42,9 @@ const char *type_name[TYPE_COUNT] = {
     "variant",
     "struct",
     "union",
-    "array"
+    "array",
+
+    "nil"
 };
 
 size_t type_sizeof_[TYPE_COUNT] = {
@@ -59,6 +61,7 @@ size_t type_sizeof_[TYPE_COUNT] = {
     0, /* TYPE_STRUCT   */
     0, /* TYPE_UNION    */
     0, /* TYPE_ARRAY    */
+    0, /* TYPE_NIL      */
 };
 
 uint16_t type_store_instr[TYPE_COUNT] = {
@@ -81,6 +84,7 @@ uint16_t type_store_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 uint16_t field_store_instr[TYPE_COUNT] = {
@@ -103,6 +107,7 @@ uint16_t field_store_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 uint16_t type_storep_instr[TYPE_COUNT] = {
@@ -125,6 +130,7 @@ uint16_t type_storep_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 uint16_t type_eq_instr[TYPE_COUNT] = {
@@ -147,6 +153,7 @@ uint16_t type_eq_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 uint16_t type_ne_instr[TYPE_COUNT] = {
@@ -169,6 +176,7 @@ uint16_t type_ne_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 uint16_t type_not_instr[TYPE_COUNT] = {
@@ -191,10 +199,12 @@ uint16_t type_not_instr[TYPE_COUNT] = {
     AINSTR_END, /* struct */
     AINSTR_END, /* union  */
     AINSTR_END, /* array  */
+    AINSTR_END, /* nil    */
 };
 
 /* protos */
-static void ir_gen_extparam(ir_builder *ir);
+static ir_value* ir_gen_extparam_proto(ir_builder *ir);
+static void      ir_gen_extparam      (ir_builder *ir);
 
 /* error functions */
 
@@ -220,7 +230,7 @@ static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
  * Vector utility functions
  */
 
-bool GMQCC_WARN vec_ir_value_find(ir_value **vec, ir_value *what, size_t *idx)
+bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *idx)
 {
     size_t i;
     size_t len = vec_size(vec);
@@ -278,14 +288,19 @@ ir_builder* ir_builder_new(const char *modulename)
     self->functions   = NULL;
     self->globals     = NULL;
     self->fields      = NULL;
-    self->extparams   = NULL;
     self->filenames   = NULL;
     self->filestrings = NULL;
     self->htglobals   = util_htnew(IR_HT_SIZE);
     self->htfields    = util_htnew(IR_HT_SIZE);
     self->htfunctions = util_htnew(IR_HT_SIZE);
 
-    self->max_locals  = 0;
+    self->extparams       = NULL;
+    self->extparam_protos = NULL;
+
+    self->first_common_globaltemp = 0;
+    self->max_globaltemps         = 0;
+    self->first_common_local      = 0;
+    self->max_locals              = 0;
 
     self->str_immediate = 0;
     self->name = NULL;
@@ -294,6 +309,9 @@ ir_builder* ir_builder_new(const char *modulename)
         return NULL;
     }
 
+    self->nil = ir_value_var("nil", store_value, TYPE_NIL);
+    self->nil->cvq = CV_CONST;
+
     return self;
 }
 
@@ -319,6 +337,7 @@ void ir_builder_delete(ir_builder* self)
     for (i = 0; i != vec_size(self->fields); ++i) {
         ir_value_delete(self->fields[i]);
     }
+    ir_value_delete(self->nil);
     vec_free(self->fields);
     vec_free(self->filenames);
     vec_free(self->filestrings);
@@ -451,6 +470,7 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
 
     self->code_function_def = -1;
     self->allocated_locals = 0;
+    self->globaltemps      = 0;
 
     self->run_id = 0;
     return self;
@@ -733,6 +753,8 @@ bool ir_function_pass_tailrecursion(ir_function *self)
 
 bool ir_function_finalize(ir_function *self)
 {
+    size_t i;
+
     if (self->builtin)
         return true;
 
@@ -750,8 +772,31 @@ bool ir_function_finalize(ir_function *self)
         }
     }
 
-    if (!ir_function_naive_phi(self))
+    if (!ir_function_naive_phi(self)) {
+        irerror(self->context, "internal error: ir_function_naive_phi failed");
         return false;
+    }
+
+    for (i = 0; i < vec_size(self->locals); ++i) {
+        ir_value *v = self->locals[i];
+        if (v->vtype == TYPE_VECTOR ||
+            (v->vtype == TYPE_FIELD && v->outtype == TYPE_VECTOR))
+        {
+            ir_value_vector_member(v, 0);
+            ir_value_vector_member(v, 1);
+            ir_value_vector_member(v, 2);
+        }
+    }
+    for (i = 0; i < vec_size(self->values); ++i) {
+        ir_value *v = self->values[i];
+        if (v->vtype == TYPE_VECTOR ||
+            (v->vtype == TYPE_FIELD && v->outtype == TYPE_VECTOR))
+        {
+            ir_value_vector_member(v, 0);
+            ir_value_vector_member(v, 1);
+            ir_value_vector_member(v, 2);
+        }
+    }
 
     ir_function_enumerate(self);
 
@@ -774,6 +819,8 @@ ir_value* ir_function_create_local(ir_function *self, const char *name, int vtyp
     }
 
     ve = ir_value_var(name, (param ? store_param : store_local), vtype);
+    if (param)
+        ve->locked = true;
     vec_push(self->locals, ve);
     return ve;
 }
@@ -988,6 +1035,7 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
 
     self->unique_life = false;
     self->locked      = false;
+    self->callparam   = false;
 
     self->life = NULL;
     return self;
@@ -2106,11 +2154,13 @@ typedef struct {
     bool      *unique;
 } function_allocator;
 
-static bool function_allocator_alloc(function_allocator *alloc, const ir_value *var)
+static bool function_allocator_alloc(function_allocator *alloc, ir_value *var)
 {
     ir_value *slot;
     size_t vsize = ir_value_sizeof(var);
 
+    var->code.local = vec_size(alloc->locals);
+
     slot = ir_value_var("reg", store_global, var->vtype);
     if (!slot)
         return false;
@@ -2129,30 +2179,91 @@ localerror:
     return false;
 }
 
+static bool ir_function_allocator_assign(ir_function *self, function_allocator *alloc, ir_value *v)
+{
+    size_t a;
+    ir_value *slot;
+
+    for (a = 0; a < vec_size(alloc->locals); ++a)
+    {
+        /* if it's reserved for a unique liferange: skip */
+        if (alloc->unique[a])
+            continue;
+
+        slot = alloc->locals[a];
+
+        /* never resize parameters
+         * will be required later when overlapping temps + locals
+         */
+        if (a < vec_size(self->params) &&
+            alloc->sizes[a] < ir_value_sizeof(v))
+        {
+            continue;
+        }
+
+        if (ir_values_overlap(v, slot))
+            continue;
+
+        if (!ir_value_life_merge_into(slot, v))
+            return false;
+
+        /* adjust size for this slot */
+        if (alloc->sizes[a] < ir_value_sizeof(v))
+            alloc->sizes[a] = ir_value_sizeof(v);
+
+        v->code.local = a;
+        return true;
+    }
+    if (a >= vec_size(alloc->locals)) {
+        if (!function_allocator_alloc(alloc, v))
+            return false;
+    }
+    return true;
+}
+
 bool ir_function_allocate_locals(ir_function *self)
 {
-    size_t i, a;
+    size_t i;
     bool   retval = true;
     size_t pos;
+    bool   opt_gt = OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS);
 
-    ir_value *slot;
-    const ir_value *v;
+    ir_value *v;
 
-    function_allocator alloc;
+    function_allocator lockalloc, globalloc;
 
     if (!vec_size(self->locals) && !vec_size(self->values))
         return true;
 
-    alloc.locals    = NULL;
-    alloc.sizes     = NULL;
-    alloc.positions = NULL;
-    alloc.unique    = NULL;
+    globalloc.locals    = NULL;
+    globalloc.sizes     = NULL;
+    globalloc.positions = NULL;
+    globalloc.unique    = NULL;
+    lockalloc.locals    = NULL;
+    lockalloc.sizes     = NULL;
+    lockalloc.positions = NULL;
+    lockalloc.unique    = NULL;
 
     for (i = 0; i < vec_size(self->locals); ++i)
     {
-        if (!OPTS_OPTIMIZATION(OPTIM_LOCAL_TEMPS))
-            self->locals[i]->unique_life = true;
-        if (!function_allocator_alloc(&alloc, self->locals[i]))
+        v = self->locals[i];
+        if (!OPTS_OPTIMIZATION(OPTIM_LOCAL_TEMPS)) {
+            v->locked      = true;
+            v->unique_life = true;
+        }
+        else if (i >= vec_size(self->params))
+            break;
+        else
+            v->locked = true; /* lock parameters locals */
+        if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), self->locals[i]))
+            goto error;
+    }
+    for (; i < vec_size(self->locals); ++i)
+    {
+        v = self->locals[i];
+        if (!vec_size(v->life))
+            continue;
+        if (!ir_function_allocator_assign(self, (v->locked || !opt_gt ? &lockalloc : &globalloc), v))
             goto error;
     }
 
@@ -2164,69 +2275,100 @@ bool ir_function_allocate_locals(ir_function *self)
         if (!vec_size(v->life))
             continue;
 
-        for (a = 0; a < vec_size(alloc.locals); ++a)
-        {
-            /* if it's reserved for a unique liferange: skip */
-            if (alloc.unique[a])
-                continue;
-
-            slot = alloc.locals[a];
-
-            /* never resize parameters
-             * will be required later when overlapping temps + locals
-             */
-            if (a < vec_size(self->params) &&
-                alloc.sizes[a] < ir_value_sizeof(v))
+        /* CALL optimization:
+         * If the value is a parameter-temp: 1 write, 1 read from a CALL
+         * and it's not "locked", write it to the OFS_PARM directly.
+         */
+        if (OPTS_OPTIMIZATION(OPTIM_CALL_STORES) && !v->locked && !v->unique_life) {
+            if (vec_size(v->reads) == 1 && vec_size(v->writes) == 1 &&
+                (v->reads[0]->opcode == VINSTR_NRCALL ||
+                 (v->reads[0]->opcode >= INSTR_CALL0 && v->reads[0]->opcode <= INSTR_CALL8)
+                )
+               )
             {
+                size_t    param;
+                ir_instr *call = v->reads[0];
+                if (!vec_ir_value_find(call->params, v, &param)) {
+                    irerror(call->context, "internal error: unlocked parameter %s not found", v->name);
+                    goto error;
+                }
+
+                ++opts_optimizationcount[OPTIM_CALL_STORES];
+                v->callparam = true;
+                if (param < 8)
+                    ir_value_code_setaddr(v, OFS_PARM0 + 3*param);
+                else {
+                    ir_value *ep;
+                    param -= 8;
+                    if (vec_size(self->owner->extparam_protos) <= param)
+                        ep = ir_gen_extparam_proto(self->owner);
+                    else
+                        ep = self->owner->extparam_protos[param];
+                    ir_instr_op(v->writes[0], 0, ep, true);
+                    call->params[param+8] = ep;
+                }
                 continue;
             }
-
-            if (ir_values_overlap(v, slot))
+            if (vec_size(v->writes) == 1 && v->writes[0]->opcode == INSTR_CALL0)
+            {
+                v->store = store_return;
+                if (v->members[0]) v->members[0]->store = store_return;
+                if (v->members[1]) v->members[1]->store = store_return;
+                if (v->members[2]) v->members[2]->store = store_return;
+                ++opts_optimizationcount[OPTIM_CALL_STORES];
                 continue;
-
-            if (!ir_value_life_merge_into(slot, v))
-                goto error;
-
-            /* adjust size for this slot */
-            if (alloc.sizes[a] < ir_value_sizeof(v))
-                alloc.sizes[a] = ir_value_sizeof(v);
-
-            self->values[i]->code.local = a;
-            break;
-        }
-        if (a >= vec_size(alloc.locals)) {
-            self->values[i]->code.local = vec_size(alloc.locals);
-            if (!function_allocator_alloc(&alloc, v))
-                goto error;
+            }
         }
+
+        if (!ir_function_allocator_assign(self, (v->locked || !opt_gt ? &lockalloc : &globalloc), v))
+            goto error;
     }
 
-    if (!alloc.sizes) {
+    if (!lockalloc.sizes && !globalloc.sizes) {
         goto cleanup;
     }
+    vec_push(lockalloc.positions, 0);
+    vec_push(globalloc.positions, 0);
 
     /* Adjust slot positions based on sizes */
-    vec_push(alloc.positions, 0);
-
-    if (vec_size(alloc.sizes))
-        pos = alloc.positions[0] + alloc.sizes[0];
-    else
-        pos = 0;
-    for (i = 1; i < vec_size(alloc.sizes); ++i)
-    {
-        pos = alloc.positions[i-1] + alloc.sizes[i-1];
-        vec_push(alloc.positions, pos);
+    if (lockalloc.sizes) {
+        pos = (vec_size(lockalloc.sizes) ? lockalloc.positions[0] : 0);
+        for (i = 1; i < vec_size(lockalloc.sizes); ++i)
+        {
+            pos = lockalloc.positions[i-1] + lockalloc.sizes[i-1];
+            vec_push(lockalloc.positions, pos);
+        }
+        self->allocated_locals = pos + vec_last(lockalloc.sizes);
+    }
+    if (globalloc.sizes) {
+        pos = (vec_size(globalloc.sizes) ? globalloc.positions[0] : 0);
+        for (i = 1; i < vec_size(globalloc.sizes); ++i)
+        {
+            pos = globalloc.positions[i-1] + globalloc.sizes[i-1];
+            vec_push(globalloc.positions, pos);
+        }
+        self->globaltemps = pos + vec_last(globalloc.sizes);
     }
-
-    self->allocated_locals = pos + vec_last(alloc.sizes);
 
     /* Locals need to know their new position */
     for (i = 0; i < vec_size(self->locals); ++i) {
-        self->locals[i]->code.local = alloc.positions[i];
+        v = self->locals[i];
+        if (i >= vec_size(self->params) && !vec_size(v->life))
+            continue;
+        if (v->locked || !opt_gt)
+            v->code.local = lockalloc.positions[v->code.local];
+        else
+            v->code.local = globalloc.positions[v->code.local];
     }
     /* Take over the actual slot positions on values */
     for (i = 0; i < vec_size(self->values); ++i) {
-        self->values[i]->code.local = alloc.positions[self->values[i]->code.local];
+        v = self->values[i];
+        if (!vec_size(v->life))
+            continue;
+        if (v->locked || !opt_gt)
+            v->code.local = lockalloc.positions[v->code.local];
+        else
+            v->code.local = globalloc.positions[v->code.local];
     }
 
     goto cleanup;
@@ -2234,12 +2376,18 @@ bool ir_function_allocate_locals(ir_function *self)
 error:
     retval = false;
 cleanup:
-    for (i = 0; i < vec_size(alloc.locals); ++i)
-        ir_value_delete(alloc.locals[i]);
-    vec_free(alloc.unique);
-    vec_free(alloc.locals);
-    vec_free(alloc.sizes);
-    vec_free(alloc.positions);
+    for (i = 0; i < vec_size(lockalloc.locals); ++i)
+        ir_value_delete(lockalloc.locals[i]);
+    for (i = 0; i < vec_size(globalloc.locals); ++i)
+        ir_value_delete(globalloc.locals[i]);
+    vec_free(globalloc.unique);
+    vec_free(globalloc.locals);
+    vec_free(globalloc.sizes);
+    vec_free(globalloc.positions);
+    vec_free(lockalloc.unique);
+    vec_free(lockalloc.locals);
+    vec_free(lockalloc.sizes);
+    vec_free(lockalloc.positions);
     return retval;
 }
 
@@ -2351,7 +2499,9 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     size_t i, o, p, mem;
     /* bitmasks which operands are read from or written to */
     size_t read, write;
-    char dbg_ind[16] = { '#', '0' };
+    char dbg_ind[16];
+    dbg_ind[0] = '#';
+    dbg_ind[1] = '0';
     (void)dbg_ind;
 
     if (prev)
@@ -2498,6 +2648,11 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             }
         }
 
+        /* on a call, all these values must be "locked" */
+        if (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8) {
+            if (ir_block_living_lock(self))
+                *changed = true;
+        }
         /* call params are read operands too */
         for (p = 0; p < vec_size(instr->params); ++p)
         {
@@ -2512,11 +2667,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                     vec_push(self->living, value->members[mem]);
             }
         }
-        /* on a call, all these values must be "locked" */
-        if (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8) {
-            if (ir_block_living_lock(self))
-                *changed = true;
-        }
 
         /* (A) */
         tempbool = ir_block_living_add_instr(self, instr->eid);
@@ -2554,7 +2704,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
  *
  * Breaking conventions is annoying...
  */
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal, bool defs_only);
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
 
 static bool gen_global_field(ir_value *global)
 {
@@ -2765,19 +2915,6 @@ tailcall:
         if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
            || instr->opcode == VINSTR_NRCALL)
         {
-            /* Trivial call translation:
-             * copy all params to OFS_PARM*
-             * if the output's storetype is not store_return,
-             * add append a STORE instruction!
-             *
-             * NOTES on how to do it better without much trouble:
-             * -) The liferanges!
-             *      Simply check the liferange of all parameters for
-             *      other CALLs. For each param with no CALL in its
-             *      liferange, we can store it in an OFS_PARM at
-             *      generation already. This would even include later
-             *      reuse.... probably... :)
-             */
             size_t p, first;
             ir_value *retvalue;
 
@@ -2787,6 +2924,8 @@ tailcall:
             for (p = 0; p < first; ++p)
             {
                 ir_value *param = instr->params[p];
+                if (param->callparam)
+                    continue;
 
                 stmt.opcode = INSTR_STORE_F;
                 stmt.o3.u1 = 0;
@@ -2807,6 +2946,9 @@ tailcall:
                 ir_value *param = instr->params[p];
                 ir_value *targetparam;
 
+                if (param->callparam)
+                    continue;
+
                 if (p-8 >= vec_size(ir->extparams))
                     ir_gen_extparam(ir);
 
@@ -2902,7 +3044,7 @@ tailcall:
 static bool gen_function_code(ir_function *self)
 {
     ir_block *block;
-    prog_section_statement stmt;
+    prog_section_statement stmt, *retst;
 
     /* Starting from entry point, we generate blocks "as they come"
      * for now. Dead blocks will not be translated obviously.
@@ -2922,11 +3064,21 @@ static bool gen_function_code(ir_function *self)
     }
 
     /* code_write and qcvm -disasm need to know that the function ends here */
-    stmt.opcode = INSTR_DONE;
-    stmt.o1.u1 = 0;
-    stmt.o2.u1 = 0;
-    stmt.o3.u1 = 0;
-    code_push_statement(&stmt, vec_last(code_linenums));
+    retst = &vec_last(code_statements);
+    if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
+        self->outtype == TYPE_VOID &&
+        retst->opcode == INSTR_RETURN &&
+        !retst->o1.u1 && !retst->o2.u1 && !retst->o3.u1)
+    {
+        retst->opcode = INSTR_DONE;
+        ++opts_optimizationcount[OPTIM_VOID_RETURN];
+    } else {
+        stmt.opcode = INSTR_DONE;
+        stmt.o1.u1 = 0;
+        stmt.o2.u1 = 0;
+        stmt.o3.u1 = 0;
+        code_push_statement(&stmt, vec_last(code_linenums));
+    }
     return true;
 }
 
@@ -2992,16 +3144,29 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     return true;
 }
 
+static ir_value* ir_gen_extparam_proto(ir_builder *ir)
+{
+    ir_value *global;
+    char      name[128];
+
+    snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparam_protos)+8));
+    global = ir_value_var(name, store_global, TYPE_VECTOR);
+
+    vec_push(ir->extparam_protos, global);
+    return global;
+}
+
 static void ir_gen_extparam(ir_builder *ir)
 {
     prog_section_def def;
     ir_value        *global;
-    char             name[128];
 
-    snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparams)+8));
-    global = ir_value_var(name, store_global, TYPE_VECTOR);
+    if (vec_size(ir->extparam_protos) < vec_size(ir->extparams)+1)
+        global = ir_gen_extparam_proto(ir);
+    else
+        global = ir->extparam_protos[vec_size(ir->extparams)];
 
-    def.name = code_genstring(name);
+    def.name = code_genstring(global->name);
     def.type = TYPE_VECTOR;
     def.offset = vec_size(code_globals);
 
@@ -3054,7 +3219,7 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
     prog_section_function *def;
     ir_function           *irfun;
     size_t                 i;
-    uint32_t               firstlocal;
+    uint32_t               firstlocal, firstglobal;
 
     irfun = global->constval.vfunc;
     def   = code_functions + irfun->code_function_def;
@@ -3066,19 +3231,31 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
         ++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
     }
 
+    firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
+
     for (i = vec_size(code_globals); i < firstlocal + irfun->allocated_locals; ++i)
         vec_push(code_globals, 0);
     for (i = 0; i < vec_size(irfun->locals); ++i) {
-        ir_value_code_setaddr(irfun->locals[i], firstlocal + irfun->locals[i]->code.local);
-        if (!ir_builder_gen_global(ir, irfun->locals[i], true, true)) {
-            irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
-            return false;
+        ir_value *v = irfun->locals[i];
+        if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
+            ir_value_code_setaddr(v, firstlocal + v->code.local);
+            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;
+            }
         }
+        else
+            ir_value_code_setaddr(v, firstglobal + v->code.local);
     }
     for (i = 0; i < vec_size(irfun->values); ++i)
     {
         ir_value *v = irfun->values[i];
-        ir_value_code_setaddr(v, firstlocal + v->code.local);
+        if (v->callparam)
+            continue;
+        if (v->locked)
+            ir_value_code_setaddr(v, firstlocal + v->code.local);
+        else
+            ir_value_code_setaddr(v, firstglobal + v->code.local);
     }
     return true;
 }
@@ -3181,18 +3358,19 @@ static void gen_vector_fields(prog_section_field fld, const char *name)
     }
 }
 
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal, bool defs_only)
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
 {
     size_t           i;
     int32_t         *iptr;
     prog_section_def def;
     bool             pushdef = false;
 
+    def.type   = global->vtype;
+    def.offset = vec_size(code_globals);
+    def.name   = 0;
     if (opts.g || !islocal)
     {
         pushdef = true;
-        def.type   = global->vtype;
-        def.offset = vec_size(code_globals);
 
         if (OPTS_OPTIMIZATION(OPTIM_STRIP_CONSTANT_NAMES) &&
             (global->name[0] == '#' || global->cvq == CV_CONST))
@@ -3211,7 +3389,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
         }
         else
             def.name   = 0;
-        if (defs_only) {
+        if (islocal) {
             def.offset = ir_value_code_addr(global);
             vec_push(code_defs, def);
             if (global->vtype == TYPE_VECTOR)
@@ -3221,7 +3399,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
             return true;
         }
     }
-    if (defs_only)
+    if (islocal)
         return true;
 
     switch (global->vtype)
@@ -3255,12 +3433,8 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     case TYPE_FIELD:
         if (pushdef) {
             vec_push(code_defs, def);
-            if (global->fieldtype == TYPE_VECTOR) {
+            if (global->fieldtype == TYPE_VECTOR)
                 gen_vector_defs(def, global->name);
-                ir_value_vector_member(global, 0);
-                ir_value_vector_member(global, 1);
-                ir_value_vector_member(global, 2);
-            }
         }
         return gen_global_field(global);
     case TYPE_ENTITY:
@@ -3296,9 +3470,6 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     case TYPE_VECTOR:
     {
         size_t d;
-        ir_value_vector_member(global, 0);
-        ir_value_vector_member(global, 1);
-        ir_value_vector_member(global, 2);
         ir_value_code_setaddr(global, vec_size(code_globals));
         if (global->hasvalue) {
             iptr = (int32_t*)&global->constval.ivec[0];
@@ -3446,7 +3617,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 
     for (i = 0; i < vec_size(self->globals); ++i)
     {
-        if (!ir_builder_gen_global(self, self->globals[i], false, false)) {
+        if (!ir_builder_gen_global(self, self->globals[i], false)) {
             return false;
         }
         if (self->globals[i]->vtype == TYPE_FUNCTION) {
@@ -3456,6 +3627,8 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
             {
                 self->max_locals = func->allocated_locals;
             }
+            if (func && self->max_globaltemps < func->globaltemps)
+                self->max_globaltemps = func->globaltemps;
         }
     }
 
@@ -3466,6 +3639,11 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    /* generate global temps */
+    self->first_common_globaltemp = vec_size(code_globals);
+    for (i = 0; i < self->max_globaltemps; ++i) {
+        vec_push(code_globals, 0);
+    }
     /* generate common locals */
     self->first_common_local = vec_size(code_globals);
     for (i = 0; i < self->max_locals; ++i) {
@@ -3597,9 +3775,16 @@ void ir_function_dump(ir_function *f, char *ind,
     }
     oprintf("%sliferanges:\n", ind);
     for (i = 0; i < vec_size(f->locals); ++i) {
+        const char *attr = "";
         size_t l, m;
         ir_value *v = f->locals[i];
-        oprintf("%s\t%s: %s@%i ", ind, v->name, (v->unique_life ? "unique " : ""), (int)v->code.local);
+        if (v->unique_life && v->locked)
+            attr = "unique,locked ";
+        else if (v->unique_life)
+            attr = "unique ";
+        else if (v->locked)
+            attr = "locked ";
+        oprintf("%s\t%s: %s %s@%i ", ind, v->name, type_name[v->vtype], attr, (int)v->code.local);
         for (l = 0; l < vec_size(v->life); ++l) {
             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
         }
@@ -3608,7 +3793,13 @@ void ir_function_dump(ir_function *f, char *ind,
             ir_value *vm = v->members[m];
             if (!vm)
                 continue;
-            oprintf("%s\t%s: %s@%i ", ind, vm->name, (vm->unique_life ? "unique " : ""), (int)vm->code.local);
+            if (vm->unique_life && vm->locked)
+                attr = "unique,locked ";
+            else if (vm->unique_life)
+                attr = "unique ";
+            else if (vm->locked)
+                attr = "locked ";
+            oprintf("%s\t%s: %s@%i ", ind, vm->name, attr, (int)vm->code.local);
             for (l = 0; l < vec_size(vm->life); ++l) {
                 oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
             }
@@ -3616,13 +3807,36 @@ void ir_function_dump(ir_function *f, char *ind,
         }
     }
     for (i = 0; i < vec_size(f->values); ++i) {
-        size_t l;
+        const char *attr = "";
+        size_t l, m;
         ir_value *v = f->values[i];
-        oprintf("%s\t%s: @%i ", ind, v->name, (int)v->code.local);
+        if (v->unique_life && v->locked)
+            attr = "unique,locked ";
+        else if (v->unique_life)
+            attr = "unique ";
+        else if (v->locked)
+            attr = "locked ";
+        oprintf("%s\t%s: %s %s@%i ", ind, v->name, type_name[v->vtype], attr, (int)v->code.local);
         for (l = 0; l < vec_size(v->life); ++l) {
             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
         }
         oprintf("\n");
+        for (m = 0; m < 3; ++m) {
+            ir_value *vm = v->members[m];
+            if (!vm)
+                continue;
+            if (vm->unique_life && vm->locked)
+                attr = "unique,locked ";
+            else if (vm->unique_life)
+                attr = "unique ";
+            else if (vm->locked)
+                attr = "locked ";
+            oprintf("%s\t%s: %s@%i ", ind, vm->name, attr, (int)vm->code.local);
+            for (l = 0; l < vec_size(vm->life); ++l) {
+                oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
+            }
+            oprintf("\n");
+        }
     }
     if (vec_size(f->blocks))
     {