X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyopt.c;h=930233ee35e3d2ddf03c2232941dbd5f70bdb98a;hb=fe36fbcb66909a979e16111b8dc8cee19088fede;hp=6cf88f7f1c64e867cc527bba9e62792044609758;hpb=04a44481131aeef9e6c67b26a9e76557e6873082;p=libfirm

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index 6cf88f7f1..930233ee3 100644
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -48,7 +48,7 @@
 
 #include "bemodule.h"
 #include "bearch.h"
-#include "benode_t.h"
+#include "benode.h"
 #include "beutil.h"
 #include "beifg_t.h"
 #include "beintlive_t.h"
@@ -77,7 +77,6 @@ static unsigned   dump_flags  = 0;
 static unsigned   style_flags = 0;
 static unsigned   do_stats    = 0;
 static cost_fct_t cost_func   = co_get_costs_exec_freq;
-static unsigned   algo        = CO_ALGO_HEUR4;
 static int        improve     = 1;
 
 static const lc_opt_enum_mask_items_t dump_items[] = {
@@ -97,17 +96,6 @@ static const lc_opt_enum_mask_items_t style_items[] = {
 	{ NULL,      0 }
 };
 
-static const lc_opt_enum_mask_items_t algo_items[] = {
-	{ "none",   CO_ALGO_NONE  },
-	{ "heur",   CO_ALGO_HEUR  },
-	{ "heur2",  CO_ALGO_HEUR2 },
-	{ "heur3",  CO_ALGO_HEUR3 },
-	{ "heur4",  CO_ALGO_HEUR4 },
-	{ "ilp",    CO_ALGO_ILP   },
-	{ "pbqp",   CO_ALGO_PBQP  },
-	{ NULL,     0 }
-};
-
 typedef int (*opt_funcptr)(void);
 
 static const lc_opt_enum_func_ptr_items_t cost_func_items[] = {
@@ -125,30 +113,30 @@ static lc_opt_enum_mask_var_t style_var = {
 	&style_flags, style_items
 };
 
-static lc_opt_enum_mask_var_t algo_var = {
-	&algo, algo_items
-};
-
 static lc_opt_enum_func_ptr_var_t cost_func_var = {
 	(opt_funcptr*) &cost_func, cost_func_items
 };
 
 static const lc_opt_table_entry_t options[] = {
-	LC_OPT_ENT_ENUM_INT      ("algo",    "select copy optimization algo",                           &algo_var),
 	LC_OPT_ENT_ENUM_FUNC_PTR ("cost",    "select a cost function",                                  &cost_func_var),
 	LC_OPT_ENT_ENUM_MASK     ("dump",    "dump ifg before or after copy optimization",              &dump_var),
 	LC_OPT_ENT_ENUM_MASK     ("style",   "dump style for ifg dumping",                              &style_var),
 	LC_OPT_ENT_BOOL          ("stats",   "dump statistics after each optimization",                 &do_stats),
-	LC_OPT_ENT_BOOL          ("improve", "run heur3 before if algo can exploit start solutions",    &improve),
+	LC_OPT_ENT_BOOL          ("improve", "run heur1 before if algo can exploit start solutions",    &improve),
 	LC_OPT_LAST
 };
 
-/* Insert additional options registration functions here. */
-extern void be_co_ilp_register_options(lc_opt_entry_t *grp);
-extern void be_co2_register_options(lc_opt_entry_t *grp);
-extern void be_co3_register_options(lc_opt_entry_t *grp);
+static be_module_list_entry_t *copyopts = NULL;
+static const co_algo_info *selected_copyopt = NULL;
+
+void be_register_copyopt(const char *name, co_algo_info *copyopt)
+{
+	if (selected_copyopt == NULL)
+		selected_copyopt = copyopt;
+	be_add_module_to_list(&copyopts, name, copyopt);
+}
 
-void be_init_copycoal(void)
+void be_init_copyopt(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");
@@ -156,9 +144,28 @@ void be_init_copycoal(void)
 	lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co");
 
 	lc_opt_add_table(co_grp, options);
+	be_add_module_list_opt(co_grp, "algo", "select copy optimization algo",
+		                       &copyopts, (void**) &selected_copyopt);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyopt);
+
+static int void_algo(copy_opt_t *co)
+{
+	(void) co;
+	return 0;
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copycoal);
+void be_init_copynone(void)
+{
+	static co_algo_info copyheur = {
+		void_algo, 0
+	};
+
+	be_register_copyopt("none", &copyheur);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copynone);
 
 #undef QUICK_AND_DIRTY_HACK
 
@@ -208,7 +215,8 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
 	return co;
 }
 
-void free_copy_opt(copy_opt_t *co) {
+void free_copy_opt(copy_opt_t *co)
+{
 	xfree(co->name);
 	free(co);
 }
@@ -239,7 +247,8 @@ static int co_is_optimizable_root(ir_node *irn)
 	return 0;
 }
 
-int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) {
+int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos)
+{
 	int cost = 0;
 	ir_loop *loop;
 	ir_node *root_block = get_nodes_block(root);
@@ -260,7 +269,8 @@ int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, i
 	return 1+cost;
 }
 
-int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) {
+int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, 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;
@@ -272,7 +282,8 @@ int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, in
 }
 
 
-int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos) {
+int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos)
+{
 	(void) co;
 	(void) root;
 	(void) arg;
@@ -295,7 +306,8 @@ int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int
  * Determines a maximum weighted independent set with respect to
  * the interference and conflict edges of all nodes in a qnode.
  */
-static int ou_max_ind_set_costs(unit_t *ou) {
+static int ou_max_ind_set_costs(unit_t *ou)
+{
 	be_chordal_env_t *chordal_env = ou->co->cenv;
 	ir_node **safe, **unsafe;
 	int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
@@ -313,9 +325,9 @@ static int ou_max_ind_set_costs(unit_t *ou) {
 	unsafe       = ALLOCAN(ir_node*, ou->node_count - 1);
 	unsafe_costs = ALLOCAN(int,      ou->node_count - 1);
 	unsafe_count = 0;
-	for(i=1; i<ou->node_count; ++i) {
+	for (i=1; i<ou->node_count; ++i) {
 		int is_safe = 1;
-		for(o=1; o<ou->node_count; ++o) {
+		for (o=1; o<ou->node_count; ++o) {
 			if (i==o)
 				continue;
 			if (nodes_interfere(chordal_env, ou->nodes[i], ou->nodes[o])) {
@@ -504,7 +516,7 @@ static void co_collect_units(ir_node *irn, void *env)
 		struct list_head *tmp;
 
 		/* Determine the maximum costs this unit can cause: all_nodes_cost */
-		for(i=1; i<unit->node_count; ++i) {
+		for (i=1; i<unit->node_count; ++i) {
 			unit->sort_key = MAX(unit->sort_key, unit->costs[i]);
 			unit->all_nodes_costs += unit->costs[i];
 		}
@@ -523,7 +535,8 @@ static void co_collect_units(ir_node *irn, void *env)
 
 #ifdef QUICK_AND_DIRTY_HACK
 
-static int compare_ous(const void *k1, const void *k2) {
+static int compare_ous(const void *k1, const void *k2)
+{
 	const unit_t *u1 = *((const unit_t **) k1);
 	const unit_t *u2 = *((const unit_t **) k2);
 	int i, o, u1_has_constr, u2_has_constr;
@@ -567,7 +580,8 @@ static int compare_ous(const void *k1, const void *k2) {
 /**
  * Sort the ou's according to constraints and their sort_key
  */
-static void co_sort_units(copy_opt_t *co) {
+static void co_sort_units(copy_opt_t *co)
+{
 	int i, count = 0, costs;
 	unit_t *ou, **ous;
 
@@ -603,7 +617,8 @@ static void co_sort_units(copy_opt_t *co) {
 }
 #endif
 
-void co_build_ou_structure(copy_opt_t *co) {
+void co_build_ou_structure(copy_opt_t *co)
+{
 	DBG((dbg, LEVEL_1, "\tCollecting optimization units\n"));
 	INIT_LIST_HEAD(&co->units);
 	irg_walk_graph(co->irg, co_collect_units, NULL, co);
@@ -612,7 +627,8 @@ void co_build_ou_structure(copy_opt_t *co) {
 #endif
 }
 
-void co_free_ou_structure(copy_opt_t *co) {
+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) {
@@ -625,7 +641,8 @@ void co_free_ou_structure(copy_opt_t *co) {
 
 /* co_solve_heuristic() is implemented in becopyheur.c */
 
-int co_get_max_copy_costs(const copy_opt_t *co) {
+int co_get_max_copy_costs(const copy_opt_t *co)
+{
 	int i, res = 0;
 	unit_t *curr;
 
@@ -639,7 +656,8 @@ int co_get_max_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_inevit_copy_costs(const copy_opt_t *co) {
+int co_get_inevit_copy_costs(const copy_opt_t *co)
+{
 	int res = 0;
 	unit_t *curr;
 
@@ -650,7 +668,8 @@ int co_get_inevit_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_copy_costs(const copy_opt_t *co) {
+int co_get_copy_costs(const copy_opt_t *co)
+{
 	int i, res = 0;
 	unit_t *curr;
 
@@ -671,7 +690,8 @@ int co_get_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_lower_bound(const copy_opt_t *co) {
+int co_get_lower_bound(const copy_opt_t *co)
+{
 	int res = 0;
 	unit_t *curr;
 
@@ -695,7 +715,7 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
 		stat->aff_nodes += 1;
 		bitset_add_irn(seen, an->irn);
 		co_gs_foreach_neighb(an, neigh) {
-			if(!bitset_contains_irn(seen, neigh->irn)) {
+			if (!bitset_contains_irn(seen, neigh->irn)) {
 				stat->aff_edges += 1;
 				stat->max_costs += neigh->costs;
 
@@ -704,7 +724,7 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
 					stat->unsatisfied_edges += 1;
 				}
 
-				if(nodes_interfere(co->cenv, an->irn, neigh->irn)) {
+				if (nodes_interfere(co->cenv, an->irn, neigh->irn)) {
 					stat->aff_int += 1;
 					stat->inevit_costs += neigh->costs;
 				}
@@ -727,7 +747,8 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
                   |_|                                      |___/
  ******************************************************************************/
 
-static int compare_affinity_node_t(const void *k1, const void *k2, size_t size) {
+static int compare_affinity_node_t(const void *k1, const void *k2, size_t size)
+{
 	const affinity_node_t *n1 = k1;
 	const affinity_node_t *n2 = k2;
 	(void) size;
@@ -735,7 +756,8 @@ static int compare_affinity_node_t(const void *k1, const void *k2, size_t size)
 	return (n1->irn != n2->irn);
 }
 
-static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
+static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs)
+{
 	affinity_node_t new_node, *node;
 	neighb_t        *nbr;
 	int             allocnew = 1;
@@ -766,14 +788,16 @@ static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
 	nbr->costs += costs;
 }
 
-static inline void add_edges(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
+static inline void add_edges(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs)
+{
 	if (! be_ifg_connected(co->cenv->ifg, n1, n2)) {
 		add_edge(co, n1, n2, costs);
 		add_edge(co, n2, n1, costs);
 	}
 }
 
-static void build_graph_walker(ir_node *irn, void *env) {
+static void build_graph_walker(ir_node *irn, void *env)
+{
 	const arch_register_req_t *req = arch_get_register_req_out(irn);
 	copy_opt_t                *co  = env;
 	int pos, max;
@@ -810,14 +834,16 @@ static void build_graph_walker(ir_node *irn, void *env) {
 	}
 }
 
-void co_build_graph_structure(copy_opt_t *co) {
+void co_build_graph_structure(copy_opt_t *co)
+{
 	obstack_init(&co->obst);
 	co->nodes = new_set(compare_affinity_node_t, 32);
 
 	irg_walk_graph(co->irg, build_graph_walker, NULL, co);
 }
 
-void co_free_graph_structure(copy_opt_t *co) {
+void co_free_graph_structure(copy_opt_t *co)
+{
 	ASSERT_GS_AVAIL(co);
 
 	del_set(co->nodes);
@@ -827,7 +853,8 @@ void co_free_graph_structure(copy_opt_t *co) {
 
 /* co_solve_ilp1() co_solve_ilp2() are implemented in becopyilpX.c */
 
-int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn) {
+int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn)
+{
 	affinity_node_t new_node, *n;
 
 	ASSERT_GS_AVAIL(co);
@@ -851,7 +878,7 @@ static int co_dump_appel_disjoint_constraints(const copy_opt_t *co, ir_node *a,
 
 	for (j = 0; j < 2; ++j) {
 		const arch_register_req_t *req = arch_get_register_req_out(nodes[j]);
-		if(arch_register_req_is(req, limited))
+		if (arch_register_req_is(req, limited))
 			rbitset_copy_to_bitset(req->limited, constr[j]);
 		else
 			bitset_set_all(constr[j]);
@@ -873,7 +900,7 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 	unsigned i;
 
 	n_regs = 0;
-	for(i = 0; i < co->cls->n_regs; ++i) {
+	for (i = 0; i < co->cls->n_regs; ++i) {
 		const arch_register_t *reg = &co->cls->regs[i];
 		color_map[i] = arch_register_type_is(reg, ignore) ? -1 : n_regs++;
 	}
@@ -902,9 +929,9 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 			const arch_register_req_t *req = arch_get_register_req_out(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)
+			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);
 				}
 			}
@@ -913,18 +940,18 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 				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)
+					if (idx < adj_idx)
 						fprintf(f, "%d %d -1\n", idx, adj_idx);
 				}
 			}
 
-			if(a) {
+			if (a) {
 				neighb_t *n;
 
 				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)
+						if (idx < n_idx)
 							fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
 					}
 				}
@@ -1007,10 +1034,10 @@ static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn)
 	const arch_register_req_t *req     = arch_get_register_req_out(irn);
 	int                        limited = arch_register_req_is(req, limited);
 
-	if(env->flags & CO_IFG_DUMP_LABELS) {
+	if (env->flags & CO_IFG_DUMP_LABELS) {
 		ir_fprintf(f, "label=\"%+F", irn);
 
-		if((env->flags & CO_IFG_DUMP_CONSTR) && limited) {
+		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);
@@ -1020,10 +1047,10 @@ static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn)
 		fprintf(f, "label=\"\" shape=point " );
 	}
 
-	if(env->flags & CO_IFG_DUMP_SHAPE)
+	if (env->flags & CO_IFG_DUMP_SHAPE)
 		fprintf(f, "shape=%s ", limited ? "diamond" : "ellipse");
 
-	if(env->flags & CO_IFG_DUMP_COLORS)
+	if (env->flags & CO_IFG_DUMP_COLORS)
 		fprintf(f, "style=filled color=%s ", get_dot_color_name(reg->index));
 }
 
@@ -1041,12 +1068,12 @@ static void ifg_dump_at_end(FILE *file, void *self)
 			const arch_register_t *nr = arch_get_irn_register(n->irn);
 			unsigned nidx = get_irn_idx(n->irn);
 
-			if(aidx < nidx) {
+			if (aidx < nidx) {
 				const char *color = nr == ar ? "blue" : "red";
 				fprintf(file, "\tn%d -- n%d [weight=0.01 ", aidx, nidx);
-				if(env->flags & CO_IFG_DUMP_LABELS)
+				if (env->flags & CO_IFG_DUMP_LABELS)
 					fprintf(file, "label=\"%d\" ", n->costs);
-				if(env->flags & CO_IFG_DUMP_COLORS)
+				if (env->flags & CO_IFG_DUMP_COLORS)
 					fprintf(file, "color=%s ", color);
 				else
 					fprintf(file, "style=dotted");
@@ -1083,46 +1110,6 @@ void co_solve_park_moon(copy_opt_t *opt)
 	(void) opt;
 }
 
-static int void_algo(copy_opt_t *co)
-{
-	(void) co;
-	return 0;
-}
-
-/*
-		_    _                  _ _   _
-	   / \  | | __ _  ___  _ __(_) |_| |__  _ __ ___  ___
-	  / _ \ | |/ _` |/ _ \| '__| | __| '_ \| '_ ` _ \/ __|
-	 / ___ \| | (_| | (_) | |  | | |_| | | | | | | | \__ \
-	/_/   \_\_|\__, |\___/|_|  |_|\__|_| |_|_| |_| |_|___/
-			   |___/
-*/
-
-typedef struct {
-	co_algo_t  *algo;
-	const char *name;
-	int        can_improve_existing;
-} co_algo_info_t;
-
-static co_algo_info_t algos[] = {
-	{ void_algo,               "none",  0 },
-	{ co_solve_heuristic,      "heur1", 0 },
-	{ co_solve_heuristic_new,  "heur2", 0 },
-#ifdef WITH_JVM
-	{ co_solve_heuristic_java, "heur3", 0 },
-#else
-	{ NULL,                    "heur3", 0 },
-#endif
-	{ co_solve_heuristic_mst,  "heur4", 0 },
-#ifdef WITH_ILP
-	{ co_solve_ilp2,           "ilp",   1 },
-#else
-	{ NULL,                    "ilp",   1 },
-#endif
-	{ co_solve_heuristic_pbqp, "pbqp",  0 },
-	{ NULL,                    "",      0 }
-};
-
 /*
     __  __       _         ____       _
    |  \/  | __ _(_)_ __   |  _ \ _ __(_)_   _____ _ __
@@ -1150,7 +1137,7 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 	ir_snprintf(buf, sizeof(buf), "%s%s_%F_%s%s", prefix, tu_name, env->irg, env->cls->name, suffix);
 	xfree(tu_name);
 	result = fopen(buf, "wt");
-	if(result == NULL) {
+	if (result == NULL) {
 		panic("Couldn't open '%s' for writing.", buf);
 	}
 
@@ -1159,13 +1146,15 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 
 void co_driver(be_chordal_env_t *cenv)
 {
-	ir_timer_t          *timer = ir_timer_register("firm.be.copyopt", "runtime");
+	ir_timer_t          *timer = ir_timer_new();
 	co_complete_stats_t before, after;
 	copy_opt_t          *co;
-	co_algo_t           *algo_func;
 	int                 was_optimal = 0;
 
-	if (algo >= CO_ALGO_LAST)
+	assert(selected_copyopt);
+
+	/* skip copymin if algo is 'none' */
+	if (selected_copyopt->copyopt == void_algo)
 		return;
 
 	be_liveness_assure_chk(be_get_birg_liveness(cenv->birg));
@@ -1191,37 +1180,26 @@ void co_driver(be_chordal_env_t *cenv)
 		fclose(f);
 	}
 
-	/* if the algo can improve results, provide an initial solution with heur3 */
-	if (improve && algos[algo].can_improve_existing) {
+	/* if the algo can improve results, provide an initial solution with heur1 */
+	if (improve && selected_copyopt->can_improve_existing) {
 		co_complete_stats_t stats;
 
 		/* produce a heuristic solution */
-#ifdef WITH_JVM
-		co_solve_heuristic_java(co);
-#else
 		co_solve_heuristic(co);
-#endif /* WITH_JVM */
 
 		/* do the stats and provide the current costs */
 		co_complete_stats(co, &stats);
 		be_stat_ev_ull("co_prepare_costs", stats.costs);
 	}
 
-#ifdef WITH_JVM
-	/* start the JVM here so that it does not tamper the timing. */
-	if (algo == CO_ALGO_HEUR3)
-		be_java_coal_start_jvm();
-#endif /* WITH_JVM */
-
-	algo_func = algos[algo].algo;
-
 	/* perform actual copy minimization */
 	ir_timer_reset_and_start(timer);
-	was_optimal = algo_func(co);
+	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);
+	ir_timer_free(timer);
 
 	if (dump_flags & DUMP_AFTER) {
 		FILE *f = my_open(cenv, "", "-after.dot");
@@ -1238,7 +1216,7 @@ void co_driver(be_chordal_env_t *cenv)
 		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);
 
-		if(optimizable_costs > 0)
+		if (optimizable_costs > 0)
 			printf("%10" ULL_FMT " %5.2f\n", after.costs, (evitable * 100.0) / optimizable_costs);
 		else
 			printf("%10" ULL_FMT " %5s\n", after.costs, "-");