X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur.c;h=7c669b5e3fdca20b01075eea622774ce7a6ef62d;hb=5cb14f12bacb0c7d1c646112b4660d57e14236a2;hp=1afb06249a57bec350d8ede12318e6e8aa1a6bfd;hpb=d6768d8d4427959eb045aafb1d15bd189beaa5dd;p=libfirm

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index 1afb06249..7c669b5e3 100644
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.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.
  *
@@ -27,7 +27,7 @@
  * 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
  * a 'conflict graph'. 'Conflict graph' = "Interference graph' + 'conflict edges'
- * A 'max indep set' is determined form these. We try to color this mis using a
+ * A 'max indep set' is determined from these. We try to color this mis using a
  * color-exchanging mechanism. Occuring conflicts are modeled with 'conflict edges'
  * and the qnode is reinserted in the queue. The first qnode colored without
  * conflicts is the best one.
@@ -43,8 +43,7 @@
 
 #include "becopyopt_t.h"
 #include "becopystat.h"
-#include "benodesets.h"
-#include "bera.h"
+#include "beintlive_t.h"
 #include "beirg_t.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
@@ -56,7 +55,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 #define SLOTS_CHANGED_NODES 32
 
 #define list_entry_queue(lh) list_entry(lh, qnode_t, queue)
-#define HASH_CONFLICT(c) (nodeset_hash(c.n1) ^ nodeset_hash(c.n2))
+#define HASH_CONFLICT(c) (hash_irn(c.n1) ^ hash_irn(c.n2))
 
 /**
  * Modeling additional conflicts between nodes. NOT live range interference
@@ -80,7 +79,7 @@ typedef struct _node_stat_t {
  */
 typedef struct _qnode_t {
 	struct list_head queue;            /**< chaining of unit_t->queue */
-	const unit_t     *ou;              /**< the opt unit this qnode belongs to */
+	const unit_t     *ou;              /**< the opt unit this node belongs to */
 	int              color;            /**< target color */
 	set              *conflicts;       /**< contains conflict_t's. All internal conflicts */
 	int              mis_costs;        /**< costs of nodes/copies in the mis. */
@@ -96,13 +95,15 @@ static INLINE int nodes_interfere(const be_chordal_env_t *env, const ir_node *a,
 	if (env->ifg)
 		return be_ifg_connected(env->ifg, a, b);
 	else
-		return values_interfere(env->birg->lv, a, b);
+		return values_interfere(env->birg, a, b);
 }
 
 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;
-	return ! (xx->n1 == yy->n1 && xx->n2 == yy->n2);
+	(void) size;
+
+	return xx->n1 != yy->n1 || xx->n2 != yy->n2;
 }
 
 /**
@@ -113,7 +114,7 @@ static INLINE void qnode_add_conflict(const qnode_t *qn, const ir_node *n1, cons
 	conflict_t c;
 	DBG((dbg, LEVEL_4, "\t      %+F -- %+F\n", n1, n2));
 
-	if ((int)n1 < (int)n2) {
+	if (get_irn_idx(n1) < get_irn_idx(n2)) {
 		c.n1 = n1;
 		c.n2 = n2;
 	} else {
@@ -132,27 +133,28 @@ static INLINE int qnode_are_conflicting(const qnode_t *qn, const ir_node *n1, co
 	if (n1!=n2 && nodes_interfere(qn->ou->co->cenv, n1, n2))
 		return 1;
 	/* search for recoloring conflicts */
-	if ((int)n1 < (int)n2) {
+	if (get_irn_idx(n1) < get_irn_idx(n2)) {
 		c.n1 = n1;
 		c.n2 = n2;
 	} else {
 		c.n1 = n2;
 		c.n2 = n1;
 	}
-	return (int) set_find(qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c));
+	return set_find(qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c)) != 0;
 }
 
 static int set_cmp_node_stat_t(const void *x, const void *y, size_t size) {
-	return ((node_stat_t *)x)->irn != ((node_stat_t *)y)->irn;
+	(void) size;
+	return ((const node_stat_t*)x)->irn != ((const node_stat_t*)y)->irn;
 }
 
 /**
  * Finds a node status entry of a node if existent. Otherwise return NULL
  */
-static INLINE node_stat_t *qnode_find_node(const qnode_t *qn, ir_node *irn) {
+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), nodeset_hash(irn));
+	return set_find(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**
@@ -164,14 +166,14 @@ 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), nodeset_hash(irn));
+	return set_insert(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**
  * Returns the virtual color of a node if set before, else returns the real color.
  */
 static INLINE int qnode_get_new_color(const qnode_t *qn, ir_node *irn) {
-	node_stat_t *found = qnode_find_node(qn, irn);
+	const node_stat_t *found = qnode_find_node(qn, irn);
 	if (found)
 		return found->new_color;
 	else
@@ -193,7 +195,7 @@ static INLINE void qnode_set_new_color(const qnode_t *qn, ir_node *irn, int colo
  * processed node.
  */
 static INLINE int qnode_is_pinned_local(const qnode_t *qn, ir_node *irn) {
-	node_stat_t *found = qnode_find_node(qn, irn);
+	const node_stat_t *found = qnode_find_node(qn, irn);
 	if (found)
 		return found->pinned_local;
 	else
@@ -217,7 +219,6 @@ static INLINE void qnode_pin_local(const qnode_t *qn, ir_node *irn) {
  */
 #define CHANGE_SAVE NULL
 #define CHANGE_IMPOSSIBLE (ir_node *)1
-#define is_conflicting_node(n) (((int)n) > 1)
 
 /**
  * Performs virtual re-coloring of node @p n to color @p col. Virtual colors of
@@ -351,6 +352,7 @@ static int qnode_try_color(const qnode_t *qn) {
 		} else if (confl_node == CHANGE_IMPOSSIBLE) {
 			DBG((dbg, LEVEL_3, "\t    Impossible --> remove from qnode\n"));
 			qnode_add_conflict(qn, test_node, test_node);
+			return 0;
 		} else {
 			if (qnode_is_pinned_local(qn, confl_node)) {
 				/* changing test_node would change back a node of current ou */
@@ -370,10 +372,8 @@ static int qnode_try_color(const qnode_t *qn) {
 				DBG((dbg, LEVEL_3, "\t    Conflicting global --> remove from qnode\n"));
 				qnode_add_conflict(qn, test_node, test_node);
 			}
-		}
-
-		if (confl_node != CHANGE_SAVE)
 			return 0;
+		}
 	}
 	return 1;
 }
@@ -386,7 +386,8 @@ 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;
-	int max, next, pos, curr_weight, best_weight = 0;
+	bitset_pos_t pos;
+	int max, next, curr_weight, best_weight = 0;
 
 	/* assign the nodes into two groups.
 	 * safe: node has no interference, hence it is in every max stable set.
@@ -536,6 +537,7 @@ static void ou_optimize(unit_t *ou) {
 	qnode_t *curr = NULL, *tmp;
 	const arch_env_t *aenv = ou->co->aenv;
 	const arch_register_class_t *cls = ou->co->cls;
+	bitset_pos_t idx;
 	bitset_t *pos_regs = bitset_alloca(cls->n_regs);
 
 	DBG((dbg, LEVEL_1, "\tOptimizing unit:\n"));
@@ -553,11 +555,12 @@ static void ou_optimize(unit_t *ou) {
 	assert(bitset_popcnt(pos_regs) != 0 && "No register is allowed for this node !!?");
 
 	/* create new qnode */
-	bitset_foreach(pos_regs, i)
-		ou_insert_qnode(ou, new_qnode(ou, i));
+	bitset_foreach(pos_regs, idx)
+		ou_insert_qnode(ou, new_qnode(ou, idx));
 
 	/* search best */
-	while (!list_empty(&ou->queue)) {
+	for (;;) {
+		assert(!list_empty(&ou->queue));
 		/* get head of queue */
 		curr = list_entry_queue(ou->queue.next);
 		list_del(&curr->queue);