X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur2.c;h=c0dccb81e6c0e3a1189fb8554718da0d40fb657d;hb=0ac0b440ce2d239c5e7e7db56b8273559d9a7741;hp=c2231395cd3dcb87622c9fb31ce42d7f1fb29369;hpb=0df5e0ea5d4d6a566339ac4b93a73719858e81e1;p=libfirm diff --git a/ir/be/becopyheur2.c b/ir/be/becopyheur2.c index c2231395c..c0dccb81e 100644 --- a/ir/be/becopyheur2.c +++ b/ir/be/becopyheur2.c @@ -1,20 +1,6 @@ /* - * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. - * * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** @@ -22,7 +8,6 @@ * @brief More experiments on coalescing. * @author Sebastian Hack * @date 14.04.2006 - * @version $Id$ */ #include "config.h" @@ -32,6 +17,8 @@ #include #include +#include "beintlive_t.h" +#include "beirg.h" #include "list.h" #include "pdeq.h" #include "bitset.h" @@ -40,19 +27,19 @@ #include "debug.h" #include "bitfiddle.h" -#include "irphase_t.h" #include "irgraph_t.h" #include "irnode_t.h" #include "irprintf.h" +#include "util.h" #include "irtools.h" - +#include "irnodemap.h" +#include "be_t.h" #include "bemodule.h" #include "beabi.h" #include "benode.h" #include "becopyopt.h" #include "becopyopt_t.h" #include "bechordal_t.h" -#include "beirg.h" #define DUMP_BEFORE 1 #define DUMP_AFTER 2 @@ -107,12 +94,13 @@ typedef struct { } col_cost_pair_t; typedef struct { - ir_phase ph; - copy_opt_t *co; - bitset_t *allocatable_regs; - co2_irn_t *touched; - int visited; - int n_regs; + ir_nodemap map; + struct obstack obst; + copy_opt_t *co; + unsigned const *allocatable_regs; + co2_irn_t *touched; + int visited; + int n_regs; struct list_head cloud_head; DEBUG_ONLY(firm_dbg_module_t *dbg;) } co2_t; @@ -123,11 +111,9 @@ struct co2_irn_t { co2_irn_t *touched_next; col_t tmp_col; col_t orig_col; - int last_color_change; - bitset_t *adm_cache; + unsigned const *admissible; unsigned fixed : 1; unsigned tmp_fixed : 1; - unsigned is_constrained : 1; struct list_head changed_list; }; @@ -157,8 +143,6 @@ struct co2_cloud_t { int inevit; int best_costs; int n_memb; - int n_constr; - int max_degree; int ticks; double freedom; co2_cloud_irn_t *master; @@ -175,30 +159,45 @@ typedef struct { #define FRONT_BASE(ci,col) ((ci)->fronts + col * (ci)->mst_n_childs) -#define get_co2_irn(co2, irn) ((co2_irn_t *) phase_get_or_set_irn_data(&co2->ph, irn)) -#define get_co2_cloud_irn(co2, irn) ((co2_cloud_irn_t *) phase_get_or_set_irn_data(&co2->ph, irn)) - -static void *co2_irn_init(ir_phase *ph, const ir_node *irn) +static co2_irn_t *get_co2_irn(co2_t *env, const ir_node *node) { - co2_t *env = (co2_t *) ph; - affinity_node_t *a = get_affinity_info(env->co, irn); - size_t size = a ? sizeof(co2_cloud_irn_t) : sizeof(co2_irn_t); - co2_irn_t *ci = (co2_irn_t*)phase_alloc(ph, size); - - memset(ci, 0, size); - INIT_LIST_HEAD(&ci->changed_list); - ci->touched_next = env->touched; - ci->orig_col = get_irn_col(irn); - env->touched = ci; - ci->irn = irn; - ci->aff = a; + co2_irn_t *ci = ir_nodemap_get(co2_irn_t, &env->map, node); + if (ci == NULL) { + ci = OALLOCZ(&env->obst, co2_irn_t); - if (a) { - co2_cloud_irn_t *cci = (co2_cloud_irn_t *) ci; - INIT_LIST_HEAD(&cci->cloud_list); - cci->mst_parent = cci; + INIT_LIST_HEAD(&ci->changed_list); + ci->touched_next = env->touched; + ci->orig_col = get_irn_col(node); + env->touched = ci; + ci->irn = node; + ci->aff = NULL; + + arch_register_req_t const *const req = arch_get_irn_register_req(node); + ci->admissible = arch_register_req_is(req, limited) ? req->limited : env->allocatable_regs; + + ir_nodemap_insert(&env->map, node, ci); } + return ci; +} +static co2_cloud_irn_t *get_co2_cloud_irn(co2_t *env, const ir_node *node) +{ + co2_cloud_irn_t *ci = ir_nodemap_get(co2_cloud_irn_t, &env->map, node); + if (ci == NULL) { + ci = OALLOCZ(&env->obst, co2_cloud_irn_t); + + INIT_LIST_HEAD(&ci->inh.changed_list); + ci->inh.touched_next = env->touched; + ci->inh.orig_col = get_irn_col(node); + env->touched = &ci->inh; + ci->inh.irn = node; + ci->inh.aff = get_affinity_info(env->co, node); + + INIT_LIST_HEAD(&ci->cloud_list); + ci->mst_parent = ci; + + ir_nodemap_insert(&env->map, node, ci); + } return ci; } @@ -245,60 +244,20 @@ static inline int color_is_fix(co2_t *env, const ir_node *irn) return ci->fixed || ci->tmp_fixed; } -static inline bitset_t *get_adm(co2_t *env, co2_irn_t *ci) -{ - if (ci->adm_cache == NULL) { - const arch_register_req_t *req; - ci->adm_cache = bitset_obstack_alloc(phase_obst(&env->ph), env->n_regs); - req = arch_get_register_req_out(ci->irn); - - if (arch_register_req_is(req, limited)) { - int i, n; - - n = env->n_regs; - for (i = 0; i < n; ++i) { - if (rbitset_is_set(req->limited, i)) - bitset_set(ci->adm_cache, i); - } - ci->is_constrained = 1; - } else { - bitset_copy(ci->adm_cache, env->allocatable_regs); - } - } - - return ci->adm_cache; -} - -static inline bitset_t *admissible_colors(co2_t *env, co2_irn_t *ci, bitset_t *bs) +static inline int is_color_admissible(co2_irn_t *const ci, col_t const col) { - bitset_copy(bs, get_adm(env, ci)); - return bs; + unsigned const *const bs = ci->admissible; + return rbitset_is_set(bs, col); } -static inline int is_color_admissible(co2_t *env, co2_irn_t *ci, col_t col) +static void incur_constraint_costs(ir_node const *const irn, col_cost_pair_t *const col_costs, int const costs) { - bitset_t *bs = get_adm(env, ci); - return bitset_is_set(bs, col); -} - -static inline int is_constrained(co2_t *env, co2_irn_t *ci) -{ - if (!ci->adm_cache) - get_adm(env, ci); - return ci->is_constrained; -} - -static void incur_constraint_costs(co2_t *env, const ir_node *irn, col_cost_pair_t *col_costs, int costs) -{ - const arch_register_req_t *req = arch_get_register_req_out(irn); + const arch_register_req_t *req = arch_get_irn_register_req(irn); if (arch_register_req_is(req, limited)) { - unsigned n_regs = env->co->cls->n_regs; - unsigned n_constr = 0; - unsigned i; - - n_constr = rbitset_popcount(req->limited, n_regs); - for (i = 0; i < n_regs; ++i) { + unsigned const n_regs = req->cls->n_regs; + unsigned const n_constr = rbitset_popcount(req->limited, n_regs); + for (unsigned i = 0; i < n_regs; ++i) { if (rbitset_is_set(req->limited, i)) { col_costs[i].costs = add_saturated(col_costs[i].costs, costs / n_constr); } @@ -321,33 +280,24 @@ static void determine_color_costs(co2_t *env, co2_irn_t *ci, col_cost_pair_t *co const ir_node *irn = ci->irn; be_ifg_t *ifg = env->co->cenv->ifg; int n_regs = env->co->cls->n_regs; - bitset_t *forb = bitset_alloca(n_regs); affinity_node_t *a = ci->aff; - size_t elm; - const ir_node *pos; neighbours_iter_t it; int i; - /* Put all forbidden colors into the aux bitset. */ - admissible_colors(env, ci, forb); - bitset_flip_all(forb); - for (i = 0; i < n_regs; ++i) { col_costs[i].col = i; col_costs[i].costs = 0; } if (a) { - neighb_t *n; - co_gs_foreach_neighb(a, n) { if (color_is_fix(env, n->irn)) { col_t col = get_col(env, n->irn); col_costs[col].costs = add_saturated(col_costs[col].costs, -n->costs * 128); } - incur_constraint_costs(env, n->irn, col_costs, -n->costs); + incur_constraint_costs(n->irn, col_costs, -n->costs); } } @@ -357,17 +307,16 @@ static void determine_color_costs(co2_t *env, co2_irn_t *ci, col_cost_pair_t *co col_costs[col].costs = INT_MAX; } else { - incur_constraint_costs(env, pos, col_costs, INT_MAX); + incur_constraint_costs(pos, col_costs, INT_MAX); col_costs[col].costs = add_saturated(col_costs[col].costs, 8 * be_ifg_degree(ifg, pos)); } } - be_ifg_neighbours_break(&it); /* Set the costs to infinity for each color which is not allowed at this node. */ - bitset_foreach(forb, elm) { + unsigned const *const admissible = ci->admissible; + rbitset_foreach_clear(admissible, n_regs, elm) { col_costs[elm].costs = INT_MAX; } - } static void single_color_cost(co2_t *env, co2_irn_t *ci, col_t col, col_cost_pair_t *seq) @@ -381,7 +330,7 @@ static void single_color_cost(co2_t *env, co2_irn_t *ci, col_t col, col_cost_pai } (void) ci; - assert(is_color_admissible(env, ci, col)); + assert(is_color_admissible(ci, col)); seq[col].col = 0; seq[0].col = col; seq[0].costs = 0; @@ -389,16 +338,12 @@ static void single_color_cost(co2_t *env, co2_irn_t *ci, col_t col, col_cost_pai static void reject_coloring(struct list_head *h) { - co2_irn_t *pos; - list_for_each_entry(co2_irn_t, pos, h, changed_list) pos->tmp_fixed = 0; } static void materialize_coloring(struct list_head *h) { - co2_irn_t *pos; - list_for_each_entry(co2_irn_t, pos, h, changed_list) { pos->orig_col = pos->tmp_col; pos->tmp_fixed = 0; @@ -425,7 +370,6 @@ static int recolor(co2_t *env, const ir_node *irn, col_cost_pair_t *col_list, st int neigh_ok = 1; struct list_head changed; - const ir_node *n; neighbours_iter_t it; DBG((env->dbg, LEVEL_3, "\t\t%2{firm:indent}trying color %d(%d) on %+F\n", depth, tgt_col, costs, irn)); @@ -463,11 +407,12 @@ static int recolor(co2_t *env, const ir_node *irn, col_cost_pair_t *col_list, st INIT_LIST_HEAD(&tmp); neigh_ok = change_color_not(env, n, tgt_col, &tmp, depth + 1); list_splice(&tmp, &changed); - if (!neigh_ok) + if (!neigh_ok) { + be_ifg_neighbours_break(&it); break; + } } } - be_ifg_neighbours_break(&it); /* We managed to assign the target color to all neighbors, so from the perspective @@ -552,7 +497,7 @@ static int change_color_single(co2_t *env, const ir_node *irn, col_t tgt_col, st goto end; } - if (!color_is_fix(env, irn) && is_color_admissible(env, ci, tgt_col)) { + if (!color_is_fix(env, irn) && is_color_admissible(ci, tgt_col)) { int n_regs = env->co->cls->n_regs; col_cost_pair_t *seq = ALLOCAN(col_cost_pair_t, n_regs); @@ -603,37 +548,30 @@ static int examine_subtree_coloring(co2_cloud_irn_t *ci, col_t col) */ static void node_color_badness(co2_cloud_irn_t *ci, int *badness) { - co2_t *env = ci->cloud->env; - co2_irn_t *ir = &ci->inh; - int n_regs = env->n_regs; - be_ifg_t *ifg = env->co->cenv->ifg; - bitset_t *bs = bitset_alloca(n_regs); + co2_t *const env = ci->cloud->env; + size_t const n_regs = env->n_regs; - size_t elm; - const ir_node *irn; neighbours_iter_t it; - admissible_colors(env, &ci->inh, bs); - bitset_flip_all(bs); - bitset_foreach(bs, elm) - badness[elm] = ci->costs; + { + unsigned const *const bs = ci->inh.admissible; + rbitset_foreach_clear(bs, n_regs, elm) + badness[elm] = ci->costs; + } /* Use constrained/fixed interfering neighbors to influence the color badness */ - be_ifg_foreach_neighbour(ifg, &it, ir->irn, irn) { + be_ifg_foreach_neighbour(env->co->cenv->ifg, &it, ci->inh.irn, irn) { co2_irn_t *ni = get_co2_irn(env, irn); - admissible_colors(env, ni, bs); - if (bitset_popcount(bs) == 1) { - size_t c = bitset_next_set(bs, 0); + unsigned const *const bs = ni->admissible; + if (rbitset_popcount(bs, n_regs) == 1) { + size_t const c = rbitset_next_max(bs, 0, n_regs, true); badness[c] += ci->costs; - } - - else if (ni->fixed) { + } else if (ni->fixed) { col_t c = get_col(env, ni->irn); badness[c] += ci->costs; } } - be_ifg_neighbours_break(&it); } /** @@ -694,13 +632,13 @@ static int coalesce_top_down(co2_cloud_irn_t *ci, int child_nr, int depth) int badness = ci->color_badness[i]; seq[i].col = i; - seq[i].costs = is_color_admissible(env, &ci->inh, i) ? badness : INT_MAX; + seq[i].costs = is_color_admissible(&ci->inh, i) ? badness : INT_MAX; min_badness = MIN(min_badness, badness); } /* If we are not the root and the parent's color is allowed for this node give it top prio. */ - if (!is_root && is_color_admissible(env, &ci->inh, parent_col)) + if (!is_root && is_color_admissible(&ci->inh, parent_col)) seq[parent_col].costs = min_badness - 1; /* Sort the colors. The will be processed in that ordering. */ @@ -764,10 +702,8 @@ static int coalesce_top_down(co2_cloud_irn_t *ci, int child_nr, int depth) static void populate_cloud(co2_t *env, co2_cloud_t *cloud, affinity_node_t *a, int curr_costs) { - be_ifg_t *ifg = env->co->cenv->ifg; co2_cloud_irn_t *ci = get_co2_cloud_irn(env, a->irn); int costs = 0; - neighb_t *n; if (ci->cloud) return; @@ -779,20 +715,19 @@ static void populate_cloud(co2_t *env, co2_cloud_t *cloud, affinity_node_t *a, i DB((env->dbg, LEVEL_2, "\t%+F\n", ci->inh.irn)); /* determine the nodes costs */ + be_lv_t *const lv = be_get_irg_liveness(env->co->irg); co_gs_foreach_neighb(a, n) { costs += n->costs; DB((env->dbg, LEVEL_3, "\t\tneigh %+F cost %d\n", n->irn, n->costs)); - if (be_ifg_connected(ifg, a->irn, n->irn)) + if (be_values_interfere(lv, a->irn, n->irn)) cloud->inevit += n->costs; } /* add the node's cost to the total costs of the cloud. */ - ci->costs = costs; - cloud->costs += costs; - cloud->n_constr += is_constrained(env, &ci->inh); - cloud->freedom += bitset_popcount(get_adm(env, &ci->inh)); - cloud->max_degree = MAX(cloud->max_degree, ci->inh.aff->degree); - cloud->n_memb++; + ci->costs = costs; + cloud->costs += costs; + cloud->freedom += rbitset_popcount(ci->inh.admissible, env->n_regs); + cloud->n_memb += 1; /* If this is the heaviest node in the cloud, set it as the cloud's master. */ if (costs >= curr_costs) { @@ -810,8 +745,7 @@ static void populate_cloud(co2_t *env, co2_cloud_t *cloud, affinity_node_t *a, i static co2_cloud_t *new_cloud(co2_t *env, affinity_node_t *a) { - co2_cloud_t *cloud = (co2_cloud_t*)phase_alloc(&env->ph, sizeof(cloud[0])); - co2_cloud_irn_t *ci; + co2_cloud_t *cloud = OALLOC(&env->obst, co2_cloud_t); int i; DBG((env->dbg, LEVEL_2, "new cloud with %+F\n", a->irn)); @@ -826,7 +760,7 @@ static co2_cloud_t *new_cloud(co2_t *env, affinity_node_t *a) cloud->freedom = (cloud->n_memb * env->n_regs) / cloud->freedom; /* Also allocate space for the node sequence and compute that sequence. */ - cloud->seq = (co2_cloud_irn_t**)phase_alloc(&env->ph, cloud->n_memb * sizeof(cloud->seq[0])); + cloud->seq = OALLOCN(&env->obst, co2_cloud_irn_t*, cloud->n_memb); i = 0; list_for_each_entry(co2_cloud_irn_t, ci, &cloud->members_head, cloud_list) { @@ -842,14 +776,13 @@ static void apply_coloring(co2_cloud_irn_t *ci, col_t col, int depth) { const ir_node *irn = ci->inh.irn; int *front = FRONT_BASE(ci, col); - int i, ok; + int i; struct list_head changed; INIT_LIST_HEAD(&changed); DBG((ci->cloud->env->dbg, LEVEL_2, "%2{firm:indent}setting %+F to %d\n", depth, irn, col)); - ok = change_color_single(ci->cloud->env, irn, col, &changed, depth); - // assert(ok && "Color changing may not fail while committing the coloring"); + change_color_single(ci->cloud->env, irn, col, &changed, depth); materialize_coloring(&changed); for (i = 0; i < ci->mst_n_childs; ++i) { @@ -881,7 +814,6 @@ static void process_cloud(co2_cloud_t *cloud) obstack_init(&cloud->obst); for (i = 0; i < cloud->n_memb; ++i) { co2_cloud_irn_t *ci = cloud->seq[i]; - neighb_t *n; co_gs_foreach_neighb(ci->inh.aff, n) { co2_cloud_irn_t *ni = get_co2_cloud_irn(cloud->env, n->irn); @@ -959,7 +891,7 @@ static void process_cloud(co2_cloud_t *cloud) DBG((env->dbg, LEVEL_3, "mst:\n")); for (i = 0; i < cloud->n_memb; ++i) { - DEBUG_ONLY(co2_cloud_irn_t *ci = cloud->seq[i]); + DEBUG_ONLY(co2_cloud_irn_t *ci = cloud->seq[i];) DBG((env->dbg, LEVEL_3, "\t%+F -> %+F\n", ci->inh.irn, ci->mst_parent->inh.irn)); } @@ -998,7 +930,6 @@ static void process_cloud(co2_cloud_t *cloud) static int cloud_costs(co2_cloud_t *cloud) { int i, costs = 0; - neighb_t *n; for (i = 0; i < cloud->n_memb; ++i) { co2_irn_t *ci = (co2_irn_t *) cloud->seq[i]; @@ -1022,150 +953,8 @@ static void writeback_colors(co2_t *env) } } - -/* - ___ _____ ____ ____ ___ _____ ____ _ - |_ _| ___/ ___| | _ \ / _ \_ _| | _ \ _ _ _ __ ___ _ __ (_)_ __ __ _ - | || |_ | | _ | | | | | | || | | | | | | | | '_ ` _ \| '_ \| | '_ \ / _` | - | || _|| |_| | | |_| | |_| || | | |_| | |_| | | | | | | |_) | | | | | (_| | - |___|_| \____| |____/ \___/ |_| |____/ \__,_|_| |_| |_| .__/|_|_| |_|\__, | - |_| |___/ -*/ - -static const char *get_dot_color_name(size_t col) -{ - static const char *const names[] = { - "blue", - "red", - "green", - "yellow", - "cyan", - "magenta", - "orange", - "chocolate", - "beige", - "navy", - "darkgreen", - "darkred", - "lightPink", - "chartreuse", - "lightskyblue", - "linen", - "pink", - "lightslateblue", - "mintcream", - "red", - "darkolivegreen", - "mediumblue", - "mistyrose", - "salmon", - "darkseagreen", - "mediumslateblue" - "moccasin", - "tomato", - "forestgreen", - "darkturquoise", - "palevioletred" - }; - - return col < (sizeof(names)/sizeof(names[0])) ? names[col] : "white"; -} - -static const char *get_dot_shape_name(co2_irn_t *ci) -{ - const arch_register_req_t *req = arch_get_register_req_out(ci->irn); - - if (arch_register_req_is(req, limited)) - return "diamond"; - - if (ci->fixed) - return "rectangle"; - - if (ci->tmp_fixed) - return "hexagon"; - - return "ellipse"; -} - -static void ifg_dump_graph_attr(FILE *f, void *self) -{ - (void) self; - fprintf(f, "overlay=false"); -} - -static int ifg_is_dump_node(void *self, ir_node *irn) -{ - const arch_register_req_t *req = arch_get_register_req_out(irn); - (void)self; - return !(req->type & arch_register_req_type_ignore); -} - -static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn) -{ - co2_t *env = (co2_t*)self; - co2_irn_t *ci = get_co2_irn(env, irn); - int peri = 1; - - char buf[128] = ""; - - if (ci->aff) { - co2_cloud_irn_t *cci = (co2_cloud_irn_t*) ci; - if (cci->cloud && cci->cloud->mst_root == cci) - peri = 2; - - if (cci->cloud && cci->cloud->mst_root) - ir_snprintf(buf, sizeof(buf), "%+F", cci->cloud->mst_root->inh.irn); - } - - ir_fprintf(f, "label=\"%+F%s\" style=filled peripheries=%d color=%s shape=%s", irn, buf, peri, - get_dot_color_name(get_col(env, irn)), get_dot_shape_name(ci)); -} - -static void ifg_dump_at_end(FILE *file, void *self) -{ - co2_t *env = (co2_t*)self; - affinity_node_t *a; - - co_gs_foreach_aff_node(env->co, a) { - co2_cloud_irn_t *ai = get_co2_cloud_irn(env, a->irn); - int idx = get_irn_idx(a->irn); - neighb_t *n; - - if (ai->mst_parent != ai) - fprintf(file, "\tn%d -- n%u [style=dotted color=blue arrowhead=normal];\n", idx, get_irn_idx(ai->mst_parent->inh.irn)); - - co_gs_foreach_neighb(a, n) { - int nidx = get_irn_idx(n->irn); - co2_cloud_irn_t *ci = get_co2_cloud_irn(env, n->irn); - - if (idx < nidx) { - const char *color = get_col(env, a->irn) == get_col(env, n->irn) ? "black" : "red"; - const char *arr = "arrowhead=dot arrowtail=dot"; - - if (ci->mst_parent == ai) - arr = "arrowtail=normal"; - else if (ai->mst_parent == ci) - arr = "arrowhead=normal"; - - fprintf(file, "\tn%d -- n%d [label=\"%d\" %s style=dashed color=%s weight=0.01];\n", idx, nidx, n->costs, arr, color); - } - } - } -} - -static be_ifg_dump_dot_cb_t ifg_dot_cb = { - ifg_is_dump_node, - ifg_dump_graph_attr, - ifg_dump_node_attr, - NULL, - NULL, - ifg_dump_at_end -}; - static void process(co2_t *env) { - affinity_node_t *a; - co2_cloud_t *pos; co2_cloud_t **clouds; int n_clouds; int i; @@ -1197,19 +986,6 @@ static void process(co2_t *env) all_costs += clouds[i]->costs; final_costs += cloud_costs(clouds[i]); - - /* Dump the IFG if the user demanded it. */ - if (dump_flags & DUMP_CLOUD) { - char buf[256]; - FILE *f; - - ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_cloud_%d.dot", env->co->irg, env->co->cls->name, i); - f = fopen(buf, "wt"); - if (f != NULL) { - be_ifg_dump_dot(env->co->cenv->ifg, env->co->irg, f, &ifg_dot_cb, env); - fclose(f); - } - } } DB((env->dbg, LEVEL_1, "all costs: %d, init costs: %d, final costs: %d\n", all_costs, init_costs, final_costs)); @@ -1217,44 +993,25 @@ static void process(co2_t *env) xfree(clouds); } -int co_solve_heuristic_new(copy_opt_t *co) +static int co_solve_heuristic_new(copy_opt_t *co) { - char buf[256]; co2_t env; - FILE *f; - - phase_init(&env.ph, co->cenv->irg, co2_irn_init); - env.touched = NULL; - env.visited = 0; - env.co = co; - env.n_regs = co->cls->n_regs; - env.allocatable_regs = bitset_alloca(co->cls->n_regs); - be_put_allocatable_regs(co->cenv->irg, co->cls, env.allocatable_regs); + + ir_nodemap_init(&env.map, co->irg); + obstack_init(&env.obst); + env.touched = NULL; + env.visited = 0; + env.co = co; + env.n_regs = co->cls->n_regs; + env.allocatable_regs = co->cenv->allocatable_regs->data; FIRM_DBG_REGISTER(env.dbg, "firm.be.co2"); INIT_LIST_HEAD(&env.cloud_head); - if (dump_flags & DUMP_BEFORE) { - ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_before.dot", co->irg, co->cls->name); - f = fopen(buf, "wt"); - if (f != NULL) { - be_ifg_dump_dot(co->cenv->ifg, co->irg, f, &ifg_dot_cb, &env); - fclose(f); - } - } - process(&env); - if (dump_flags & DUMP_AFTER) { - ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_after.dot", co->irg, co->cls->name); - f = fopen(buf, "wt"); - if (f != NULL) { - be_ifg_dump_dot(co->cenv->ifg, co->irg, f, &ifg_dot_cb, &env); - fclose(f); - } - } - writeback_colors(&env); - phase_deinit(&env.ph); + obstack_free(&env.obst, NULL); + ir_nodemap_destroy(&env.map); return 0; }