X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=5461b44cfabdb65bf60297eb1a4912cd6e32334b;hb=87ff481abffb79150974b4d460c3bd96c3399be2;hp=6ac74e868c5a8f0610a08d310d05499a87d4495d;hpb=54c8801becfc2e0bc4cf965c1d62e6d75a262fe2;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index 6ac74e8..5461b44 100644
--- a/ir.c
+++ b/ir.c
@@ -1018,6 +1018,7 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
     self->fieldtype = TYPE_VOID;
     self->outtype = TYPE_VOID;
     self->store = storetype;
+    self->flags = 0;
 
     self->reads  = NULL;
     self->writes = NULL;
@@ -1913,26 +1914,6 @@ bool ir_function_naive_phi(ir_function *self)
     return true;
 }
 
-#if 0
-static bool ir_naive_phi_emit_store(ir_block *block, size_t iid, ir_value *old, ir_value *what)
-{
-    ir_instr *instr;
-    size_t i;
-
-    /* create a store */
-    if (!ir_block_create_store(block, old, what))
-        return false;
-
-    /* we now move it up */
-    instr = vec_last(block->instr);
-    for (i = vec_size(block->instr)-1; i > iid; --i)
-        block->instr[i] = block->instr[i-1];
-    block->instr[i] = instr;
-
-    return true;
-}
-#endif
-
 static bool ir_block_naive_phi(ir_block *self)
 {
     size_t i, p; /*, w;*/
@@ -1975,58 +1956,6 @@ static bool ir_block_naive_phi(ir_block *self)
                 vec_push(b->instr, prevjump);
                 b->final = true;
             }
-
-#if 0
-            ir_value *v = instr->phi[p].value;
-            for (w = 0; w < vec_size(v->writes); ++w) {
-                ir_value *old;
-
-                if (!v->writes[w]->_ops[0])
-                    continue;
-
-                /* When the write was to a global, we have to emit a mov */
-                old = v->writes[w]->_ops[0];
-
-                /* The original instruction now writes to the PHI target local */
-                if (v->writes[w]->_ops[0] == v)
-                    v->writes[w]->_ops[0] = instr->_ops[0];
-
-                if (old->store != store_value && old->store != store_local && old->store != store_param)
-                {
-                    /* If it originally wrote to a global we need to store the value
-                     * there as welli
-                     */
-                    if (!ir_naive_phi_emit_store(self, i+1, old, v))
-                        return false;
-                    if (i+1 < vec_size(self->instr))
-                        instr = self->instr[i+1];
-                    else
-                        instr = NULL;
-                    /* In case I forget and access instr later, it'll be NULL
-                     * when it's a problem, to make sure we crash, rather than accessing
-                     * invalid data.
-                     */
-                }
-                else
-                {
-                    /* If it didn't, we can replace all reads by the phi target now. */
-                    size_t r;
-                    for (r = 0; r < vec_size(old->reads); ++r)
-                    {
-                        size_t op;
-                        ir_instr *ri = old->reads[r];
-                        for (op = 0; op < vec_size(ri->phi); ++op) {
-                            if (ri->phi[op].value == old)
-                                ri->phi[op].value = v;
-                        }
-                        for (op = 0; op < 3; ++op) {
-                            if (ri->_ops[op] == old)
-                                ri->_ops[op] = v;
-                        }
-                    }
-                }
-            }
-#endif
         }
         ir_instr_delete(instr);
     }
@@ -2063,9 +1992,15 @@ static void ir_block_enumerate(ir_block *self, size_t *_eid)
 void ir_function_enumerate(ir_function *self)
 {
     size_t i;
-    size_t instruction_id = 1;
+    size_t instruction_id = 0;
     for (i = 0; i < vec_size(self->blocks); ++i)
     {
+        /* each block now gets an additional "entry" instruction id
+         * we can use to avoid point-life issues
+         */
+        self->blocks[i]->entry_id = instruction_id;
+        ++instruction_id;
+
         self->blocks[i]->eid = i;
         self->blocks[i]->run_id = 0;
         ir_block_enumerate(self->blocks[i], &instruction_id);
@@ -2192,6 +2127,9 @@ static bool ir_function_allocator_assign(ir_function *self, function_allocator *
     size_t a;
     ir_value *slot;
 
+    if (v->unique_life)
+        return function_allocator_alloc(alloc, v);
+
     for (a = 0; a < vec_size(alloc->locals); ++a)
     {
         /* if it's reserved for a unique liferange: skip */
@@ -2263,7 +2201,7 @@ bool ir_function_allocate_locals(ir_function *self)
             break;
         else
             v->locked = true; /* lock parameters locals */
-        if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), self->locals[i]))
+        if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), v))
             goto error;
     }
     for (; i < vec_size(self->locals); ++i)
@@ -2457,9 +2395,10 @@ static bool ir_block_living_lock(ir_block *self)
     bool changed = false;
     for (i = 0; i != vec_size(self->living); ++i)
     {
-        if (!self->living[i]->locked)
+        if (!self->living[i]->locked) {
+            self->living[i]->locked = true;
             changed = true;
-        self->living[i]->locked = true;
+        }
     }
     return changed;
 }
@@ -2526,19 +2465,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         /* 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
          * writes first, then reads
          */
@@ -2612,6 +2538,25 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             }
         }
 
+        if (instr->opcode == INSTR_MUL_VF)
+        {
+            value = instr->_ops[2];
+            /* the float source will get an additional lifetime */
+            if (ir_value_life_merge(value, instr->eid+1))
+                *changed = true;
+            if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
+                *changed = true;
+        }
+        else if (instr->opcode == INSTR_MUL_FV)
+        {
+            value = instr->_ops[1];
+            /* the float source will get an additional lifetime */
+            if (ir_value_life_merge(value, instr->eid+1))
+                *changed = true;
+            if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
+                *changed = true;
+        }
+
         for (o = 0; o < 3; ++o)
         {
             if (!instr->_ops[o]) /* no such operand */
@@ -2680,8 +2625,10 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         tempbool = ir_block_living_add_instr(self, instr->eid);
         /*con_err( "living added values\n");*/
         *changed = *changed || tempbool;
-
     }
+    /* the "entry" instruction ID */
+    tempbool = ir_block_living_add_instr(self, self->entry_id);
+    *changed = *changed || tempbool;
 
     if (self->run_id == self->owner->run_id)
         return true;
@@ -2795,7 +2742,6 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
     size_t    stidx;
     size_t    i;
 
-tailcall:
     block->generated = true;
     block->code_start = vec_size(code_statements);
     for (i = 0; i < vec_size(block->instr); ++i)
@@ -2812,10 +2758,8 @@ tailcall:
             /* for uncoditional jumps, if the target hasn't been generated
              * yet, we generate them right here.
              */
-            if (!target->generated) {
-                block = target;
-                goto tailcall;
-            }
+            if (!target->generated)
+                return gen_blocks_recursive(func, target);
 
             /* otherwise we generate a jump instruction */
             stmt.opcode = INSTR_GOTO;
@@ -2853,16 +2797,12 @@ tailcall:
                     code_push_statement(&stmt, instr->context.line);
             }
             if (!ontrue->generated) {
-                if (onfalse->generated) {
-                    block = ontrue;
-                    goto tailcall;
-                }
+                if (onfalse->generated)
+                    return gen_blocks_recursive(func, ontrue);
             }
             if (!onfalse->generated) {
-                if (ontrue->generated) {
-                    block = onfalse;
-                    goto tailcall;
-                }
+                if (ontrue->generated)
+                    return gen_blocks_recursive(func, onfalse);
             }
             /* neither ontrue nor onfalse exist */
             stmt.opcode = INSTR_IFNOT;
@@ -2916,8 +2856,7 @@ tailcall:
                 code_pop_statement();
             }
             /* if not, generate now */
-            block = onfalse;
-            goto tailcall;
+            return gen_blocks_recursive(func, onfalse);
         }
 
         if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
@@ -3385,6 +3324,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
         pushdef = true;
 
         if (OPTS_OPTIMIZATION(OPTIM_STRIP_CONSTANT_NAMES) &&
+            !(global->flags & IR_FLAG_INCLUDE_DEF) &&
             (global->name[0] == '#' || global->cvq == CV_CONST))
         {
             pushdef = false;
@@ -3772,6 +3712,10 @@ void ir_builder_dump(ir_builder *b, int (*oprintf)(const char*, ...))
     oprintf("endmodule %s\n", b->name);
 }
 
+static const char *storenames[] = {
+    "[global]", "[local]", "[param]", "[value]", "[return]"
+};
+
 void ir_function_dump(ir_function *f, char *ind,
                       int (*oprintf)(const char*, ...))
 {
@@ -3802,7 +3746,12 @@ void ir_function_dump(ir_function *f, char *ind,
             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);
+        oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
+                storenames[v->store],
+                attr, (v->callparam ? "callparam " : ""),
+                (int)v->code.local);
+        if (!v->life)
+            oprintf("[null]");
         for (l = 0; l < vec_size(v->life); ++l) {
             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
         }
@@ -3811,13 +3760,7 @@ void ir_function_dump(ir_function *f, char *ind,
             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);
+            oprintf("%s\t%s: @%i ", ind, vm->name, (int)vm->code.local);
             for (l = 0; l < vec_size(vm->life); ++l) {
                 oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
             }
@@ -3834,7 +3777,12 @@ void ir_function_dump(ir_function *f, char *ind,
             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);
+        oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
+                storenames[v->store],
+                attr, (v->callparam ? "callparam " : ""),
+                (int)v->code.local);
+        if (!v->life)
+            oprintf("[null]");
         for (l = 0; l < vec_size(v->life); ++l) {
             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
         }
@@ -3878,6 +3826,8 @@ void ir_block_dump(ir_block* b, char *ind,
     oprintf("%s:%s\n", ind, b->label);
     strncat(ind, "\t", IND_BUFSZ);
 
+    if (b->instr && b->instr[0])
+        oprintf("%s (%i) [entry]\n", ind, (int)(b->instr[0]->eid-1));
     for (i = 0; i < vec_size(b->instr); ++i)
         ir_instr_dump(b->instr[i], ind, oprintf);
     ind[strlen(ind)-1] = 0;