What was I thinking... fixing loop's jump creation so it doesn't try creating multipl...

[xonotic/gmqcc.git] / ir.c

diff --git a/ir.c b/ir.c
index ea3a9cae2229fa3722cc77a71981ba64e8bd9c1a..8e8ffb7db1926c743f24d7f883ea57e9d1d0419d 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -582,8 +582,13 @@ bool ir_values_overlap(ir_value *a, 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
         {
             return true;
         }
@@ -620,6 +625,7 @@ bool ir_block_create_store_op(ir_block *self, int op, ir_value *target, ir_value
 {
     if (target->store == store_value) {
         fprintf(stderr, "cannot store to an SSA value\n");
+        fprintf(stderr, "trying to store: %s <- %s\n", target->name, what->name);
         return false;
     } else {
         ir_instr *in = ir_instr_new(self, op);
@@ -846,7 +852,7 @@ ir_instr* ir_block_create_phi(ir_block *self, const char *label, int ot)
     in = ir_instr_new(self, VINSTR_PHI);
     if (!in)
         return NULL;
-    out = ir_value_out(self->owner, label, store_local, ot);
+    out = ir_value_out(self->owner, label, store_value, ot);
     if (!out) {
         ir_instr_delete(in);
         return NULL;
@@ -894,9 +900,6 @@ ir_value* ir_block_create_binop(ir_block *self,
                                 const char *label, int opcode,
                                 ir_value *left, ir_value *right)
 {
-    ir_value *out = NULL;
-    ir_instr *in  = NULL;
-
     int ot = TYPE_VOID;
     switch (opcode) {
         case INSTR_ADD_F:
@@ -1032,6 +1035,7 @@ ir_value* ir_block_create_fieldaddress(ir_block *self, const char *label, ir_val
 
 ir_value* ir_block_create_load_from_ent(ir_block *self, const char *label, ir_value *ent, ir_value *field, int outype)
 {
+    int op;
     if (ent->vtype != TYPE_ENTITY)
         return NULL;
 
@@ -1279,7 +1283,7 @@ static bool ir_block_naive_phi(ir_block *self)
                 if (v->writes[w]->_ops[0] == v)
                     v->writes[w]->_ops[0] = instr->_ops[0];
 
-                if (old->store != store_local)
+                if (old->store != store_value && old->store != store_local)
                 {
                     /* If it originally wrote to a global we need to store the value
                      * there as welli
@@ -1474,14 +1478,19 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     ir_instr *instr;
     ir_value *value;
     bool  tempbool;
-    size_t i, o, p, rd;
+    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)
     {
@@ -1498,16 +1507,19 @@ 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;
-            /* used this before new_reads - puts the last read into the life range as well
-            if (!ir_block_living_find(self, value, NULL))
-                ir_block_living_add(self, value);
-            */
-            /* fprintf(stderr, "read: %s\n", value->_name); */
+#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
             if (!new_reads_t_v_find(&new_reads, value, NULL))
             {
                 if (!new_reads_t_v_add(&new_reads, value))
                     goto on_error;
             }
+#endif
         }
 
         /* See which operands are read and write operands */
@@ -1529,16 +1541,20 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             /* read operands */
             if (read & (1<<o))
             {
-                /* used this before new_reads - puts the last read into the life range as well
-                if (!ir_block_living_find(self, value, NULL))
-                    ir_block_living_add(self, value);
-                */
+#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;
                 }
+#endif
             }
 
             /* write operands */
@@ -1548,10 +1564,15 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
              */
             if (write & (1<<o))
             {
-                size_t idx, readidx;
+                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
@@ -1580,13 +1601,16 @@ 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
                 }
             }
         }
@@ -1595,6 +1619,7 @@ 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)
         {
@@ -1608,6 +1633,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             }
         }
         MEM_VECTOR_CLEAR(&new_reads, v);
+#endif
     }
 
     if (self->run_id == self->owner->run_id)
@@ -1623,7 +1649,9 @@ 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;
 }
 
@@ -1684,10 +1712,13 @@ void ir_function_dump(ir_function *f, char *ind,
        }
        if (f->blocks_count)
        {
-
-               oprintf("%slife passes: %i\n", ind, (int)f->blocks[0]->run_id);
-               for (i = 0; i < f->blocks_count; ++i)
+               oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
+               for (i = 0; i < f->blocks_count; ++i) {
+                   if (f->blocks[i]->run_id != f->run_id) {
+                       oprintf("%slife pass check fail! %i != %i\n", ind, (int)f->blocks[i]->run_id, (int)f->run_id);
+                   }
                        ir_block_dump(f->blocks[i], ind, oprintf);
+               }
 
        }
        ind[strlen(ind)-1] = 0;