* (also known as "heur3" :)
* Performs simple copy minimization.
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif /* HAVE_CONFIG_H */
#define DISABLE_STATEV
pqueue_t *chunks; /**< priority queue for chunks */
pset *chunkset; /**< set holding all chunks */
be_ifg_t *ifg; /**< the interference graph */
- const arch_env_t *aenv; /**< the arch environment */
copy_opt_t *co; /**< the copy opt object */
unsigned chunk_visited;
col_cost_t **single_cols;
#endif /* DEBUG_libfirm */
-static INLINE int get_mst_irn_col(const co_mst_irn_t *node) {
+static inline int get_mst_irn_col(const co_mst_irn_t *node) {
return node->tmp_col >= 0 ? node->tmp_col : node->col;
}
/**
* Creates a new affinity chunk
*/
-static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
+static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
aff_chunk_t *c = XMALLOCF(aff_chunk_t, color_affinity, env->n_regs);
c->n = NEW_ARR_F(const ir_node *, 0);
c->interfere = NEW_ARR_F(const ir_node *, 0);
/**
* 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(co_mst_env_t *env, aff_chunk_t *c) {
pset_remove(env->chunkset, c, c->id);
DEL_ARR_F(c->interfere);
DEL_ARR_F(c->n);
* @return the position where n is found in the array arr or ~pos
* if the nodes is not here.
*/
-static INLINE int nodes_bsearch(const ir_node **arr, const ir_node *n) {
+static inline int nodes_bsearch(const ir_node **arr, const ir_node *n) {
int hi = ARR_LEN(arr);
int lo = 0;
/**
* Adds a node to an affinity chunk
*/
-static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
int i;
if (! nodes_insert(&c->n, node->irn))
res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
/* Exclude colors not assignable to the irn */
- req = arch_get_register_req(irn, -1);
+ req = arch_get_register_req_out(irn);
if (arch_register_req_is(req, limited))
rbitset_copy_to_bitset(req->limited, res->adm_colors);
else
/* build list of interfering neighbours */
len = 0;
be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
- if (! arch_irn_is(env->aenv, neigh, ignore)) {
+ if (!arch_irn_is_ignore(neigh)) {
obstack_ptr_grow(phase_obst(ph), neigh);
++len;
}
/**
* Check if affinity chunk @p chunk interferes with node @p irn.
*/
-static INLINE int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn) {
+static inline int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn) {
return node_contains(chunk->interfere, irn);
}
* @param c2 Another chunk
* @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
*/
-static INLINE int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
+static inline int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
int i;
if (c1 == c2)
* 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_aff_chunk(co_mst_env_t *env, const ir_node *irn) {
+static inline aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn) {
co_mst_irn_t *node = get_co_mst_irn(env, irn);
return node->chunk;
}
if (an != NULL) {
neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
- const ir_node *m = neigh->irn;
+ const ir_node *m = neigh->irn;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
w += node_contains(c->n, m) ? neigh->costs : 0;
const ir_node *n = neigh->irn;
int i;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
/* check if the affinity neighbour interfere */
co_mst_irn_t *n1;
affinity_node_t *an;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
n1 = get_co_mst_irn(env, n);
aff_edge_t edge;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
edge.src = n;
int w = 0;
neighb_t *neigh;
- if (arch_irn_is(env->aenv, irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
if (an) {
while (!pqueue_empty(grow)) {
ir_node *irn = pqueue_pop_front(grow);
affinity_node_t *an = get_affinity_info(env->co, irn);
- neighb_t *neigh;
+ neighb_t *neigh;
- if (arch_irn_is(env->aenv, irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
assert(i <= ARR_LEN(chunk->n));
int m_idx = get_irn_idx(m);
co_mst_irn_t *n2;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
n2 = get_co_mst_irn(env, m);
* Resets the temporary fixed color of all nodes within wait queue @p nodes.
* ATTENTION: the queue is empty after calling this function!
*/
-static INLINE void reject_coloring(struct list_head *nodes) {
+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, "\n"));
}
-static INLINE void materialize_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);
}
}
-static INLINE void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
+static inline void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
{
assert(col >= 0);
assert(!node->fixed);
node->tmp_col = col;
}
-static INLINE int is_loose(co_mst_irn_t *node)
+static inline int is_loose(co_mst_irn_t *node)
{
return !node->fixed && node->tmp_col < 0;
}
/**
* Determines the costs for each color if it would be assigned to node @p node.
*/
-static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
- int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
- int n_loose = 0;
+static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs)
+{
+ int *neigh_cols = ALLOCAN(int, env->n_regs);
+ int n_loose = 0;
real_t coeff;
- int i;
+ int i;
for (i = 0; i < env->n_regs; ++i) {
neigh_cols[i] = 0;
/* The node has the color it should not have _and_ has not been visited yet. */
if (is_loose(node)) {
- col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+ col_cost_t *costs = ALLOCAN(col_cost_t, env->n_regs);
/* Get the costs for giving the node a specific color. */
determine_color_costs(env, node, costs);
neigh = node->int_neighs[j];
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, neigh, ignore))
+ if (arch_irn_is_ignore(neigh))
continue;
nn = get_co_mst_irn(env, neigh);
int n_int_chunks = 0;
waitq *tmp_chunks = new_waitq();
waitq *best_starts = NULL;
- col_cost_t *order = alloca(env->n_regs * sizeof(order[0]));
+ col_cost_t *order = ALLOCANZ(col_cost_t, env->n_regs);
bitset_t *visited;
int idx, len, i, nidx, pos;
struct list_head changed;
++env->chunk_visited;
/* compute color preference */
- memset(order, 0, env->n_regs * sizeof(order[0]));
-
for (pos = 0, len = ARR_LEN(c->interfere); pos < len; ++pos) {
const ir_node *n = c->interfere[pos];
co_mst_irn_t *node = get_co_mst_irn(env, n);
/**
* Main driver for mst safe coalescing algorithm.
*/
-int co_solve_heuristic_mst(copy_opt_t *co) {
+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;
mst_env.co = co;
mst_env.ignore_regs = ignore_regs;
mst_env.ifg = co->cenv->ifg;
- mst_env.aenv = co->aenv;
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);
/* apply coloring */
foreach_phase_irn(&mst_env.ph, irn) {
- co_mst_irn_t *mirn;
+ co_mst_irn_t *mirn;
const arch_register_t *reg;
- if (arch_irn_is(mst_env.aenv, irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
mirn = get_co_mst_irn(&mst_env, irn);
lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4");
lc_opt_add_table(heur4_grp, options);
+
+ static co_algo_info copyheur = {
+ co_solve_heuristic_mst, 0
+ };
+
+ be_register_copyopt("heur4", ©heur);
+
FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
}
-
BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
projects / libfirm / blobdiff