merge after_ra and finish phase, and move stack_bias fixing into backends

[libfirm] / ir / be / beprefalloc.c

diff --git a/ir/be/beprefalloc.c b/ir/be/beprefalloc.c
index d3ce882..5a80f9c 100644 (file)
--- a/ir/be/beprefalloc.c
+++ b/ir/be/beprefalloc.c
@@ -635,12 +635,12 @@ static bool try_optimistic_split(ir_node *to_split, ir_node *before,
        ir_node               *original_insn;
        ir_node               *block;
        ir_node               *copy;
-       unsigned               r;
+       unsigned               r = 0;
        unsigned               from_r;
        unsigned               i;
        allocation_info_t     *info = get_allocation_info(to_split);
        reg_pref_t            *prefs;
-       float                  delta;
+       float                  delta = 0;
        float                  split_threshold;
 
        (void) pref;
@@ -747,7 +747,7 @@ static void assign_reg(const ir_node *block, ir_node *node,
        ir_node                   *in_node;
        unsigned                   i;
        const unsigned            *allowed_regs;
-       unsigned                   r;
+       unsigned                   r = 0;
 
        assert(!is_Phi(node));
        /* preassigned register? */
@@ -859,7 +859,7 @@ static void assign_reg(const ir_node *block, ir_node *node,
  * First we count how many destinations a single value has. At the same time
  * we can be sure that each destination register has at most 1 source register
  * (it can have 0 which means we don't care what value is in it).
- * We ignore all fullfilled permuations (like 7->7)
+ * We ignore all fulfilled permuations (like 7->7)
  * In a first pass we create as much copy instructions as possible as they
  * are generally cheaper than exchanges. We do this by counting into how many
  * destinations a register has to be copied (in the example it's 2 for register
@@ -867,8 +867,8 @@ static void assign_reg(const ir_node *block, ir_node *node,
  * We can then create a copy into every destination register when the usecount
  * of that register is 0 (= noone else needs the value in the register).
  *
- * After this step we should have cycles left. We implement a cyclic permutation
- * of n registers with n-1 transpositions.
+ * After this step we should only have cycles left. We implement a cyclic
+ * permutation of n registers with n-1 transpositions.
  *
  * @param live_nodes   the set of live nodes, updated due to live range split
  * @param before       the node before we add the permutation
@@ -1239,7 +1239,7 @@ static void enforce_constraints(ir_nodeset_t *live_nodes, ir_node *node,
        permute_values(live_nodes, node, assignment);
 }
 
-/** test wether a node @p n is a copy of the value of node @p of */
+/** test whether a node @p n is a copy of the value of node @p of */
 static bool is_copy_of(ir_node *value, ir_node *test_value)
 {
        allocation_info_t *test_info;
@@ -1964,7 +1964,7 @@ static void be_pref_alloc(ir_graph *new_irg)
        obstack_free(&obst, NULL);
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_pref_alloc);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_pref_alloc)
 void be_init_pref_alloc(void)
 {
        static be_ra_t be_ra_pref = {