becopyopt: Remove the unnecessary attribute name from struct copy_opt_t.

[libfirm] / ir / be / beblocksched.c

diff --git a/ir/be/beblocksched.c b/ir/be/beblocksched.c
index e920d2c..d1b58e5 100644 (file)
--- a/ir/be/beblocksched.c
+++ b/ir/be/beblocksched.c
@@ -1,20 +1,6 @@
 /*
- * Copyright (C) 1995-2008 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.
+ * Copyright (C) 2012 University of Karlsruhe.
  */
 
 /**
@@ -41,7 +27,7 @@
 
 #include "array.h"
 #include "pdeq.h"
-
+#include "beirg.h"
 #include "iredges.h"
 #include "irgwalk.h"
 #include "irnode_t.h"
@@ -120,8 +106,7 @@ struct edge_t {
 typedef struct blocksched_env_t blocksched_env_t;
 struct blocksched_env_t {
        ir_graph       *irg;
-       struct obstack *obst;
-       ir_exec_freq   *execfreqs;
+       struct obstack  obst;
        edge_t         *edges;
        pdeq           *worklist;
        int            blockcount;
@@ -146,7 +131,7 @@ static void collect_egde_frequency(ir_node *block, void *data)
 
        memset(&edge, 0, sizeof(edge));
 
-       entry = OALLOCZ(env->obst, blocksched_entry_t);
+       entry = OALLOCZ(&env->obst, blocksched_entry_t);
        entry->block = block;
        set_irn_link(block, entry);
 
@@ -164,11 +149,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       = (float)get_block_execfreq(env->execfreqs, block);
+               float    freq       = (float)get_block_execfreq(block);
 
                /* is it an edge leaving a loop */
                if (get_loop_depth(pred_loop) > get_loop_depth(loop)) {
-                       float pred_freq = (float)get_block_execfreq(env->execfreqs, pred_block);
+                       float pred_freq = (float)get_block_execfreq(pred_block);
                        edge.outedge_penalty_freq = -(pred_freq - freq);
                }
 
@@ -187,7 +172,7 @@ static void collect_egde_frequency(ir_node *block, void *data)
                        double  execfreq;
                        ir_node *pred_block = get_Block_cfgpred_block(block, i);
 
-                       execfreq = get_block_execfreq(env->execfreqs, pred_block);
+                       execfreq = get_block_execfreq(pred_block);
 
                        edge.pos              = i;
                        edge.execfreq         = execfreq;
@@ -444,7 +429,6 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
 
        foreach_block_succ(block, edge) {
                ir_node *succ_block = get_edge_src_irn(edge);
-               double  execfreq;
 
                if (irn_visited(succ_block))
                        continue;
@@ -453,7 +437,7 @@ static void pick_block_successor(blocksched_entry_t *entry, blocksched_env_t *en
                if (succ_entry->prev != NULL)
                        continue;
 
-               execfreq = get_block_execfreq(env->execfreqs, succ_block);
+               double execfreq = get_block_execfreq(succ_block);
                if (execfreq > best_succ_execfreq) {
                        best_succ_execfreq = execfreq;
                        succ = succ_block;
@@ -519,21 +503,17 @@ static ir_node **create_blocksched_array(blocksched_env_t *env, blocksched_entry
        return block_list;
 }
 
-static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execfreqs)
+static ir_node **create_block_schedule_greedy(ir_graph *irg)
 {
        blocksched_env_t   env;
-       struct obstack     obst;
        blocksched_entry_t *start_entry;
        ir_node            **block_list;
 
-       obstack_init(&obst);
-
        env.irg        = irg;
-       env.obst       = &obst;
-       env.execfreqs  = execfreqs;
        env.edges      = NEW_ARR_F(edge_t, 0);
        env.worklist   = NULL;
        env.blockcount = 0;
+       obstack_init(&env.obst);
 
        assure_loopinfo(irg);
 
@@ -550,7 +530,7 @@ static ir_node **create_block_schedule_greedy(ir_graph *irg, ir_exec_freq *execf
                                              be_get_be_obst(irg));
 
        DEL_ARR_F(env.edges);
-       obstack_free(&obst, NULL);
+       obstack_free(&env.obst, NULL);
 
        return block_list;
 }
@@ -613,7 +593,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          = OALLOC(env->env.obst, blocksched_ilp_entry_t);
+       entry          = OALLOC(&env->env.obst, blocksched_ilp_entry_t);
        entry->block   = block;
        entry->next    = NULL;
        entry->prev    = NULL;
@@ -625,7 +605,7 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
 
        arity = get_irn_arity(block);
        if (arity == 1) {
-               double execfreq = get_block_execfreq(env->env.execfreqs, block);
+               double execfreq = get_block_execfreq(block);
                add_ilp_edge(block, 0, execfreq, env);
        }
        else {
@@ -641,7 +621,7 @@ static void collect_egde_frequency_ilp(ir_node *block, void *data)
                        ilp_edge_t *edge;
                        ir_node    *pred_block = get_Block_cfgpred_block(block, i);
 
-                       execfreq = get_block_execfreq(env->env.execfreqs, pred_block);
+                       execfreq = get_block_execfreq(pred_block);
                        edgenum  = add_ilp_edge(block, i, execfreq, env);
                        edge     = &env->ilpedges[edgenum];
                        lpp_set_factor_fast(env->lpp, cst_idx, edge->ilpvar, 1.0);
@@ -708,21 +688,17 @@ static void coalesce_blocks_ilp(blocksched_ilp_env_t *env)
        }
 }
 
-static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreqs)
+static ir_node **create_block_schedule_ilp(ir_graph *irg)
 {
        blocksched_ilp_env_t env;
-       struct obstack       obst;
        blocksched_entry_t   *start_entry;
        ir_node              **block_list;
 
-       obstack_init(&obst);
-
        env.env.irg        = irg;
-       env.env.obst       = &obst;
-       env.env.execfreqs  = execfreqs;
        env.env.worklist   = NULL;
        env.env.blockcount = 0;
        env.ilpedges       = NEW_ARR_F(ilp_edge_t, 0);
+       obstack_init(&env.env.obst);
 
        env.lpp = lpp_new("blockschedule", lpp_minimize);
        lpp_set_time_limit(env.lpp, 20);
@@ -740,7 +716,7 @@ static ir_node **create_block_schedule_ilp(ir_graph *irg, ir_exec_freq *execfreq
 
        DEL_ARR_F(env.ilpedges);
        lpp_free(env.lpp);
-       obstack_free(&obst, NULL);
+       obstack_free(&env.env.obst, NULL);
 
        return block_list;
 }
@@ -765,14 +741,12 @@ void be_init_blocksched(void)
 
 ir_node **be_create_block_schedule(ir_graph *irg)
 {
-       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);
+               return create_block_schedule_greedy(irg);
        case BLOCKSCHED_ILP:
-               return create_block_schedule_ilp(irg, execfreqs);
+               return create_block_schedule_ilp(irg);
        }
 
        panic("unknown blocksched algo");