X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeblocksched.c;h=97184dfe3b2beb79acadc3939b136799436682ab;hb=5474a1c188c9d59eea2c915515980cd9cbab58d8;hp=cbbfc37166f56d05c3320b635d4dbff9b56c517c;hpb=a1e9069afa4fa1e16e2d176bcd7905d6a1ed4677;p=libfirm

diff --git a/ir/be/beblocksched.c b/ir/be/beblocksched.c
index cbbfc3716..97184dfe3 100644
--- a/ir/be/beblocksched.c
+++ b/ir/be/beblocksched.c
@@ -22,7 +22,6 @@
  * @brief       Block-scheduling strategies.
  * @author      Matthias Braun, Christoph Mallon
  * @date        27.09.2006
- * @version     $Id$
  *
  * The goals of the greedy (and ILP) algorithm here works by assuming that
  * we want to change as many jumps to fallthroughs as possible (executed jumps
@@ -52,6 +51,7 @@
 #include "execfreq.h"
 #include "irdump_t.h"
 #include "irtools.h"
+#include "util.h"
 #include "debug.h"
 #include "beirgmod.h"
 #include "bemodule.h"
@@ -61,10 +61,8 @@
 #include "lc_opts.h"
 #include "lc_opts_enum.h"
 
-#ifdef WITH_ILP
-#include <lpp/lpp.h>
-#include <lpp/lpp_net.h>
-#endif /* WITH_ILP */
+#include "lpp.h"
+#include "lpp_net.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
@@ -77,9 +75,7 @@ static int algo = BLOCKSCHED_GREEDY;
 static const lc_opt_enum_int_items_t blockschedalgo_items[] = {
 	{ "naiv",   BLOCKSCHED_NAIV },
 	{ "greedy", BLOCKSCHED_GREEDY },
-#ifdef WITH_ILP
 	{ "ilp",    BLOCKSCHED_ILP },
-#endif /* WITH_ILP */
 	{ NULL,     0 }
 };
 
@@ -88,7 +84,7 @@ static lc_opt_enum_int_var_t algo_var = {
 };
 
 static const lc_opt_table_entry_t be_blocksched_options[] = {
-	LC_OPT_ENT_ENUM_INT ("algo", "the block scheduling algorithm", &algo_var),
+	LC_OPT_ENT_ENUM_INT ("blockscheduler", "the block scheduling algorithm", &algo_var),
 	LC_OPT_LAST
 };
 
@@ -137,7 +133,7 @@ struct blocksched_env_t {
  */
 static void collect_egde_frequency(ir_node *block, void *data)
 {
-	blocksched_env_t   *env = data;
+	blocksched_env_t   *env = (blocksched_env_t*)data;
 	int                arity;
 	edge_t             edge;
 	blocksched_entry_t *entry;
@@ -206,16 +202,16 @@ static void collect_egde_frequency(ir_node *block, void *data)
 
 static int cmp_edges(const void *d1, const void *d2)
 {
-	const edge_t *e1 = d1;
-	const edge_t *e2 = d2;
+	const edge_t *e1 = (const edge_t*)d1;
+	const edge_t *e2 = (const edge_t*)d2;
 
 	return QSORT_CMP(e2->execfreq, e1->execfreq);
 }
 
 static int cmp_edges_outedge_penalty(const void *d1, const void *d2)
 {
-	const edge_t *e1 = d1;
-	const edge_t *e2 = d2;
+	const edge_t *e1 = (const edge_t*)d1;
+	const edge_t *e2 = (const edge_t*)d2;
 	/* reverse sorting as penalties are negative */
 	return QSORT_CMP(e1->outedge_penalty_freq, e2->outedge_penalty_freq);
 }
@@ -260,8 +256,8 @@ static void coalesce_blocks(blocksched_env_t *env)
 			continue;
 
 		pred_block = get_Block_cfgpred_block(block, pos);
-		entry      = get_irn_link(block);
-		pred_entry = get_irn_link(pred_block);
+		entry      = (blocksched_entry_t*)get_irn_link(block);
+		pred_entry = (blocksched_entry_t*)get_irn_link(pred_block);
 
 		if (pred_entry->next != NULL || entry->prev != NULL)
 			continue;
@@ -299,8 +295,8 @@ static void coalesce_blocks(blocksched_env_t *env)
 			continue;
 
 		pred_block = get_Block_cfgpred_block(block, pos);
-		entry      = get_irn_link(block);
-		pred_entry = get_irn_link(pred_block);
+		entry      = (blocksched_entry_t*)get_irn_link(block);
+		pred_entry = (blocksched_entry_t*)get_irn_link(pred_block);
 
 		if (pred_entry->next != NULL || entry->prev != NULL)
 			continue;
@@ -341,8 +337,8 @@ static void coalesce_blocks(blocksched_env_t *env)
 			continue;
 
 		pred_block = get_Block_cfgpred_block(block, pos);
-		entry      = get_irn_link(block);
-		pred_entry = get_irn_link(pred_block);
+		entry      = (blocksched_entry_t*)get_irn_link(block);
+		pred_entry = (blocksched_entry_t*)get_irn_link(pred_block);
 
 		/* is 1 of the blocks already attached to another block? */
 		if (pred_entry->next != NULL || entry->prev != NULL)
@@ -380,7 +376,7 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
 
 		/* we only need to put the first of a series of already connected
 		 * blocks into the worklist */
-		succ_entry = get_irn_link(succ_block);
+		succ_entry = (blocksched_entry_t*)get_irn_link(succ_block);
 		while (succ_entry->prev != NULL) {
 			/* break cycles... */
 			if (succ_entry->prev->block == succ_block) {
@@ -389,7 +385,7 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
 				break;
 			}
 			succ_entry = succ_entry->prev;
-		};
+		}
 
 		if (irn_visited(succ_entry->block))
 			continue;
@@ -416,7 +412,7 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
 		if (irn_visited(succ_block))
 			continue;
 
-		succ_entry = get_irn_link(succ_block);
+		succ_entry = (blocksched_entry_t*)get_irn_link(succ_block);
 		if (succ_entry->prev != NULL)
 			continue;
 
@@ -435,11 +431,11 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
 				DB((dbg, LEVEL_1, "worklist empty\n"));
 				return;
 			}
-			succ = pdeq_getl(env->worklist);
+			succ = (ir_node*)pdeq_getl(env->worklist);
 		} while (irn_visited(succ));
 	}
 
-	succ_entry       = get_irn_link(succ);
+	succ_entry       = (blocksched_entry_t*)get_irn_link(succ);
 	entry->next      = succ_entry;
 	succ_entry->prev = entry;
 
@@ -450,7 +446,7 @@ static blocksched_entry_t *finish_block_schedule(blocksched_env_t *env)
 {
 	ir_graph           *irg        = env->irg;
 	ir_node            *startblock = get_irg_start_block(irg);
-	blocksched_entry_t *entry      = get_irn_link(startblock);
+	blocksched_entry_t *entry      = (blocksched_entry_t*)get_irn_link(startblock);
 
 	ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
 	inc_irg_visited(irg);
@@ -502,10 +498,7 @@ static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execf
 	env.worklist   = NULL;
 	env.blockcount = 0;
 
-	/* make sure loopinfo is up-to-date */
-	if (! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) {
-		construct_cf_backedges(irg);
-	}
+	assure_loopinfo(irg);
 
 	// collect edge execution frequencies
 	irg_block_walk_graph(irg, collect_egde_frequency, NULL, &env);
@@ -534,7 +527,6 @@ static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execf
  *
  */
 
-#ifdef WITH_ILP
 typedef struct ilp_edge_t {
 	ir_node *block;   /**< source block */
 	int     pos;      /**< number of cfg predecessor (target) */
@@ -589,7 +581,7 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
 	entry->block   = block;
 	entry->next    = NULL;
 	entry->prev    = NULL;
-	entry->out_cst = lpp_add_cst_uniq(env->lpp, name, lpp_greater, out_count - 1);
+	entry->out_cst = lpp_add_cst_uniq(env->lpp, name, lpp_greater_equal, out_count - 1);
 	set_irn_link(block, entry);
 
 	if (block == startblock)
@@ -604,7 +596,7 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
 		int i;
 
 		snprintf(name, sizeof(name), "block_in_constr_%ld", get_irn_node_nr(block));
-		cst = lpp_add_cst_uniq(env->lpp, name, lpp_greater, arity - 1);
+		cst = lpp_add_cst_uniq(env->lpp, name, lpp_greater_equal, arity - 1);
 
 		for (i = 0; i < arity; ++i) {
 			double     execfreq;
@@ -692,7 +684,7 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
 	env.env.blockcount = 0;
 	env.ilpedges       = NEW_ARR_F(ilp_edge_t, 0);
 
-	env.lpp = new_lpp("blockschedule", lpp_minimize);
+	env.lpp = lpp_new("blockschedule", lpp_minimize);
 	lpp_set_time_limit(env.lpp, 20);
 	lpp_set_log(env.lpp, stdout);
 
@@ -707,12 +699,11 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
 	                                      be_get_be_obst(irg));
 
 	DEL_ARR_F(env.ilpedges);
-	free_lpp(env.lpp);
+	lpp_free(env.lpp);
 	obstack_free(&obst, NULL);
 
 	return block_list;
 }
-#endif /* WITH_ILP */
 
 /*
  *  __  __       _
@@ -722,13 +713,12 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
  * |_|  |_|\__,_|_|_| |_|
  *
  */
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_blocksched);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_blocksched)
 void be_init_blocksched(void)
 {
 	lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
-	lc_opt_entry_t *blocksched_grp = lc_opt_get_grp(be_grp, "blocksched");
 
-	lc_opt_add_table(blocksched_grp, be_blocksched_options);
+	lc_opt_add_table(be_grp, be_blocksched_options);
 
 	FIRM_DBG_REGISTER(dbg, "firm.be.blocksched");
 }
@@ -741,10 +731,8 @@ ir_node **be_create_block_schedule(ir_graph *irg)
 	case BLOCKSCHED_GREEDY:
 	case BLOCKSCHED_NAIV:
 		return create_block_schedule_greedy(irg, execfreqs);
-#ifdef WITH_ILP
 	case BLOCKSCHED_ILP:
 		return create_block_schedule_ilp(irg, execfreqs);
-#endif /* WITH_ILP */
 	}
 
 	panic("unknown blocksched algo");