backend: remove unused omitleaffp option

[libfirm] / ir / be / beblocksched.c

diff --git a/ir/be/beblocksched.c b/ir/be/beblocksched.c
index b8de83b..387749a 100644 (file)
--- a/ir/be/beblocksched.c
+++ b/ir/be/beblocksched.c
@@ -68,7 +68,7 @@
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
-typedef enum _blocksched_algos_t {
+typedef enum blocksched_algos_t {
        BLOCKSCHED_NAIV, BLOCKSCHED_GREEDY, BLOCKSCHED_ILP
 } blocksched_algos_t;
 
@@ -145,8 +145,7 @@ static void collect_egde_frequency(ir_node *block, void *data)
 
        memset(&edge, 0, sizeof(edge));
 
-       entry = obstack_alloc(env->obst, sizeof(entry[0]));
-       memset(entry, 0, sizeof(*entry));
+       entry = OALLOCZ(env->obst, blocksched_entry_t);
        entry->block = block;
        set_irn_link(block, entry);
 
@@ -164,11 +163,11 @@ static void collect_egde_frequency(ir_node *block, void *data)
        } else if (arity == 1) {
                ir_node *pred_block = get_Block_cfgpred_block(block, 0);
                ir_loop *pred_loop  = get_irn_loop(pred_block);
-               float    freq       = get_block_execfreq(env->execfreqs, block);
+               float    freq       = (float)get_block_execfreq(env->execfreqs, block);
 
                /* is it an edge leaving a loop */
                if (get_loop_depth(pred_loop) > get_loop_depth(loop)) {
-                       float pred_freq = get_block_execfreq(env->execfreqs, pred_block);
+                       float pred_freq = (float)get_block_execfreq(env->execfreqs, pred_block);
                        edge.outedge_penalty_freq = -(pred_freq - freq);
                }
 
@@ -200,7 +199,7 @@ static void collect_egde_frequency(ir_node *block, void *data)
                        }
                }
 
-               if(highest_edge_num >= 0)
+               if (highest_edge_num >= 0)
                        env->edges[highest_edge_num].highest_execfreq = 1;
        }
 }
@@ -517,7 +516,8 @@ static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execf
                coalesce_blocks(&env);
 
        start_entry = finish_block_schedule(&env);
-       block_list  = create_blocksched_array(&env, start_entry, env.blockcount, get_irg_obstack(irg));
+       block_list  = create_blocksched_array(&env, start_entry, env.blockcount,
+                                             be_get_be_obst(irg));
 
        DEL_ARR_F(env.edges);
        obstack_free(&obst, NULL);
@@ -535,22 +535,22 @@ static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execf
  */
 
 #ifdef WITH_ILP
-typedef struct _ilp_edge_t {
+typedef struct ilp_edge_t {
        ir_node *block;   /**< source block */
        int     pos;      /**< number of cfg predecessor (target) */
        int     ilpvar;
 } ilp_edge_t;
 
-typedef struct _blocksched_ilp_env_t {
+typedef struct blocksched_ilp_env_t {
        blocksched_env_t env;
        ilp_edge_t       *ilpedges;
        lpp_t            *lpp;
 } blocksched_ilp_env_t;
 
-typedef struct _blocksched_ilp_entry_t {
+typedef struct blocksched_ilp_entry_t {
        ir_node *block;
-       struct _blocksched_entry_t *next;
-       struct _blocksched_entry_t *prev;
+       struct blocksched_entry_t *next;
+       struct blocksched_entry_t *prev;
 
        int out_cst;
 } blocksched_ilp_entry_t;
@@ -585,7 +585,7 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
        snprintf(name, sizeof(name), "block_out_constr_%ld", get_irn_node_nr(block));
        out_count = get_irn_n_edges_kind(block, EDGE_KIND_BLOCK);
 
-       entry          = obstack_alloc(env->env.obst, sizeof(entry[0]));
+       entry          = OALLOC(env->env.obst, blocksched_ilp_entry_t);
        entry->block   = block;
        entry->next    = NULL;
        entry->prev    = NULL;
@@ -623,11 +623,12 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
 
 static void coalesce_blocks_ilp(blocksched_ilp_env_t *env)
 {
-       int  i;
-       int  edge_count = ARR_LEN(env->ilpedges);
+       int           edge_count = ARR_LEN(env->ilpedges);
+       be_options_t *options    = be_get_irg_options(env->env.irg);
+       int           i;
 
        /* complete out constraints */
-       for(i = 0; i < edge_count; ++i) {
+       for (i = 0; i < edge_count; ++i) {
                const ilp_edge_t *edge  = &env->ilpedges[i];
                ir_node          *block = edge->block;
                ir_node          *pred;
@@ -645,20 +646,7 @@ static void coalesce_blocks_ilp(blocksched_ilp_env_t *env)
                lpp_set_factor_fast(env->lpp, entry->out_cst, edge->ilpvar, 1.0);
        }
 
-#if 0
-       {
-               FILE *f;
-               char fname[256];
-               lpp_dump(env->lpp, "lpp.out");
-               snprintf(fname, sizeof(fname), "lpp_%s.plain", get_irg_dump_name(env->env.irg));
-               f = fopen(fname, "w");
-               lpp_dump_plain(env->lpp, f);
-               fclose(f);
-       }
-#endif
-
-       //lpp_solve_net(env->lpp, main_env->options->ilp_server, main_env->options->ilp_solver);
-       lpp_solve_net(env->lpp, "i44pc52", "cplex");
+       lpp_solve_net(env->lpp, options->ilp_server, options->ilp_solver);
        assert(lpp_is_sol_valid(env->lpp));
 
        /* Apply results to edges */
@@ -714,7 +702,9 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
        coalesce_blocks_ilp(&env);
 
        start_entry = finish_block_schedule(&env.env);
-       block_list  = create_blocksched_array(&env.env, start_entry, env.env.blockcount, get_irg_obstack(irg));
+       block_list  = create_blocksched_array(&env.env, start_entry,
+                                             env.env.blockcount,
+                                             be_get_be_obst(irg));
 
        DEL_ARR_F(env.ilpedges);
        free_lpp(env.lpp);
@@ -732,6 +722,7 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
  * |_|  |_|\__,_|_|_| |_|
  *
  */
+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");
@@ -742,11 +733,11 @@ void be_init_blocksched(void)
        FIRM_DBG_REGISTER(dbg, "firm.be.blocksched");
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_blocksched);
-
-ir_node **be_create_block_schedule(ir_graph *irg, ir_exec_freq *execfreqs)
+ir_node **be_create_block_schedule(ir_graph *irg)
 {
-       switch(algo) {
+       ir_exec_freq *execfreqs = be_get_irg_exec_freq(irg);
+
+       switch (algo) {
        case BLOCKSCHED_GREEDY:
        case BLOCKSCHED_NAIV:
                return create_block_schedule_greedy(irg, execfreqs);
@@ -757,5 +748,4 @@ ir_node **be_create_block_schedule(ir_graph *irg, ir_exec_freq *execfreqs)
        }
 
        panic("unknown blocksched algo");
-       return NULL;
 }