/**
- * This is the C implementation of the trivial mst algo
+ * This is the C implementation of the mst algorithm
* originally written in Java by Sebastian Hack.
- * Performs simple copy minimzation.
+ * (also known as "heur3" :)
+ * Performs simple copy minimization.
*
* @author Christian Wuerdig
* @date 27.04.2007
#include "pset_new.h"
#include "xmalloc.h"
#include "pdeq.h"
+#include "irprintf.h"
#include "bearch.h"
#include "beifg.h"
#define AFF_NEIGHBOUR_FIX_BENEFIT 128.0
#define NEIGHBOUR_CONSTR_COSTS 64.0
+#define DBG_AFF_CHUNK(env, level, chunk) DEBUG_ONLY(if (firm_dbg_get_mask((env)->dbg) & (level)) dbg_aff_chunk((env), (chunk));)
+#define DBG_COL_COST(env, level, cost) DEBUG_ONLY(if (firm_dbg_get_mask((env)->dbg) & (level)) dbg_col_cost((env), (cost));)
+
+static int last_chunk_id = 0;
+
typedef struct _col_cost_t {
int col;
double cost;
typedef struct _aff_chunk_t {
bitset_t *nodes;
- double weight;
+ int weight;
unsigned weight_consistent : 1;
+ int id;
} aff_chunk_t;
typedef struct _aff_edge_t {
be_ifg_t *ifg; /**< the interference graph */
const arch_env_t *aenv; /**< the arch environment */
copy_opt_t *co; /**< the copy opt object */
+ DEBUG_ONLY(firm_dbg_module_t *dbg);
} co_mst_env_t;
/* stores coalescing related information for a node */
bitset_t *adm_colors;
int int_neigh;
int col;
+ int init_col;
int tmp_col;
unsigned fixed : 1;
unsigned tmp_fixed : 1;
} co_mst_irn_t;
-
#define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn)))
typedef int decide_func_t(co_mst_irn_t *node, int col);
+#ifdef DEBUG_libfirm
+
+static void dbg_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+ int idx;
+ bitset_foreach(c->nodes, idx) {
+ ir_node *n = get_idx_irn(env->co->irg, idx);
+ ir_fprintf(stderr, " %+F", n);
+ }
+ if (c->weight_consistent)
+ ir_fprintf(stderr, " weight %d", c->weight);
+}
+
+static void dbg_admissible_colors(co_mst_env_t *env, co_mst_irn_t *node) {
+ int idx;
+ if (bitset_popcnt(node->adm_colors) < 1)
+ fprintf(stderr, "no admissible colors?!?");
+ else {
+ bitset_foreach(node->adm_colors, idx)
+ fprintf(stderr, " %d", idx);
+ }
+}
+
+static void dbg_col_cost(co_mst_env_t *env, col_cost_t *cost) {
+ int i;
+ for (i = 0; i < env->n_regs; ++i) {
+ if (cost[i].cost == COL_COST_INFEASIBLE)
+ fprintf(stderr, " (%d, INF)", cost[i].col);
+ else
+ fprintf(stderr, " (%d, %.1f)", cost[i].col, cost[i].cost);
+ }
+}
+
+#endif /* DEBUG_libfirm */
+
static INLINE int get_mst_irn_col(co_mst_irn_t *node) {
return node->tmp_fixed ? node->tmp_col : node->col;
}
const aff_edge_t *e2 = b;
/* sort in descending order */
- return e1->weight < e2->weight ? 1 : -1;
+ return QSORT_CMP(e2, e1);
}
/* compares to color-cost pairs */
return c1->cost < c2->cost ? -1 : 1;
}
+/**
+ * Creates a new affinity chunk
+ */
+static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
+ aff_chunk_t *c = xmalloc(sizeof(*c));
+ c->weight = -1;
+ c->weight_consistent = 0;
+ c->nodes = bitset_irg_malloc(env->co->irg);
+ c->id = last_chunk_id++;
+ pset_new_insert(&env->chunkset, c);
+ return c;
+}
+
+/**
+ * Frees all memory allocated by an affinity chunk.
+ */
+static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+ pset_new_remove(&env->chunkset, c);
+ bitset_free(c->nodes);
+ free(c);
+}
+
+/**
+ * Adds a node to an affinity chunk
+ */
+static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+ c->weight_consistent = 0;
+ node->chunk = c;
+ bitset_set(c->nodes, get_irn_idx(node->irn));
+}
+
+
/**
* In case there is no phase information for irn, initialize it.
*/
ir_node *m;
res->irn = irn;
- res->chunk = NULL;
+ res->chunk = new_aff_chunk(env);
res->fixed = 0;
res->tmp_fixed = 0;
res->tmp_col = -1;
res->int_neigh = 0;
res->col = arch_register_get_index(arch_get_irn_register(env->aenv, irn));
+ res->init_col = res->col;
+
+ /* add note to new chunk */
+ aff_chunk_add_node(res->chunk, res);
+
+ DBG((env->dbg, LEVEL_2, "Creating phase info for %+F, chunk %d\n", irn, res->chunk->id));
/* set admissible registers */
res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
req = arch_get_register_req(env->aenv, irn, -1);
if (arch_register_req_is(req, limited))
rbitset_copy_to_bitset(req->limited, res->adm_colors);
+ else
+ bitset_set_all(res->adm_colors);
/* exclude global ignore registers as well */
bitset_andnot(res->adm_colors, env->ignore_regs);
}
/**
- * Creates a new affinity chunk
+ * Check if affinity chunk @p chunk interferes with node @p irn.
*/
-static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
- aff_chunk_t *c = xmalloc(sizeof(*c));
- c->weight_consistent = 0;
- c->nodes = bitset_irg_malloc(env->co->irg);
- pset_new_insert(&env->chunkset, c);
- return c;
-}
+static INLINE int aff_chunk_interferes(co_mst_env_t *env, aff_chunk_t *chunk, ir_node *irn) {
+ void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ ir_node *neigh;
-/**
- * Frees all memory allocated by an affinity chunk.
- */
-static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
- pset_new_remove(&env->chunkset, c);
- bitset_free(c->nodes);
- free(c);
-}
+ be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
+ if (! arch_irn_is(env->aenv, neigh, ignore) && bitset_is_set(chunk->nodes, get_irn_idx(neigh)))
+ return 1;
+ }
-/**
- * Adds a node to an affinity chunk
- */
-static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
- c->weight_consistent = 0;
- node->chunk = c;
- bitset_set(c->nodes, get_irn_idx(node->irn));
+ return 0;
}
/**
* @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
*/
static INLINE int aff_chunks_interfere(co_mst_env_t *env, aff_chunk_t *c1, aff_chunk_t *c2) {
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
- int idx;
+ int idx;
+
+ if (c1 == c2)
+ return 0;
- /* check if there is a node in c1 having an interfering neighbour in c2 */
- bitset_foreach(c1->nodes, idx) {
+ /* check if there is a node in c2 having an interfering neighbour in c1 */
+ bitset_foreach(c2->nodes, idx) {
ir_node *n = get_idx_irn(env->co->irg, idx);
- ir_node *neigh;
- be_ifg_foreach_neighbour(env->ifg, nodes_it, n, neigh) {
- if (bitset_is_set(c2->nodes, get_irn_idx(neigh)))
- return 1;
- }
+ if (aff_chunk_interferes(env, c1, n))
+ return 1;
}
return 0;
* @return 1 if successful, 0 if not possible
*/
static INLINE int aff_chunk_absorb(co_mst_env_t *env, aff_chunk_t *c1, aff_chunk_t *c2) {
- if (! aff_chunks_interfere(env, c1, c2)) {
+ DBG((env->dbg, LEVEL_1, "Attempt to let c1 (id %d): ", c1->id));
+ DBG_AFF_CHUNK(env, LEVEL_1, c1);
+ DB((env->dbg, LEVEL_1, "\n\tabsorb c2 (id %d): ", c2->id));
+ DBG_AFF_CHUNK(env, LEVEL_1, c2);
+ DB((env->dbg, LEVEL_1, "\n"));
+
+ if (! aff_chunks_interfere(env, c1, c2) && c1 != c2) {
+ int idx;
+
bitset_or(c1->nodes, c2->nodes);
c1->weight_consistent = 0;
+
+ bitset_foreach(c2->nodes, idx) {
+ ir_node *n = get_idx_irn(env->co->irg, idx);
+ co_mst_irn_t *mn = get_co_mst_irn(env, n);
+ mn->chunk = c1;
+ }
+
+ DB((env->dbg, LEVEL_1, " ... absorbed, c2 deleted\n"));
+ delete_aff_chunk(env, c2);
return 1;
}
+ DB((env->dbg, LEVEL_1, " ... c1 interferes with c2, skipped\n"));
return 0;
}
* Returns the affinity chunk of @p irn or creates a new
* one with @p irn as element if there is none assigned.
*/
-static INLINE aff_chunk_t *get_or_set_aff_chunk(co_mst_env_t *env, ir_node *irn) {
+static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, ir_node *irn) {
co_mst_irn_t *node = get_co_mst_irn(env, irn);
-
- if (node->chunk == NULL) {
- node->chunk = new_aff_chunk(env);
- aff_chunk_add_node(node->chunk, node);
- }
-
+ assert(node->chunk && "Node should have a chunk.");
return node->chunk;
}
*/
static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
if (! c->weight_consistent) {
- double w = 0.0;
- int idx;
+ int w = 0;
+ int idx;
bitset_foreach(c->nodes, idx) {
ir_node *n = get_idx_irn(env->co->irg, idx);
affinity_node_t *an = get_affinity_info(env->co, n);
- co_mst_irn_t *n1 = get_co_mst_irn(env, n);
if (an != NULL) {
neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
ir_node *m = neigh->irn;
int m_idx = get_irn_idx(m);
- co_mst_irn_t *n2;
/* skip ignore nodes */
if (arch_irn_is(env->aenv, m, ignore))
continue;
- n2 = get_co_mst_irn(env, m);
-
- /* record the edge in only one direction */
- if (idx < m_idx)
- w += (double)neigh->costs / (double)(1 + n1->int_neigh + n2->int_neigh);
+ w += bitset_is_set(c->nodes, m_idx) ? neigh->costs : 0;
}
}
}
/* now: sort edges and build the affinity chunks */
qsort(edges, ARR_LEN(edges), sizeof(edges[0]), cmp_aff_edge);
for (i = 0; i < ARR_LEN(edges); ++i) {
- aff_chunk_t *c1 = get_or_set_aff_chunk(env, edges[i].src);
- aff_chunk_t *c2 = get_or_set_aff_chunk(env, edges[i].tgt);
- int res = aff_chunk_absorb(env, c1, c2);
-
- /* if c2 was absorbed by c1, we can remove c2 */
- if (res) {
- co_mst_irn_t *node = get_co_mst_irn(env, edges[i].tgt);
- node->chunk = c1;
- delete_aff_chunk(env, c2);
- }
+ aff_chunk_t *c1 = get_aff_chunk(env, edges[i].src);
+ aff_chunk_t *c2 = get_aff_chunk(env, edges[i].tgt);
+
+ (void)aff_chunk_absorb(env, c1, c2);
}
/* now insert all chunks into a priority queue */
foreach_pset_new(&env->chunkset, curr_chunk, iter) {
aff_chunk_assure_weight(env, curr_chunk);
+
+ DBG((env->dbg, LEVEL_1, "Putting chunk (id %d): ", curr_chunk->id));
+ DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
+ DB((env->dbg, LEVEL_1, "\n\tinto priority queue\n"));
+
pqueue_put(env->chunks, curr_chunk, curr_chunk->weight);
}
{
waitq *nodes = new_waitq();
+ DBG((env->dbg, LEVEL_1, "\nExpanding new chunk (id %d) from %+F:", chunk->id, node->irn));
+
/* init queue and chunk */
waitq_put(nodes, node);
bitset_set(visited, get_irn_idx(node->irn));
aff_chunk_add_node(chunk, node);
+ DB((env->dbg, LEVEL_1, " %+F", node->irn));
/* as long as there are nodes in the queue */
while (! waitq_empty(nodes)) {
- co_mst_irn_t *n = waitq_get(nodes);
- affinity_node_t *an = get_affinity_info(env->co, n->irn);
- int n_idx = get_irn_idx(n->irn);
+ co_mst_irn_t *n = waitq_get(nodes);
+ affinity_node_t *an = get_affinity_info(env->co, n->irn);
/* check all affinity neighbors */
if (an != NULL) {
n2 = get_co_mst_irn(env, m);
- if (n_idx < m_idx &&
- ! bitset_is_set(visited, m_idx) &&
- decider(n2, col) &&
- ! n2->fixed &&
- ! aff_chunks_interfere(env, chunk, n2->chunk) &&
+ if (! bitset_is_set(visited, m_idx) &&
+ decider(n2, col) &&
+ ! n2->fixed &&
+ ! aff_chunk_interferes(env, chunk, m) &&
bitset_is_set(orig_chunk->nodes, m_idx))
{
/*
- neighbour is not visited
- neighbour likes the color
- neighbour has not yet a fixed color
- - the new chunk doesn't interfere with the chunk of the neighbour
+ - the new chunk doesn't interfere with the neighbour
- neighbour belongs or belonged once to the original chunk
*/
bitset_set(visited, m_idx);
aff_chunk_add_node(chunk, n2);
+ DB((env->dbg, LEVEL_1, " %+F", n2->irn));
/* enqueue for further search */
waitq_put(nodes, n2);
}
}
}
+ DB((env->dbg, LEVEL_1, "\n"));
+
del_waitq(nodes);
}
co_mst_irn_t *node;
aff_chunk_t *tmp_chunk;
decide_func_t *decider;
+ int check_for_best;
if (bitset_is_set(visited, idx))
continue;
irn = get_idx_irn(env->co->irg, idx);
node = get_co_mst_irn(env, irn);
+ if (get_mst_irn_col(node) == col) {
+ decider = decider_has_color;
+ check_for_best = 1;
+ }
+ else {
+ decider = decider_hasnot_color;
+ check_for_best = 0;
+ }
+
/* create a new chunk starting at current node */
tmp_chunk = new_aff_chunk(env);
waitq_put(tmp, tmp_chunk);
- decider = get_mst_irn_col(node) == col ? decider_has_color : decider_hasnot_color;
expand_chunk_from(env, node, visited, tmp_chunk, c, decider, col);
assert(bitset_popcnt(tmp_chunk->nodes) > 0 && "No nodes added to chunk");
/* remember the local best */
aff_chunk_assure_weight(env, tmp_chunk);
- if (! best || best->weight < tmp_chunk->weight)
+ if (check_for_best && (! best || best->weight < tmp_chunk->weight))
best = tmp_chunk;
}
col_cost_init(env, costs, 0.0);
/* calculate (negative) costs for affinity neighbours */
- co_gs_foreach_neighb(an, aff_neigh) {
- ir_node *m = aff_neigh->irn;
- co_mst_irn_t *neigh = get_co_mst_irn(env, m);
- double c = (double)aff_neigh->costs;
-
- /* calculate costs for fixed affinity neighbours */
- if (neigh->tmp_fixed || neigh->fixed) {
- int col = get_mst_irn_col(neigh);
- costs[col].cost -= c * AFF_NEIGHBOUR_FIX_BENEFIT;
+ if (an != NULL) {
+ co_gs_foreach_neighb(an, aff_neigh) {
+ ir_node *m = aff_neigh->irn;
+ co_mst_irn_t *neigh;
+ double c;
+
+ /* skip ignore nodes */
+ if (arch_irn_is(env->aenv, m, ignore))
+ continue;
+
+ neigh = get_co_mst_irn(env, m);
+ c = (double)aff_neigh->costs;
+
+ /* calculate costs for fixed affinity neighbours */
+ if (neigh->tmp_fixed || neigh->fixed) {
+ int col = get_mst_irn_col(neigh);
+ costs[col].cost -= c * AFF_NEIGHBOUR_FIX_BENEFIT;
+ }
}
}
/* calculate (positive) costs for interfering neighbours */
be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, int_neigh) {
- co_mst_irn_t *neigh = get_co_mst_irn(env, int_neigh);
- int col = get_mst_irn_col(neigh);
- int col_cnt = bitset_popcnt(neigh->adm_colors);
+ co_mst_irn_t *neigh;
+ int col, col_cnt;
+
+ /* skip ignore nodes */
+ if (arch_irn_is(env->aenv, int_neigh, ignore))
+ continue;
+
+ neigh = get_co_mst_irn(env, int_neigh);
+ col = get_mst_irn_col(neigh);
+ col_cnt = bitset_popcnt(neigh->adm_colors);
if (neigh->tmp_fixed || neigh->fixed) {
/* colors of fixed interfering neighbours are infeasible */
int i;
waitq *local_changed = new_waitq();
+ DBG((env->dbg, LEVEL_1, "\tRecoloring %+F with color-costs", node->irn));
+ DBG_COL_COST(env, LEVEL_1, costs);
+ DB((env->dbg, LEVEL_1, "\n"));
+
for (i = 0; i < env->n_regs; ++i) {
void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
int tgt_col = costs[i].col;
/* try to color all interfering neighbours with current color forbidden */
be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, neigh) {
- co_mst_irn_t *nn = get_co_mst_irn(env, neigh);
+ co_mst_irn_t *nn;
+
+ /* skip ignore nodes */
+ if (arch_irn_is(env->aenv, neigh, ignore))
+ continue;
+
+ nn = get_co_mst_irn(env, neigh);
+
/*
Try to change the color of the neighbor and record all nodes which
get changed in the tmp list. Add this list to the "changed" list for
/* if node already has the target color -> good, temporary fix it */
if (col == tgt_col) {
+ DBG((env->dbg, LEVEL_1, "\t\tCNC: %+F has already color %d, fix temporary\n", node->irn, tgt_col));
if (! node->tmp_fixed) {
node->tmp_fixed = 1;
node->tmp_col = tgt_col;
*/
if (! (node->fixed || node->tmp_fixed) && bitset_is_set(node->adm_colors, tgt_col)) {
col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+ int res;
+
col_cost_init_single(env, costs, tgt_col);
- return recolor_nodes(env, node, costs, changed_ones);
+
+ DBG((env->dbg, LEVEL_1, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
+ res = recolor_nodes(env, node, costs, changed_ones);
+ DBG((env->dbg, LEVEL_1, "\t\tCNC: <<=== Recoloring of %+F %s\n", node->irn, res ? "succeeded" : "failed"));
+
+ return res;
}
+ DEBUG_ONLY(
+ if (firm_dbg_get_mask(env->dbg) & LEVEL_1) {
+ if (node->fixed || node->tmp_fixed)
+ DBG((env->dbg, LEVEL_1, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
+ else {
+ DBG((env->dbg, LEVEL_1, "\t\tCNC: color %d not admissible for %+F (", tgt_col, node->irn));
+ dbg_admissible_colors(env, node);
+ DB((env->dbg, LEVEL_1, ")\n"));
+ }
+ }
+ )
+
return 0;
}
int one_good = 0;
aff_chunk_t *local_best;
+ DBG((env->dbg, LEVEL_1, "Trying color %d\n", col));
+
/* try to bring all nodes of given chunk to the current color. */
bitset_foreach(c->nodes, idx) {
ir_node *irn = get_idx_irn(env->co->irg, idx);
assert(! node->fixed && "Node must not have a fixed color.");
+ DBG((env->dbg, LEVEL_1, "\tBringing %+F from color %d to color %d ...\n", irn, node->col, col));
one_good = change_node_color(env, node, col, changed_ones);
+ DBG((env->dbg, LEVEL_1, "\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
if (one_good)
break;
if (local_best) {
aff_chunk_assure_weight(env, local_best);
+ DBG((env->dbg, LEVEL_1, "\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
+ DBG_AFF_CHUNK(env, LEVEL_1, local_best);
+
if (! best_chunk || best_chunk->weight < local_best->weight) {
- /* kill the old best */
- if (best_chunk)
- delete_aff_chunk(env, best_chunk);
best_chunk = local_best;
best_color = col;
+ DB((env->dbg, LEVEL_1, "\n\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+ }
+ else {
+ DB((env->dbg, LEVEL_1, "\n\t... omitting, global best is better\n"));
}
}
return;
}
+ DBG((env->dbg, LEVEL_1, "\tBringing best chunk (id %d) to color %d: ", best_chunk->id, best_color));
+ DBG_AFF_CHUNK(env, LEVEL_1, best_chunk);
+ DB((env->dbg, LEVEL_1, "\n"));
+
/* get the best fragment from the best list and color it */
bitset_foreach(best_chunk->nodes, idx) {
ir_node *irn = get_idx_irn(env->co->irg, idx);
co_mst_irn_t *node = get_co_mst_irn(env, irn);
int res;
- res = change_node_color(env, node, col, changed_ones);
+ res = change_node_color(env, node, best_color, changed_ones);
assert(res && "Coloring failed");
node->fixed = 1;
- node->col = node->tmp_col;
node->chunk = best_chunk;
}
- /* fix colors */
+ /* materialize colors on changed nodes */
while (! waitq_empty(changed_ones)) {
co_mst_irn_t *n = waitq_get(changed_ones);
- n->fixed = 1;
- n->col = n->tmp_col;
+ n->tmp_fixed = 0;
+ n->col = n->tmp_col;
}
/* remove the nodes in best chunk from original chunk */
bitset_andnot(c->nodes, best_chunk->nodes);
+ /* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
+ bitset_foreach(c->nodes, idx) {
+ ir_node *n = get_idx_irn(env->co->irg, idx);
+ co_mst_irn_t *nn = get_co_mst_irn(env, n);
+ nn->chunk = c;
+ }
+
/* fragment the remaining chunk */
visited = bitset_irg_malloc(env->co->irg);
bitset_or(visited, best_chunk->nodes);
*/
int co_solve_heuristic_mst(copy_opt_t *co)
{
- unsigned n_regs = co->cenv->cls->n_regs;
+ unsigned n_regs = co->cls->n_regs;
bitset_t *ignore_regs = bitset_alloca(n_regs);
unsigned k;
+ ir_node *irn;
co_mst_env_t mst_env;
+ memset(&mst_env, 0, sizeof(mst_env));
+
/* init phase */
phase_init(&mst_env.ph, "co_mst", co->irg, PHASE_DEFAULT_GROWTH, co_mst_irn_init, &mst_env);
- k = be_put_ignore_regs(co->cenv->birg, co->cenv->cls, ignore_regs);
+ k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
k = n_regs - k;
+ FIRM_DBG_REGISTER(mst_env.dbg, "firm.be.co.heur4");
mst_env.n_regs = n_regs;
mst_env.k = k;
mst_env.chunks = new_pqueue();
mst_env.co = co;
mst_env.ignore_regs = ignore_regs;
mst_env.ifg = co->cenv->ifg;
+ mst_env.aenv = co->aenv;
pset_new_init(&mst_env.chunkset);
+ DBG((mst_env.dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
+
/* build affinity chunks */
build_affinity_chunks(&mst_env);
/* color chunks as long as there are some */
while (! pqueue_empty(mst_env.chunks)) {
aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
+
+ DBG((mst_env.dbg, LEVEL_1, "\nColoring chunk (id %d): ", chunk->id));
+ DBG_AFF_CHUNK(&mst_env, LEVEL_1, chunk);
+ DB((mst_env.dbg, LEVEL_1, "\n======>>> \n"));
+
color_aff_chunk(&mst_env, chunk);
+
+ DB((mst_env.dbg, LEVEL_1, "<<<====== Coloring chunk (%d) done\n", chunk->id));
+ }
+
+ /* apply coloring */
+ foreach_phase_irn(&mst_env.ph, irn) {
+ co_mst_irn_t *mirn = get_co_mst_irn(&mst_env, irn);
+ const arch_register_t *reg;
+
+ if (arch_irn_is(mst_env.aenv, irn, ignore))
+ continue;
+
+ assert(mirn->fixed && "Node should have fixed color");
+
+ /* skip nodes where color hasn't changed */
+ if (mirn->init_col == mirn->col)
+ continue;
+
+ reg = arch_register_for_index(co->cls, mirn->col);
+ arch_set_irn_register(co->aenv, irn, reg);
+ DBG((mst_env.dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
}
/* free allocated memory */
projects / libfirm / blobdiff