+/*
+ * Copyright (C) 1995-2008 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.
+ */
/**
- * More experiments on coalescing.
- * @author Sebastian Hack
- * @date 14.04.2006
+ * @file
+ * @brief More experiments on coalescing.
+ * @author Sebastian Hack
+ * @date 14.04.2006
+ * @version $Id$
*/
-
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
-#ifdef WITH_LIBCORE
-#include <libcore/lc_opts.h>
-#include <libcore/lc_opts_enum.h>
-#endif /* WITH_LIBCORE */
+#include "lc_opts.h"
+#include "lc_opts_enum.h"
#include <stdlib.h>
#include <limits.h>
#include "list.h"
#include "pdeq.h"
#include "bitset.h"
+#include "raw_bitset.h"
#include "debug.h"
#include "bitfiddle.h"
#include "irprintf.h"
#include "irtools.h"
+#include "bemodule.h"
#include "beabi.h"
-#include "benode_t.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
#define DUMP_CLOUD 4
#define DUMP_ALL 2 * DUMP_CLOUD - 1
-static int dump_flags = 0;
-static int subtree_iter = 4;
-static double constr_factor = 0.5;
-
-/* Options using libcore */
-#ifdef WITH_LIBCORE
+static unsigned dump_flags = 0;
+static int subtree_iter = 4;
+static int max_depth = 20;
+static double constr_factor = 0.9;
static const lc_opt_enum_mask_items_t dump_items[] = {
{ "before", DUMP_BEFORE },
- { "after", DUMP_AFTER },
- { "cloud", DUMP_CLOUD },
+ { "after", DUMP_AFTER },
+ { "cloud", DUMP_CLOUD },
{ "all", DUMP_ALL },
{ NULL, 0 }
};
};
static const lc_opt_table_entry_t options[] = {
- LC_OPT_ENT_ENUM_MASK("dump", "dump ifg before, after or after each cloud", &dump_var),
- LC_OPT_ENT_INT ("iter", "iterations for subtree nodes (standard: 3)", &subtree_iter),
+ LC_OPT_ENT_ENUM_MASK("dump", "dump ifg cloud", &dump_var),
+ LC_OPT_ENT_INT ("iter", "iterations for subtree nodes", &subtree_iter),
LC_OPT_ENT_DBL ("cf", "factor of constraint importance (between 0.0 and 1.0)", &constr_factor),
- { NULL }
+ LC_OPT_ENT_INT ("max", "maximum recursion depth", &max_depth),
+ LC_OPT_LAST
};
-void be_co2_register_options(lc_opt_entry_t *grp)
-{
- lc_opt_entry_t *co2_grp = lc_opt_get_grp(grp, "co2");
- lc_opt_add_table(co2_grp, options);
-}
-#endif
-
/*
____ _ _
/ ___|| |_ __ _ _ __| |_
} col_cost_pair_t;
typedef struct {
- phase_t ph;
+ ir_phase ph;
copy_opt_t *co;
bitset_t *ignore_regs;
co2_irn_t *touched;
} co2_t;
struct _co2_irn_t {
- ir_node *irn;
+ const ir_node *irn;
affinity_node_t *aff;
co2_irn_t *touched_next;
col_t tmp_col;
#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(phase_t *ph, ir_node *irn, void *data)
+static void *co2_irn_init(ir_phase *ph, const ir_node *irn, void *data)
{
co2_t *env = (co2_t *) ph;
affinity_node_t *a = get_affinity_info(env->co, irn);
memset(ci, 0, size);
INIT_LIST_HEAD(&ci->changed_list);
ci->touched_next = env->touched;
- ci->orig_col = get_irn_col(env->co, irn);
+ ci->orig_col = get_irn_col(irn);
env->touched = ci;
ci->irn = irn;
ci->aff = a;
- if(a) {
+ if (a) {
co2_cloud_irn_t *cci = (co2_cloud_irn_t *) ci;
INIT_LIST_HEAD(&cci->cloud_list);
cci->mst_parent = cci;
static int cmp_clouds_gt(const void *a, const void *b)
{
- const co2_cloud_t **p = a;
- const co2_cloud_t **q = b;
+ const co2_cloud_t * const *p = a;
+ const co2_cloud_t * const *q = b;
double c = CLOUD_WEIGHT(*p);
double d = CLOUD_WEIGHT(*q);
return QSORT_CMP(d, c);
return QSORT_CMP(c, d);
}
-int cmp_edges(const void *a, const void *b)
+static int cmp_edges(const void *a, const void *b)
{
const edge_t *p = a;
const edge_t *q = b;
return QSORT_CMP(q->costs, p->costs);
}
-static col_t get_col(co2_t *env, ir_node *irn)
+static col_t get_col(co2_t *env, const ir_node *irn)
{
co2_irn_t *ci = get_co2_irn(env, irn);
return ci->tmp_fixed ? ci->tmp_col : ci->orig_col;
}
-static INLINE int color_is_fix(co2_t *env, ir_node *irn)
+static inline int color_is_fix(co2_t *env, const ir_node *irn)
{
co2_irn_t *ci = get_co2_irn(env, irn);
return ci->fixed || ci->tmp_fixed;
}
-static INLINE bitset_t *get_adm(co2_t *env, co2_irn_t *ci)
+static inline bitset_t *get_adm(co2_t *env, co2_irn_t *ci)
{
- if(!ci->adm_cache) {
- arch_register_req_t req;
+ if (ci->adm_cache == NULL) {
+ const arch_register_req_t *req;
ci->adm_cache = bitset_obstack_alloc(phase_obst(&env->ph), env->n_regs);
- arch_get_register_req(env->co->aenv, &req, ci->irn, BE_OUT_POS(0));
- if(arch_register_req_is(&req, limited)) {
- req.limited(req.limited_env, ci->adm_cache);
+ 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 {
+ } else {
bitset_copy(ci->adm_cache, env->ignore_regs);
bitset_flip_all(ci->adm_cache);
}
return ci->adm_cache;
}
-static INLINE bitset_t *admissible_colors(co2_t *env, co2_irn_t *ci, bitset_t *bs)
+static inline bitset_t *admissible_colors(co2_t *env, co2_irn_t *ci, bitset_t *bs)
{
bitset_copy(bs, get_adm(env, ci));
return bs;
}
-static INLINE int is_color_admissible(co2_t *env, co2_irn_t *ci, col_t col)
+static inline int is_color_admissible(co2_t *env, co2_irn_t *ci, col_t col)
{
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)
+static inline int is_constrained(co2_t *env, co2_irn_t *ci)
{
- if(!ci->adm_cache)
+ if (!ci->adm_cache)
get_adm(env, ci);
return ci->is_constrained;
}
-static void incur_constraint_costs(co2_t *env, ir_node *irn, col_cost_pair_t *col_costs, int costs)
+static void incur_constraint_costs(co2_t *env, const ir_node *irn, col_cost_pair_t *col_costs, int costs)
{
- bitset_t *aux = bitset_alloca(env->co->cls->n_regs);
- arch_register_req_t req;
+ const arch_register_req_t *req = arch_get_register_req_out(irn);
- arch_get_register_req(env->co->aenv, &req, irn, BE_OUT_POS(0));
+ if (arch_register_req_is(req, limited)) {
+ unsigned n_regs = env->co->cls->n_regs;
+ unsigned n_constr = 0;
+ unsigned i;
- if(arch_register_req_is(&req, limited)) {
- bitset_pos_t elm;
- int n_constr;
-
- req.limited(req.limited_env, aux);
- n_constr = bitset_popcnt(aux);
- bitset_foreach(aux, elm) {
- col_costs[elm].costs = add_saturated(col_costs[elm].costs, costs / n_constr);
+ n_constr = rbitset_popcount(req->limited, n_regs);
+ for (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);
+ }
}
}
}
*/
static void determine_color_costs(co2_t *env, co2_irn_t *ci, col_cost_pair_t *col_costs)
{
- ir_node *irn = ci->irn;
+ 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;
- bitset_pos_t elm;
- ir_node *pos;
- void *it;
+ unsigned 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) {
+ for (i = 0; i < n_regs; ++i) {
col_costs[i].col = i;
col_costs[i].costs = 0;
}
- if(a) {
+ if (a) {
neighb_t *n;
co_gs_foreach_neighb(a, n) {
- if(color_is_fix(env, n->irn)) {
+ 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);
}
}
}
- it = be_ifg_neighbours_iter_alloca(ifg);
- be_ifg_foreach_neighbour(ifg, it, irn, pos) {
+ be_ifg_foreach_neighbour(ifg, &it, irn, pos) {
col_t col = get_col(env, pos);
- if(color_is_fix(env, pos)) {
+ if (color_is_fix(env, pos)) {
col_costs[col].costs = INT_MAX;
}
else {
col_costs[col].costs = add_saturated(col_costs[col].costs, 8 * be_ifg_degree(ifg, pos));
}
}
- be_ifg_neighbours_break(ifg, it);
+ be_ifg_neighbours_break(&it);
/* Set the costs to infinity for each color which is not allowed at this node. */
bitset_foreach(forb, elm) {
int n_regs = env->co->cls->n_regs;
int i;
- for(i = 0; i < n_regs; ++i) {
+ for (i = 0; i < n_regs; ++i) {
seq[i].col = i;
seq[i].costs = INT_MAX;
}
+ (void) ci;
assert(is_color_admissible(env, ci, col));
seq[col].col = 0;
seq[0].col = col;
}
}
-static int change_color_not(co2_t *env, ir_node *irn, col_t not_col, struct list_head *parent_changed, int depth);
+static int change_color_not(co2_t *env, const ir_node *irn, col_t not_col, struct list_head *parent_changed, int depth);
-static int recolor(co2_t *env, ir_node *irn, col_cost_pair_t *col_list, struct list_head *parent_changed, int depth)
+static int recolor(co2_t *env, const ir_node *irn, col_cost_pair_t *col_list, struct list_head *parent_changed, int depth)
{
int n_regs = env->co->cls->n_regs;
be_ifg_t *ifg = env->co->cenv->ifg;
co2_irn_t *ci = get_co2_irn(env, irn);
int res = 0;
- int n_aff = 0;
int i;
- for(i = 0; i < n_regs; ++i) {
+ if (depth >= max_depth)
+ return 0;
+
+ for (i = 0; i < n_regs; ++i) {
col_t tgt_col = col_list[i].col;
unsigned costs = col_list[i].costs;
int neigh_ok = 1;
struct list_head changed;
- ir_node *n;
- void *it;
+ 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));
/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
- if(INFEASIBLE(costs)) {
+ if (INFEASIBLE(costs)) {
DB((env->dbg, LEVEL_4, "\t\t%2{firm:indent}color %d infeasible\n", depth, tgt_col));
ci->tmp_fixed = 0;
return 0;
INIT_LIST_HEAD(&changed);
list_add(&ci->changed_list, &changed);
- it = be_ifg_neighbours_iter_alloca(ifg);
- be_ifg_foreach_neighbour(ifg, it, irn, n) {
+ be_ifg_foreach_neighbour(ifg, &it, irn, n) {
/* try to re-color the neighbor if it has the target color. */
- if(get_col(env, n) == tgt_col) {
+ if (get_col(env, n) == tgt_col) {
struct list_head tmp;
/*
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)
break;
}
}
- be_ifg_neighbours_break(ifg, it);
+ be_ifg_neighbours_break(&it);
/*
We managed to assign the target color to all neighbors, so from the perspective
of the current node, every thing was ok and we can return safely.
*/
- if(neigh_ok) {
+ if (neigh_ok) {
DBG((env->dbg, LEVEL_3, "\t\t%2{firm:indent}color %d(%d) was ok\n", depth, tgt_col, costs));
list_splice(&changed, parent_changed);
res = 1;
return res;
}
-static int change_color_not(co2_t *env, ir_node *irn, col_t not_col, struct list_head *parent_changed, int depth)
+static int change_color_not(co2_t *env, const ir_node *irn, col_t not_col, struct list_head *parent_changed, int depth)
{
co2_irn_t *ci = get_co2_irn(env, irn);
int res = 0;
DBG((env->dbg, LEVEL_3, "\t\t%2{firm:indent}clearing %+F(%d) of color %d\n", depth, irn, col, not_col));
/* the node does not have to forbidden color. That's fine, mark it as visited and return. */
- if(col != not_col) {
- if(!ci->tmp_fixed) {
+ if (col != not_col) {
+ if (!ci->tmp_fixed) {
ci->tmp_col = col;
ci->tmp_fixed = 1;
}
}
/* The node has the color it should not have _and_ has not been visited yet. */
- if(!color_is_fix(env, irn)) {
+ if (!color_is_fix(env, irn)) {
int n_regs = env->co->cls->n_regs;
- col_cost_pair_t *csts = alloca(n_regs * sizeof(csts[0]));
+ col_cost_pair_t *csts = ALLOCAN(col_cost_pair_t, n_regs);
/* Get the costs for giving the node a specific color. */
determine_color_costs(env, ci, csts);
return res;
}
-static int change_color_single(co2_t *env, ir_node *irn, col_t tgt_col, struct list_head *parent_changed, int depth)
+static int change_color_single(co2_t *env, const ir_node *irn, col_t tgt_col, struct list_head *parent_changed, int depth)
{
co2_irn_t *ci = get_co2_irn(env, irn);
col_t col = get_col(env, irn);
DBG((env->dbg, LEVEL_3, "\t\t%2{firm:indent}trying to set %+F(%d) to color %d\n", depth, irn, col, tgt_col));
/* the node has the wanted color. That's fine, mark it as visited and return. */
- if(col == tgt_col) {
- if(!ci->tmp_fixed) {
+ if (col == tgt_col) {
+ if (!ci->tmp_fixed) {
ci->tmp_col = col;
ci->tmp_fixed = 1;
list_add(&ci->changed_list, parent_changed);
goto end;
}
- if(!color_is_fix(env, irn) && is_color_admissible(env, ci, tgt_col)) {
+ if (!color_is_fix(env, irn) && is_color_admissible(env, ci, tgt_col)) {
int n_regs = env->co->cls->n_regs;
- col_cost_pair_t *seq = alloca(n_regs * sizeof(seq[0]));
+ col_cost_pair_t *seq = ALLOCAN(col_cost_pair_t, n_regs);
/* Get the costs for giving the node a specific color. */
single_color_cost(env, ci, tgt_col, seq);
int cost = 0;
int i;
- for(i = 0; i < ci->mst_n_childs; ++i) {
+ for (i = 0; i < ci->mst_n_childs; ++i) {
co2_cloud_irn_t *chld = ci->mst_childs[i];
col_t chld_col = front[i];
be_ifg_t *ifg = env->co->cenv->ifg;
bitset_t *bs = bitset_alloca(n_regs);
- bitset_pos_t elm;
- ir_node *irn;
- void *it;
+ unsigned elm;
+ const ir_node *irn;
+ neighbours_iter_t it;
admissible_colors(env, &ci->inh, bs);
bitset_flip_all(bs);
badness[elm] = ci->costs;
/* Use constrained/fixed interfering neighbors to influence the color badness */
- it = be_ifg_neighbours_iter_alloca(ifg);
- be_ifg_foreach_neighbour(ifg, it, ir->irn, irn) {
+ be_ifg_foreach_neighbour(ifg, &it, ir->irn, irn) {
co2_irn_t *ni = get_co2_irn(env, irn);
admissible_colors(env, ni, bs);
- if(bitset_popcnt(bs) == 1) {
- bitset_pos_t c = bitset_next_set(bs, 0);
+ if (bitset_popcount(bs) == 1) {
+ unsigned c = bitset_next_set(bs, 0);
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(ifg, it);
+ be_ifg_neighbours_break(&it);
}
/**
node_color_badness(ci, ci->color_badness);
/* Collect the color badness for the whole subtree */
- for(i = 0; i < ci->mst_n_childs; ++i) {
+ for (i = 0; i < ci->mst_n_childs; ++i) {
co2_cloud_irn_t *child = ci->mst_childs[i];
determine_color_badness(child, depth + 1);
- for(j = 0; j < env->n_regs; ++j)
+ for (j = 0; j < env->n_regs; ++j)
ci->color_badness[j] += child->color_badness[j];
}
- for(j = 0; j < env->n_regs; ++j)
+ for (j = 0; j < env->n_regs; ++j)
DBG((env->dbg, LEVEL_2, "%2{firm:indent}%+F col %d badness %d\n", depth, ci->inh.irn, j, ci->color_badness[j]));
}
int i;
ci->inh.fixed = 0;
- for(i = 0; i < ci->mst_n_childs; ++i)
+ for (i = 0; i < ci->mst_n_childs; ++i)
unfix_subtree(ci->mst_childs[i]);
}
static int coalesce_top_down(co2_cloud_irn_t *ci, int child_nr, int depth)
{
co2_t *env = ci->cloud->env;
- col_cost_pair_t *seq = alloca(env->n_regs * sizeof(seq[0]));
+ col_cost_pair_t *seq = ALLOCAN(col_cost_pair_t, env->n_regs);
int is_root = ci->mst_parent == ci;
- col_t parent_col = is_root ? -1 : get_col(env, ci->mst_parent->inh.irn);
+ col_t parent_col = is_root ? (col_t) -1 : get_col(env, ci->mst_parent->inh.irn);
int min_badness = INT_MAX;
int best_col_costs = INT_MAX;
int best_col = -1;
struct list_head changed;
int ok, i, j;
- for(i = 0; i < n_regs; ++i) {
+ for (i = 0; i < n_regs; ++i) {
int badness = ci->color_badness[i];
seq[i].col = i;
}
/* 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(env, &ci->inh, parent_col))
seq[parent_col].costs = min_badness - 1;
/* Sort the colors. The will be processed in that ordering. */
DBG((env->dbg, LEVEL_2, "\t%2{firm:indent}starting top-down coalesce for %+F\n", depth, ci->inh.irn));
INIT_LIST_HEAD(&changed);
- for(i = 0; i < (best_col < 0 ? n_regs : n_iter); ++i) {
+ for (i = 0; i < (best_col < 0 ? n_regs : n_iter); ++i) {
col_t col = seq[i].col;
- int costs = seq[i].costs;
int add_cost = !is_root && col != parent_col ? ci->mst_costs : 0;
int subtree_costs, sum_costs;
unfix_subtree(ci);
INIT_LIST_HEAD(&changed);
ok = change_color_single(env, ci->inh.irn, col, &changed, depth);
- if(ok) {
+ if (ok) {
materialize_coloring(&changed);
ci->inh.fixed = 1;
}
else
continue;
- for(j = 0; j < ci->mst_n_childs; ++j) {
+ for (j = 0; j < ci->mst_n_childs; ++j) {
co2_cloud_irn_t *child = ci->mst_childs[j];
ok = coalesce_top_down(child, j, depth + 1) >= 0;
- if(ok)
+ if (ok)
child->inh.fixed = 1;
else
break;
}
/* If the subtree could not be colored, we have to try another color. */
- if(!ok)
+ if (!ok)
continue;
subtree_costs = examine_subtree_coloring(ci, col);
sum_costs = subtree_costs + add_cost;
DBG((env->dbg, LEVEL_2, "\t%2{firm:indent}-> %+F costing %d + %d is ok.\n", depth, ci->inh.irn, subtree_costs, add_cost));
- if(sum_costs < best_col_costs) {
+ if (sum_costs < best_col_costs) {
best_col = col;
best_col_costs = sum_costs;
ci->col_costs[col] = subtree_costs;
}
- if(sum_costs == 0)
+ if (sum_costs == 0)
break;
}
- if(!is_root) {
+ if (!is_root) {
int *front = FRONT_BASE(ci->mst_parent, parent_col);
front[child_nr] = best_col;
}
int costs = 0;
neighb_t *n;
- if(ci->cloud)
+ if (ci->cloud)
return;
/* mark the node as visited and add it to the cloud. */
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_ifg_connected(ifg, a->irn, n->irn))
cloud->inevit += n->costs;
}
ci->costs = costs;
cloud->costs += costs;
cloud->n_constr += is_constrained(env, &ci->inh);
- cloud->freedom += bitset_popcnt(get_adm(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++;
/* If this is the heaviest node in the cloud, set it as the cloud's master. */
- if(costs >= curr_costs) {
+ if (costs >= curr_costs) {
curr_costs = costs;
cloud->master = ci;
}
static void apply_coloring(co2_cloud_irn_t *ci, col_t col, int depth)
{
- ir_node *irn = ci->inh.irn;
+ const ir_node *irn = ci->inh.irn;
int *front = FRONT_BASE(ci, col);
int i, ok;
struct 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");
+ // assert(ok && "Color changing may not fail while committing the coloring");
materialize_coloring(&changed);
- for(i = 0; i < ci->mst_n_childs; ++i) {
+ for (i = 0; i < ci->mst_n_childs; ++i) {
apply_coloring(ci->mst_childs[i], front[i], depth + 1);
}
}
static co2_cloud_irn_t *find_mst_root(co2_cloud_irn_t *ci)
{
- while(ci != ci->mst_parent)
+ while (ci != ci->mst_parent)
ci = ci->mst_parent;
return ci;
}
co2_t *env = cloud->env;
int n_regs = env->n_regs;
int n_edges = 0;
- int *mst_edges = malloc(cloud->n_memb * cloud->n_memb * sizeof(mst_edges[0]));
+ int *mst_edges = XMALLOCNZ(int, cloud->n_memb * cloud->n_memb);
pdeq *q;
- struct list_head changed;
edge_t *edges;
int i;
int best_col;
- memset(mst_edges, 0, cloud->n_memb * cloud->n_memb * sizeof(mst_edges[0]));
-
/* Collect all edges in the cloud on an obstack and sort the increasingly */
obstack_init(&cloud->obst);
- for(i = 0; i < cloud->n_memb; ++i) {
+ 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);
- if(ci->index < ni->index) {
+ if (ci->index < ni->index) {
edge_t e;
e.src = ci;
e.tgt = ni;
/* Compute the maximum spanning tree using Kruskal/Union-Find */
DBG((env->dbg, LEVEL_2, "computing spanning tree of cloud with master %+F\n", cloud->master->inh.irn));
- for(i = 0; i < n_edges; ++i) {
+ for (i = 0; i < n_edges; ++i) {
edge_t *e = &edges[i];
co2_cloud_irn_t *rs = find_mst_root(e->src);
co2_cloud_irn_t *rt = find_mst_root(e->tgt);
/* if the union/find roots are different */
- if(rs != rt) {
+ if (rs != rt) {
int si = e->src->index;
int ti = e->tgt->index;
cloud->master->mst_parent = cloud->master;
cloud->mst_root = cloud->master;
q = new_pdeq1(cloud->master);
- while(!pdeq_empty(q)) {
+ while (!pdeq_empty(q)) {
co2_cloud_irn_t *ci = pdeq_getl(q);
int ofs = ci->index * cloud->n_memb;
int end = ofs + cloud->n_memb;
int i;
ci->mst_n_childs = 0;
- for(i = ofs; i < end; ++i) {
- if(mst_edges[i] != 0) {
+ for (i = ofs; i < end; ++i) {
+ if (mst_edges[i] != 0) {
int other = i - ofs;
co2_cloud_irn_t *child = cloud->seq[i - ofs];
DBG((env->dbg, LEVEL_3, "mst:\n"));
- for(i = 0; i < cloud->n_memb; ++i) {
- co2_cloud_irn_t *ci = cloud->seq[i];
+ for (i = 0; i < cloud->n_memb; ++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));
}
- for(i = 0; i < cloud->n_memb; ++i) {
+ for (i = 0; i < cloud->n_memb; ++i) {
co2_cloud_irn_t *ci = cloud->seq[i];
int n_childs = ci->mst_n_childs;
int j;
- ci->col_costs = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->col_costs[0]));
- ci->tmp_coloring = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->tmp_coloring[0]));
- ci->fronts = obstack_alloc(&cloud->obst, n_regs * n_childs * sizeof(ci->fronts[0]));
- ci->color_badness = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->fronts[0]));
- memset(ci->color_badness, 0, n_regs * sizeof(ci->color_badness[0]));
- memset(ci->col_costs, 0, n_regs * sizeof(ci->col_costs[0]));
- memset(ci->tmp_coloring, 0, n_regs * sizeof(ci->tmp_coloring[0]));
- memset(ci->fronts, 0, n_regs * n_childs * sizeof(ci->fronts[0]));
+ ci->col_costs = OALLOCNZ(&cloud->obst, int, n_regs);
+ ci->tmp_coloring = OALLOCNZ(&cloud->obst, col_cost_pair_t, n_regs);
+ ci->fronts = OALLOCNZ(&cloud->obst, int, n_regs * n_childs);
+ ci->color_badness = OALLOCNZ(&cloud->obst, int, n_regs);
- for(j = 0; j < env->n_regs; j++)
+ for (j = 0; j < env->n_regs; j++)
ci->col_costs[j] = INT_MAX;
-
}
determine_color_badness(cloud->mst_root, 0);
cloud->mst_root->inh.irn, best_col, examine_subtree_coloring(cloud->mst_root, best_col)));
/* Fix all nodes in the cloud. */
- for(i = 0; i < cloud->n_memb; ++i)
+ for (i = 0; i < cloud->n_memb; ++i)
cloud->seq[i]->inh.fixed = 1;
/* Free all space used while optimizing this cloud. */
int i, costs = 0;
neighb_t *n;
- for(i = 0; i < cloud->n_memb; ++i) {
+ for (i = 0; i < cloud->n_memb; ++i) {
co2_irn_t *ci = (co2_irn_t *) cloud->seq[i];
col_t col = get_col(cloud->env, ci->irn);
co_gs_foreach_neighb(ci->aff, n) {
co_gs_foreach_aff_node(env->co, a) {
co2_cloud_irn_t *ci = get_co2_cloud_irn(env, a->irn);
- if(!ci->cloud) {
- co2_cloud_t *cloud = new_cloud(env, a);
+ if (!ci->cloud) {
+ new_cloud(env, a);
n_clouds++;
}
}
i = 0;
- clouds = xmalloc(n_clouds * sizeof(clouds[0]));
+ clouds = XMALLOCN(co2_cloud_t*, n_clouds);
list_for_each_entry(co2_cloud_t, pos, &env->cloud_head, list)
clouds[i++] = pos;
qsort(clouds, n_clouds, sizeof(clouds[0]), cmp_clouds_gt);
- for(i = 0; i < n_clouds; ++i) {
+ for (i = 0; i < n_clouds; ++i) {
init_costs += cloud_costs(clouds[i]);
/* Process the cloud. */
FILE *f;
ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_cloud_%d.dot", env->co->irg, env->co->cls->name, i);
- if(f = fopen(buf, "wt")) {
+ 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);
}
static void writeback_colors(co2_t *env)
{
- const arch_env_t *aenv = env->co->aenv;
co2_irn_t *irn;
- for(irn = env->touched; irn; irn = irn->touched_next) {
+ for (irn = env->touched; irn; irn = irn->touched_next) {
const arch_register_t *reg = arch_register_for_index(env->co->cls, irn->orig_col);
- arch_set_irn_register(aenv, irn->irn, reg);
+ arch_set_irn_register((ir_node*)irn->irn, reg);
}
}
|_| |___/
*/
-static const char *get_dot_color_name(int col)
+static const char *get_dot_color_name(size_t col)
{
- static const char *names[] = {
+ static const char *const names[] = {
"blue",
"red",
"green",
"palevioletred"
};
- return col < sizeof(names)/sizeof(names[0]) ? names[col] : "white";
+ return col < (sizeof(names)/sizeof(names[0])) ? names[col] : "white";
}
-static const char *get_dot_shape_name(co2_t *env, co2_irn_t *ci)
+static const char *get_dot_shape_name(co2_irn_t *ci)
{
- arch_register_req_t req;
+ const arch_register_req_t *req = arch_get_register_req_out(ci->irn);
- arch_get_register_req(env->co->aenv, &req, ci->irn, BE_OUT_POS(0));
- if(arch_register_req_is(&req, limited))
+ if (arch_register_req_is(req, limited))
return "diamond";
- if(ci->fixed)
+ if (ci->fixed)
return "rectangle";
- if(ci->tmp_fixed)
+ 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)
{
- co2_t *env = self;
- return !arch_irn_is(env->co->aenv, irn, ignore);
+ 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)
char buf[128] = "";
- if(ci->aff) {
+ if (ci->aff) {
co2_cloud_irn_t *cci = (void *) ci;
if (cci->cloud && cci->cloud->mst_root == cci)
peri = 2;
- if(cci->cloud && cci->cloud->mst_root)
- snprintf(buf, sizeof(buf), "%+F", cci->cloud->mst_root->inh.irn);
+ 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(env, ci));
+ get_dot_color_name(get_col(env, irn)), get_dot_shape_name(ci));
}
static void ifg_dump_at_end(FILE *file, void *self)
int idx = get_irn_idx(a->irn);
neighb_t *n;
- if(ai->mst_parent != ai)
+ if (ai->mst_parent != ai)
fprintf(file, "\tn%d -- n%d [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) {
+ 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)
+ if (ci->mst_parent == ai)
arr = "arrowtail=normal";
- else if(ai->mst_parent == ci)
+ 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);
ifg_dump_at_end
};
-
-void co_solve_heuristic_new(copy_opt_t *co)
+int co_solve_heuristic_new(copy_opt_t *co)
{
- char buf[256];
+ char buf[256];
co2_t env;
- FILE *f;
+ FILE *f;
- phase_init(&env.ph, "co2", co->cenv->birg->irg, PHASE_DEFAULT_GROWTH, co2_irn_init);
+ 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.ignore_regs = bitset_alloca(co->cls->n_regs);
- arch_put_non_ignore_regs(co->aenv, co->cls, env.ignore_regs);
- bitset_flip_all(env.ignore_regs);
- be_abi_put_ignore_regs(co->cenv->birg->abi, co->cls, env.ignore_regs);
+ be_put_ignore_regs(co->cenv->irg, co->cls, env.ignore_regs);
FIRM_DBG_REGISTER(env.dbg, "firm.be.co2");
INIT_LIST_HEAD(&env.cloud_head);
- if(dump_flags & DUMP_BEFORE) {
+ if (dump_flags & DUMP_BEFORE) {
ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_before.dot", co->irg, co->cls->name);
- if(f = fopen(buf, "wt")) {
+ 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) {
+ if (dump_flags & DUMP_AFTER) {
ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_after.dot", co->irg, co->cls->name);
- if(f = fopen(buf, "wt")) {
+ 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_free(&env.ph);
+ phase_deinit(&env.ph);
+ return 0;
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2);
+void be_init_copyheur2(void)
+{
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+ lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra");
+ lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal");
+ lc_opt_entry_t *co2_grp = lc_opt_get_grp(chordal_grp, "co2");
+
+ static co_algo_info copyheur = {
+ co_solve_heuristic_new, 0
+ };
+
+ lc_opt_add_table(co2_grp, options);
+ be_register_copyopt("heur2", ©heur);
}
projects / libfirm / blobdiff