fixed warning on VC build

[libfirm] / ir / be / bespill.c

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index 26cff16..2d65965 100644 (file)
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -262,6 +262,26 @@ void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before,
                to_spill, before, allow_remat ? "" : " not"));
 }
 
+ir_node *be_get_end_of_block_insertion_point(const ir_node *block)
+{
+       ir_node *last = sched_last(block);
+
+       /* we might have projs and keepanys behind the jump... */
+       while(is_Proj(last) || be_is_Keep(last)) {
+               last = sched_prev(last);
+               assert(!sched_is_end(last));
+       }
+
+       if(!is_cfop(last)) {
+               last = sched_next(last);
+               /* last node must be a cfop, only exception is the start block */
+               assert(last     == get_irg_start_block(get_irn_irg(block)));
+       }
+
+       /* add the reload before the (cond-)jump */
+       return last;
+}
+
 /**
  * Returns the point at which you can insert a node that should be executed
  * before block @p block when coming from pred @p pos.
@@ -269,7 +289,7 @@ void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before,
 static
 ir_node *get_block_insertion_point(ir_node *block, int pos)
 {
-       ir_node *predblock, *last;
+       ir_node *predblock;
 
        /* simply add the reload to the beginning of the block if we only have 1
         * predecessor. We don't need to check for phis as there can't be any in a
@@ -281,22 +301,15 @@ ir_node *get_block_insertion_point(ir_node *block, int pos)
 
        /* We have to reload the value in pred-block */
        predblock = get_Block_cfgpred_block(block, pos);
-       last = sched_last(predblock);
-
-       /* we might have projs and keepanys behind the jump... */
-       while(is_Proj(last) || be_is_Keep(last)) {
-               last = sched_prev(last);
-               assert(!sched_is_end(last));
-       }
-
-       if(!is_cfop(last)) {
-               last = sched_next(last);
-               /* last node must be a cfop, only exception is the start block */
-               assert(last     == get_irg_start_block(get_irn_irg(block)));
-       }
+       return be_get_end_of_block_insertion_point(predblock);
+}
 
-       /* add the reload before the (cond-)jump */
-       return last;
+void be_add_reload_at_end(spill_env_t *env, ir_node *to_spill, const ir_node *block,
+                          const arch_register_class_t *reload_cls,
+                          int allow_remat)
+{
+       ir_node *before = be_get_end_of_block_insertion_point(block);
+       be_add_reload(env, to_spill, before, reload_cls, allow_remat);
 }
 
 void be_add_reload_on_edge(spill_env_t *env, ir_node *to_spill, ir_node *block,
@@ -529,7 +542,7 @@ void spill_node(spill_env_t *env, spill_info_t *spillinfo)
  * @returns 1 if value is available, 0 otherwise
  */
 static
-int is_value_available(spill_env_t *env, ir_node *arg, ir_node *reloader)
+int is_value_available(spill_env_t *env, const ir_node *arg, const ir_node *reloader)
 {
        if(is_Unknown(arg) || arg == new_NoMem())
                return 1;
@@ -581,7 +594,7 @@ int is_value_available(spill_env_t *env, ir_node *arg, ir_node *reloader)
  * Checks whether the node can principally be rematerialized
  */
 static
-int is_remat_node(spill_env_t *env, ir_node *node)
+int is_remat_node(spill_env_t *env, const ir_node *node)
 {
        const arch_env_t *arch_env = env->arch_env;
 
@@ -604,8 +617,8 @@ int is_remat_node(spill_env_t *env, ir_node *node)
  * >= REMAT_COST_INFINITE if remat is not possible.
  */
 static
-int check_remat_conditions_costs(spill_env_t *env, ir_node *spilled,
-                                 ir_node *reloader, int parentcosts)
+int check_remat_conditions_costs(spill_env_t *env, const ir_node *spilled,
+                                 const ir_node *reloader, int parentcosts)
 {
        int i, arity;
        int argremats;
@@ -689,15 +702,17 @@ ir_node *do_remat(spill_env_t *env, ir_node *spilled, ir_node *reloader)
                          get_irn_arity(spilled), ins);
        copy_node_attr(spilled, res);
        new_backedge_info(res);
-       sched_reset(res);
 
        DBG((dbg, LEVEL_1, "Insert remat %+F of %+F before reloader %+F\n", res, spilled, reloader));
 
-       /* insert in schedule */
-       sched_add_before(reloader, res);
+       if (! is_Proj(res)) {
+               /* insert in schedule */
+               sched_reset(res);
+               sched_add_before(reloader, res);
 #ifdef FIRM_STATISTICS
-       env->remat_count++;
+               env->remat_count++;
 #endif
+       }
 
        return res;
 }
@@ -726,6 +741,11 @@ double be_get_reload_costs(spill_env_t *env, ir_node *to_spill, ir_node *before)
        return env->reload_cost * freq;
 }
 
+int be_is_rematerializable(spill_env_t *env, const ir_node *to_remat, const ir_node *before)
+{
+       return check_remat_conditions_costs(env, to_remat, before, 0) < REMAT_COST_INFINITE;
+}
+
 double be_get_reload_costs_on_edge(spill_env_t *env, ir_node *to_spill,
                                 ir_node *block, int pos)
 {
@@ -801,7 +821,7 @@ void be_insert_spills_reloads(spill_env_t *env)
 
                                remat_cost_delta      = remat_cost - env->reload_cost;
                                rld->remat_cost_delta = remat_cost_delta;
-                               block                 = get_nodes_block(reloader);
+                               block                 = is_Block(reloader) ? reloader : get_nodes_block(reloader);
                                freq                  = get_block_execfreq(exec_freq, block);
                                all_remat_costs      += remat_cost_delta * freq;
                                DBG((dbg, LEVEL_2, "\tremat costs delta before %+F: "
@@ -883,14 +903,10 @@ void be_insert_spills_reloads(spill_env_t *env)
                si->reloaders = NULL;
        }
 
-#ifdef FIRM_STATISTICS
-       if (be_stat_ev_is_active()) {
-               be_stat_ev("spill_spills", env->spill_count);
-               be_stat_ev("spill_reloads", env->reload_count);
-               be_stat_ev("spill_remats", env->remat_count);
-               be_stat_ev("spill_spilled_phis", env->spilled_phi_count);
-       }
-#endif
+       stat_ev_dbl("spill_spills", env->spill_count);
+       stat_ev_dbl("spill_reloads", env->reload_count);
+       stat_ev_dbl("spill_remats", env->remat_count);
+       stat_ev_dbl("spill_spilled_phis", env->spilled_phi_count);
 
        /* Matze: In theory be_ssa_construction should take care of the liveness...
         * try to disable this again in the future */