Do not emit cld in the CopyB prologue. The ABI mandates that DF is cleared, so do...

[libfirm] / ir / be / beflags.c

diff --git a/ir/be/beflags.c b/ir/be/beflags.c
index ccc1e18..97905da 100644 (file)
--- a/ir/be/beflags.c
+++ b/ir/be/beflags.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -57,6 +57,7 @@ static const arch_env_t            *arch_env   = NULL;
 static const arch_register_class_t *flag_class = NULL;
 static const arch_register_t       *flags_reg  = NULL;
 static func_rematerialize           remat      = NULL;
+static int                          changed;
 
 static ir_node *default_remat(ir_node *node, ir_node *after)
 {
@@ -126,7 +127,7 @@ static int can_move(ir_node *node, ir_node *after)
 }
 
 static void rematerialize_or_move(ir_node *flags_needed, ir_node *node,
-                                  ir_node *flag_consumers, int pn)
+                                  ir_node *flag_consumers, int pn, be_lv_t *lv)
 {
        ir_node *n;
        ir_node *copy;
@@ -138,10 +139,12 @@ static void rematerialize_or_move(ir_node *flags_needed, ir_node *node,
                /* move it */
                sched_remove(flags_needed);
                sched_add_after(node, flags_needed);
+               /* No need to update liveness, because the node stays in the same block */
                return;
        }
 
-       copy = remat(flags_needed, node);
+       changed = 1;
+       copy    = remat(flags_needed, node);
 
        if(get_irn_mode(copy) == mode_T) {
                ir_node *block = get_nodes_block(copy);
@@ -166,6 +169,17 @@ static void rematerialize_or_move(ir_node *flags_needed, ir_node *node,
                }
                n = get_irn_link(n);
        } while(n != NULL);
+
+       /* No need to introduce the copy, because it only lives in this block, but
+        * we have to update the liveness of all operands */
+       if (is_Block(node) ||
+                       get_nodes_block(node) != get_nodes_block(flags_needed)) {
+               int i;
+
+               for (i = get_irn_arity(copy) - 1; i >= 0; --i) {
+                       be_liveness_update(lv, get_irn_n(copy, i));
+               }
+       }
 }
 
 static int is_modify_flags(ir_node *node) {
@@ -199,8 +213,7 @@ static void fix_flags_walker(ir_node *block, void *env)
        ir_node *node;
        ir_node *flags_needed   = NULL;
        ir_node *flag_consumers = NULL;
-       int      pn;
-       (void) env;
+       int      pn = -1;
 
        sched_foreach_reverse(block, node) {
                int i, arity;
@@ -215,18 +228,17 @@ static void fix_flags_walker(ir_node *block, void *env)
                        flag_consumers = NULL;
                }
 
-               /* test wether node destroys the flags */
+               /* test whether node destroys the flags */
                if(flags_needed != NULL && is_modify_flags(node)) {
                        /* rematerialize */
-                       rematerialize_or_move(flags_needed, node, flag_consumers, pn);
+                       rematerialize_or_move(flags_needed, node, flag_consumers, pn, env);
                        flags_needed   = NULL;
                        flag_consumers = NULL;
                }
 
-               /* test wether the current node needs flags */
+               /* test whether the current node needs flags */
                arity = get_irn_arity(node);
                for(i = 0; i < arity; ++i) {
-                       //ir_node *in = get_irn_n(node, i);
                        const arch_register_class_t *cls
                                = arch_get_irn_reg_class(arch_env, node, i);
                        if(cls == flag_class) {
@@ -240,16 +252,17 @@ static void fix_flags_walker(ir_node *block, void *env)
 
                /* spiller can't (correctly) remat flag consumers at the moment */
                assert(!arch_irn_is(arch_env, node, rematerializable));
-               if(new_flags_needed != flags_needed) {
+
+               if(skip_Proj(new_flags_needed) != flags_needed) {
                        if(flags_needed != NULL) {
                                /* rematerialize node */
-                               rematerialize_or_move(flags_needed, node, flag_consumers, pn);
+                               rematerialize_or_move(flags_needed, node, flag_consumers, pn, env);
                                flags_needed   = NULL;
                                flag_consumers = NULL;
                        }
 
                        flags_needed = new_flags_needed;
-                                       arch_set_irn_register(arch_env, flags_needed, flags_reg);
+                       arch_set_irn_register(arch_env, flags_needed, flags_reg);
                        if(is_Proj(flags_needed)) {
                                pn           = get_Proj_proj(flags_needed);
                                flags_needed = get_Proj_pred(flags_needed);
@@ -266,7 +279,7 @@ static void fix_flags_walker(ir_node *block, void *env)
 
        if(flags_needed != NULL) {
                assert(get_nodes_block(flags_needed) != block);
-               rematerialize_or_move(flags_needed, node, flag_consumers, pn);
+               rematerialize_or_move(flags_needed, node, flag_consumers, pn, env);
                flags_needed   = NULL;
                flag_consumers = NULL;
        }
@@ -284,10 +297,15 @@ void be_sched_fix_flags(be_irg_t *birg, const arch_register_class_t *flag_cls,
        flag_class = flag_cls;
        flags_reg  = & flag_class->regs[0];
        remat      = remat_func;
+       changed    = 0;
        if(remat == NULL)
                remat = &default_remat;
 
-       set_using_irn_link(irg);
-       irg_block_walk_graph(irg, fix_flags_walker, NULL, NULL);
-       clear_using_irn_link(irg);
+       ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
+       irg_block_walk_graph(irg, fix_flags_walker, NULL, birg->lv);
+       ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
+
+       if(changed) {
+               be_remove_dead_nodes_from_schedule(birg);
+       }
 }