X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeprefalloc.c;h=5a80f9ccba00b7430edf6ebedc38cc8ea9be0232;hb=ee2ce90606e3b629b45482964a70a71a46aa6966;hp=e6cea4fe3b46f4595fefbd759c3d7c23712944f2;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm

diff --git a/ir/be/beprefalloc.c b/ir/be/beprefalloc.c
index e6cea4fe3..5a80f9ccb 100644
--- a/ir/be/beprefalloc.c
+++ b/ir/be/beprefalloc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -93,7 +93,7 @@ static unsigned                     n_regs;
 static unsigned                    *normal_regs;
 static int                         *congruence_classes;
 static ir_node                    **block_order;
-static int                          n_block_order;
+static size_t                       n_block_order;
 static int                          create_preferences        = true;
 static int                          create_congruence_classes = true;
 static int                          propagate_phi_registers   = true;
@@ -218,7 +218,7 @@ static void give_penalties_for_limits(const ir_nodeset_t *live_nodes,
 {
 	ir_nodeset_iterator_t iter;
 	unsigned              r;
-	unsigned              n_allowed;
+	size_t                n_allowed;
 	allocation_info_t     *info = get_allocation_info(node);
 	ir_node               *neighbor;
 
@@ -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;
@@ -1736,13 +1736,13 @@ static int cmp_block_costs(const void *d1, const void *d2)
 
 static void determine_block_order(void)
 {
-	int i;
+	size_t    i;
 	ir_node **blocklist = be_get_cfgpostorder(irg);
-	int       n_blocks  = ARR_LEN(blocklist);
+	size_t    n_blocks  = ARR_LEN(blocklist);
 	int       dfs_num   = 0;
 	pdeq     *worklist  = new_pdeq();
 	ir_node **order     = XMALLOCN(ir_node*, n_blocks);
-	int       order_p   = 0;
+	size_t    order_p   = 0;
 
 	/* clear block links... */
 	for (i = 0; i < n_blocks; ++i) {
@@ -1753,9 +1753,9 @@ static void determine_block_order(void)
 	/* walk blocks in reverse postorder, the costs for each block are the
 	 * sum of the costs of its predecessors (excluding the costs on backedges
 	 * which we can't determine) */
-	for (i = n_blocks-1; i >= 0; --i) {
+	for (i = n_blocks; i > 0;) {
 		block_costs_t *cost_info;
-		ir_node *block = blocklist[i];
+		ir_node *block = blocklist[--i];
 
 		float execfreq   = (float)get_block_execfreq(execfreqs, block);
 		float costs      = execfreq;
@@ -1840,7 +1840,7 @@ static void determine_block_order(void)
  */
 static void be_pref_alloc_cls(void)
 {
-	int i;
+	size_t i;
 
 	lv = be_assure_liveness(irg);
 	be_liveness_assure_sets(lv);
@@ -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 = {