+/*
+ * Copyright (C) 1995-2007 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.
+ */
+
/**
+ * @file
+ * @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.
* (also known as "heur3" :)
* Performs simple copy minimization.
- *
- * @author Christian Wuerdig
- * @date 27.04.2007
- * @id $Id$
*/
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include <float.h>
#include "array.h"
-#include "irnode.h"
+#include "irnode_t.h"
#include "bitset.h"
#include "raw_bitset.h"
#include "irphase_t.h"
#include "xmalloc.h"
#include "pdeq.h"
#include "irprintf.h"
+#include "irbitset.h"
#include "bearch.h"
#include "beifg.h"
#include "be_t.h"
#include "becopyopt_t.h"
-#include "irbitset.h"
#define COL_COST_INFEASIBLE DBL_MAX
#define AFF_NEIGHBOUR_FIX_BENEFIT 128.0
/* stores coalescing related information for a node */
typedef struct _co_mst_irn_t {
- ir_node *irn;
- aff_chunk_t *chunk;
- bitset_t *adm_colors;
- int int_neigh;
- int col;
- int init_col;
- int tmp_col;
- unsigned fixed : 1;
- unsigned tmp_fixed : 1;
+ 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 */
+ ir_node **int_neighs; /**< ARR_D of all interfering neighbours (cached for speed reasons) */
+ int int_aff_neigh; /**< number of interfering affinity neighbours */
+ int col; /**< color currently assigned */
+ int init_col; /**< the initial color */
+ int tmp_col; /**< a temporary assigned color */
+ unsigned fixed : 1; /**< the color is fixed */
+ unsigned tmp_fixed : 1; /**< the color is temporary fixed */
} co_mst_irn_t;
#define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn)))
#ifdef DEBUG_libfirm
+/**
+ * Write a chunk to stderr for debugging.
+ */
static void dbg_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
int idx;
+ if (c->weight_consistent)
+ ir_fprintf(stderr, " $%d ", c->weight);
+ ir_fprintf(stderr, "{");
bitset_foreach(c->nodes, idx) {
ir_node *n = get_idx_irn(env->co->irg, idx);
- ir_fprintf(stderr, " %+F", n);
+ ir_fprintf(stderr, " %+F,", n);
}
- if (c->weight_consistent)
- ir_fprintf(stderr, " weight %d", c->weight);
+ ir_fprintf(stderr, "}");
}
+/**
+ * Dump all admissible colors to stderr.
+ */
static void dbg_admissible_colors(co_mst_env_t *env, co_mst_irn_t *node) {
int idx;
if (bitset_popcnt(node->adm_colors) < 1)
}
}
+/**
+ * Dump color-cost pairs to stderr.
+ */
static void dbg_col_cost(co_mst_env_t *env, col_cost_t *cost) {
int i;
for (i = 0; i < env->n_regs; ++i) {
return 1;
}
-/* compares two affinity edges */
+/* > 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;
+ if (e2->weight == e1->weight) {
+ if (e2->src->node_idx == e1->src->node_idx)
+ return QSORT_CMP(e2->tgt->node_idx, e1->tgt->node_idx);
+ else
+ return QSORT_CMP(e2->src->node_idx, e1->src->node_idx);
+ }
/* sort in descending order */
- return QSORT_CMP(e2, e1);
+ return QSORT_CMP(e2->weight, e1->weight);
}
/* compares to color-cost pairs */
bitset_set(c->nodes, get_irn_idx(node->irn));
}
-
/**
* In case there is no phase information for irn, initialize it.
*/
co_mst_env_t *env = ph->priv;
if (res != old) {
- void *neigh_it = be_ifg_neighbours_iter_alloca(env->ifg);
const arch_register_req_t *req;
- ir_node *m;
-
- res->irn = irn;
- 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;
+ void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ ir_node *neigh;
+ unsigned len;
+
+ res->irn = irn;
+ res->chunk = new_aff_chunk(env);
+ res->fixed = 0;
+ res->tmp_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(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));
+ DB((env->dbg, LEVEL_4, "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);
/* exclude global ignore registers as well */
bitset_andnot(res->adm_colors, env->ignore_regs);
- /* calculate the number of interfering neighbours */
- be_ifg_foreach_neighbour(env->ifg, neigh_it, irn, m) {
- if (! arch_irn_is(env->aenv, m, ignore))
- res->int_neigh++;
- }
-
+ /* 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;
+ /* count them first as an obstack array cannot be extended */
+ be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh)
+ len++;
+ res->int_neighs = NEW_ARR_D(ir_node *, phase_obst(ph), len);
+ len = 0;
+ be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh)
+ res->int_neighs[len++] = neigh;
}
-
return res;
}
* Check if affinity chunk @p chunk interferes with node @p irn.
*/
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;
+ co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ ir_node *neigh;
+ int i;
- be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
+ for (i = 0; i < ARR_LEN(node->int_neighs); ++i) {
+ neigh = node->int_neighs[i];
if (! arch_irn_is(env->aenv, neigh, ignore) && bitset_is_set(chunk->nodes, get_irn_idx(neigh)))
return 1;
}
if (c1 == c2)
return 0;
- /* check if there is a node in c2 having an interfering neighbour in c1 */
+ /* check if there is a node in c2 having an interfering neighbor in c1 */
bitset_foreach(c2->nodes, idx) {
ir_node *n = get_idx_irn(env->co->irg, idx);
* are no interference edges from c1 to c2).
* @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) {
- 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) {
+static int aff_chunk_absorb(co_mst_env_t *env, aff_chunk_t *c1, aff_chunk_t *c2) {
+ DB((env->dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1->id));
+ DBG_AFF_CHUNK(env, LEVEL_4, c1);
+ DB((env->dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2->id));
+ DBG_AFF_CHUNK(env, LEVEL_4, c2);
+ DB((env->dbg, LEVEL_4, "\n"));
+
+ if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
int idx;
bitset_or(c1->nodes, c2->nodes);
mn->chunk = c1;
}
- DB((env->dbg, LEVEL_1, " ... absorbed, c2 deleted\n"));
+ DB((env->dbg, LEVEL_4, " ... absorbed, c2 deleted\n"));
delete_aff_chunk(env, c2);
return 1;
}
- DB((env->dbg, LEVEL_1, " ... c1 interferes with c2, skipped\n"));
+ DB((env->dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n"));
return 0;
}
}
}
+/**
+ * Count the number of interfering affinity neighbours
+ */
+static int count_interfering_aff_neighs(co_mst_env_t *env, affinity_node_t *an) {
+ neighb_t *neigh;
+ ir_node *irn = an->irn;
+ co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ int res = 0;
+
+ co_gs_foreach_neighb(an, neigh) {
+ ir_node *n = neigh->irn;
+ int i;
+
+ /* skip ignore nodes */
+ if (arch_irn_is(env->aenv, n, ignore))
+ continue;
+
+ /* check if the affinity neighbour interfere */
+ for (i = 0; i < ARR_LEN(node->int_neighs); ++i) {
+ if (node->int_neighs[i] == n) {
+ ++res;
+ break;
+ }
+ }
+ }
+ return res;
+}
+
+
/**
* Build chunks of nodes connected by affinity edges.
* We start at the heaviest affinity edge.
void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0);
ir_node *n;
- int i;
+ int i, len;
aff_chunk_t *curr_chunk;
pset_new_iterator_t iter;
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);
+ if (n1->int_aff_neigh < 0)
+ n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
+ co_gs_foreach_neighb(an, neigh) {
+ ir_node *m = neigh->irn;
+ int m_idx = get_irn_idx(m);
/* record the edge in only one direction */
if (n_idx < m_idx) {
- aff_edge_t edge;
+ co_mst_irn_t *n2;
+ aff_edge_t edge;
+
+ /* skip ignore nodes */
+ if (arch_irn_is(env->aenv, m, ignore))
+ continue;
- edge.src = n;
- edge.tgt = m;
- edge.weight = (double)neigh->costs / (double)(1 + n1->int_neigh + n2->int_neigh);
+ edge.src = n;
+ edge.tgt = m;
+
+ n2 = get_co_mst_irn(env, m);
+ if (n2->int_aff_neigh < 0) {
+ affinity_node_t *am = get_affinity_info(env->co, m);
+ n2->int_aff_neigh = count_interfering_aff_neighs(env, am);
+ }
+ edge.weight = (double)neigh->costs / (double)(1 + n1->int_aff_neigh + n2->int_aff_neigh);
ARR_APP1(aff_edge_t, edges, edge);
}
}
}
/* 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) {
+ len = ARR_LEN(edges);
+ qsort(edges, len, sizeof(edges[0]), cmp_aff_edge);
+ for (i = 0; i < len; ++i) {
aff_chunk_t *c1 = get_aff_chunk(env, edges[i].src);
aff_chunk_t *c2 = get_aff_chunk(env, edges[i].tgt);
+ DBG((env->dbg, LEVEL_1, "edge (%u,%u) %f\n", edges[i].src->node_idx, edges[i].tgt->node_idx, edges[i].weight));
+
(void)aff_chunk_absorb(env, c1, c2);
}
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((env->dbg, LEVEL_1, "entry #%d", curr_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
- DB((env->dbg, LEVEL_1, "\n\tinto priority queue\n"));
+ DBG((env->dbg, LEVEL_1, "\n"));
+
pqueue_put(env->chunks, curr_chunk, curr_chunk->weight);
}
* 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) {
- affinity_node_t *an = get_affinity_info(env->co, node->irn);
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ affinity_node_t *an = get_affinity_info(env->co, node->irn);
neighb_t *aff_neigh;
- ir_node *int_neigh;
- int idx;
+ int idx, i;
col_cost_init(env, costs, 0.0);
}
/* calculate (positive) costs for interfering neighbours */
- be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, int_neigh) {
+ for (i = 0; i < ARR_LEN(node->int_neighs); ++i) {
co_mst_irn_t *neigh;
int col, col_cnt;
+ ir_node *int_neigh;
+
+ int_neigh = node->int_neighs[i];
/* skip ignore nodes */
if (arch_irn_is(env->aenv, int_neigh, ignore))
static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, waitq *changed_ones) {
int i;
waitq *local_changed = new_waitq();
+ waitq *tmp = 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;
- int neigh_ok = 1;
- ir_node *neigh;
+ int tgt_col = costs[i].col;
+ int neigh_ok = 1;
+ int j;
/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
if (costs[i].cost == COL_COST_INFEASIBLE) {
node->tmp_fixed = 0;
del_waitq(local_changed);
+ del_waitq(tmp);
return 0;
}
waitq_put(local_changed, node);
/* try to color all interfering neighbours with current color forbidden */
- be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, neigh) {
+ for (j = 0; j < ARR_LEN(node->int_neighs); ++j) {
co_mst_irn_t *nn;
+ ir_node *neigh;
+
+ neigh = node->int_neighs[j];
/* skip ignore nodes */
if (arch_irn_is(env->aenv, neigh, ignore))
we bail out and try the next color.
*/
if (get_mst_irn_col(nn) == tgt_col) {
- waitq *tmp = new_waitq();
-
/* try to color neighbour with tgt_col forbidden */
neigh_ok = change_node_color_excluded(env, nn, tgt_col, tmp);
/* join lists of changed nodes */
while (! waitq_empty(tmp))
waitq_put(local_changed, waitq_get(tmp));
- del_waitq(tmp);
if (! neigh_ok)
break;
while (! waitq_empty(local_changed))
waitq_put(changed_ones, waitq_get(local_changed));
del_waitq(local_changed);
+ del_waitq(tmp);
return 1;
}
else {
}
del_waitq(local_changed);
+ del_waitq(tmp);
return 0;
}
/* 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));
+ DBG((env->dbg, LEVEL_4, "\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;
col_cost_init_single(env, costs, tgt_col);
- DBG((env->dbg, LEVEL_1, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
+ DBG((env->dbg, LEVEL_4, "\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"));
+ DBG((env->dbg, LEVEL_4, "\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 (firm_dbg_get_mask(env->dbg) & LEVEL_4) {
if (node->fixed || node->tmp_fixed)
- DBG((env->dbg, LEVEL_1, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
+ DB((env->dbg, LEVEL_4, "\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));
+ DB((env->dbg, LEVEL_4, "\t\tCNC: color %d not admissible for %+F (", tgt_col, node->irn));
dbg_admissible_colors(env, node);
- DB((env->dbg, LEVEL_1, ")\n"));
+ DB((env->dbg, LEVEL_4, ")\n"));
}
}
)
bitset_t *visited;
int col, idx;
+ DB((env->dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+ DBG_AFF_CHUNK(env, LEVEL_2, c);
+ DB((env->dbg, LEVEL_2, "\n"));
+
+
/* check which color is the "best" for the given chunk */
for (col = 0; col < env->k; ++col) {
int one_good = 0;
aff_chunk_t *local_best;
- DBG((env->dbg, LEVEL_1, "Trying color %d\n", col));
+ DB((env->dbg, LEVEL_3, "\ttrying color %d\n", col));
/* try to bring all nodes of given chunk to the current color. */
bitset_foreach(c->nodes, 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;
+ DB((env->dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, col));
+ one_good |= change_node_color(env, node, col, changed_ones);
+ DB((env->dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
}
/* try next color when failed */
/* fragment the chunk according to the coloring */
local_best = fragment_chunk(env, col, c, tmp_chunks);
- /* check if the local best is global best */
+ /* search the best of the good list
+ and make it the new best if it is better than the current */
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);
+ DB((env->dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
+ DBG_AFF_CHUNK(env, LEVEL_4, local_best);
if (! best_chunk || best_chunk->weight < local_best->weight) {
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"));
+ DB((env->dbg, LEVEL_4, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+ } else {
+ DB((env->dbg, LEVEL_4, "\n\t\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"));
+ DB((env->dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
+ DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
+ DB((env->dbg, LEVEL_2, "using color %d\n", best_color));
/* get the best fragment from the best list and color it */
bitset_foreach(best_chunk->nodes, idx) {
int res;
res = change_node_color(env, node, best_color, changed_ones);
- assert(res && "Coloring failed");
+ assert(res && "color manifesting failed");
node->fixed = 1;
node->chunk = best_chunk;
}
}
/* clear obsolete chunks and free some memory */
- delete_aff_chunk(env, c);
delete_aff_chunk(env, best_chunk);
bitset_free(visited);
del_waitq(changed_ones);
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);
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));
+ DB((mst_env.dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
+ delete_aff_chunk(&mst_env, chunk);
}
/* apply coloring */
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));
+ DB((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