sqrt and normalize builtins

[xonotic/gmqcc.git] / ir.c

diff --git a/ir.c b/ir.c
index 7a4986f052661ab8cd6ba922ddd4fad0617f529f..74b2e4cc8b1560e256dfa1c716558fa83956921a 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -1913,26 +1913,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 +1955,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 +1991,14 @@ 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
+         */
+        ++instruction_id;
+
         self->blocks[i]->eid = i;
         self->blocks[i]->run_id = 0;
         ir_block_enumerate(self->blocks[i], &instruction_id);
@@ -2192,6 +2125,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 */
@@ -2681,8 +2617,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, instr->eid-1);
+    *changed = *changed || tempbool;
 
     if (self->run_id == self->owner->run_id)
         return true;
@@ -3883,6 +3821,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;