removed dependencies on chordal_env

diff --git a/ir/be/bearch.h b/ir/be/bearch.h
index af3c634..a084563 100644 (file)
--- a/ir/be/bearch.h
+++ b/ir/be/bearch.h
@@ -17,6 +17,7 @@
 #include "bearch_t.h"
 #include "be_t.h"
 #include "bemachine.h"
+#include "beirg.h"
 
 struct _be_node_factory_t;
 
@@ -544,7 +545,7 @@ struct _arch_code_generator_if_t {
         * Backend may provide an own spiller.
         * This spiller needs to spill all register classes.
         */
-       void (*spill)(void *self, void *env);
+       void (*spill)(void *self, be_irg_t *birg);
 
        /**
         * Called before scheduling.
@@ -598,7 +599,7 @@ do { \
 #define arch_code_generator_after_ra(cg)        _arch_cg_call(cg, after_ra)
 #define arch_code_generator_finish(cg)          _arch_cg_call(cg, finish)
 #define arch_code_generator_done(cg)            _arch_cg_call(cg, done)
-#define arch_code_generator_spill(cg, env)      _arch_cg_call_env(cg, env, spill)
+#define arch_code_generator_spill(cg, birg)     _arch_cg_call_env(cg, birg, spill)
 #define arch_code_generator_has_spiller(cg)     ((cg)->impl->spill != NULL)
 
 /**

diff --git a/ir/be/bechordal_main.c b/ir/be/bechordal_main.c
index 97f196b..29ca472 100644 (file)
--- a/ir/be/bechordal_main.c
+++ b/ir/be/bechordal_main.c
@@ -86,8 +86,10 @@ static be_ra_chordal_opts_t options = {
 static int be_elr_split = 0;
 
 typedef struct _post_spill_env_t {
-       be_chordal_env_t cenv;
-       double           pre_spill_cost;
+       be_chordal_env_t            cenv;
+       be_irg_t                    *birg;
+       const arch_register_class_t *cls;
+       double                      pre_spill_cost;
 } post_spill_env_t;
 
 static be_ra_timer_t ra_timer = {
@@ -231,17 +233,18 @@ typedef struct _node_stat_t {
 } node_stat_t;
 
 struct node_stat_walker {
-       node_stat_t *stat;
-       const be_chordal_env_t *cenv;
-       bitset_t *mem_phis;
+       node_stat_t      *stat;
+       const arch_env_t *arch_env;
+       bitset_t         *mem_phis;
+       const arch_register_class_t *cls;
 };
 
 static void node_stat_walker(ir_node *irn, void *data)
 {
-       struct node_stat_walker *env = data;
-       const arch_env_t *aenv       = env->cenv->birg->main_env->arch_env;
+       struct node_stat_walker *env  = data;
+       const arch_env_t        *aenv = env->arch_env;
 
-       if(arch_irn_consider_in_reg_alloc(aenv, env->cenv->cls, irn)) {
+       if (arch_irn_consider_in_reg_alloc(aenv, env->cls, irn)) {
 
                /* if the node is a normal phi */
                if(is_Phi(irn))
@@ -276,15 +279,16 @@ static void node_stat_walker(ir_node *irn, void *data)
        }
 }
 
-static void node_stats(const be_chordal_env_t *cenv, node_stat_t *stat)
+static void node_stats(be_irg_t *birg, const arch_register_class_t *cls, node_stat_t *stat)
 {
        struct node_stat_walker env;
 
        memset(stat, 0, sizeof(stat[0]));
-       env.cenv     = cenv;
-       env.mem_phis = bitset_irg_malloc(cenv->irg);
+       env.arch_env = birg->main_env->arch_env;
+       env.mem_phis = bitset_irg_malloc(birg->irg);
        env.stat     = stat;
-       irg_walk_graph(cenv->irg, NULL, node_stat_walker, &env);
+       env.cls      = cls;
+       irg_walk_graph(birg->irg, NULL, node_stat_walker, &env);
        bitset_free(env.mem_phis);
 }
 
@@ -378,33 +382,35 @@ static void be_init_timer(be_options_t *main_opts)
  */
 static void pre_spill(const arch_isa_t *isa, int cls_idx, post_spill_env_t *pse) {
        be_chordal_env_t *chordal_env = &pse->cenv;
+       be_irg_t         *birg        = pse->birg;
        node_stat_t      node_stat;
 
-       chordal_env->cls           = arch_isa_get_reg_class(isa, cls_idx);
+       pse->cls                   = arch_isa_get_reg_class(isa, cls_idx);
+       chordal_env->cls           = pse->cls;
        chordal_env->border_heads  = pmap_create();
        chordal_env->ignore_colors = bitset_malloc(chordal_env->cls->n_regs);
 
 #ifdef FIRM_STATISTICS
        if (be_stat_ev_is_active()) {
-               be_stat_tags[STAT_TAG_CLS] = chordal_env->cls->name;
+               be_stat_tags[STAT_TAG_CLS] = pse->cls->name;
                be_stat_ev_push(be_stat_tags, STAT_TAG_LAST, be_stat_file);
 
                /* perform some node statistics. */
-               node_stats(chordal_env, &node_stat);
+               node_stats(birg, pse->cls, &node_stat);
                be_stat_ev("phis_before_spill", node_stat.n_phis);
        }
 #endif /* FIRM_STATISTICS */
 
        /* put all ignore registers into the ignore register set. */
-       be_put_ignore_regs(chordal_env->birg, chordal_env->cls, chordal_env->ignore_colors);
+       be_put_ignore_regs(birg, pse->cls, chordal_env->ignore_colors);
 
        be_pre_spill_prepare_constr(chordal_env);
-       dump(BE_CH_DUMP_CONSTR, chordal_env->irg, chordal_env->cls, "-constr-pre", dump_ir_block_graph_sched);
+       dump(BE_CH_DUMP_CONSTR, birg->irg, pse->cls, "-constr-pre", dump_ir_block_graph_sched);
 
 #ifdef FIRM_STATISTICS
        if (be_stat_ev_is_active()) {
-               pse->pre_spill_cost = be_estimate_irg_costs(chordal_env->irg,
-                       chordal_env->birg->main_env->arch_env, chordal_env->birg->exec_freq);
+               pse->pre_spill_cost = be_estimate_irg_costs(birg->irg,
+                       birg->main_env->arch_env, birg->exec_freq);
        }
 #endif /* FIRM_STATISTICS */
 }
@@ -414,8 +420,8 @@ static void pre_spill(const arch_isa_t *isa, int cls_idx, post_spill_env_t *pse)
  */
 static void post_spill(post_spill_env_t *pse) {
        be_chordal_env_t    *chordal_env = &pse->cenv;
-       ir_graph            *irg         = chordal_env->irg;
-       be_irg_t            *birg        = chordal_env->birg;
+       be_irg_t            *birg        = pse->birg;
+       ir_graph            *irg         = birg->irg;
        const be_main_env_t *main_env    = birg->main_env;
        be_options_t        *main_opts   = main_env->options;
        static int          splitted     = 0;
@@ -427,7 +433,7 @@ static void post_spill(post_spill_env_t *pse) {
 
                be_stat_ev_l("spillcosts", (long) spillcosts);
 
-               node_stats(chordal_env, &node_stat);
+               node_stats(birg, pse->cls, &node_stat);
                be_stat_ev("phis_after_spill", node_stat.n_phis);
                be_stat_ev("mem_phis", node_stat.n_mem_phis);
                be_stat_ev("reloads", node_stat.n_reloads);
@@ -444,11 +450,11 @@ static void post_spill(post_spill_env_t *pse) {
        /* verify schedule and register pressure */
        if (chordal_env->opts->vrfy_option == BE_CH_VRFY_WARN) {
                be_verify_schedule(irg);
-               be_verify_register_pressure(chordal_env->birg, chordal_env->cls, irg);
+               be_verify_register_pressure(birg, pse->cls, irg);
        }
        else if (chordal_env->opts->vrfy_option == BE_CH_VRFY_ASSERT) {
                assert(be_verify_schedule(irg) && "Schedule verification failed");
-               assert(be_verify_register_pressure(chordal_env->birg, chordal_env->cls, irg)
+               assert(be_verify_register_pressure(birg, pse->cls, irg)
                        && "Register pressure verification failed");
        }
        BE_TIMER_POP(ra_timer.t_verify);
@@ -463,7 +469,7 @@ static void post_spill(post_spill_env_t *pse) {
        be_ra_chordal_color(chordal_env);
        BE_TIMER_POP(ra_timer.t_color);
 
-       dump(BE_CH_DUMP_CONSTR, irg, chordal_env->cls, "-color", dump_ir_block_graph_sched);
+       dump(BE_CH_DUMP_CONSTR, irg, pse->cls, "-color", dump_ir_block_graph_sched);
 
        /* Create the ifg with the selected flavor */
        BE_TIMER_PUSH(ra_timer.t_ifg);
@@ -473,12 +479,13 @@ static void post_spill(post_spill_env_t *pse) {
 #ifdef FIRM_STATISTICS
        if (be_stat_ev_is_active()) {
                be_ifg_stat_t stat;
-               be_ifg_stat(chordal_env, &stat);
+
+               be_ifg_stat(birg, chordal_env->ifg, &stat);
                be_stat_ev("ifg_nodes", stat.n_nodes);
                be_stat_ev("ifg_edges", stat.n_edges);
                be_stat_ev("ifg_comps", stat.n_comps);
 
-               node_stats(chordal_env, &node_stat);
+               node_stats(birg, pse->cls, &node_stat);
                be_stat_ev("perms_before_coal", node_stat.n_perms);
                be_stat_ev("copies_before_coal", node_stat.n_copies);
        }
@@ -489,7 +496,7 @@ static void post_spill(post_spill_env_t *pse) {
        co_driver(chordal_env);
        BE_TIMER_POP(ra_timer.t_copymin);
 
-       dump(BE_CH_DUMP_COPYMIN, irg, chordal_env->cls, "-copymin", dump_ir_block_graph_sched);
+       dump(BE_CH_DUMP_COPYMIN, irg, pse->cls, "-copymin", dump_ir_block_graph_sched);
 
        BE_TIMER_PUSH(ra_timer.t_ssa);
 
@@ -498,7 +505,7 @@ static void post_spill(post_spill_env_t *pse) {
 
        BE_TIMER_POP(ra_timer.t_ssa);
 
-       dump(BE_CH_DUMP_SSADESTR, irg, chordal_env->cls, "-ssadestr", dump_ir_block_graph_sched);
+       dump(BE_CH_DUMP_SSADESTR, irg, pse->cls, "-ssadestr", dump_ir_block_graph_sched);
 
        BE_TIMER_PUSH(ra_timer.t_verify);
        if (chordal_env->opts->vrfy_option != BE_CH_VRFY_OFF) {
@@ -506,13 +513,14 @@ static void post_spill(post_spill_env_t *pse) {
        }
        BE_TIMER_POP(ra_timer.t_verify);
 
+       /* free some data structures */
        be_ifg_free(chordal_env->ifg);
        pmap_destroy(chordal_env->border_heads);
        bitset_free(chordal_env->ignore_colors);
 
 #ifdef FIRM_STATISTICS
        if (be_stat_ev_is_active()) {
-               node_stats(chordal_env, &node_stat);
+               node_stats(birg, pse->cls, &node_stat);
                be_stat_ev("perms_after_coal", node_stat.n_perms);
                be_stat_ev("copies_after_coal", node_stat.n_copies);
                be_stat_ev_pop();
@@ -561,13 +569,14 @@ static void be_ra_chordal_main(be_irg_t *birg)
                        post_spill_env_t pse;
 
                        memcpy(&pse.cenv, &chordal_env, sizeof(chordal_env));
+                       pse.birg = birg;
                        pre_spill(isa, j, &pse);
 
                        BE_TIMER_PUSH(ra_timer.t_spill);
                        be_do_spill(&pse.cenv);
                        BE_TIMER_POP(ra_timer.t_spill);
 
-                       dump(BE_CH_DUMP_SPILL, irg, pse.cenv.cls, "-spill", dump_ir_block_graph_sched);
+                       dump(BE_CH_DUMP_SPILL, irg, pse.cls, "-spill", dump_ir_block_graph_sched);
 
                        post_spill(&pse);
                }
@@ -582,11 +591,12 @@ static void be_ra_chordal_main(be_irg_t *birg)
 
                for (j = 0; j < m; ++j) {
                        memcpy(&pse[j].cenv, &chordal_env, sizeof(chordal_env));
+                       pse[j].birg = birg;
                        pre_spill(isa, j, &pse[j]);
                }
 
                BE_TIMER_PUSH(ra_timer.t_spill);
-               arch_code_generator_spill(birg->cg, &chordal_env);
+               arch_code_generator_spill(birg->cg, birg);
                BE_TIMER_POP(ra_timer.t_spill);
                dump(BE_CH_DUMP_SPILL, irg, NULL, "-spill", dump_ir_block_graph_sched);
 

diff --git a/ir/be/beifg.c b/ir/be/beifg.c
index c3224c6..3b3b439 100644 (file)
--- a/ir/be/beifg.c
+++ b/ir/be/beifg.c
@@ -637,33 +637,33 @@ void be_ifg_dump_dot(be_ifg_t *ifg, ir_graph *irg, FILE *file, const be_ifg_dump
        bitset_free(nodes);
 }
 
-static void int_comp_rec(const be_chordal_env_t *cenv, ir_node *n, bitset_t *seen)
+static void int_comp_rec(be_irg_t *birg, be_ifg_t *ifg, ir_node *n, bitset_t *seen)
 {
-       void *neigh_it  = be_ifg_neighbours_iter_alloca(cenv->ifg);
+       void    *neigh_it = be_ifg_neighbours_iter_alloca(ifg);
        ir_node *m;
 
-       be_ifg_foreach_neighbour(cenv->ifg, neigh_it, n, m) {
-               if(!bitset_contains_irn(seen, m) && !arch_irn_is(cenv->birg->main_env->arch_env, m, ignore)) {
+       be_ifg_foreach_neighbour(ifg, neigh_it, n, m) {
+               if(!bitset_contains_irn(seen, m) && !arch_irn_is(birg->main_env->arch_env, m, ignore)) {
                        bitset_add_irn(seen, m);
-                       int_comp_rec(cenv, m, seen);
+                       int_comp_rec(birg, ifg, m, seen);
                }
        }
 
 }
 
-static int int_component_stat(const be_chordal_env_t *cenv)
+static int int_component_stat(be_irg_t *birg, be_ifg_t *ifg)
 {
-       int n_comp     = 0;
-       void *nodes_it = be_ifg_nodes_iter_alloca(cenv->ifg);
-       bitset_t *seen = bitset_irg_malloc(cenv->irg);
+       int      n_comp    = 0;
+       void     *nodes_it = be_ifg_nodes_iter_alloca(ifg);
+       bitset_t *seen     = bitset_irg_malloc(birg->irg);
 
        ir_node *n;
 
-       be_ifg_foreach_node(cenv->ifg, nodes_it, n) {
-               if(!bitset_contains_irn(seen, n) && !arch_irn_is(cenv->birg->main_env->arch_env, n, ignore)) {
+       be_ifg_foreach_node(ifg, nodes_it, n) {
+               if (! bitset_contains_irn(seen, n) && ! arch_irn_is(birg->main_env->arch_env, n, ignore)) {
                        ++n_comp;
                        bitset_add_irn(seen, n);
-                       int_comp_rec(cenv, n, seen);
+                       int_comp_rec(birg, ifg, n, seen);
                }
        }
 
@@ -671,24 +671,24 @@ static int int_component_stat(const be_chordal_env_t *cenv)
        return n_comp;
 }
 
-void be_ifg_stat(const be_chordal_env_t *cenv, be_ifg_stat_t *stat)
+void be_ifg_stat(be_irg_t *birg, be_ifg_t *ifg, be_ifg_stat_t *stat)
 {
-       void *nodes_it  = be_ifg_nodes_iter_alloca(cenv->ifg);
-       void *neigh_it  = be_ifg_neighbours_iter_alloca(cenv->ifg);
-       bitset_t *nodes = bitset_irg_malloc(cenv->irg);
-
-       ir_node *n, *m;
+       void     *nodes_it = be_ifg_nodes_iter_alloca(ifg);
+       void     *neigh_it = be_ifg_neighbours_iter_alloca(ifg);
+       bitset_t *nodes    = bitset_irg_malloc(birg->irg);
+       ir_node  *n, *m;
 
        memset(stat, 0, sizeof(stat[0]));
-       be_ifg_foreach_node(cenv->ifg, nodes_it, n) {
+
+       be_ifg_foreach_node(ifg, nodes_it, n) {
                stat->n_nodes += 1;
-               be_ifg_foreach_neighbour(cenv->ifg, neigh_it, n, m) {
+               be_ifg_foreach_neighbour(ifg, neigh_it, n, m) {
                        bitset_add_irn(nodes, n);
                        stat->n_edges += !bitset_contains_irn(nodes, m);
                }
        }
 
-       stat->n_comps = int_component_stat(cenv);
+       stat->n_comps = int_component_stat(birg, ifg);
        bitset_free(nodes);
 }
 

diff --git a/ir/be/beifg.h b/ir/be/beifg.h
index 4a7579e..0e0eb8d 100644 (file)
--- a/ir/be/beifg.h
+++ b/ir/be/beifg.h
@@ -54,7 +54,7 @@ typedef struct {
        int n_comps;
 } be_ifg_stat_t;
 
-void be_ifg_stat(const be_chordal_env_t *cenv, be_ifg_stat_t *stat);
+void be_ifg_stat(be_irg_t *birg, be_ifg_t *ifg, be_ifg_stat_t *stat);
 
 be_ifg_t *be_create_ifg(const be_chordal_env_t *env);
 

diff --git a/ir/be/bepressurestat.c b/ir/be/bepressurestat.c
index 03a36c7..5cae11a 100644 (file)
--- a/ir/be/bepressurestat.c
+++ b/ir/be/bepressurestat.c
@@ -72,12 +72,12 @@ regpressure(pset * live)
 static void
 regpressureanawalker(ir_node * bb, void * data)
 {
-  regpressure_ana_t  *ra = data;
+  regpressure_ana_t  *ra   = data;
   pset               *live = pset_new_ptr_default();
   const ir_node      *irn;
   unsigned int       *stat = ra->stat;
-  int                 i;
-  be_lv_t *lv = ra->lv;
+  int                i;
+  const be_lv_t      *lv   = ra->lv;
 
   be_lv_foreach(lv, bb, be_lv_state_end, i) {
     ir_node *value = be_lv_get_irn(lv, bb, i);

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index 7b172be..84ee0cf 100644 (file)
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -45,8 +45,9 @@ typedef struct _reloader_t reloader_t;
 
 struct _reloader_t {
        reloader_t *next;
-       ir_node *reloader;
-       ir_node *rematted_node;
+       ir_node    *reloader;
+       ir_node    *rematted_node;
+       int        allow_remat;     /**< the node may be rematted instead of reloaded if global remat option is on */
 };
 
 typedef struct _spill_info_t {
@@ -167,23 +168,27 @@ void be_add_remat(spill_env_t *env, ir_node *to_spill, ir_node *before, ir_node
 
        spill_info = get_spillinfo(env, to_spill);
 
-       reloader = obstack_alloc(&env->obst, sizeof(reloader[0]));
-       reloader->next = spill_info->reloaders;
-       reloader->reloader = before;
+       /* add the remat information */
+       reloader                = obstack_alloc(&env->obst, sizeof(reloader[0]));
+       reloader->next          = spill_info->reloaders;
+       reloader->reloader      = before;
        reloader->rematted_node = rematted_node;
+       reloader->allow_remat   = 1;
 
-       spill_info->reloaders = reloader;
+       spill_info->reloaders  = reloader;
        assert(spill_info->reload_cls == NULL || spill_info->reload_cls == reload_cls);
        spill_info->reload_cls = reload_cls;
 }
 
-void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before, const arch_register_class_t *reload_cls) {
+void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before,
+               const arch_register_class_t *reload_cls, int allow_remat)
+{
        spill_info_t *info;
        reloader_t *rel;
 
        info = get_spillinfo(env, to_spill);
 
-       if(is_Phi(to_spill)) {
+       if (is_Phi(to_spill)) {
                int i, arity;
 
                /* create spillinfos for the phi arguments */
@@ -198,7 +203,8 @@ void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before, const a
                // spill node and adds a reload for that spill node, problem is the
                // reload gets attach to that same spill (and is totally unnecessary)
                if (info->old_spill != NULL &&
-                       (before == info->old_spill || value_dominates(before, info->old_spill))) {
+                       (before == info->old_spill || value_dominates(before, info->old_spill)))
+               {
                        printf("spilledphi hack was needed...\n");
                        before = sched_next(info->old_spill);
                }
@@ -206,10 +212,11 @@ void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before, const a
        }
 
        /* put reload into list */
-       rel           = obstack_alloc(&env->obst, sizeof(rel[0]));
-       rel->next     = info->reloaders;
-       rel->reloader = before;
+       rel                = obstack_alloc(&env->obst, sizeof(rel[0]));
+       rel->next          = info->reloaders;
+       rel->reloader      = before;
        rel->rematted_node = NULL;
+       rel->allow_remat   = allow_remat;
 
        info->reloaders  = rel;
        assert(info->reload_cls == NULL || info->reload_cls == reload_cls);
@@ -250,11 +257,11 @@ static ir_node *get_reload_insertion_point(ir_node *block, int pos) {
        return last;
 }
 
-void be_add_reload_on_edge(spill_env_t *env, ir_node *to_spill,
-               ir_node *block, int pos, const arch_register_class_t *reload_cls)
+void be_add_reload_on_edge(spill_env_t *env, ir_node *to_spill, ir_node *block, int pos,
+               const arch_register_class_t *reload_cls, int allow_remat)
 {
        ir_node *before = get_reload_insertion_point(block, pos);
-       be_add_reload(env, to_spill, before, reload_cls);
+       be_add_reload(env, to_spill, before, reload_cls, allow_remat);
 }
 
 void be_spill_phi(spill_env_t *env, ir_node *node) {
@@ -650,11 +657,12 @@ void be_insert_spills_reloads(spill_env_t *env) {
                for (rld = si->reloaders; rld; rld = rld->next) {
                        ir_node *new_val;
 
-                       if(rld->rematted_node != NULL) {
+                       if (rld->rematted_node != NULL) {
                                new_val = rld->rematted_node;
                                remats++;
                                sched_add_before(rld->reloader, new_val);
-                       } else if (be_do_remats && check_remat_conditions(env, si->spilled_node, rld->reloader)) {
+                       }
+                       else if (be_do_remats && rld->allow_remat && check_remat_conditions(env, si->spilled_node, rld->reloader)) {
                                new_val = do_remat(env, si->spilled_node, rld->reloader);
                                remats++;
                        }

diff --git a/ir/be/bespill.h b/ir/be/bespill.h
index 19abf47..1a48274 100644 (file)
--- a/ir/be/bespill.h
+++ b/ir/be/bespill.h
@@ -40,13 +40,22 @@ DEBUG_ONLY(void be_set_spill_env_dbg_module(spill_env_t *env, firm_dbg_module_t
  * explicitly create spill nodes, they will be created automatically after
  * the definition of a value as soon as a reload is created. (we should add a
  * possibility for explicit spill placement in the future)
+ *
+ * @param senv        The spill environment
+ * @param to_spill    The node which is about to be spilled
+ * @param before      The node before the reload should be added
+ * @param reload_cls  The register class the reloaded value will be put into
+ * @param allow_remat Set to 1 if the node may be rematerialized instead of reloaded
  */
-void be_add_reload(spill_env_t *senv, ir_node *to_spill, ir_node *before, const arch_register_class_t *reload_cls);
+void be_add_reload(spill_env_t *senv, ir_node *to_spill, ir_node *before,
+       const arch_register_class_t *reload_cls, int allow_remat);
 
 /**
  * Analog to be_add_reload, but places the reload "on an edge" between 2 blocks
+ * @see be_add_reload
  */
-void be_add_reload_on_edge(spill_env_t *senv, ir_node *to_spill, ir_node *bl, int pos, const arch_register_class_t *reload_cls);
+void be_add_reload_on_edge(spill_env_t *senv, ir_node *to_spill, ir_node *bl, int pos,
+       const arch_register_class_t *reload_cls, int allow_remat);
 
 /**
  * Analog to be_add_reload but adds an already created rematerialized node.

diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c
index cd1acec..dcc5868 100644 (file)
--- a/ir/be/bespillbelady.c
+++ b/ir/be/bespillbelady.c
@@ -318,7 +318,7 @@ static void displace(belady_env_t *env, workset_t *new_vals, int is_usage) {
                        to_insert[demand++] = val;
                        if (is_usage) {
                                DBG((dbg, DBG_SPILL, "Reload %+F before %+F\n", val, env->instr));
-                               be_add_reload(env->senv, val, env->instr, env->cls);
+                               be_add_reload(env->senv, val, env->instr, env->cls, 1);
                        }
                }
                else {
@@ -680,7 +680,7 @@ static void fix_block_borders(ir_node *block, void *data) {
                        /* irnb is not in memory at the end of pred, so we have to reload it */
                        DBG((dbg, DBG_FIX, "    reload %+F\n", irnb));
                        DBG((dbg, DBG_SPILL, "Reload %+F before %+F,%d\n", irnb, block, i));
-                       be_add_reload_on_edge(env->senv, irnb, block, i, env->cls);
+                       be_add_reload_on_edge(env->senv, irnb, block, i, env->cls, 1);
 
 next_value:
                        /*epsilon statement :)*/;

diff --git a/ir/be/bespillmorgan.c b/ir/be/bespillmorgan.c
index b321d80..89b0a5e 100644 (file)
--- a/ir/be/bespillmorgan.c
+++ b/ir/be/bespillmorgan.c
@@ -63,7 +63,7 @@ typedef struct loop_attr {
        bitset_t *livethrough_unused;
 } loop_attr_t;
 
-typedef struct block_attr {
+typedef struct morgan_block_attr {
        const ir_node *block;
        /** set of all values that are live in the block but not used in the block */
        bitset_t *livethrough_unused;
@@ -433,7 +433,7 @@ static void spill_values(morgan_env_t *env, const loop_attr_t *loop_attr, int sp
                DBG((dbg, DBG_CHOOSE, "Spilling %+F ", to_spill));
 
                for(edge = set_first(loop_attr->out_edges); edge != NULL; edge = set_next(loop_attr->out_edges)) {
-                       be_add_reload_on_edge(env->senv, to_spill, edge->block, edge->pos, env->cls);
+                       be_add_reload_on_edge(env->senv, to_spill, edge->block, edge->pos, env->cls, 1);
                }
        }
 }

diff --git a/ir/be/bespillremat.c b/ir/be/bespillremat.c
index c02b51e..552322e 100644 (file)
--- a/ir/be/bespillremat.c
+++ b/ir/be/bespillremat.c
@@ -4537,7 +4537,7 @@ be_spill_remat(be_irg_t *birg, const arch_register_class_t *cls)
 
 static void be_spill_remat_oldinterface(const be_chordal_env_t *cenv)
 {
-       return be_spill_remat(cenv->birg, cenv->cls);
+       be_spill_remat(cenv->birg, cenv->cls);
 }
 
 void be_init_spillremat(void)