Loads do not remove any nodes from the exec after sets. Also fix a 'node leak'.

[libfirm] / ir / opt / ldst2.c

diff --git a/ir/opt/ldst2.c b/ir/opt/ldst2.c
index 4372bac..f5ae3a2 100644 (file)
--- a/ir/opt/ldst2.c
+++ b/ir/opt/ldst2.c
@@ -21,7 +21,7 @@
  * @file
  * @brief   parallelizing Load/Store optimisation
  * @author  Christoph Mallon
- * @version $Id$
+ * @version $Id: $
  */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -41,7 +41,7 @@
 #include "obst.h"
 #include "return.h"
 #include "irdump.h"
-
+#include "irflag_t.h"
 
 #define OPTIMISE_LOAD_AFTER_LOAD
 
@@ -92,7 +92,7 @@ static void CollectAddresses(ir_graph* irg)
                for (i = 0; i < count_addrs; i++) {
                        ir_node* addr = ir_nodeset_iterator_next(&addr_iter);
                        assert(addr != NULL);
-                       set_irn_link(addr, (void*)(uintptr_t)i);
+                       set_irn_link(addr, (void *)i);
                        addrs[i] = addr;
                        DB((dbg, LEVEL_2, "===> Collected unique symbolic address %+F\n", addr));
                }
@@ -243,7 +243,7 @@ static void WalkMemPhi(ir_graph* irg, ir_node* block, ir_node* phi)
 static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* memory)
 {
        ir_node* addr = get_Load_ptr(load);
-       size_t addr_idx = (size_t)(uintptr_t)get_irn_link(addr);
+       size_t addr_idx = (size_t)get_irn_link(addr);
        ir_nodeset_t* interfere_sets = get_irn_link(block);
        ir_nodeset_t* interfere_set = &interfere_sets[addr_idx];
        size_t size = ir_nodeset_size(interfere_set);
@@ -254,27 +254,18 @@ static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* mem
        ir_nodeset_iterator_init(&interfere_iter, interfere_set);
        if (size == 1) {
                ir_node* after = ir_nodeset_iterator_next(&interfere_iter);
-               if (is_Proj(after)) {
-                       ir_node* pred = get_Proj_pred(after);
-                       if (is_Load(pred)) {
-#ifdef OPTIMISE_LOAD_AFTER_LOAD
-                               if (get_Load_ptr(pred) == addr && get_Load_mode(pred) == get_Load_mode(load)) {
-                                       exchange(load, pred);
-                                       return;
-                               }
-#endif
-                               after = get_Load_mem(pred);
-                       }
-               }
+               assert(!is_Proj(after) || !is_Load(get_Proj_pred(after)));
                DB((dbg, LEVEL_3, "===> %+F must be executed after %+F\n", load, after));
                set_Load_mem(load, after);
        } else {
                ir_node** after_set;
-               ir_node* sync;
+               ir_node* after;
+               ir_node* mem;
+               size_t i;
 
                NEW_ARR_A(ir_node*, after_set, size);
-               for (i = 0; i < size; i++) {
-                       ir_node* mem = ir_nodeset_iterator_next(&interfere_iter);
+               i = 0;
+               while ((mem = ir_nodeset_iterator_next(&interfere_iter)) != NULL) {
                        if (is_Proj(mem)) {
                                ir_node* pred = get_Proj_pred(mem);
                                if (is_Load(pred)) {
@@ -284,13 +275,19 @@ static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* mem
                                                return;
                                        }
 #endif
-                                       mem = get_Load_mem(pred);
+                                       continue;
                                }
                        }
-                       after_set[i] = mem;
-                       sync = new_r_Sync(irg, block, size, after_set);
+                       DB((dbg, LEVEL_3, "===> %+F must be executed after %+F\n", load, mem));
+                       after_set[i++] = mem;
+               }
+               assert(i != 0);
+               if (i == 1) {
+                       after = after_set[0];
+               } else {
+                       after = new_r_Sync(irg, block, i, after_set);
                }
-               set_Load_mem(load, sync);
+               set_Load_mem(load, after);
        }
 
        for (i = 0; i < count_addrs; i++) {
@@ -298,7 +295,6 @@ static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* mem
                ir_node* other_addr = addrs[i];
                ir_mode* other_mode = mode; // XXX second mode is nonsense
                ir_alias_relation rel = get_alias_relation(irg, addr, mode, other_addr, other_mode);
-               ir_node* other_node;
 
                DB((dbg, LEVEL_3, "===> Testing for alias between %+F and %+F. Relation is %d\n", addr, other_addr, rel));
                if (rel == no_alias) {
@@ -306,15 +302,6 @@ static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* mem
                }
                DB((dbg, LEVEL_3, "===> %+F potentially aliases address %+F\n", load, other_addr));
 
-               ir_nodeset_iterator_init(&interfere_iter, &interfere_sets[i]);
-               while ((other_node = ir_nodeset_iterator_next(&interfere_iter)) != NULL) {
-                       if (is_Proj(other_node) && is_Load(get_Proj_pred(other_node))) continue;
-                       if (AliasTest(irg, addr, mode, other_node) != no_alias) {
-                               DB((dbg, LEVEL_3, "===> Removing %+F from execute-after set of %+F due to %+F\n", other_node, addrs[i], load));
-                               ir_nodeset_remove_iterator(&interfere_sets[i], &interfere_iter);
-                       }
-               }
-
                ir_nodeset_insert(&interfere_sets[i], memory);
        }
 }
@@ -323,7 +310,7 @@ static void PlaceLoad(ir_graph* irg, ir_node* block, ir_node* load, ir_node* mem
 static void PlaceStore(ir_graph* irg, ir_node* block, ir_node* store, ir_node* memory)
 {
        ir_node* addr = get_Store_ptr(store);
-       size_t addr_idx = (size_t)(uintptr_t)get_irn_link(addr);
+       size_t addr_idx = (size_t)get_irn_link(addr);
        ir_nodeset_t* interfere_sets = get_irn_link(block);
        ir_nodeset_t* interfere_set = &interfere_sets[addr_idx];
        ir_node* after;
@@ -415,6 +402,7 @@ static int WalkMem(ir_graph* irg, ir_node* node, ir_node* last_block)
                                unknown = new_r_Unknown(irg, mode_M);
                                for (i = 0; i < count_addrs; i++) {
                                        ir_node* phi_unk = new_r_Phi(irg, block, 1, &unknown, mode_M);
+                                       DB((dbg, LEVEL_3, "===> Placing unfinished %+F for %+F in %+F\n", phi_unk, addrs[i], block));
                                        set_irn_link(phi_unk, unfinished_phis[i]);
                                        unfinished_phis[i] = phi_unk;
                                        ir_nodeset_insert(&thissets[i], phi_unk);
@@ -592,6 +580,7 @@ void opt_ldst2(ir_graph* irg)
        DB((dbg, LEVEL_1, "===> Performing load/store optimisation on %+F\n", irg));
 
        normalize_one_return(irg);
+       dump_ir_block_graph(irg, "-prefluffig");
 
        obstack_init(&obst);
 
@@ -608,7 +597,6 @@ void opt_ldst2(ir_graph* irg)
        inc_irg_block_visited(irg);
        SetStartAddressesTop(irg);
        Detotalise(irg);
-
        dump_ir_block_graph(irg, "-fluffig");
 
        irg_block_walk_graph(irg, AliasSetDestroyer, NULL, NULL);
@@ -618,4 +606,5 @@ void opt_ldst2(ir_graph* irg)
        irg_walk_graph(irg, NormaliseSync, NULL, NULL);
   optimize_graph_df(irg);
        irg_walk_graph(irg, NormaliseSync, NULL, NULL);
+       dump_ir_block_graph(irg, "-postfluffig");
 }