* @brief Copy minimization driver.
* @author Daniel Grund
* @date 12.04.2005
- * @version $Id$
*
* Main file for the optimization reducing the copies needed for:
* - Phi coalescing
*/
#include "config.h"
-#include "execfreq.h"
-#include "xmalloc.h"
#include "debug.h"
-#include "pmap.h"
-#include "raw_bitset.h"
-#include "irnode.h"
+#include "error.h"
+#include "execfreq_t.h"
+#include "irdump_t.h"
+#include "iredges_t.h"
#include "irgraph.h"
#include "irgwalk.h"
-#include "irprog.h"
#include "irloop_t.h"
-#include "iredges_t.h"
-#include "irbitset.h"
-#include "irprintf_t.h"
+#include "irnode.h"
+#include "irprintf.h"
+#include "irprog.h"
#include "irtools.h"
+#include "pmap.h"
+#include "raw_bitset.h"
#include "util.h"
+#include "xmalloc.h"
-#include "bemodule.h"
#include "bearch.h"
-#include "benode.h"
-#include "beutil.h"
-#include "beifg.h"
-#include "beintlive_t.h"
#include "becopyopt_t.h"
#include "becopystat.h"
-#include "belive_t.h"
+#include "bedump.h"
+#include "beifg.h"
#include "beinsn_t.h"
-#include "besched.h"
-#include "bestatevent.h"
+#include "beintlive_t.h"
#include "beirg.h"
-#include "error.h"
+#include "belive_t.h"
+#include "bemodule.h"
+#include "benode.h"
+#include "besched.h"
+#include "statev_t.h"
+#include "beutil.h"
#include "lc_opts.h"
#include "lc_opts_enum.h"
#define COST_FUNC_LOOP 2
#define COST_FUNC_ALL_ONE 3
+/**
+ * Flags for dumping the IFG.
+ */
+enum {
+ CO_IFG_DUMP_COLORS = 1 << 0, /**< Dump the graph colored. */
+ CO_IFG_DUMP_LABELS = 1 << 1, /**< Dump node/edge labels. */
+ CO_IFG_DUMP_SHAPE = 1 << 2, /**< Give constrained nodes special shapes. */
+ CO_IFG_DUMP_CONSTR = 1 << 3, /**< Dump the node constraints in the label. */
+};
+
+static int co_get_costs_loop_depth(const ir_node *root, int pos);
+static int co_get_costs_exec_freq(const ir_node *root, int pos);
+static int co_get_costs_all_one(const ir_node *root, int pos);
+
static unsigned dump_flags = 0;
-static unsigned style_flags = 0;
+static unsigned style_flags = CO_IFG_DUMP_COLORS;
static int do_stats = 0;
static cost_fct_t cost_func = co_get_costs_exec_freq;
static int improve = 1;
};
typedef int (*opt_funcptr)(void);
-
static const lc_opt_enum_func_ptr_items_t cost_func_items[] = {
{ "freq", (opt_funcptr) co_get_costs_exec_freq },
{ "loop", (opt_funcptr) co_get_costs_loop_depth },
*/
static int co_is_optimizable_root(ir_node *irn)
{
- const arch_register_req_t *req;
-
- if (arch_irn_is_ignore(irn))
+ arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+ if (arch_register_req_is(req, ignore))
return 0;
if (is_Reg_Phi(irn) || is_Perm_Proj(irn))
return 1;
- req = arch_get_irn_register_req(irn);
- if (is_2addr_code(req))
+ if (arch_register_req_is(req, should_be_same))
return 1;
return 0;
}
-int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos)
+/**
+ * Computes the costs of a copy according to loop depth
+ * @param pos the argument position of arg in the root arguments
+ * @return Must be >= 0 in all cases.
+ */
+static int co_get_costs_loop_depth(const ir_node *root, int pos)
{
- int cost = 0;
+ ir_node *block = get_nodes_block(root);
ir_loop *loop;
- ir_node *root_block = get_nodes_block(root);
- (void) co;
- (void) arg;
+ int cost;
if (is_Phi(root)) {
- /* for phis the copies are placed in the corresponding pred-block */
- loop = get_irn_loop(get_Block_cfgpred_block(root_block, pos));
- } else {
- /* a perm places the copy in the same block as it resides */
- loop = get_irn_loop(root_block);
+ block = get_Block_cfgpred_block(block, pos);
}
+ loop = get_irn_loop(block);
if (loop) {
int d = get_loop_depth(loop);
cost = d*d;
+ } else {
+ cost = 0;
}
return 1+cost;
}
-int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos)
+static ir_execfreq_int_factors factors;
+
+/**
+ * Computes the costs of a copy according to execution frequency
+ * @param pos the argument position of arg in the root arguments
+ * @return Must be >= 0 in all cases.
+ */
+static int co_get_costs_exec_freq(const ir_node *root, int pos)
{
- int res;
ir_node *root_bl = get_nodes_block(root);
- ir_node *copy_bl = is_Phi(root) ? get_Block_cfgpred_block(root_bl, pos) : root_bl;
- ir_exec_freq *exec_freq = be_get_irg_exec_freq(co->cenv->irg);
- (void) arg;
- res = get_block_execfreq_ulong(exec_freq, copy_bl);
+ ir_node *copy_bl
+ = is_Phi(root) ? get_Block_cfgpred_block(root_bl, pos) : root_bl;
+ int res = get_block_execfreq_int(&factors, copy_bl);
/* don't allow values smaller than one. */
return res < 1 ? 1 : res;
}
-
-int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos)
+/**
+ * All costs equal 1. Using this will reduce the _number_ of copies.
+ * @param co The copy opt object.
+ * @return Must be >= 0 in all cases.
+ */
+static int co_get_costs_all_one(const ir_node *root, int pos)
{
- (void) co;
(void) root;
- (void) arg;
(void) pos;
return 1;
}
ir_node **safe, **unsafe;
int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
bitset_t *curr;
- size_t pos;
int curr_weight, best_weight = 0;
/* assign the nodes into two groups.
if (arg == irn)
continue;
if (nodes_interfere(co->cenv, irn, arg)) {
- unit->inevitable_costs += co->get_costs(co, irn, arg, i);
+ unit->inevitable_costs += co->get_costs(irn, i);
continue;
}
if (!arg_pos) { /* a new argument */
/* insert node, set costs */
unit->nodes[unit->node_count] = arg;
- unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
+ unit->costs[unit->node_count] = co->get_costs(irn, i);
unit->node_count++;
} else { /* arg has occurred before in same phi */
/* increase costs for existing arg */
- unit->costs[arg_pos] += co->get_costs(co, irn, arg, i);
+ unit->costs[arg_pos] += co->get_costs(irn, i);
}
}
unit->nodes = XREALLOC(unit->nodes, ir_node*, unit->node_count);
unit->node_count = 2;
unit->nodes[0] = irn;
unit->nodes[1] = get_Perm_src(irn);
- unit->costs[1] = co->get_costs(co, irn, unit->nodes[1], -1);
- } else {
+ unit->costs[1] = co->get_costs(irn, -1);
+ } else if (arch_register_req_is(req, should_be_same)) {
/* Src == Tgt of a 2-addr-code instruction */
- if (is_2addr_code(req)) {
- const unsigned other = req->other_same;
- int count = 0;
- int i;
+ const unsigned other = req->other_same;
+ int count = 0;
+ int i;
+
+ for (i = 0; (1U << i) <= other; ++i) {
+ if (other & (1U << i)) {
+ ir_node *o = get_irn_n(skip_Proj(irn), i);
+ if (arch_irn_is_ignore(o))
+ continue;
+ if (nodes_interfere(co->cenv, irn, o))
+ continue;
+ ++count;
+ }
+ }
+
+ if (count != 0) {
+ int k = 0;
+ ++count;
+ unit->nodes = XMALLOCN(ir_node*, count);
+ unit->costs = XMALLOCN(int, count);
+ unit->node_count = count;
+ unit->nodes[k++] = irn;
- for (i = 0; (1U << i) <= other; ++i) {
+ for (i = 0; 1U << i <= other; ++i) {
if (other & (1U << i)) {
ir_node *o = get_irn_n(skip_Proj(irn), i);
- if (arch_irn_is_ignore(o))
- continue;
- if (nodes_interfere(co->cenv, irn, o))
- continue;
- ++count;
- }
- }
-
- if (count != 0) {
- int k = 0;
- ++count;
- unit->nodes = XMALLOCN(ir_node*, count);
- unit->costs = XMALLOCN(int, count);
- unit->node_count = count;
- unit->nodes[k++] = irn;
-
- for (i = 0; 1U << i <= other; ++i) {
- if (other & (1U << i)) {
- ir_node *o = get_irn_n(skip_Proj(irn), i);
- if (!arch_irn_is_ignore(o) &&
- !nodes_interfere(co->cenv, irn, o)) {
- unit->nodes[k] = o;
- unit->costs[k] = co->get_costs(co, irn, o, -1);
- ++k;
- }
+ if (!arch_irn_is_ignore(o) &&
+ !nodes_interfere(co->cenv, irn, o)) {
+ unit->nodes[k] = o;
+ unit->costs[k] = co->get_costs(irn, -1);
+ ++k;
}
}
}
- } else {
- assert(0 && "This is not an optimizable node!");
}
+ } else {
+ assert(0 && "This is not an optimizable node!");
}
/* Insert the new unit at a position according to its costs */
static void co_sort_units(copy_opt_t *co)
{
int i, count = 0, costs;
- unit_t *ou, **ous;
+ unit_t **ous;
/* get the number of ous, remove them form the list and fill the array */
list_for_each_entry(unit_t, ou, &co->units, units)
void co_free_ou_structure(copy_opt_t *co)
{
- unit_t *curr, *tmp;
ASSERT_OU_AVAIL(co);
list_for_each_entry_safe(unit_t, curr, tmp, &co->units, units) {
xfree(curr->nodes);
int co_get_max_copy_costs(const copy_opt_t *co)
{
int i, res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_inevit_copy_costs(const copy_opt_t *co)
{
int res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_copy_costs(const copy_opt_t *co)
{
int i, res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_lower_bound(const copy_opt_t *co)
{
int res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
{
- bitset_t *seen = bitset_irg_malloc(co->irg);
- affinity_node_t *an;
+ bitset_t *seen = bitset_malloc(get_irg_last_idx(co->irg));
memset(stat, 0, sizeof(stat[0]));
/* count affinity edges. */
co_gs_foreach_aff_node(co, an) {
- neighb_t *neigh;
stat->aff_nodes += 1;
- bitset_add_irn(seen, an->irn);
+ bitset_set(seen, get_irn_idx(an->irn));
co_gs_foreach_neighb(an, neigh) {
- if (!bitset_contains_irn(seen, neigh->irn)) {
+ if (!bitset_is_set(seen, get_irn_idx(neigh->irn))) {
stat->aff_edges += 1;
stat->max_costs += neigh->costs;
new_node.irn = n1;
new_node.degree = 0;
new_node.neighbours = NULL;
- node = (affinity_node_t*)set_insert(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
+ node = set_insert(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
for (nbr = node->neighbours; nbr; nbr = nbr->next)
if (nbr->irn == n2) {
if (get_irn_mode(irn) == mode_T)
return;
req = arch_get_irn_register_req(irn);
- if (req->cls != co->cls || arch_irn_is_ignore(irn))
+ if (req->cls != co->cls || arch_register_req_is(req, ignore))
return;
if (is_Reg_Phi(irn)) { /* Phis */
for (pos=0, max=get_irn_arity(irn); pos<max; ++pos) {
ir_node *arg = get_irn_n(irn, pos);
- add_edges(co, irn, arg, co->get_costs(co, irn, arg, pos));
+ add_edges(co, irn, arg, co->get_costs(irn, pos));
}
} else if (is_Perm_Proj(irn)) { /* Perms */
ir_node *arg = get_Perm_src(irn);
- add_edges(co, irn, arg, co->get_costs(co, irn, arg, 0));
- } else { /* 2-address code */
- if (is_2addr_code(req)) {
- const unsigned other = req->other_same;
- int i;
+ add_edges(co, irn, arg, co->get_costs(irn, -1));
+ } else if (arch_register_req_is(req, should_be_same)) {
+ const unsigned other = req->other_same;
+ int i;
- for (i = 0; 1U << i <= other; ++i) {
- if (other & (1U << i)) {
- ir_node *other = get_irn_n(skip_Proj(irn), i);
- if (!arch_irn_is_ignore(other))
- add_edges(co, irn, other, co->get_costs(co, irn, other, 0));
- }
+ for (i = 0; 1U << i <= other; ++i) {
+ if (other & (1U << i)) {
+ ir_node *other = get_irn_n(skip_Proj(irn), i);
+ if (!arch_irn_is_ignore(other))
+ add_edges(co, irn, other, co->get_costs(irn, -1));
}
}
}
ASSERT_GS_AVAIL(co);
new_node.irn = irn;
- n = (affinity_node_t*)set_find(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
+ n = set_find(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
if (n) {
return (n->degree > 0);
} else
return !bitset_intersect(constr[0], constr[1]);
}
-void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
+/**
+ * Dump the interference graph according to the Appel/George coalescing contest file format.
+ * See: http://www.cs.princeton.edu/~appel/coalesce/format.html
+ * @note Requires graph structure.
+ * @param co The copy opt object.
+ * @param f A file to dump to.
+ */
+static void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
{
be_ifg_t *ifg = co->cenv->ifg;
int *color_map = ALLOCAN(int, co->cls->n_regs);
fprintf(f, "%d %d\n", n, n_regs);
be_ifg_foreach_node(ifg, &it, irn) {
- if (!arch_irn_is_ignore(irn)) {
- int idx = node_map[get_irn_idx(irn)];
- affinity_node_t *a = get_affinity_info(co, irn);
- const arch_register_req_t *req = arch_get_irn_register_req(irn);
- ir_node *adj;
-
- if (arch_register_req_is(req, limited)) {
- for (i = 0; i < co->cls->n_regs; ++i) {
- if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
- fprintf(f, "%d %d -1\n", color_map[i], idx);
- }
- }
-
- be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
- if (!arch_irn_is_ignore(adj) &&
- !co_dump_appel_disjoint_constraints(co, irn, adj)) {
- int adj_idx = node_map[get_irn_idx(adj)];
- if (idx < adj_idx)
- fprintf(f, "%d %d -1\n", idx, adj_idx);
- }
- }
+ arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+ if (arch_register_req_is(req, ignore))
+ continue;
- if (a) {
- neighb_t *n;
+ int idx = node_map[get_irn_idx(irn)];
+ affinity_node_t *a = get_affinity_info(co, irn);
+ ir_node *adj;
- co_gs_foreach_neighb(a, n) {
- if (!arch_irn_is_ignore(n->irn)) {
- int n_idx = node_map[get_irn_idx(n->irn)];
- if (idx < n_idx)
- fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
- }
- }
+ if (arch_register_req_is(req, limited)) {
+ for (i = 0; i < co->cls->n_regs; ++i) {
+ if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
+ fprintf(f, "%d %d -1\n", color_map[i], idx);
}
}
- }
-
- xfree(node_map);
-}
-
-/*
- ___ _____ ____ ____ ___ _____ ____ _
- |_ _| ___/ ___| | _ \ / _ \_ _| | _ \ _ _ _ __ ___ _ __ (_)_ __ __ _
- | || |_ | | _ | | | | | | || | | | | | | | | '_ ` _ \| '_ \| | '_ \ / _` |
- | || _|| |_| | | |_| | |_| || | | |_| | |_| | | | | | | |_) | | | | | (_| |
- |___|_| \____| |____/ \___/ |_| |____/ \__,_|_| |_| |_| .__/|_|_| |_|\__, |
- |_| |___/
-*/
-
-static const char *get_dot_color_name(size_t col)
-{
- static const char *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";
-}
-
-typedef struct co_ifg_dump_t {
- const copy_opt_t *co;
- unsigned flags;
-} co_ifg_dump_t;
-
-static void ifg_dump_graph_attr(FILE *f, void *self)
-{
- (void) self;
- fprintf(f, "overlap=scale");
-}
-
-static int ifg_is_dump_node(void *self, ir_node *irn)
-{
- (void)self;
- return !arch_irn_is_ignore(irn);
-}
-static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn)
-{
- co_ifg_dump_t *env = (co_ifg_dump_t*)self;
- const arch_register_t *reg = arch_get_irn_register(irn);
- const arch_register_req_t *req = arch_get_irn_register_req(irn);
- int limited = arch_register_req_is(req, limited);
-
- if (env->flags & CO_IFG_DUMP_LABELS) {
- ir_fprintf(f, "label=\"%+F", irn);
-
- if ((env->flags & CO_IFG_DUMP_CONSTR) && limited) {
- bitset_t *bs = bitset_alloca(env->co->cls->n_regs);
- rbitset_copy_to_bitset(req->limited, bs);
- ir_fprintf(f, "\\n%B", bs);
+ be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
+ if (!arch_irn_is_ignore(adj) &&
+ !co_dump_appel_disjoint_constraints(co, irn, adj)) {
+ int adj_idx = node_map[get_irn_idx(adj)];
+ if (idx < adj_idx)
+ fprintf(f, "%d %d -1\n", idx, adj_idx);
+ }
}
- ir_fprintf(f, "\" ");
- } else {
- fprintf(f, "label=\"\" shape=point " );
- }
- if (env->flags & CO_IFG_DUMP_SHAPE)
- fprintf(f, "shape=%s ", limited ? "diamond" : "ellipse");
-
- if (env->flags & CO_IFG_DUMP_COLORS)
- fprintf(f, "style=filled color=%s ", get_dot_color_name(reg->index));
-}
-
-static void ifg_dump_at_end(FILE *file, void *self)
-{
- co_ifg_dump_t *env = (co_ifg_dump_t*)self;
- affinity_node_t *a;
-
- co_gs_foreach_aff_node(env->co, a) {
- const arch_register_t *ar = arch_get_irn_register(a->irn);
- unsigned aidx = get_irn_idx(a->irn);
- neighb_t *n;
-
- co_gs_foreach_neighb(a, n) {
- const arch_register_t *nr = arch_get_irn_register(n->irn);
- unsigned nidx = get_irn_idx(n->irn);
-
- if (aidx < nidx) {
- const char *color = nr == ar ? "blue" : "red";
- fprintf(file, "\tn%u -- n%u [weight=0.01 ", aidx, nidx);
- if (env->flags & CO_IFG_DUMP_LABELS)
- fprintf(file, "label=\"%d\" ", n->costs);
- if (env->flags & CO_IFG_DUMP_COLORS)
- fprintf(file, "color=%s ", color);
- else
- fprintf(file, "style=dotted");
- fprintf(file, "];\n");
+ if (a) {
+ co_gs_foreach_neighb(a, n) {
+ if (!arch_irn_is_ignore(n->irn)) {
+ int n_idx = node_map[get_irn_idx(n->irn)];
+ if (idx < n_idx)
+ fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
+ }
}
}
}
-}
-
-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
-};
-
-
-
-void co_dump_ifg_dot(const copy_opt_t *co, FILE *f, unsigned flags)
-{
- co_ifg_dump_t cod;
-
- cod.co = co;
- cod.flags = flags;
- be_ifg_dump_dot(co->cenv->ifg, co->irg, f, &ifg_dot_cb, &cod);
-}
-
-
-void co_solve_park_moon(copy_opt_t *opt)
-{
- (void) opt;
+ xfree(node_map);
}
-/*
- __ __ _ ____ _
- | \/ | __ _(_)_ __ | _ \ _ __(_)_ _____ _ __
- | |\/| |/ _` | | '_ \ | | | | '__| \ \ / / _ \ '__|
- | | | | (_| | | | | | | |_| | | | |\ V / __/ |
- |_| |_|\__,_|_|_| |_| |____/|_| |_| \_/ \___|_|
-
-*/
-
-static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char *suffix)
+static FILE *my_open(const be_chordal_env_t *env, const char *prefix,
+ const char *suffix)
{
FILE *result;
char buf[1024];
if (selected_copyopt->copyopt == void_algo)
return;
- be_liveness_assure_chk(be_get_irg_liveness(cenv->irg));
+ be_assure_live_chk(cenv->irg);
co = new_copy_opt(cenv, cost_func);
co_build_ou_structure(co);
co_complete_stats(co, &before);
- be_stat_ev_ull("co_aff_nodes", before.aff_nodes);
- be_stat_ev_ull("co_aff_edges", before.aff_edges);
- be_stat_ev_ull("co_max_costs", before.max_costs);
- be_stat_ev_ull("co_inevit_costs", before.inevit_costs);
- be_stat_ev_ull("co_aff_int", before.aff_int);
+ stat_ev_ull("co_aff_nodes", before.aff_nodes);
+ stat_ev_ull("co_aff_edges", before.aff_edges);
+ stat_ev_ull("co_max_costs", before.max_costs);
+ stat_ev_ull("co_inevit_costs", before.inevit_costs);
+ stat_ev_ull("co_aff_int", before.aff_int);
- be_stat_ev_ull("co_init_costs", before.costs);
- be_stat_ev_ull("co_init_unsat", before.unsatisfied_edges);
+ stat_ev_ull("co_init_costs", before.costs);
+ stat_ev_ull("co_init_unsat", before.unsatisfied_edges);
if (dump_flags & DUMP_BEFORE) {
- FILE *f = my_open(cenv, "", "-before.dot");
- co_dump_ifg_dot(co, f, style_flags);
+ FILE *f = my_open(cenv, "", "-before.vcg");
+ be_dump_ifg_co(f, co, style_flags & CO_IFG_DUMP_LABELS, style_flags & CO_IFG_DUMP_COLORS);
fclose(f);
}
/* do the stats and provide the current costs */
co_complete_stats(co, &stats);
- be_stat_ev_ull("co_prepare_costs", stats.costs);
+ stat_ev_ull("co_prepare_costs", stats.costs);
}
/* perform actual copy minimization */
was_optimal = selected_copyopt->copyopt(co);
ir_timer_stop(timer);
- be_stat_ev("co_time", ir_timer_elapsed_msec(timer));
- be_stat_ev_ull("co_optimal", was_optimal);
+ stat_ev_dbl("co_time", ir_timer_elapsed_msec(timer));
+ stat_ev_ull("co_optimal", was_optimal);
ir_timer_free(timer);
if (dump_flags & DUMP_AFTER) {
- FILE *f = my_open(cenv, "", "-after.dot");
- co_dump_ifg_dot(co, f, style_flags);
+ FILE *f = my_open(cenv, "", "-after.vcg");
+ be_dump_ifg_co(f, co, style_flags & CO_IFG_DUMP_LABELS, style_flags & CO_IFG_DUMP_COLORS);
fclose(f);
}
co_complete_stats(co, &after);
if (do_stats) {
- ulong64 optimizable_costs = after.max_costs - after.inevit_costs;
- ulong64 evitable = after.costs - after.inevit_costs;
+ unsigned long long optimizable_costs = after.max_costs - after.inevit_costs;
+ unsigned long long evitable = after.costs - after.inevit_costs;
ir_printf("%30F ", cenv->irg);
- printf("%10s %10" ULL_FMT "%10" ULL_FMT "%10" ULL_FMT, cenv->cls->name, after.max_costs, before.costs, after.inevit_costs);
+ printf("%10s %10llu%10llu%10llu", cenv->cls->name, after.max_costs, before.costs, after.inevit_costs);
if (optimizable_costs > 0)
- printf("%10" ULL_FMT " %5.2f\n", after.costs, (evitable * 100.0) / optimizable_costs);
+ printf("%10llu %5.2f\n", after.costs, (evitable * 100.0) / optimizable_costs);
else
- printf("%10" ULL_FMT " %5s\n", after.costs, "-");
+ printf("%10llu %5s\n", after.costs, "-");
}
/* Dump the interference graph in Appel's format. */
fclose(f);
}
- be_stat_ev_ull("co_after_costs", after.costs);
- be_stat_ev_ull("co_after_unsat", after.unsatisfied_edges);
+ stat_ev_ull("co_after_costs", after.costs);
+ stat_ev_ull("co_after_unsat", after.unsatisfied_edges);
co_free_graph_structure(co);
co_free_ou_structure(co);
projects / libfirm / blobdiff