merge common graph copying code; move dead code elimination into an own file

[libfirm] / ir / opt / ldstopt.c

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index ac7137e..7ac484a 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]) {
@@ -1311,7 +1285,7 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr)
                                ir_node *predvalue = get_Store_value(pred);
                                ir_mode *predmode  = get_irn_mode(predvalue);
 
-                               if(is_completely_overwritten(predmode, mode)
+                               if (is_completely_overwritten(predmode, mode)
                                        || is_partially_same(predvalue, value)) {
                                        DBG_OPT_WAW(pred, store);
                                        exchange(pred_info->projs[pn_Store_M], get_Store_mem(pred));
@@ -1331,7 +1305,7 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr)
                                && !info->projs[pn_Store_X_except]) {
                                ir_node *predvalue = get_Store_value(pred);
 
-                               if(is_partially_same(value, predvalue)) {
+                               if (is_partially_same(value, predvalue)) {
                                        DBG_OPT_WAW(pred, store);
                                        exchange(info->projs[pn_Store_M], mem);
                                        kill_node(store);
@@ -1402,7 +1376,7 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr)
 /** find entity used as base for an address calculation */
 static ir_entity *find_entity(ir_node *ptr)
 {
-       switch(get_irn_opcode(ptr)) {
+       switch (get_irn_opcode(ptr)) {
        case iro_SymConst:
                return get_SymConst_entity(ptr);
        case iro_Sel: {
@@ -1627,7 +1601,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv)
        for (i = n - 1; i >= 0; --i) {
                ir_node *proj  = projMs[i];
 
-               if(is_Proj(proj)) {
+               if (is_Proj(proj)) {
                        ir_node *store = get_Proj_pred(proj);
                        exchange(proj, inM[i]);
                        kill_node(store);
@@ -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 */