Reverted r27368, needed for propagation of changed nodes ...

[libfirm] / ir / opt / ldstopt.c

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index 1b7b1f4..8e703d1 100644 (file)
--- a/ir/opt/ldstopt.c
+++ b/ir/opt/ldstopt.c
@@ -723,19 +723,20 @@ static void handle_load_update(ir_node *load)
  */
 static void reduce_adr_usage(ir_node *ptr)
 {
-       if (is_Proj(ptr)) {
-               if (get_irn_n_edges(ptr) <= 0) {
-                       /* this Proj is dead now */
-                       ir_node *pred = get_Proj_pred(ptr);
+       ir_node *pred;
+       if (!is_Proj(ptr))
+               return;
+       if (get_irn_n_edges(ptr) > 0)
+               return;
 
-                       if (is_Load(pred)) {
-                               ldst_info_t *info = get_irn_link(pred);
-                               info->projs[get_Proj_proj(ptr)] = NULL;
+       /* this Proj is dead now */
+       pred = get_Proj_pred(ptr);
+       if (is_Load(pred)) {
+               ldst_info_t *info = get_irn_link(pred);
+               info->projs[get_Proj_proj(ptr)] = NULL;
 
-                               /* this node lost its result proj, handle that */
-                               handle_load_update(pred);
-                       }
-               }
+               /* this node lost its result proj, handle that */
+               handle_load_update(pred);
        }
 }  /* reduce_adr_usage */
 
@@ -981,7 +982,7 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr)
                                if (info->projs[pn_Load_res]) {
                                        if (pred_info->projs[pn_Load_res] == NULL) {
                                                /* create a new Proj again */
-                                               pred_info->projs[pn_Load_res] = new_r_Proj(get_nodes_block(pred), pred, get_Load_mode(pred), pn_Load_res);
+                                               pred_info->projs[pn_Load_res] = new_r_Proj(pred, get_Load_mode(pred), pn_Load_res);
                                        }
                                        value = pred_info->projs[pn_Load_res];
 
@@ -1107,39 +1108,12 @@ static unsigned optimize_load(ir_node *load)
        /* the address of the load to be optimized */
        ptr = get_Load_ptr(load);
 
-       /*
-        * Check if we can remove the exception from a Load:
-        * This can be done, if the address is from an Sel(Alloc) and
-        * the Sel type is a subtype of the allocated type.
-        *
-        * This optimizes some often used OO constructs,
-        * like x = new O; x->t;
-        */
-       if (info->projs[pn_Load_X_except]) {
-               ir_node *addr = ptr;
-
-               /* find base address */
-               while (is_Sel(addr))
-                       addr = get_Sel_ptr(addr);
-               if (is_Alloc(skip_Proj(skip_Cast(addr)))) {
-                       /* simple case: a direct load after an Alloc. Firm Alloc throw
-                        * an exception in case of out-of-memory. So, there is no way for an
-                        * exception in this load.
-                        * This code is constructed by the "exception lowering" in the Jack compiler.
-                        */
-                       exchange(info->projs[pn_Load_X_except], new_Bad());
-                       info->projs[pn_Load_X_except] = NULL;
-                       exchange(info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load)));
-                       info->projs[pn_Load_X_regular] = NULL;
-                       res |= CF_CHANGED;
-               }
-       }
-
        /* The mem of the Load. Must still be returned after optimization. */
        mem = get_Load_mem(load);
 
-       if (! info->projs[pn_Load_res] && ! info->projs[pn_Load_X_except]) {
-               /* a Load which value is neither used nor exception checked, remove it */
+       if (info->projs[pn_Load_res] == NULL
+                       && info->projs[pn_Load_X_except] == NULL) {
+               /* the value is never used and we don't care about exceptions, remove */
                exchange(info->projs[pn_Load_M], mem);
 
                if (info->projs[pn_Load_X_regular]) {
@@ -1640,14 +1614,14 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv)
        co_set_irn_name(store, co_get_irn_ident(old_store));
 #endif
 
-       projM = new_rd_Proj(NULL, block, store, mode_M, pn_Store_M);
+       projM = new_rd_Proj(NULL, store, mode_M, pn_Store_M);
 
        info = get_ldst_info(store, &wenv->obst);
        info->projs[pn_Store_M] = projM;
 
        /* fifths step: repair exception flow */
        if (exc) {
-               ir_node *projX = new_rd_Proj(NULL, block, store, mode_X, pn_Store_X_except);
+               ir_node *projX = new_rd_Proj(NULL, store, mode_X, pn_Store_X_except);
 
                info->projs[pn_Store_X_except] = projX;
                info->exc_block                = exc;
@@ -1938,10 +1912,10 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env)
                                        pe->load = irn;
                                        ninfo = get_ldst_info(irn, phase_obst(&env->ph));
 
-                                       ninfo->projs[pn_Load_M] = mem = new_r_Proj(pred, irn, mode_M, pn_Load_M);
+                                       ninfo->projs[pn_Load_M] = mem = new_r_Proj(irn, mode_M, pn_Load_M);
                                        set_Phi_pred(phi, pos, mem);
 
-                                       ninfo->projs[pn_Load_res] = new_r_Proj(pred, irn, load_mode, pn_Load_res);
+                                       ninfo->projs[pn_Load_res] = new_r_Proj(irn, load_mode, pn_Load_res);
                                }
 
                                /* now kill the old Load */
@@ -2257,13 +2231,13 @@ static int optimize_loops(ir_graph *irg)
        env.nextDFSnum    = 0;
        env.POnum         = 0;
        env.changes       = 0;
-       phase_init(&env.ph, "ldstopt", irg, PHASE_DEFAULT_GROWTH, init_loop_data, NULL);
+       phase_init(&env.ph, irg, init_loop_data);
 
        /* calculate the SCC's and drive loop optimization. */
        do_dfs(irg, &env);
 
        DEL_ARR_F(env.stack);
-       phase_free(&env.ph);
+       phase_deinit(&env.ph);
 
        return env.changes;
 }  /* optimize_loops */