X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur.c;h=627810f014ceca39e03b7bde6cc8762c11feccb7;hb=5474a1c188c9d59eea2c915515980cd9cbab58d8;hp=b9003c7cc1b3d96a9d52900b88d99691019431fb;hpb=ab182d4b9ed44239ab3ff1d08b2f8e14a3699ccf;p=libfirm

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index b9003c7cc..627810f01 100644
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -22,7 +22,6 @@
  * @brief       First simple copy minimization heuristics.
  * @author      Daniel Grund
  * @date        12.04.2005
- * @version     $Id$
  *
  * Heuristic for minimizing copies using a queue which holds 'qnodes' not yet
  * examined. A qnode has a 'target color', nodes out of the opt unit and
@@ -47,6 +46,9 @@
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
+/** Defines an invalid register index. */
+#define NO_COLOR (-1)
+
 #define SEARCH_FREE_COLORS
 
 #define SLOTS_PINNED_GLOBAL 64
@@ -87,7 +89,7 @@ typedef struct qnode_t {
 	set              *changed_nodes;   /**< contains node_stat_t's. */
 } qnode_t;
 
-static pset *pinned_global;			/**< optimized nodes should not be altered any more */
+static pset *pinned_global;  /**< optimized nodes should not be altered any more */
 
 static inline int nodes_interfere(const be_chordal_env_t *env, const ir_node *a, const ir_node *b)
 {
@@ -101,8 +103,8 @@ static inline int nodes_interfere(const be_chordal_env_t *env, const ir_node *a,
 
 static int set_cmp_conflict_t(const void *x, const void *y, size_t size)
 {
-	const conflict_t *xx = x;
-	const conflict_t *yy = y;
+	const conflict_t *xx = (const conflict_t*)x;
+	const conflict_t *yy = (const conflict_t*)y;
 	(void) size;
 
 	return xx->n1 != yy->n1 || xx->n2 != yy->n2;
@@ -160,7 +162,7 @@ static inline const node_stat_t *qnode_find_node(const qnode_t *qn, ir_node *irn
 {
 	node_stat_t find;
 	find.irn = irn;
-	return set_find(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
+	return (const node_stat_t*)set_find(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**
@@ -173,7 +175,7 @@ static inline node_stat_t *qnode_find_or_insert_node(const qnode_t *qn, ir_node
 	find.irn = irn;
 	find.new_color = NO_COLOR;
 	find.pinned_local = 0;
-	return set_insert(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
+	return (node_stat_t*)set_insert(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**
@@ -258,7 +260,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
 	ir_node *sub_res, *curr;
 	be_ifg_t *ifg = chordal_env->ifg;
 	neighbours_iter_t iter;
-
+	const arch_register_req_t *req;
 
 	DBG((dbg, LEVEL_3, "\t    %+F \tcaused col(%+F) \t%2d --> %2d\n", trigger, irn, irn_col, col));
 
@@ -274,22 +276,20 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
 		return irn;
 	}
 
+	req = arch_get_irn_register_req(irn);
 #ifdef SEARCH_FREE_COLORS
 	/* If we resolve conflicts (recursive calls) we can use any unused color.
 	 * In case of the first call @p col must be used.
 	 */
 	if (irn != trigger) {
 		bitset_t *free_cols = bitset_alloca(cls->n_regs);
-		const arch_register_req_t *req;
 		ir_node *curr;
 		int free_col;
 
 		/* Get all possible colors */
-		bitset_copy(free_cols, co->cenv->ignore_colors);
-		bitset_flip_all(free_cols);
+		bitset_copy(free_cols, co->cenv->allocatable_regs);
 
 		/* Exclude colors not assignable to the irn */
-		req = arch_get_register_req_out(irn);
 		if (arch_register_req_is(req, limited)) {
 			bitset_t *limited = bitset_alloca(cls->n_regs);
 			rbitset_copy_to_bitset(req->limited, limited);
@@ -313,7 +313,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
 #endif /* SEARCH_FREE_COLORS */
 
 	/* If target color is not allocatable changing color is impossible */
-	if (!arch_reg_out_is_allocatable(irn, arch_register_for_index(cls, col))) {
+	if (!arch_reg_is_allocatable(req, arch_register_for_index(cls, col))) {
 		DBG((dbg, LEVEL_3, "\t      %+F impossible\n", irn));
 		return CHANGE_IMPOSSIBLE;
 	}
@@ -399,7 +399,7 @@ static inline void qnode_max_ind_set(qnode_t *qn, const unit_t *ou)
 	ir_node **safe, **unsafe;
 	int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
 	bitset_t *curr, *best;
-	unsigned pos;
+	size_t pos;
 	int next, curr_weight, best_weight = 0;
 
 	/* assign the nodes into two groups.
@@ -462,7 +462,7 @@ static inline void qnode_max_ind_set(qnode_t *qn, const unit_t *ou)
 							goto no_stable_set;
 
 			/* if we arrive here, we have a stable set */
-			/* compute the weigth of the stable set*/
+			/* compute the weight of the stable set*/
 			curr_weight = 0;
 			bitset_foreach(curr, pos)
 				curr_weight += unsafe_costs[pos];
@@ -553,7 +553,7 @@ static void ou_optimize(unit_t *ou)
 	qnode_t                     *curr = NULL;
 	qnode_t                     *tmp;
 	const arch_register_req_t   *req;
-	bitset_t const*              ignore;
+	bitset_t const*              allocatable_regs;
 	unsigned                     n_regs;
 	unsigned                     idx;
 	int                          i;
@@ -565,14 +565,14 @@ static void ou_optimize(unit_t *ou)
 	/* init queue */
 	INIT_LIST_HEAD(&ou->queue);
 
-	req     = arch_get_register_req_out(ou->nodes[0]);
-	ignore  = ou->co->cenv->ignore_colors;
-	n_regs  = req->cls->n_regs;
+	req              = arch_get_irn_register_req(ou->nodes[0]);
+	allocatable_regs = ou->co->cenv->allocatable_regs;
+	n_regs           = req->cls->n_regs;
 	if (arch_register_req_is(req, limited)) {
 		unsigned const* limited = req->limited;
 
 		for (idx = 0; idx != n_regs; ++idx) {
-			if (bitset_is_set(ignore, idx))
+			if (!bitset_is_set(allocatable_regs, idx))
 				continue;
 			if (!rbitset_is_set(limited, idx))
 				continue;
@@ -581,7 +581,7 @@ static void ou_optimize(unit_t *ou)
 		}
 	} else {
 		for (idx = 0; idx != n_regs; ++idx) {
-			if (bitset_is_set(ignore, idx))
+			if (!bitset_is_set(allocatable_regs, idx))
 				continue;
 
 			ou_insert_qnode(ou, new_qnode(ou, idx));
@@ -621,11 +621,12 @@ static void ou_optimize(unit_t *ou)
 		}
 
 		/* set color of all changed nodes */
-		for (ns = set_first(curr->changed_nodes); ns; ns = set_next(curr->changed_nodes)) {
+		for (ns = (node_stat_t*)set_first(curr->changed_nodes); ns != NULL;
+		     ns = (node_stat_t*)set_next(curr->changed_nodes)) {
 			/* NO_COLOR is possible, if we had an undo */
 			if (ns->new_color != NO_COLOR) {
 				DBG((dbg, LEVEL_1, "\t    color(%+F) := %d\n", ns->irn, ns->new_color));
-				set_irn_col(ou->co, ns->irn, ns->new_color);
+				set_irn_col(ou->co->cls, ns->irn, ns->new_color);
 			}
 		}
 	}
@@ -655,7 +656,7 @@ int co_solve_heuristic(copy_opt_t *co)
 	return 0;
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur)
 void be_init_copyheur(void)
 {
 	static co_algo_info copyheur = {