X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=40105fc1582c130e231b2c0f3d3d337e154bf43a;hb=df2faee01a5832057bb3ca0ba5f67e979c916e19;hp=c7c1c75455cf2beeb31ab838c1593f01b4c24d3d;hpb=3a655a311371c919abe77558a5ef6986fc4be093;p=libfirm diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c index c7c1c7545..40105fc15 100644 --- a/ir/be/becopyheur4.c +++ b/ir/be/becopyheur4.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. * @@ -22,7 +22,6 @@ * @brief Simple copy minimization heuristics. * @author Christian Wuerdig * @date 27.04.2007 - * @version $Id$ * * This is the C implementation of the mst algorithm * originally written in Java by Sebastian Hack. @@ -39,18 +38,16 @@ #include "irnode_t.h" #include "bitset.h" #include "raw_bitset.h" -#include "irphase_t.h" +#include "irnodemap.h" #include "pqueue.h" #include "xmalloc.h" #include "pdeq.h" -#include "pset.h" #include "irprintf.h" -#include "irbitset.h" +#include "util.h" +#include "irtools.h" #include "error.h" #include "list.h" -#include "statev.h" - -#include "irbitset.h" +#include "statev_t.h" #include "bearch.h" #include "beifg.h" @@ -59,11 +56,6 @@ #include "bemodule.h" -#define COL_COST_INFEASIBLE DBL_MAX -#define AFF_NEIGHBOUR_FIX_BENEFIT 128.0 -#define NEIGHBOUR_CONSTR_COSTS 64.0 - - #ifdef DEBUG_libfirm #define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while (0) @@ -83,9 +75,9 @@ typedef float real_t; static unsigned last_chunk_id = 0; static int recolor_limit = 7; -static real_t dislike_influence = REAL(0.1); +static double dislike_influence = REAL(0.1); -typedef struct _col_cost_t { +typedef struct col_cost_t { int col; real_t cost; } col_cost_t; @@ -93,34 +85,35 @@ typedef struct _col_cost_t { /** * An affinity chunk. */ -typedef struct _aff_chunk_t { - const ir_node **n; /**< An ARR_F containing all nodes of the chunk. */ +typedef struct aff_chunk_t { + const ir_node **n; /**< An ARR_F containing all nodes of the chunk. */ const ir_node **interfere; /**< An ARR_F containing all inference. */ int weight; /**< Weight of this chunk */ unsigned weight_consistent : 1; /**< Set if the weight is consistent. */ unsigned deleted : 1; /**< For debugging: Set if the was deleted. */ unsigned id; /**< An id of this chunk. */ unsigned visited; + list_head list; col_cost_t color_affinity[1]; } aff_chunk_t; /** * An affinity edge. */ -typedef struct _aff_edge_t { +typedef struct aff_edge_t { const ir_node *src; /**< Source node. */ const ir_node *tgt; /**< Target node. */ int weight; /**< The weight of this edge. */ } aff_edge_t; /* main coalescing environment */ -typedef struct _co_mst_env_t { +typedef struct co_mst_env_t { int n_regs; /**< number of regs in class */ - int k; /**< number of non-ignore registers in class */ - bitset_t *ignore_regs; /**< set containing all global ignore registers */ - ir_phase ph; /**< phase object holding data for nodes */ + bitset_t *allocatable_regs; /**< set containing all global ignore registers */ + ir_nodemap map; /**< phase object holding data for nodes */ + struct obstack obst; pqueue_t *chunks; /**< priority queue for chunks */ - pset *chunkset; /**< set holding all chunks */ + list_head chunklist; /**< list holding all chunks */ be_ifg_t *ifg; /**< the interference graph */ copy_opt_t *co; /**< the copy opt object */ unsigned chunk_visited; @@ -128,7 +121,7 @@ typedef struct _co_mst_env_t { } co_mst_env_t; /* stores coalescing related information for a node */ -typedef struct _co_mst_irn_t { +typedef struct co_mst_irn_t { const ir_node *irn; /**< the irn this information belongs to */ aff_chunk_t *chunk; /**< the chunk this irn belongs to */ bitset_t *adm_colors; /**< set of admissible colors for this irn */ @@ -143,7 +136,71 @@ typedef struct _co_mst_irn_t { real_t constr_factor; } co_mst_irn_t; -#define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn))) +/** + * In case there is no phase information for irn, initialize it. + */ +static co_mst_irn_t *co_mst_irn_init(co_mst_env_t *env, const ir_node *irn) +{ + co_mst_irn_t *res = OALLOC(&env->obst, co_mst_irn_t); + + const arch_register_req_t *req; + neighbours_iter_t nodes_it; + ir_node *neigh; + unsigned len; + + res->irn = irn; + res->chunk = NULL; + res->fixed = 0; + res->tmp_col = -1; + res->int_neighs = NULL; + res->int_aff_neigh = 0; + res->col = arch_get_irn_register(irn)->index; + res->init_col = res->col; + INIT_LIST_HEAD(&res->list); + + DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn)); + + /* set admissible registers */ + res->adm_colors = bitset_obstack_alloc(&env->obst, env->n_regs); + + /* Exclude colors not assignable to the irn */ + req = arch_get_irn_register_req(irn); + if (arch_register_req_is(req, limited)) { + rbitset_copy_to_bitset(req->limited, res->adm_colors); + /* exclude global ignore registers as well */ + bitset_and(res->adm_colors, env->allocatable_regs); + } else { + bitset_copy(res->adm_colors, env->allocatable_regs); + } + + /* compute the constraint factor */ + res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcount(res->adm_colors)) / env->n_regs; + + /* set the number of interfering affinity neighbours to -1, they are calculated later */ + res->int_aff_neigh = -1; + + /* build list of interfering neighbours */ + len = 0; + be_ifg_foreach_neighbour(env->ifg, &nodes_it, irn, neigh) { + if (!arch_irn_is_ignore(neigh)) { + obstack_ptr_grow(&env->obst, neigh); + ++len; + } + } + res->int_neighs = (ir_node**)obstack_finish(&env->obst); + res->n_neighs = len; + return res; +} + +static co_mst_irn_t *get_co_mst_irn(co_mst_env_t *env, const ir_node *node) +{ + co_mst_irn_t *res = ir_nodemap_get(co_mst_irn_t, &env->map, node); + if (res == NULL) { + res = co_mst_irn_init(env, node); + ir_nodemap_insert(&env->map, node, res); + } + return res; +} typedef int decide_func_t(const co_mst_irn_t *node, int col); @@ -171,14 +228,13 @@ static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) */ static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node) { - unsigned idx; (void) env; if (bitset_popcount(node->adm_colors) < 1) fprintf(stderr, "no admissible colors?!?"); else { bitset_foreach(node->adm_colors, idx) { - fprintf(stderr, " %d", idx); + ir_fprintf(stderr, " %zu", idx); } } } @@ -229,8 +285,8 @@ static int decider_always_yes(const co_mst_irn_t *node, int col) /** compares two affinity edges by its weight */ static int cmp_aff_edge(const void *a, const void *b) { - const aff_edge_t *e1 = a; - const aff_edge_t *e2 = b; + const aff_edge_t *e1 = (const aff_edge_t*)a; + const aff_edge_t *e2 = (const aff_edge_t*)b; if (e2->weight == e1->weight) { if (e2->src->node_idx == e1->src->node_idx) @@ -245,18 +301,30 @@ static int cmp_aff_edge(const void *a, const void *b) /** compares to color-cost pairs */ static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b) { - const col_cost_t *c1 = a; - const col_cost_t *c2 = b; + const col_cost_t *c1 = (const col_cost_t*)a; + const col_cost_t *c2 = (const col_cost_t*)b; real_t diff = c1->cost - c2->cost; - return (diff > 0) - (diff < 0); + + if (diff < 0) + return 1; + if (diff > 0) + return -1; + + return QSORT_CMP(c1->col, c2->col); } static int cmp_col_cost_gt(const void *a, const void *b) { - const col_cost_t *c1 = a; - const col_cost_t *c2 = b; + const col_cost_t *c1 = (const col_cost_t*)a; + const col_cost_t *c2 = (const col_cost_t*)b; real_t diff = c2->cost - c1->cost; - return (diff > 0) - (diff < 0); + + if (diff > 0) + return 1; + if (diff < 0) + return -1; + + return QSORT_CMP(c1->col, c2->col); } /** @@ -272,16 +340,16 @@ static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env) c->deleted = 0; c->id = ++last_chunk_id; c->visited = 0; - pset_insert(env->chunkset, c, c->id); + list_add(&c->list, &env->chunklist); 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) +static inline void delete_aff_chunk(aff_chunk_t *c) { - pset_remove(env->chunkset, c, c->id); + list_del(&c->list); DEL_ARR_F(c->interfere); DEL_ARR_F(c->n); c->deleted = 1; @@ -365,65 +433,6 @@ static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) } } -/** - * In case there is no phase information for irn, initialize it. - */ -static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) -{ - co_mst_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0])); - co_mst_env_t *env = ph->priv; - - if (!old) { - const arch_register_req_t *req; - neighbours_iter_t nodes_it; - ir_node *neigh; - unsigned len; - - res->irn = irn; - res->chunk = NULL; - res->fixed = 0; - res->tmp_col = -1; - res->int_neighs = NULL; - res->int_aff_neigh = 0; - res->col = arch_register_get_index(arch_get_irn_register(irn)); - res->init_col = res->col; - INIT_LIST_HEAD(&res->list); - - DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn)); - - /* set admissible registers */ - res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs); - - /* Exclude colors not assignable to the irn */ - req = arch_get_register_req_out(irn); - 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); - - /* compute the constraint factor */ - res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcount(res->adm_colors)) / env->n_regs; - - /* set the number of interfering affinity neighbours to -1, they are calculated later */ - res->int_aff_neigh = -1; - - /* build list of interfering neighbours */ - len = 0; - be_ifg_foreach_neighbour(env->ifg, &nodes_it, irn, neigh) { - if (!arch_irn_is_ignore(neigh)) { - obstack_ptr_grow(phase_obst(ph), neigh); - ++len; - } - } - res->int_neighs = obstack_finish(phase_obst(ph)); - res->n_neighs = len; - } - return res; -} - /** * Check if affinity chunk @p chunk interferes with node @p irn. */ @@ -534,7 +543,7 @@ static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node c1->weight_consistent = 0; - delete_aff_chunk(env, c2); + delete_aff_chunk(c2); goto absorbed; } DB((dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n")); @@ -566,13 +575,11 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) node->chunk = c; if (node->constr_factor > REAL(0.0)) { - unsigned col; bitset_foreach (node->adm_colors, col) c->color_affinity[col].cost += node->constr_factor; } if (an != NULL) { - neighb_t *neigh; co_gs_foreach_neighb(an, neigh) { const ir_node *m = neigh->irn; @@ -598,7 +605,6 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) */ static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an) { - const neighb_t *neigh; const ir_node *irn = an->irn; const co_mst_irn_t *node = get_co_mst_irn(env, irn); int res = 0; @@ -635,7 +641,7 @@ static void build_affinity_chunks(co_mst_env_t *env) aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0); ir_node *n; int i, len; - aff_chunk_t *curr_chunk; + size_t pn; /* at first we create the affinity edge objects */ be_ifg_foreach_node(env->ifg, &nodes_it, n) { @@ -650,8 +656,6 @@ static void build_affinity_chunks(co_mst_env_t *env) an = get_affinity_info(env->co, n); if (an != NULL) { - neighb_t *neigh; - if (n1->int_aff_neigh < 0) n1->int_aff_neigh = count_interfering_aff_neighs(env, an); @@ -698,7 +702,7 @@ static void build_affinity_chunks(co_mst_env_t *env) } /* now insert all chunks into a priority queue */ - foreach_pset(env->chunkset, curr_chunk) { + list_for_each_entry(aff_chunk_t, curr_chunk, &env->chunklist, list) { aff_chunk_assure_weight(env, curr_chunk); DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id)); @@ -708,22 +712,24 @@ static void build_affinity_chunks(co_mst_env_t *env) pqueue_put(env->chunks, curr_chunk, curr_chunk->weight); } - foreach_phase_irn(&env->ph, n) { - co_mst_irn_t *mirn = get_co_mst_irn(env, n); + for (pn = 0; pn < ARR_LEN(env->map.data); ++pn) { + co_mst_irn_t *mirn = (co_mst_irn_t*)env->map.data[pn]; + if (mirn == NULL) + continue; + if (mirn->chunk != NULL) + continue; - if (mirn->chunk == NULL) { - /* no chunk is allocated so far, do it now */ - aff_chunk_t *curr_chunk = new_aff_chunk(env); - aff_chunk_add_node(curr_chunk, mirn); + /* no chunk is allocated so far, do it now */ + aff_chunk_t *curr_chunk = new_aff_chunk(env); + aff_chunk_add_node(curr_chunk, mirn); - aff_chunk_assure_weight(env, curr_chunk); + aff_chunk_assure_weight(env, curr_chunk); - DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id)); - DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk); - DBG((dbg, LEVEL_1, "\n")); + DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id)); + DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk); + DBG((dbg, LEVEL_1, "\n")); - pqueue_put(env->chunks, curr_chunk, curr_chunk->weight); - } + pqueue_put(env->chunks, curr_chunk, curr_chunk->weight); } DEL_ARR_F(edges); @@ -731,16 +737,15 @@ static void build_affinity_chunks(co_mst_env_t *env) static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chunk_t *chunk) { - pqueue_t *grow = new_pqueue(); - const ir_node *max_node = NULL; - int max_weight = 0; - int i; + pqueue_t *grow = new_pqueue(); + ir_node const *max_node = NULL; + int max_weight = 0; + size_t i; - for (i = ARR_LEN(chunk->n) - 1; i >= 0; i--) { - const ir_node *irn = chunk->n[i]; + for (i = ARR_LEN(chunk->n); i != 0;) { + const ir_node *irn = chunk->n[--i]; affinity_node_t *an = get_affinity_info(env->co, irn); int w = 0; - neighb_t *neigh; if (arch_irn_is_ignore(irn)) continue; @@ -757,18 +762,17 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu } if (max_node) { - bitset_t *visited = bitset_irg_malloc(env->co->irg); + bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg)); - for (i = ARR_LEN(chunk->n) - 1; i >= 0; --i) - bitset_add_irn(visited, chunk->n[i]); + for (i = ARR_LEN(chunk->n); i != 0;) + bitset_set(visited, get_irn_idx(chunk->n[--i])); pqueue_put(grow, (void *) max_node, max_weight); - bitset_remv_irn(visited, max_node); + bitset_clear(visited, get_irn_idx(max_node)); i = 0; while (!pqueue_empty(grow)) { - ir_node *irn = pqueue_pop_front(grow); + ir_node *irn = (ir_node*)pqueue_pop_front(grow); affinity_node_t *an = get_affinity_info(env->co, irn); - neighb_t *neigh; if (arch_irn_is_ignore(irn)) continue; @@ -782,9 +786,9 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu co_gs_foreach_neighb(an, neigh) { co_mst_irn_t *node = get_co_mst_irn(env, neigh->irn); - if (bitset_contains_irn(visited, node->irn)) { + if (bitset_is_set(visited, get_irn_idx(node->irn))) { pqueue_put(grow, (void *) neigh->irn, neigh->costs); - bitset_remv_irn(visited, node->irn); + bitset_clear(visited, get_irn_idx(node->irn)); } } } @@ -812,12 +816,11 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v /* as long as there are nodes in the queue */ while (! waitq_empty(nodes)) { - co_mst_irn_t *n = waitq_get(nodes); + co_mst_irn_t *n = (co_mst_irn_t*)waitq_get(nodes); affinity_node_t *an = get_affinity_info(env->co, n->irn); /* check all affinity neighbors */ if (an != NULL) { - neighb_t *neigh; co_gs_foreach_neighb(an, neigh) { const ir_node *m = neigh->irn; int m_idx = get_irn_idx(m); @@ -862,7 +865,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v */ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) { - bitset_t *visited = bitset_irg_malloc(env->co->irg); + bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg)); int idx, len; aff_chunk_t *best = NULL; @@ -913,7 +916,6 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w */ static inline void reject_coloring(struct list_head *nodes) { - co_mst_irn_t *n, *temp; DB((dbg, LEVEL_4, "\treject coloring for")); list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) { DB((dbg, LEVEL_4, " %+F", n->irn)); @@ -926,7 +928,6 @@ static inline void reject_coloring(struct list_head *nodes) static inline void materialize_coloring(struct list_head *nodes) { - co_mst_irn_t *n, *temp; list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) { assert(n->tmp_col >= 0); n->col = n->tmp_col; @@ -1113,7 +1114,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost } /** - * Tries to bring node @p node and all it's neighbours to color @p tgt_col. + * Tries to bring node @p node and all its neighbours to color @p tgt_col. * @return 1 if color @p col could be applied, 0 otherwise */ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed) @@ -1130,7 +1131,7 @@ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, /* Node has not yet a fixed color and target color is admissible - -> try to recolor node and it's affinity neighbours + -> try to recolor node and its affinity neighbours */ if (is_loose(node) && bitset_is_set(node->adm_colors, tgt_col)) { col_cost_t *costs = env->single_cols[tgt_col]; @@ -1178,7 +1179,11 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) waitq *best_starts = NULL; col_cost_t *order = ALLOCANZ(col_cost_t, env->n_regs); bitset_t *visited; - int idx, len, i, nidx, pos; + int i; + size_t idx; + size_t len; + size_t nidx; + size_t pos; struct list_head changed; DB((dbg, LEVEL_2, "fragmentizing chunk #%u", c->id)); @@ -1225,19 +1230,20 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) * TODO Sebastian: Perhaps we should at all nodes and figure out * a suitable color using costs as done above (determine_color_costs). */ - for (i = 0; i < env->k; ++i) { + for (i = 0; i < env->n_regs; ++i) { int col = order[i].col; - waitq *good_starts = new_waitq(); + waitq *good_starts; aff_chunk_t *local_best; int n_succeeded; /* skip ignore colors */ - if (bitset_is_set(env->ignore_regs, col)) + if (!bitset_is_set(env->allocatable_regs, col)) continue; DB((dbg, LEVEL_2, "\ttrying color %d\n", col)); n_succeeded = 0; + good_starts = new_waitq(); /* try to bring all nodes of given chunk to the current color. */ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) { @@ -1276,8 +1282,10 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) } /* try next color when failed */ - if (n_succeeded == 0) + if (n_succeeded == 0) { + del_waitq(good_starts); continue; + } /* fragment the chunk according to the coloring */ local_best = fragment_chunk(env, col, c, tmp_chunks); @@ -1315,9 +1323,9 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) /* free all intermediate created chunks except best one */ while (! waitq_empty(tmp_chunks)) { - aff_chunk_t *tmp = waitq_get(tmp_chunks); + aff_chunk_t *tmp = (aff_chunk_t*)waitq_get(tmp_chunks); if (tmp != best_chunk) - delete_aff_chunk(env, tmp); + delete_aff_chunk(tmp); } del_waitq(tmp_chunks); @@ -1378,7 +1386,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) } /* fragment the remaining chunk */ - visited = bitset_irg_malloc(env->co->irg); + visited = bitset_malloc(get_irg_last_idx(env->co->irg)); for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx) bitset_set(visited, get_irn_idx(best_chunk->n[idx])); @@ -1401,7 +1409,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) } /* clear obsolete chunks and free some memory */ - delete_aff_chunk(env, best_chunk); + delete_aff_chunk(best_chunk); bitset_free(visited); if (best_starts) del_waitq(best_starts); @@ -1414,9 +1422,10 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) */ static int co_solve_heuristic_mst(copy_opt_t *co) { - unsigned n_regs = co->cls->n_regs; - bitset_t *ignore_regs = bitset_alloca(n_regs); - unsigned i, j, k; + unsigned n_regs = co->cls->n_regs; + bitset_t *allocatable_regs = bitset_alloca(n_regs); + unsigned i, j; + size_t pn; ir_node *irn; co_mst_env_t mst_env; @@ -1425,24 +1434,22 @@ static int co_solve_heuristic_mst(copy_opt_t *co) stat_ev_tim_push(); /* init phase */ - phase_init(&mst_env.ph, co->irg, co_mst_irn_init); - phase_set_private(&mst_env.ph, &mst_env); - - k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs); - k = n_regs - k; - - 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.chunkset = pset_new_ptr(512); - mst_env.chunk_visited = 0; - mst_env.single_cols = phase_alloc(&mst_env.ph, sizeof(*mst_env.single_cols) * n_regs); + ir_nodemap_init(&mst_env.map, co->irg); + obstack_init(&mst_env.obst); + + be_put_allocatable_regs(co->cenv->irg, co->cls, allocatable_regs); + + mst_env.n_regs = n_regs; + mst_env.chunks = new_pqueue(); + mst_env.co = co; + mst_env.allocatable_regs = allocatable_regs; + mst_env.ifg = co->cenv->ifg; + INIT_LIST_HEAD(&mst_env.chunklist); + mst_env.chunk_visited = 0; + mst_env.single_cols = OALLOCN(&mst_env.obst, col_cost_t*, n_regs); for (i = 0; i < n_regs; ++i) { - col_cost_t *vec = phase_alloc(&mst_env.ph, sizeof(*vec) * n_regs); + col_cost_t *vec = OALLOCN(&mst_env.obst, col_cost_t, n_regs); mst_env.single_cols[i] = vec; for (j = 0; j < n_regs; ++j) { @@ -1463,24 +1470,23 @@ static int co_solve_heuristic_mst(copy_opt_t *co) /* color chunks as long as there are some */ while (! pqueue_empty(mst_env.chunks)) { - aff_chunk_t *chunk = pqueue_pop_front(mst_env.chunks); + aff_chunk_t *chunk = (aff_chunk_t*)pqueue_pop_front(mst_env.chunks); color_aff_chunk(&mst_env, chunk); DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%u) done\n", chunk->id)); - delete_aff_chunk(&mst_env, chunk); + delete_aff_chunk(chunk); } /* apply coloring */ - foreach_phase_irn(&mst_env.ph, irn) { - co_mst_irn_t *mirn; + for (pn = 0; pn < ARR_LEN(mst_env.map.data); ++pn) { + co_mst_irn_t *mirn = (co_mst_irn_t*)mst_env.map.data[pn]; const arch_register_t *reg; - + if (mirn == NULL) + continue; + irn = get_idx_irn(co->irg, pn); if (arch_irn_is_ignore(irn)) continue; - mirn = get_co_mst_irn(&mst_env, irn); - // assert(mirn->fixed && "Node should have fixed color"); - /* skip nodes where color hasn't changed */ if (mirn->init_col == mirn->col) continue; @@ -1492,8 +1498,8 @@ static int co_solve_heuristic_mst(copy_opt_t *co) /* free allocated memory */ del_pqueue(mst_env.chunks); - phase_deinit(&mst_env.ph); - del_pset(mst_env.chunkset); + obstack_free(&mst_env.obst, NULL); + ir_nodemap_destroy(&mst_env.map); stat_ev_tim_pop("heur4_total"); @@ -1506,7 +1512,7 @@ static const lc_opt_table_entry_t options[] = { LC_OPT_LAST }; -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4); +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4) void be_init_copyheur4(void) { lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");