X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillremat.c;h=69c216dce0e8b1b34282ce743d7b57d9a2301638;hb=92dc34b4a3a1880d8e39cc87aaa2bdfcdaf517f2;hp=6c3624728793e25eecbc558d6501d7f72e523819;hpb=c7dc4e00778a90bdedd07340767ff85731376c3b;p=libfirm

diff --git a/ir/be/bespillremat.c b/ir/be/bespillremat.c
index 6c3624728..69c216dce 100644
--- a/ir/be/bespillremat.c
+++ b/ir/be/bespillremat.c
@@ -35,6 +35,7 @@
 #include "irvrfy.h"
 
 #include <lpp/lpp.h>
+#include <lpp/mps.h>
 #include <lpp/lpp_net.h>
 #include <lpp/lpp_cplex.h>
 //#include <lc_pset.h>
@@ -53,37 +54,120 @@
 
 #include "bechordal_t.h"
 
-#define BIGM 100000.0
-
-#define DUMP_SOLUTION
-#define DUMP_ILP
-//#define KEEPALIVE /* keep alive all inserted remats and dump graph with remats */
-#define COLLECT_REMATS /* enable rematerialization */
-#define COLLECT_INVERSE_REMATS /* enable placement of inverse remats */
-#define REMAT_WHILE_LIVE /* only remat values that are live */
-//#define NO_ENLARGE_L1V3N355 /* do not remat after the death of some operand */
-//#define EXECFREQ_LOOPDEPH /* compute execution frequency from loop depth only */
-#define MAY_DIE_AT_REMAT /* allow values to die after a pre remat */
-#define NO_SINGLE_USE_REMATS /* do not repair schedule */
-//#define KEEPALIVE_SPILLS
-//#define KEEPALIVE_RELOADS
-#define GOODWIN_REDUCTION
-//#define NO_MEMCOPIES
-//#define VERIFY_DOMINANCE
-#define WITH_MEMOPERANDS
+#ifdef WITH_LIBCORE
+#include <libcore/lc_opts.h>
+#include <libcore/lc_opts_enum.h>
+#endif /* WITH_LIBCORE */
+
+#define DUMP_PROBLEM       1
+#define DUMP_MPS           2
+#define DUMP_SOLUTION      4
+
+#define KEEPALIVE_REMATS   1
+#define KEEPALIVE_SPILLS   2
+#define KEEPALIVE_RELOADS  4
+
+#define VERIFY_MEMINTERF   1
+#define VERIFY_DOMINANCE   2
+
+#define REMATS_NONE        0
+#define REMATS_BRIGGS      1
+#define REMATS_NOINVERSE   2
+#define REMATS_ALL         3
+
+static int opt_dump_flags   = 0;
+static int opt_log = 0;
+static int opt_keep_alive   = 0;
+static int opt_goodwin = 1;
+static int opt_memcopies = 1;
+static int opt_memoperands = 1;
+static int opt_verify = VERIFY_MEMINTERF;
+static int opt_remats = REMATS_ALL;
+static int opt_repair_schedule = 0;
+static int opt_no_enlarge_liveness = 0;
+static int opt_remat_while_live = 1;
+static int opt_timeout = 300;
+static double opt_cost_reload = 8.0;
+static double opt_cost_memoperand =  7.0;
+static double opt_cost_spill =  50.0;
+static double opt_cost_remat =  1.0;
+
+
+#ifdef WITH_LIBCORE
+static const lc_opt_enum_mask_items_t dump_items[] = {
+	{ "problem",  DUMP_PROBLEM  },
+	{ "mps",      DUMP_MPS      },
+	{ "solution", DUMP_SOLUTION },
+	{ NULL,       0 }
+};
+
+static lc_opt_enum_mask_var_t dump_var = {
+	&opt_dump_flags, dump_items
+};
+
+static const lc_opt_enum_mask_items_t keepalive_items[] = {
+	{ "remats",  KEEPALIVE_REMATS  },
+	{ "spills",  KEEPALIVE_SPILLS  },
+	{ "reloads", KEEPALIVE_RELOADS },
+	{ NULL,      0 }
+};
+
+static lc_opt_enum_mask_var_t keep_alive_var = {
+	&opt_keep_alive, keepalive_items
+};
+
+static const lc_opt_enum_mask_items_t remats_items[] = {
+	{ "none",      REMATS_NONE      },
+	{ "briggs",    REMATS_BRIGGS    },
+	{ "noinverse", REMATS_NOINVERSE },
+	{ "all",       REMATS_ALL       },
+	{ NULL,        0 }
+};
+
+static lc_opt_enum_mask_var_t remats_var = {
+	&opt_remats, remats_items
+};
+
+static const lc_opt_table_entry_t options[] = {
+	LC_OPT_ENT_ENUM_MASK("keepalive", "keep alive remats, spills or reloads",                   &keep_alive_var),
+
+	LC_OPT_ENT_BOOL     ("goodwin",  "activate goodwin reduction",                              &opt_goodwin),
+	LC_OPT_ENT_BOOL     ("memcopies",  "activate memcopy handling",                             &opt_memcopies),
+	LC_OPT_ENT_BOOL     ("memoperands",  "activate memoperands",                                &opt_memoperands),
+	LC_OPT_ENT_ENUM_INT ("remats",  "type of remats to insert (none, briggs, noinverse or all)",&remats_var),
+	LC_OPT_ENT_BOOL     ("repair_schedule",  "repair the schedule by rematting once used nodes",&opt_repair_schedule),
+	LC_OPT_ENT_BOOL     ("no_enlage_liveness",  "do not enlarge liveness of operands of remats",&opt_no_enlarge_liveness),
+	LC_OPT_ENT_BOOL     ("remat_while_live",  "remat only values that can be used by real ops", &opt_remat_while_live),
+
+	LC_OPT_ENT_ENUM_MASK("dump", "dump problem, mps or solution",                               &dump_var),
+	LC_OPT_ENT_BOOL     ("log",  "activate the lpp log",                                        &opt_log),
+	LC_OPT_ENT_INT      ("timeout",  "ILP solver timeout",                                      &opt_timeout),
+
+	LC_OPT_ENT_DBL      ("cost_reload",  "cost of a reload",                                    &opt_cost_reload),
+	LC_OPT_ENT_DBL      ("cost_memoperand",  "cost of a memory operand",                        &opt_cost_memoperand),
+	LC_OPT_ENT_DBL      ("cost_spill",  "cost of a spill instruction",                          &opt_cost_spill),
+	LC_OPT_ENT_DBL      ("cost_remat",  "cost of a rematerialization",                          &opt_cost_remat),
+	{ NULL }
+};
+
+void be_spill_remat_register_options(lc_opt_entry_t *grp)
+{
+	lc_opt_entry_t *my_grp = lc_opt_get_grp(grp, "remat");
+	lc_opt_add_table(my_grp, options);
+}
+#endif
+
+
+//#define EXECFREQ_LOOPDEPH   /* compute execution frequency from loop depth only */
+//#define SCHEDULE_PHIM   /* insert phim nodes into schedule */
 
 #define  SOLVE
 //#define  SOLVE_LOCAL
 #define LPP_SERVER "i44pc52"
 #define LPP_SOLVER "cplex"
 
-#define COST_LOAD        8
-#define COST_MEMOPERAND  7
-#define COST_STORE       50
-#define COST_REMAT       1
 
-#define ILP_TIMEOUT    300
-#define MAX_PATHS      16
+#define MAX_PATHS      INT_MAX
 #define ILP_UNDEF		-1
 
 typedef struct _spill_ilp_t {
@@ -96,16 +180,12 @@ typedef struct _spill_ilp_t {
 	set                          *remat_info;
 	pset                         *all_possible_remats;
 	pset                         *inverse_ops;
-#ifdef KEEPALIVE
 	ir_node                      *keep;
-#endif
 	set                          *values; /**< for collecting all definitions of values before running ssa-construction */
 	pset                         *spills;
 	set                          *interferences;
 	ir_node                      *m_unknown;
-#ifdef WITH_MEMOPERANDS
 	set                          *memoperands;
-#endif
 	DEBUG_ONLY(firm_dbg_module_t * dbg);
 } spill_ilp_t;
 
@@ -175,13 +255,11 @@ typedef struct _spill_t {
 	ilp_var_t           spill;
 } spill_t;
 
-#ifdef WITH_MEMOPERANDS
 typedef struct _memoperand_t {
 	ir_node             *irn; /**< the irn */
 	unsigned int         pos; /**< the position of the argument */
 	ilp_var_t            ilp; /**< the ilp var for this memory operand */
 } memoperand_t;
-#endif
 
 static INLINE int
 has_reg_class(const spill_ilp_t * si, const ir_node * irn)
@@ -222,7 +300,6 @@ cmp_spill(const void *a, const void *b, size_t size)
 	return !(p->irn == q->irn);
 }
 
-#ifdef WITH_MEMOPERANDS
 static int
 cmp_memoperands(const void *a, const void *b, size_t size)
 {
@@ -231,7 +308,6 @@ cmp_memoperands(const void *a, const void *b, size_t size)
 
 	return !(p->irn == q->irn && p->pos == q->pos);
 }
-#endif
 
 static keyval_t *
 set_find_keyval(set * set, const void * key)
@@ -272,7 +348,6 @@ set_insert_def(set * set, const ir_node * value)
 	return set_insert(set, &query, sizeof(query), HASH_PTR(value));
 }
 
-#ifdef WITH_MEMOPERANDS
 static memoperand_t *
 set_insert_memoperand(set * set, ir_node * irn, unsigned int pos, ilp_var_t ilp)
 {
@@ -293,7 +368,6 @@ set_find_memoperand(set * set, const ir_node * irn, unsigned int pos)
 	query.pos = pos;
 	return set_find(set, &query, sizeof(query), HASH_PTR(irn)+pos);
 }
-#endif
 
 
 static spill_t *
@@ -356,9 +430,9 @@ static double
 get_cost(const spill_ilp_t * si, const ir_node * irn)
 {
 	if(be_is_Spill(irn)) {
-		return COST_STORE;
+		return opt_cost_spill;
 	} else if(be_is_Reload(irn)){
-		return COST_LOAD;
+		return opt_cost_reload;
 	} else {
 		return arch_get_op_estimated_cost(si->chordal_env->birg->main_env->arch_env, irn);
 	}
@@ -405,7 +479,7 @@ get_remat_from_op(spill_ilp_t * si, const ir_node * dest_value, const ir_node *
 		const ir_node *proj = NULL;
 
 		if(is_Proj(dest_value)) {
-			op = get_irn_n(op, 0);
+			op = get_Proj_pred(op);
 			proj = dest_value;
 		}
 
@@ -522,39 +596,55 @@ get_irn_n_nonremat_edges(const spill_ilp_t * si, const ir_node * irn)
 	return i;
 }
 
+static int
+get_irn_n_nonignore_args(const spill_ilp_t * si, const ir_node * irn)
+{
+	int n;
+	int ret = 0;
+
+//	if(is_Proj(irn))
+//		irn = get_Proj_pred(irn);
+
+	for(n=get_irn_arity(irn)-1; n>=0; --n) {
+		const ir_node  *arg = get_irn_n(irn, n);
+
+		if(has_reg_class(si, arg)) ++ret;
+	}
+
+	return ret;
+}
+
 static INLINE void
 get_remats_from_op(spill_ilp_t * si, const ir_node * op)
 {
 	int      n;
 	remat_t *remat;
 
-#ifdef NO_SINGLE_USE_REMATS
-	if(has_reg_class(si, op) && (get_irn_n_nonremat_edges(si, op) > 1)) {
-#else
-	if(has_reg_class(si, op)) {
-#endif
+	if( has_reg_class(si, op)
+	&& (opt_repair_schedule || get_irn_n_nonremat_edges(si, op) > 1)
+	&& (opt_remats !=  REMATS_BRIGGS || get_irn_n_nonignore_args(si, op) == 0)
+	) {
 		remat = get_remat_from_op(si, op, op);
 		if(remat) {
 			add_remat(si, remat);
 		}
 	}
 
-#ifdef COLLECT_INVERSE_REMATS
-	/* repeat the whole stuff for each remat retrieved by get_remat_from_op(op, arg)
-	   for each arg */
-	for (n = get_irn_arity(op)-1; n>=0; --n) {
-		ir_node        *arg = get_irn_n(op, n);
-
-		if(has_reg_class(si, arg)) {
-			/* try to get an inverse remat */
-			remat = get_remat_from_op(si, arg, op);
-			if(remat) {
-				add_remat(si, remat);
+	if(opt_remats == REMATS_ALL) {
+		/* repeat the whole stuff for each remat retrieved by get_remat_from_op(op, arg)
+		   for each arg */
+		for (n = get_irn_arity(op)-1; n>=0; --n) {
+			ir_node        *arg = get_irn_n(op, n);
+
+			if(has_reg_class(si, arg)) {
+				/* try to get an inverse remat */
+				remat = get_remat_from_op(si, arg, op);
+				if(remat) {
+					add_remat(si, remat);
+				}
 			}
 		}
 	}
-#endif
-
 }
 
 static INLINE int
@@ -704,15 +794,15 @@ can_remat_before(const spill_ilp_t * si, const remat_t * remat, const ir_node *
 	for(n=get_irn_arity(op)-1; n>=0 && res; --n) {
 		const ir_node   *arg = get_irn_n(op, n);
 
-#ifdef NO_ENLARGE_L1V3N355
-		if(has_reg_class(si, arg) && live) {
-			res &= pset_find_ptr(live, arg)?1:0;
+		if(opt_no_enlarge_liveness) {
+			if(has_reg_class(si, arg) && live) {
+				res &= pset_find_ptr((pset*)live, arg)?1:0;
+			} else {
+				res &= value_is_defined_before(si, pos, arg);
+			}
 		} else {
 			res &= value_is_defined_before(si, pos, arg);
 		}
-#else
-		res &= value_is_defined_before(si, pos, arg);
-#endif
 	}
 
 	return res;
@@ -800,7 +890,7 @@ insert_remat_after(spill_ilp_t * si, const remat_t * remat, ir_node * pos, const
 						*proj_copy;
 		op_t            *op;
 
-		DBG((si->dbg, LEVEL_3, "\t  >inserting remat %+F\n", remat->op));
+		DBG((si->dbg, LEVEL_3, "\t  >inserting remat2 %+F\n", remat->op));
 
 		copy = insert_copy_after(si, remat->op, pos);
 
@@ -809,7 +899,7 @@ insert_remat_after(spill_ilp_t * si, const remat_t * remat, ir_node * pos, const
 		op->is_remat = 1;
 		op->attr.remat.remat = remat;
 		op->attr.remat.pre = 0;
-		op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos));
+		op->attr.remat.ilp = lpp_add_var_default(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos), 0.0);
 
 		set_irn_link(copy, op);
 		pset_insert_ptr(si->all_possible_remats, copy);
@@ -847,7 +937,7 @@ insert_remat_before(spill_ilp_t * si, const remat_t * remat, ir_node * pos, cons
 		op->is_remat = 1;
 		op->attr.remat.remat = remat;
 		op->attr.remat.pre = 1;
-		op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos));
+		op->attr.remat.ilp = lpp_add_var_default(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos), 0.0);
 
 		set_irn_link(copy, op);
 		pset_insert_ptr(si->all_possible_remats, copy);
@@ -880,24 +970,45 @@ get_block_n_succs(const ir_node *block) {
 	return edge ? 2 : 1;
 }
 
+static int
+is_start_block(const ir_node * bb)
+{
+	return get_irg_start_block(get_irn_irg(bb)) == bb;
+}
+
+static int
+is_before_frame(const ir_node * bb, const ir_node * irn)
+{
+	const ir_node  *frame  = get_irg_frame(get_irn_irg(bb));
+
+	if(is_start_block(bb) && sched_get_time_step(frame) >= sched_get_time_step(irn))
+		return 1;
+	else
+		return 0;
+}
+
 static int
 is_merge_edge(const ir_node * bb)
 {
-#ifdef GOODWIN_REDUCTION
-	return get_block_n_succs(bb) == 1;
-#else
-	return 1;
-#endif
+	if(is_start_block(bb))
+		return 0;
+
+	if(opt_goodwin)
+		return get_block_n_succs(bb) == 1;
+	else
+		return 1;
 }
 
 static int
 is_diverge_edge(const ir_node * bb)
 {
-#ifdef GOODWIN_REDUCTION
-	return get_Block_n_cfgpreds(bb) == 1;
-#else
-	return 1;
-#endif
+	if(is_start_block(bb))
+		return 0;
+
+	if(opt_goodwin)
+		return get_Block_n_cfgpreds(bb) == 1;
+	else
+		return 1;
 }
 
 static void
@@ -1042,13 +1153,13 @@ walker_remat_insertor(ir_node * bb, void * data)
 					ir_node  *remat_irn = NULL;
 
 					DBG((si->dbg, LEVEL_4, "\t  considering remat %+F for arg %+F\n", remat->op, arg));
-#ifdef REMAT_WHILE_LIVE
-					if(pset_find_ptr(live, remat->value)) {
+					if(opt_remat_while_live) {
+						if(pset_find_ptr(live, remat->value)) {
+							remat_irn = insert_remat_before(si, remat, irn, live);
+						}
+					} else {
 						remat_irn = insert_remat_before(si, remat, irn, live);
 					}
-#else
-					remat_irn = insert_remat_before(si, remat, irn, live);
-#endif
 					if(remat_irn) {
 						for(n=get_irn_arity(remat_irn)-1; n>=0; --n) {
 							ir_node  *remat_arg = get_irn_n(remat_irn, n);
@@ -1099,13 +1210,13 @@ walker_remat_insertor(ir_node * bb, void * data)
 					/* do not insert remats producing the same value as one of the operands */
 					if(!pset_find_ptr(args, remat->value)) {
 						DBG((si->dbg, LEVEL_4, "\t  considering remat %+F with arg %+F\n", remat->op, arg));
-#ifdef REMAT_WHILE_LIVE
-						if(pset_find_ptr(live, remat->value)) {
+						if(opt_remat_while_live) {
+							if(pset_find_ptr(live, remat->value)) {
+								insert_remat_after(si, remat, irn, live);
+							}
+						} else {
 							insert_remat_after(si, remat, irn, live);
 						}
-#else
-						insert_remat_after(si, remat, irn, live);
-#endif
 					}
 				}
 			}
@@ -1116,33 +1227,55 @@ walker_remat_insertor(ir_node * bb, void * data)
 		irn = next;
 	}
 
-	be_lv_foreach(si->lv, bb, be_lv_state_end | be_lv_state_in, i) {
-		ir_node        *value = be_lv_get_irn(si->lv, bb, i);
+	/* add remats at end if successor has multiple predecessors */
+	if(is_merge_edge(bb)) {
+		pset     *live_out = pset_new_ptr_default();
+		ir_node  *value;
+
+		be_lv_foreach(si->lv, bb, be_lv_state_end, i) {
+			value = be_lv_get_irn(si->lv, bb, i);
 
-		/* add remats at end if successor has multiple predecessors */
-		if(is_merge_edge(bb)) {
-			/* add remats at end of block */
 			if (be_is_live_end(si->lv, bb, value) && has_reg_class(si, value)) {
-				remat_info_t   *remat_info,
-							   query;
-				remat_t        *remat;
+				pset_insert_ptr(live_out, value);
+			}
+		}
 
-				query.irn = value;
-				query.remats = NULL;
-				query.remats_by_operand = NULL;
-				remat_info = set_find(si->remat_info, &query, sizeof(query), HASH_PTR(value));
+		/* add remats at end of block */
+		pset_foreach(live_out, value) {
+			remat_info_t   *remat_info,
+						   query;
+			remat_t        *remat;
+
+			query.irn = value;
+			query.remats = NULL;
+			query.remats_by_operand = NULL;
+			remat_info = set_find(si->remat_info, &query, sizeof(query), HASH_PTR(value));
 
-				if(remat_info && remat_info->remats) {
-					pset_foreach(remat_info->remats, remat) {
-						DBG((si->dbg, LEVEL_4, "\t  considering remat %+F at end of block %+F\n", remat->op, bb));
+			if(remat_info && remat_info->remats) {
+				pset_foreach(remat_info->remats, remat) {
+					DBG((si->dbg, LEVEL_4, "\t  considering remat %+F at end of block %+F\n", remat->op, bb));
 
-						insert_remat_before(si, remat, bb, NULL);
-					}
+					insert_remat_before(si, remat, bb, live_out);
 				}
 			}
 		}
-		if(is_diverge_edge(bb)) {
-			/* add remat2s at beginning of block */
+		del_pset(live_out);
+	}
+
+	if(is_diverge_edge(bb)) {
+		pset     *live_in = pset_new_ptr_default();
+		ir_node  *value;
+
+		be_lv_foreach(si->lv, bb, be_lv_state_in, i) {
+			value = be_lv_get_irn(si->lv, bb, i);
+
+			if (has_reg_class(si, value)) {
+				pset_insert_ptr(live_in, value);
+			}
+		}
+
+		/* add remat2s at beginning of block */
+		pset_foreach(live_in, value) {
 			if ((be_is_live_in(si->lv, bb, value) || (is_Phi(value) && get_nodes_block(value)==bb)) && has_reg_class(si, value)) {
 				remat_info_t   *remat_info,
 							   query;
@@ -1153,17 +1286,18 @@ walker_remat_insertor(ir_node * bb, void * data)
 				query.remats_by_operand = NULL;
 				remat_info = set_find(si->remat_info, &query, sizeof(query), HASH_PTR(value));
 
-				if(remat_info && remat_info->remats) {
-					pset_foreach(remat_info->remats, remat) {
-						DBG((si->dbg, LEVEL_4, "\t  considering remat %+F at beginning of block %+F\n", remat->op, bb));
+				if(remat_info && remat_info->remats_by_operand) {
+					pset_foreach(remat_info->remats_by_operand, remat) {
+						DBG((si->dbg, LEVEL_4, "\t  considering remat2 %+F at beginning of block %+F\n", remat->op, bb));
 
 						/* put the remat here if all its args are available */
-						insert_remat_after(si, remat, bb, NULL);
+						insert_remat_after(si, remat, bb, live_in);
 
 					}
 				}
 			}
 		}
+		del_pset(live_in);
 	}
 }
 
@@ -1232,6 +1366,7 @@ luke_endwalker(ir_node * bb, void * data)
 		spill_t     query,
 					*spill;
 		double      spill_cost;
+		int         default_spilled;
 
 
 		/* handle values used by control flow nodes later separately */
@@ -1240,24 +1375,26 @@ luke_endwalker(ir_node * bb, void * data)
 		query.irn = irn;
 		spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
 
-		spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+		spill_cost = is_Unknown(irn)?0.0001:opt_cost_spill*execution_frequency(si, bb);
 
 		ir_snprintf(buf, sizeof(buf), "reg_out_%N_%N", irn, bb);
-		spill->reg_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->reg_out = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 		lpp_set_factor_fast(si->lpp, cst, spill->reg_out, 1.0);
 
 		ir_snprintf(buf, sizeof(buf), "mem_out_%N_%N", irn, bb);
-		spill->mem_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->mem_out = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 		ir_snprintf(buf, sizeof(buf), "spill_%N_%N", irn, bb);
-		spill->spill = lpp_add_var(si->lpp, buf, lpp_binary, spill_cost);
+		/* by default spill value right after definition */
+		default_spilled = be_is_live_in(si->lv, bb, irn) || is_Phi(irn);
+		spill->spill    = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, !default_spilled);
 
 		if(is_merge_edge(bb)) {
 			ilp_var_t   reload;
 			ilp_cst_t   rel_cst;
 
 			ir_snprintf(buf, sizeof(buf), "reload_%N_%N", bb, irn);
-			reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+			reload = lpp_add_var_default(si->lpp, buf, lpp_binary, opt_cost_reload*execution_frequency(si, bb), 1.0);
 			set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
 
 			/* reload <= mem_out */
@@ -1277,25 +1414,28 @@ luke_endwalker(ir_node * bb, void * data)
 		ilp_cst_t   end_use_req,
 					rel_cst;
 		ilp_var_t   reload;
+		int         default_spilled;
 
 		query.irn = irn;
 		spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
 
-		spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+		spill_cost = is_Unknown(irn)?0.0001:opt_cost_spill*execution_frequency(si, bb);
 
 		ir_snprintf(buf, sizeof(buf), "reg_out_%N_%N", irn, bb);
-		spill->reg_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->reg_out = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 		/* if irn is used at the end of the block, then it is live anyway */
 		//lpp_set_factor_fast(si->lpp, cst, spill->reg_out, 1.0);
 
 		ir_snprintf(buf, sizeof(buf), "mem_out_%N_%N", irn, bb);
-		spill->mem_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->mem_out = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 		ir_snprintf(buf, sizeof(buf), "spill_%N_%N", irn, bb);
-		spill->spill = lpp_add_var(si->lpp, buf, lpp_binary, spill_cost);
+		default_spilled = be_is_live_in(si->lv, bb, irn) || is_Phi(irn);
+		spill->spill    = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, !default_spilled);
 
+		/* reload for use be control flow op */
 		ir_snprintf(buf, sizeof(buf), "reload_%N_%N", bb, irn);
-		reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+		reload = lpp_add_var_default(si->lpp, buf, lpp_binary, opt_cost_reload*execution_frequency(si, bb), 1.0);
 		set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
 
 		/* reload <= mem_out */
@@ -1399,11 +1539,12 @@ add_to_spill_bb(spill_ilp_t * si, ir_node * bb, ir_node * irn)
 	spill_t     *spill,
 				 query;
 	char         buf[256];
+	int          default_spilled;
 
 	query.irn = irn;
 	spill = set_find(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
 	if(!spill) {
-		double   spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+		double   spill_cost = is_Unknown(irn)?0.0001:opt_cost_spill*execution_frequency(si, bb);
 
 		spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
 
@@ -1412,10 +1553,11 @@ add_to_spill_bb(spill_ilp_t * si, ir_node * bb, ir_node * irn)
 		spill->mem_in  = ILP_UNDEF;
 
 		ir_snprintf(buf, sizeof(buf), "mem_out_%N_%N", irn, bb);
-		spill->mem_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->mem_out = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 		ir_snprintf(buf, sizeof(buf), "spill_%N_%N", irn, bb);
-		spill->spill = lpp_add_var(si->lpp, buf, lpp_binary, spill_cost);
+		default_spilled = be_is_live_in(si->lv, bb, irn) || is_Phi(irn);
+		spill->spill    = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, !default_spilled);
 	}
 
 	return spill;
@@ -1483,7 +1625,7 @@ insert_mem_copy_position(spill_ilp_t * si, pset * live, const ir_node * block)
 	if(edge) return;
 
 	ir_snprintf(buf, sizeof(buf), "copyreg_%N", block);
-	copyreg = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+	copyreg = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 	ir_snprintf(buf, sizeof(buf), "check_copyreg_%N", block);
 	cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, si->n_regs);
@@ -1568,9 +1710,7 @@ luke_blockwalker(ir_node * bb, void * data)
 	ir_node        *tmp;
 	spill_t        *spill;
 	pset           *defs = pset_new_ptr_default();
-#ifdef WITH_MEMOPERANDS
 	const arch_env_t *arch_env = si->chordal_env->birg->main_env->arch_env;
-#endif
 
 
 	live = pset_new_ptr_default();
@@ -1602,7 +1742,7 @@ luke_blockwalker(ir_node * bb, void * data)
 		assert(!op->is_remat);
 
 		ir_snprintf(buf, sizeof(buf), "lr_%N_%N", irn, bb);
-		op->attr.live_range.ilp = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		op->attr.live_range.ilp = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 		op->attr.live_range.op = bb;
 
 		ir_snprintf(buf, sizeof(buf), "reg_out_%N_%N", bb, irn);
@@ -1621,9 +1761,8 @@ luke_blockwalker(ir_node * bb, void * data)
 		/* maybe we should also assure that reg_out >= live_range etc. */
 	}
 
-#ifndef NO_MEMCOPIES
-	insert_mem_copy_position(si, live, bb);
-#endif
+	if(opt_memcopies)
+		insert_mem_copy_position(si, live, bb);
 
 	/*
 	 * start new live ranges for values used by remats at end of block
@@ -1643,7 +1782,7 @@ luke_blockwalker(ir_node * bb, void * data)
 			/* if value is becoming live through use by remat */
 			if(!pset_find_ptr(live, remat_arg)) {
 				ir_snprintf(buf, sizeof(buf), "lr_%N_end%N", remat_arg, bb);
-				prev_lr = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+				prev_lr = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 
 				arg_op->attr.live_range.ilp = prev_lr;
 				arg_op->attr.live_range.op = bb;
@@ -1694,9 +1833,7 @@ luke_blockwalker(ir_node * bb, void * data)
 		pset       *used;
 		pset       *remat_defs;
 		keyval_t   *keyval;
-#ifdef WITH_MEMOPERANDS
 		ilp_cst_t   one_memoperand;
-#endif
 
 		/* iterate only until first phi */
 		if(is_Phi(irn))
@@ -1841,7 +1978,7 @@ skip_one_must_die:
 					cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
 
 					ir_snprintf(buf, sizeof(buf), "lr_%N_%N", value, irn);
-					prev_lr = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+					prev_lr = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 
 					lpp_set_factor_fast(si->lpp, cst, value_op->attr.live_range.ilp, 1.0);
 					lpp_set_factor_fast(si->lpp, cst, prev_lr, -1.0);
@@ -1883,7 +2020,7 @@ skip_one_must_die:
 						ilp_var_t     lr;
 
 						ir_snprintf(buf, sizeof(buf), "lr_%N_%N", remat_arg, irn);
-						lr = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+						lr = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 
 						arg_op->attr.live_range.ilp = lr;
 						arg_op->attr.live_range.op = irn;
@@ -1939,11 +2076,11 @@ skip_one_must_die:
 
 			/* new live range for each used value */
 			ir_snprintf(buf, sizeof(buf), "lr_%N_%N", arg, irn);
-			prev_lr = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+			prev_lr = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, is_before_frame(bb, irn)?1.0:0.0);
 
 			/* the epilog stuff - including post_use, check_post, check_post_remat */
 			ir_snprintf(buf, sizeof(buf), "post_use_%N_%N", arg, irn);
-			post_use = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+			post_use = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 
 			lpp_set_factor_fast(si->lpp, check_post, post_use, 1.0);
 
@@ -1998,25 +2135,25 @@ skip_one_must_die:
 				}
 			}
 
-#ifdef WITH_MEMOPERANDS
-			for(n = get_irn_arity(irn)-1; n>=0; --n) {
-				if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
-					ilp_var_t       memoperand;
+			if(opt_memoperands) {
+				for(n = get_irn_arity(irn)-1; n>=0; --n) {
+					if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
+						ilp_var_t       memoperand;
 
-					ir_snprintf(buf, sizeof(buf), "memoperand_%N_%d", irn, n);
-					memoperand = lpp_add_var(si->lpp, buf, lpp_binary, COST_MEMOPERAND*execution_frequency(si, bb));
-					set_insert_memoperand(si->memoperands, irn, n, memoperand);
+						ir_snprintf(buf, sizeof(buf), "memoperand_%N_%d", irn, n);
+						memoperand = lpp_add_var_default(si->lpp, buf, lpp_binary, opt_cost_memoperand*execution_frequency(si, bb), 0.0);
+						set_insert_memoperand(si->memoperands, irn, n, memoperand);
 
-					ir_snprintf(buf, sizeof(buf), "nolivepost_%N_%d", irn, n);
-					cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 1.0);
+						ir_snprintf(buf, sizeof(buf), "nolivepost_%N_%d", irn, n);
+						cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 1.0);
 
-					lpp_set_factor_fast(si->lpp, cst, memoperand, 1.0);
-					lpp_set_factor_fast(si->lpp, cst, post_use, 1.0);
-//					if(arg_op->attr.live_range.ilp != ILP_UNDEF)
-//						lpp_set_factor_fast(si->lpp, cst, arg_op->attr.live_range.ilp, 1.0);
+						lpp_set_factor_fast(si->lpp, cst, memoperand, 1.0);
+						lpp_set_factor_fast(si->lpp, cst, post_use, 1.0);
+//						if(arg_op->attr.live_range.ilp != ILP_UNDEF)
+//							lpp_set_factor_fast(si->lpp, cst, arg_op->attr.live_range.ilp, 1.0);
+					}
 				}
 			}
-#endif
 
 			/* new live range begins for each used value */
 			arg_op->attr.live_range.ilp = prev_lr;
@@ -2050,10 +2187,10 @@ skip_one_must_die:
 			pset_remove_ptr(live, tmp);
 		}
 
-#ifdef WITH_MEMOPERANDS
-		ir_snprintf(buf, sizeof(buf), "one_memoperand_%N", irn);
-		one_memoperand = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 1.0);
-#endif
+		if(opt_memoperands) {
+			ir_snprintf(buf, sizeof(buf), "one_memoperand_%N", irn);
+			one_memoperand = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 1.0);
+		}
 
 		/***********************************************************
 		 *  I T E R A T I O N  O V E R  A R G S  F O R  P R O L O G
@@ -2066,15 +2203,13 @@ skip_one_must_die:
 			int               i = PTR_TO_INT(keyval->val);
 			op_t             *arg_op = get_irn_link(arg);
 			ilp_cst_t         requirements;
-#ifdef WITH_MEMOPERANDS
 			int               n_memoperands;
-#endif
 
 			spill = set_find_spill(spill_bb->ilp, arg);
 			assert(spill);
 
 			ir_snprintf(buf, sizeof(buf), "reload_%N_%N", arg, irn);
-			op->attr.live_range.args.reloads[i] = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+			op->attr.live_range.args.reloads[i] = lpp_add_var_default(si->lpp, buf, lpp_binary, opt_cost_reload*execution_frequency(si, bb), is_before_frame(bb, irn)?0.0:1.0);
 
 			/* reload <= mem_out */
 			ir_snprintf(buf, sizeof(buf), "req_reload_%N_%N", arg, irn);
@@ -2096,35 +2231,35 @@ skip_one_must_die:
 				}
 			}
 
-#ifdef WITH_MEMOPERANDS
-			n_memoperands = 0;
-			for(n = get_irn_arity(irn)-1; n>=0; --n) {
-				if(get_irn_n(irn, n) == arg) {
-					n_memoperands++;
+			if(opt_memoperands) {
+				n_memoperands = 0;
+				for(n = get_irn_arity(irn)-1; n>=0; --n) {
+					if(get_irn_n(irn, n) == arg) {
+						n_memoperands++;
+					}
 				}
-			}
-			for(n = get_irn_arity(irn)-1; n>=0; --n) {
-				if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
-					memoperand_t  *memoperand;
-					memoperand = set_find_memoperand(si->memoperands, irn, n);
+				for(n = get_irn_arity(irn)-1; n>=0; --n) {
+					if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
+						memoperand_t  *memoperand;
+						memoperand = set_find_memoperand(si->memoperands, irn, n);
 
-					/* memoperand <= mem_out */
-					ir_snprintf(buf, sizeof(buf), "req_memoperand_%N_%d", irn, n);
-					cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
-					lpp_set_factor_fast(si->lpp, cst, memoperand->ilp, 1.0);
-					lpp_set_factor_fast(si->lpp, cst, spill->mem_out, -1.0);
+						/* memoperand <= mem_out */
+						ir_snprintf(buf, sizeof(buf), "req_memoperand_%N_%d", irn, n);
+						cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
+						lpp_set_factor_fast(si->lpp, cst, memoperand->ilp, 1.0);
+						lpp_set_factor_fast(si->lpp, cst, spill->mem_out, -1.0);
 
-					/* the memoperand is only sufficient if it is used once by the op */
-					if(n_memoperands == 1)
-						lpp_set_factor_fast(si->lpp, requirements, memoperand->ilp, 1.0);
+						/* the memoperand is only sufficient if it is used once by the op */
+						if(n_memoperands == 1)
+							lpp_set_factor_fast(si->lpp, requirements, memoperand->ilp, 1.0);
 
-					lpp_set_factor_fast(si->lpp, one_memoperand, memoperand->ilp, 1.0);
+						lpp_set_factor_fast(si->lpp, one_memoperand, memoperand->ilp, 1.0);
 
-					/* we have one more free register if we use a memory operand */
-					lpp_set_factor_fast(si->lpp, check_pre, memoperand->ilp, -1.0);
+						/* we have one more free register if we use a memory operand */
+						lpp_set_factor_fast(si->lpp, check_pre, memoperand->ilp, -1.0);
+					}
 				}
 			}
-#endif
 		}
 
 		/* iterate over L\U */
@@ -2215,13 +2350,15 @@ skip_one_must_die:
 		lpp_set_factor_fast(si->lpp, cst, spill->spill, -1.0);
 
 		if(pset_find_ptr(live, spill->irn)) {
+			int default_spilled;
 			DBG((si->dbg, LEVEL_5, "\t     %+F live at beginning of block %+F\n", spill->irn, bb));
 
 			ir_snprintf(buf, sizeof(buf), "mem_in_%N_%N", spill->irn, bb);
-			spill->mem_in = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+			default_spilled = be_is_live_in(si->lv, bb, spill->irn) || is_Phi(spill->irn);
+			spill->mem_in   = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, default_spilled);
 			lpp_set_factor_fast(si->lpp, cst, spill->mem_in, -1.0);
 
-			if(is_Phi(spill->irn) && get_nodes_block(spill->irn) == bb) {
+			if(opt_memcopies && is_Phi(spill->irn) && get_nodes_block(spill->irn) == bb) {
 				int   n;
 				op_t *op = get_irn_link(spill->irn);
 
@@ -2250,7 +2387,7 @@ skip_one_must_die:
 
 					/* copies are not for free */
 					ir_snprintf(buf, sizeof(buf), "copy_%N_%N", arg, spill->irn);
-					var = lpp_add_var(si->lpp, buf, lpp_binary, COST_STORE * freq);
+					var = lpp_add_var_default(si->lpp, buf, lpp_binary, opt_cost_spill * freq, 1.0);
 
 					for(m=n; m>=0; --m) {
 						const ir_node  *arg2 = get_irn_n(spill->irn, m);
@@ -2260,16 +2397,60 @@ skip_one_must_die:
 						}
 					}
 
+#if 0
 					/* copy <= mem_in */
 					ir_snprintf(buf, sizeof(buf), "nocopy_%N_%N", arg, spill->irn);
 					cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
 					lpp_set_factor_fast(si->lpp, cst, var, 1.0);
 					lpp_set_factor_fast(si->lpp, cst, spill->mem_in, -1.0);
+#endif
 				}
 			}
 		}
 	}
 
+	foreach_post_remat(bb, tmp) {
+		int         n;
+
+		for (n=get_irn_arity(tmp)-1; n>=0; --n) {
+			ir_node    *remat_arg = get_irn_n(tmp, n);
+
+			if(!has_reg_class(si, remat_arg)) continue;
+
+			/* if value is becoming live through use by remat2 */
+			if(!pset_find_ptr(live, remat_arg)) {
+				op_t       *remat_arg_op = get_irn_link(remat_arg);
+				ilp_cst_t   nomem;
+
+				DBG((si->dbg, LEVEL_3, "  value %+F becoming live through use by remat2 at bb start %+F\n", remat_arg, tmp));
+
+				pset_insert_ptr(live, remat_arg);
+				spill = add_to_spill_bb(si, bb, remat_arg);
+				remat_arg_op->attr.live_range.ilp = ILP_UNDEF;
+
+				/* we need reg_in and mem_in for this value; they will be referenced later */
+				ir_snprintf(buf, sizeof(buf), "reg_in_%N_%N", remat_arg, bb);
+				spill->reg_in = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
+				ir_snprintf(buf, sizeof(buf), "mem_in_%N_%N", remat_arg, bb);
+				spill->mem_in = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
+
+
+				/* optimization: all memory stuff should be 0, for we do not want to insert reloads for remats */
+				ir_snprintf(buf, sizeof(buf), "nomem_%N_%N", remat_arg, bb);
+				nomem = lpp_add_cst_uniq(si->lpp, buf, lpp_equal, 0.0);
+
+				lpp_set_factor_fast(si->lpp, nomem, spill->spill, 1.0);
+				if(spill_bb->reloads) {
+					keyval_t *keyval = set_find_keyval(spill_bb->reloads, remat_arg);
+
+					if(keyval) {
+						ilp_var_t reload = PTR_TO_INT(keyval->val);
+						lpp_set_factor_fast(si->lpp, nomem, reload, 1.0);
+					}
+				}
+			}
+		}
+	}
 
 	/* L\U is empty at bb start */
 	/* arg is live throughout epilog if it is reg_in into this block */
@@ -2277,6 +2458,8 @@ skip_one_must_die:
 	/* check the register pressure at the beginning of the block
 	 * including remats
 	 */
+	/* reg_in entspricht post_use */
+
 	ir_snprintf(buf, sizeof(buf), "check_start_%N", bb);
 	cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, si->n_regs);
 
@@ -2287,7 +2470,7 @@ skip_one_must_die:
 		assert(spill);
 
 		ir_snprintf(buf, sizeof(buf), "reg_in_%N_%N", irn, bb);
-		spill->reg_in = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		spill->reg_in = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 0.0);
 
 		lpp_set_factor_fast(si->lpp, cst, spill->reg_in, 1.0);
 
@@ -2298,36 +2481,8 @@ skip_one_must_die:
 		lpp_set_factor_fast(si->lpp, nospill, spill->mem_in, 1.0);
 		lpp_set_factor_fast(si->lpp, nospill, spill->spill, 1.0);
 
-	}
-	foreach_post_remat(bb, irn) {
-		op_t     *remat_op = get_irn_link(irn);
-
-		DBG((si->dbg, LEVEL_4, "\t  next post remat: %+F\n", irn));
-		assert(remat_op->is_remat && !remat_op->attr.remat.pre);
-
-		lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, 1.0);
-	}
-
-	/* forall post remats add requirements */
-	foreach_post_remat(bb, tmp) {
-		int         n;
-
-		for (n=get_irn_arity(tmp)-1; n>=0; --n) {
-			ir_node    *remat_arg = get_irn_n(tmp, n);
-			op_t       *remat_op = get_irn_link(tmp);
-
-			if(!has_reg_class(si, remat_arg)) continue;
-
-			spill = set_find_spill(spill_bb->ilp, remat_arg);
-			assert(spill);
-
-			/* remat <= reg_in_argument */
-			ir_snprintf(buf, sizeof(buf), "req_remat2_%N_%N_arg_%N", tmp, bb, remat_arg);
-			cst = lpp_add_cst(si->lpp, buf, lpp_less, 0.0);
-			lpp_set_factor_fast(si->lpp, cst, spill->reg_in, -1.0);
-			lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, 1.0);
-		}
-	}
+	} /* post_remats are NOT included in register pressure check because
+	   they do not increase regpressure */
 
 	/* mem_in/reg_in for live_in values, especially phis and their arguments */
 	pset_foreach(live, irn) {
@@ -2367,7 +2522,9 @@ skip_one_must_die:
 					assert(spill_p);
 
 					lpp_set_factor_fast(si->lpp, mem_in, spill_p->mem_out, -1.0);
-					lpp_set_factor_fast(si->lpp, mem_in, op->attr.live_range.args.copies[n], -1.0);
+					if(opt_memcopies)
+						lpp_set_factor_fast(si->lpp, mem_in, op->attr.live_range.args.copies[n], -1.0);
+
 					lpp_set_factor_fast(si->lpp, reg_in, spill_p->reg_out, -1.0);
 				}
 			}
@@ -2398,23 +2555,80 @@ skip_one_must_die:
 		}
 	}
 
+	foreach_post_remat(bb, tmp) {
+		int         n;
+
+		for (n=get_irn_arity(tmp)-1; n>=0; --n) {
+			ir_node    *remat_arg = get_irn_n(tmp, n);
+			op_t       *remat_op = get_irn_link(tmp);
+
+			if(!has_reg_class(si, remat_arg)) continue;
+
+			spill = set_find_spill(spill_bb->ilp, remat_arg);
+			assert(spill);
+
+			/* remat <= reg_in_argument */
+			ir_snprintf(buf, sizeof(buf), "req_remat2_%N_%N_arg_%N", tmp, bb, remat_arg);
+			cst = lpp_add_cst(si->lpp, buf, lpp_less, 0.0);
+			lpp_set_factor_fast(si->lpp, cst, spill->reg_in, -1.0);
+			lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, 1.0);
+		}
+	}
+
+	pset_foreach(live, irn) {
+		const op_t      *op = get_irn_link(irn);
+		const ir_node   *remat;
+		int              n_remats = 0;
+
+		if(op->attr.live_range.ilp == ILP_UNDEF) continue;
+
+		cst = ILP_UNDEF;
+
+		foreach_post_remat(bb, remat) {
+			int   n;
+
+			for (n=get_irn_arity(remat)-1; n>=0; --n) {
+				const ir_node  *arg = get_irn_n(remat, n);
+
+				if(arg == irn) {
+					const op_t   *remat_op = get_irn_link(remat);
+
+					if(cst == ILP_UNDEF) {
+						/* \sum post_remat <= 1 + #post_remats * next(lr) */
+						ir_snprintf(buf, sizeof(buf), "remat2_%N_%N_arg_%N", remat, bb, irn);
+						cst = lpp_add_cst(si->lpp, buf, lpp_less, 1.0);
+					}
+					lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, 1.0);
+					++n_remats;
+					break;
+				}
+			}
+		}
+		if(n_remats) {
+			lpp_set_factor_fast(si->lpp, cst, op->attr.live_range.ilp, n_remats);
+		}
+	}
+
 	/* first live ranges from reg_ins */
 	pset_foreach(live, irn) {
 		op_t      *op = get_irn_link(irn);
 
-		spill = set_find_spill(spill_bb->ilp, irn);
-		assert(spill && spill->irn == irn);
+		if(op->attr.live_range.ilp != ILP_UNDEF) {
 
-		ir_snprintf(buf, sizeof(buf), "first_lr_%N_%N", irn, bb);
-		cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
-		lpp_set_factor_fast(si->lpp, cst, op->attr.live_range.ilp, 1.0);
-		lpp_set_factor_fast(si->lpp, cst, spill->reg_in, -1.0);
+			spill = set_find_spill(spill_bb->ilp, irn);
+			assert(spill && spill->irn == irn);
 
-		foreach_post_remat(bb, tmp) {
-			op_t     *remat_op = get_irn_link(tmp);
+			ir_snprintf(buf, sizeof(buf), "first_lr_%N_%N", irn, bb);
+			cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0.0);
+			lpp_set_factor_fast(si->lpp, cst, op->attr.live_range.ilp, 1.0);
+			lpp_set_factor_fast(si->lpp, cst, spill->reg_in, -1.0);
 
-			if(remat_op->attr.remat.remat->value == irn) {
-				lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, -1.0);
+			foreach_post_remat(bb, tmp) {
+				op_t     *remat_op = get_irn_link(tmp);
+
+				if(remat_op->attr.remat.remat->value == irn) {
+					lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, -1.0);
+				}
 			}
 		}
 	}
@@ -2560,6 +2774,7 @@ values_interfere_in_block(const spill_ilp_t * si, const ir_node * bb, const ir_n
 		if(get_nodes_block(user) == bb
 				&& !is_Phi(user)
 				&& b != user
+				&& !pset_find_ptr(si->inverse_ops, user)
 				&& value_dominates(b, user))
 			return 1;
 	}
@@ -2580,18 +2795,22 @@ luke_interferencewalker(ir_node * bb, void * data)
 		ir_node        *a = be_lv_get_irn(si->lv, bb, l1);
 		op_t           *a_op = get_irn_link(a);
 
-		if(a_op->is_remat) continue;
 
 		/* a is only interesting if it is in my register class and if it is inside a phi class */
 		if (has_reg_class(si, a) && get_phi_class(a)) {
+			if(a_op->is_remat || pset_find_ptr(si->inverse_ops, a))
+				continue;
+
 			for(l2=_be_lv_next_irn(si->lv, bb, 0xff, l1+1); l2>=0; l2=_be_lv_next_irn(si->lv, bb, 0xff, l2+1)) {
 				ir_node        *b = be_lv_get_irn(si->lv, bb, l2);
 				op_t           *b_op = get_irn_link(b);
 
-				if(b_op->is_remat) continue;
 
 				/* a and b are only interesting if they are in the same phi class */
 				if(has_reg_class(si, b) && get_phi_class(a) == get_phi_class(b)) {
+					if(b_op->is_remat || pset_find_ptr(si->inverse_ops, b))
+						continue;
+
 					if(values_interfere_in_block(si, bb, a, b)) {
 						DBG((si->dbg, LEVEL_4, "\tvalues interfere in %+F: %+F, %+F\n", bb, a, b));
 						set_insert_interference(si, si->interferences, a, b, bb);
@@ -2667,7 +2886,7 @@ find_copy_path(spill_ilp_t * si, const ir_node * irn, const ir_node * target, il
 				paths += find_copy_path(si, arg, target, any_interfere, copies, visited);
 				pset_remove(copies, INT_TO_PTR(copy), copy);
 
-                /*if(paths > MAX_PATHS) {
+                if(paths > MAX_PATHS) {
                     if(pset_count(copies) == 0) {
                         ilp_cst_t  cst;
                         char       buf[256];
@@ -2687,7 +2906,7 @@ find_copy_path(spill_ilp_t * si, const ir_node * irn, const ir_node * target, il
                     }
                 } else if(pset_count(copies) == 0) {
 					paths = 0;
-				}*/
+				}
 			}
 		}
 
@@ -2722,7 +2941,7 @@ find_copy_path(spill_ilp_t * si, const ir_node * irn, const ir_node * target, il
 			paths += find_copy_path(si, user, target, any_interfere, copies, visited);
 			pset_remove(copies, INT_TO_PTR(copy), copy);
 
-            /*if(paths > MAX_PATHS) {
+            if(paths > MAX_PATHS) {
                 if(pset_count(copies) == 0) {
                     ilp_cst_t  cst;
                     char       buf[256];
@@ -2741,7 +2960,7 @@ find_copy_path(spill_ilp_t * si, const ir_node * irn, const ir_node * target, il
                 }
             } else if(pset_count(copies) == 0) {
 				paths = 0;
-			}*/
+			}
 		}
 	}
 
@@ -2789,7 +3008,7 @@ memcopyhandler(spill_ilp_t * si)
 		/* any_interf <= \sum interf */
 		ir_snprintf(buf, sizeof(buf), "interfere_%N_%N", a, b);
 		any_interfere_cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 0);
-		any_interfere = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+		any_interfere = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 		lpp_set_factor_fast(si->lpp, any_interfere_cst, any_interfere, 1.0);
 
@@ -2811,7 +3030,7 @@ memcopyhandler(spill_ilp_t * si)
 			/* 2: - mem_in_a - spill_a + interfere <= 0 */
 			/* 3: - mem_in_b - spill_b + interfere <= 0 */
 			ir_snprintf(buf, sizeof(buf), "interfere_%N_%N_%N", bb, a, b);
-			interfere = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
+			interfere = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
 
 			ir_snprintf(buf, sizeof(buf), "interfere_%N_%N_%N-1", bb, a, b);
 			cst = lpp_add_cst_uniq(si->lpp, buf, lpp_less, 1);
@@ -2859,7 +3078,6 @@ is_zero(double x)
 	return fabs(x) < 0.00001;
 }
 
-#ifdef KEEPALIVE
 static int mark_remat_nodes_hook(FILE *F, ir_node *n, ir_node *l)
 {
 	spill_ilp_t *si = get_irg_link(current_ir_graph);
@@ -2900,7 +3118,6 @@ dump_graph_with_remats(ir_graph * irg, const char * suffix)
 	be_dump(irg, suffix, dump_ir_block_graph_sched);
 	set_dump_node_vcgattr_hook(NULL);
 }
-#endif
 
 /**
  * Edge hook to dump the schedule edges with annotated register pressure.
@@ -2980,7 +3197,6 @@ dump_pressure_graph(spill_ilp_t * si, const char *suffix)
 	be_dump(si->chordal_env->irg, suffix, dump_ir_block_graph_sched_pressure);
 }
 
-#ifdef KEEPALIVE
 static void
 connect_all_remats_with_keep(spill_ilp_t * si)
 {
@@ -3005,7 +3221,6 @@ connect_all_remats_with_keep(spill_ilp_t * si)
 		obstack_free(si->obst, ins);
 	}
 }
-#endif
 
 static void
 connect_all_spills_with_keep(spill_ilp_t * si)
@@ -3034,7 +3249,7 @@ connect_all_spills_with_keep(spill_ilp_t * si)
 }
 
 /** insert a spill at an arbitrary position */
-ir_node *be_spill2(const arch_env_t *arch_env, ir_node *irn, ir_node *insert, ir_node *ctx)
+ir_node *be_spill2(const arch_env_t *arch_env, ir_node *irn, ir_node *insert)
 {
 	ir_node *bl     = is_Block(insert)?insert:get_nodes_block(insert);
 	ir_graph *irg   = get_irn_irg(bl);
@@ -3045,7 +3260,7 @@ ir_node *be_spill2(const arch_env_t *arch_env, ir_node *irn, ir_node *insert, ir
 	const arch_register_class_t *cls       = arch_get_irn_reg_class(arch_env, irn, -1);
 	const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1);
 
-	spill = be_new_Spill(cls, cls_frame, irg, bl, frame, irn, ctx);
+	spill = be_new_Spill(cls, cls_frame, irg, bl, frame, irn);
 
 	/*
 	 * search the right insertion point. a spill of a phi cannot be put
@@ -3115,88 +3330,88 @@ clean_remat_info(spill_ilp_t * si)
 static void
 delete_unnecessary_remats(spill_ilp_t * si)
 {
-#ifdef KEEPALIVE
-	int       n;
-	ir_node  *bad = get_irg_bad(si->chordal_env->irg);
+	if(opt_keep_alive & KEEPALIVE_REMATS) {
+		int       n;
+		ir_node  *bad = get_irg_bad(si->chordal_env->irg);
 
-	if(si->keep) {
-		ir_node   *end = get_irg_end(si->chordal_env->irg);
-		ir_node  **keeps;
+		if(si->keep) {
+//			ir_node   *end = get_irg_end(si->chordal_env->irg);
+//			ir_node  **keeps;
 
-		for (n=get_irn_arity(si->keep)-1; n>=0; --n) {
-			ir_node        *keep_arg = get_irn_n(si->keep, n);
-			op_t           *arg_op = get_irn_link(keep_arg);
-			lpp_name_t     *name;
+			for (n=get_irn_arity(si->keep)-1; n>=0; --n) {
+				ir_node        *keep_arg = get_irn_n(si->keep, n);
+				op_t           *arg_op = get_irn_link(keep_arg);
+				lpp_name_t     *name;
 
-			assert(arg_op->is_remat);
+				assert(arg_op->is_remat);
 
-			name = si->lpp->vars[arg_op->attr.remat.ilp];
+				name = si->lpp->vars[arg_op->attr.remat.ilp];
 
-			if(is_zero(name->value)) {
-				DBG((si->dbg, LEVEL_3, "\t  deleting remat %+F\n", keep_arg));
-				/* TODO check whether reload is preferred over remat (could be bug) */
-				delete_remat(si, keep_arg);
-			} else {
-				if(!arg_op->attr.remat.remat->inverse) {
-					if(arg_op->attr.remat.pre) {
-						DBG((si->dbg, LEVEL_2, "\t**remat kept: %+F\n", keep_arg));
-					} else {
-						DBG((si->dbg, LEVEL_2, "\t%%%%remat2 kept: %+F\n", keep_arg));
-					}
+				if(is_zero(name->value)) {
+					DBG((si->dbg, LEVEL_3, "\t  deleting remat %+F\n", keep_arg));
+					/* TODO check whether reload is preferred over remat (could be bug) */
+					delete_remat(si, keep_arg);
 				} else {
-					if(arg_op->attr.remat.pre) {
-						DBG((si->dbg, LEVEL_2, "\t**INVERSE remat kept: %+F\n", keep_arg));
+					if(!arg_op->attr.remat.remat->inverse) {
+						if(arg_op->attr.remat.pre) {
+							DBG((si->dbg, LEVEL_2, "\t**remat kept: %+F\n", keep_arg));
+						} else {
+							DBG((si->dbg, LEVEL_2, "\t%%%%remat2 kept: %+F\n", keep_arg));
+						}
 					} else {
-						DBG((si->dbg, LEVEL_2, "\t%%%%INVERSE remat2 kept: %+F\n", keep_arg));
+						if(arg_op->attr.remat.pre) {
+							DBG((si->dbg, LEVEL_2, "\t**INVERSE remat kept: %+F\n", keep_arg));
+						} else {
+							DBG((si->dbg, LEVEL_2, "\t%%%%INVERSE remat2 kept: %+F\n", keep_arg));
+						}
 					}
 				}
-			}
 
-			set_irn_n(si->keep, n, bad);
-		}
+				set_irn_n(si->keep, n, bad);
+			}
 #if 0
-		for (i = 0, n = get_End_n_keepalives(end); i < n; ++i) {
-			ir_node        *end_arg = get_End_keepalive(end, i);
+			for (i = 0, n = get_End_n_keepalives(end); i < n; ++i) {
+				ir_node        *end_arg = get_End_keepalive(end, i);
 
-			if(end_arg != si->keep) {
-				obstack_grow(si->obst, &end_arg, sizeof(end_arg));
+				if(end_arg != si->keep) {
+					obstack_grow(si->obst, &end_arg, sizeof(end_arg));
+				}
 			}
-		}
-		keeps = obstack_finish(si->obst);
-		set_End_keepalives(end, n-1, keeps);
-		obstack_free(si->obst, keeps);
+			keeps = obstack_finish(si->obst);
+			set_End_keepalives(end, n-1, keeps);
+			obstack_free(si->obst, keeps);
 #endif
+		} else {
+			DBG((si->dbg, LEVEL_2, "\t  no remats to delete (none have been inserted)\n"));
+		}
 	} else {
-		DBG((si->dbg, LEVEL_2, "\t  no remats to delete (none have been inserted)\n"));
-	}
-#else
-	ir_node  *remat;
+		ir_node  *remat;
 
-	pset_foreach(si->all_possible_remats, remat) {
-		op_t           *remat_op = get_irn_link(remat);
-		lpp_name_t     *name = si->lpp->vars[remat_op->attr.remat.ilp];
+		pset_foreach(si->all_possible_remats, remat) {
+			op_t           *remat_op = get_irn_link(remat);
+			lpp_name_t     *name = si->lpp->vars[remat_op->attr.remat.ilp];
 
-		if(is_zero(name->value)) {
-			DBG((si->dbg, LEVEL_3, "\t  deleting remat %+F\n", remat));
-			/* TODO check whether reload is preferred over remat (could be bug) */
-			delete_remat(si, remat);
-		} else {
-			if(!remat_op->attr.remat.remat->inverse) {
-				if(remat_op->attr.remat.pre) {
-					DBG((si->dbg, LEVEL_2, "\t**remat kept: %+F\n", remat));
-				} else {
-					DBG((si->dbg, LEVEL_2, "\t%%%%remat2 kept: %+F\n", remat));
-				}
+			if(is_zero(name->value)) {
+				DBG((si->dbg, LEVEL_3, "\t  deleting remat %+F\n", remat));
+				/* TODO check whether reload is preferred over remat (could be bug) */
+				delete_remat(si, remat);
 			} else {
-				if(remat_op->attr.remat.pre) {
-					DBG((si->dbg, LEVEL_2, "\t**INVERSE remat kept: %+F\n", remat));
+				if(!remat_op->attr.remat.remat->inverse) {
+					if(remat_op->attr.remat.pre) {
+						DBG((si->dbg, LEVEL_2, "\t**remat kept: %+F\n", remat));
+					} else {
+						DBG((si->dbg, LEVEL_2, "\t%%%%remat2 kept: %+F\n", remat));
+					}
 				} else {
-					DBG((si->dbg, LEVEL_2, "\t%%%%INVERSE remat2 kept: %+F\n", remat));
+					if(remat_op->attr.remat.pre) {
+						DBG((si->dbg, LEVEL_2, "\t**INVERSE remat kept: %+F\n", remat));
+					} else {
+						DBG((si->dbg, LEVEL_2, "\t%%%%INVERSE remat2 kept: %+F\n", remat));
+					}
 				}
 			}
 		}
 	}
-#endif
 }
 
 static pset *
@@ -3221,7 +3436,6 @@ get_spills_for_value(spill_ilp_t * si, const ir_node * value)
 /**
  * @param before   The node after which the spill will be placed in the schedule
  */
-/* TODO set context properly */
 static ir_node *
 insert_spill(spill_ilp_t * si, ir_node * irn, const ir_node * value, ir_node * before)
 {
@@ -3231,7 +3445,7 @@ insert_spill(spill_ilp_t * si, ir_node * irn, const ir_node * value, ir_node * b
 
 	DBG((si->dbg, LEVEL_3, "\t  inserting spill for value %+F after %+F\n", irn, before));
 
-	spill = be_spill2(arch_env, irn, before, irn);
+	spill = be_spill2(arch_env, irn, before);
 
 	defs = set_insert_def(si->values, value);
 	assert(defs);
@@ -3240,9 +3454,8 @@ insert_spill(spill_ilp_t * si, ir_node * irn, const ir_node * value, ir_node * b
 	set_irn_link(spill, defs->spills);
 	defs->spills = spill;
 
-#ifdef KEEPALIVE_SPILLS
-	pset_insert_ptr(si->spills, spill);
-#endif
+	if(opt_keep_alive & KEEPALIVE_SPILLS)
+		pset_insert_ptr(si->spills, spill);
 
 	return spill;
 }
@@ -3273,12 +3486,13 @@ insert_mem_phi(spill_ilp_t * si, ir_node * phi)
 	set_irn_link(mem_phi, defs->spills);
 	defs->spills = mem_phi;
 
+#ifdef SCHEDULE_PHIM
 	sched_add_after(phi, mem_phi);
-
-#ifdef KEEPALIVE_SPILLS
-	pset_insert_ptr(si->spills, mem_phi);
 #endif
 
+	if(opt_keep_alive & KEEPALIVE_SPILLS)
+		pset_insert_ptr(si->spills, mem_phi);
+
 
 	return mem_phi;
 }
@@ -3330,7 +3544,6 @@ insert_reload(spill_ilp_t * si, const ir_node * value, ir_node * after)
 	return reload;
 }
 
-#ifdef WITH_MEMOPERANDS
 void perform_memory_operand(spill_ilp_t * si, memoperand_t * memoperand)
 {
 	defs_t           *defs;
@@ -3364,7 +3577,6 @@ void insert_memoperands(spill_ilp_t * si)
 		}
 	}
 }
-#endif
 
 static void
 walker_spill_placer(ir_node * bb, void * data) {
@@ -3469,7 +3681,7 @@ insert_mem_copy(spill_ilp_t * si, ir_node * bb, ir_node * value)
 
 	DBG((si->dbg, LEVEL_2, "\t  inserting mem copy for value %+F after %+F\n", value, insert_pos));
 
-	spill = be_spill2(arch_env, is_Block(insert_pos)?value:insert_pos, insert_pos, value);
+	spill = be_spill2(arch_env, is_Block(insert_pos)?value:insert_pos, insert_pos);
 
 	return spill;
 }
@@ -3505,18 +3717,19 @@ phim_fixer(spill_ilp_t *si) {
 			ir_node      *spill;
 
 
-#ifndef NO_MEMCOPIES
-			ir_node    *pred = get_Block_cfgpred_block(get_nodes_block(phi), n);
-			lpp_name_t *name = si->lpp->vars[op->attr.live_range.args.copies[n]];
+			if(opt_memcopies) {
+				ir_node    *pred = get_Block_cfgpred_block(get_nodes_block(phi), n);
+				lpp_name_t *name = si->lpp->vars[op->attr.live_range.args.copies[n]];
 
-			if(!is_zero(name->value)) {
-				spill = insert_mem_copy(si, pred, value);
+				if(!is_zero(name->value)) {
+					spill = insert_mem_copy(si, pred, value);
+				} else {
+					spill = val_defs->spills;
+				}
 			} else {
 				spill = val_defs->spills;
 			}
-#else
-			spill = val_defs->spills;
-#endif
+
 			assert(spill && "no spill placed before PhiM");
 			set_irn_n(phi_m, n, spill);
 		}
@@ -3566,9 +3779,8 @@ walker_reload_placer(ir_node * bb, void * data) {
 
 				reload = insert_reload(si, irn, insert_pos);
 
-#ifdef KEEPALIVE_RELOADS
-				pset_insert_ptr(si->spills, reload);
-#endif
+				if(opt_keep_alive & KEEPALIVE_RELOADS)
+					pset_insert_ptr(si->spills, reload);
 			}
 		}
 	}
@@ -3623,9 +3835,8 @@ walker_reload_placer(ir_node * bb, void * data) {
 
 						set_irn_n(irn, n, reload);
 
-#ifdef KEEPALIVE_RELOADS
-						pset_insert_ptr(si->spills, reload);
-#endif
+						if(opt_keep_alive & KEEPALIVE_RELOADS)
+							pset_insert_ptr(si->spills, reload);
 					}
 				}
 			}
@@ -3694,7 +3905,7 @@ kill_all_unused_values_in_schedule(spill_ilp_t * si)
 	lc_bitset_free(kh.used);
 }
 
-static void
+void
 print_irn_pset(pset * p)
 {
 	ir_node   *irn;
@@ -3704,7 +3915,7 @@ print_irn_pset(pset * p)
 	}
 }
 
-static void
+void
 dump_phi_class(spill_ilp_t * si, pset * phiclass, const char * file)
 {
     FILE           *f = fopen(file, "w");
@@ -3827,9 +4038,8 @@ writeback_results(spill_ilp_t * si)
 	si->m_unknown = new_r_Unknown(si->chordal_env->irg, mode_M);
 	irg_block_walk_graph(si->chordal_env->irg, walker_spill_placer, NULL, si);
 	irg_block_walk_graph(si->chordal_env->irg, walker_reload_placer, NULL, si);
-#ifdef WITH_MEMOPERANDS
-	insert_memoperands(si);
-#endif
+	if(opt_memoperands)
+		insert_memoperands(si);
 	phim_fixer(si);
 
 	/* clean the remat info! there are still back-edges leading there! */
@@ -3950,33 +4160,10 @@ verify_phiclasses(spill_ilp_t * si)
 	irg_block_walk_graph(si->chordal_env->irg, luke_meminterferencechecker, NULL, si);
 }
 
-static void
-walker_spillslotassigner(ir_node * irn, void * data)
-{
-	void                   *cls;
-
-	if(!be_is_Spill(irn)) return;
-
-	/* set spill context to phi class if it has one ;) */
-
-	cls = get_phi_class(irn);
-	if(cls)
-		be_set_Spill_context(irn, cls);
-	else
-		be_set_Spill_context(irn, irn);
-}
-
-
-static void
-assign_spillslots(spill_ilp_t * si)
-{
-	DBG((si->dbg, LEVEL_2, "\t calling spill slot assigner\n"));
-	irg_walk_graph(si->chordal_env->irg, walker_spillslotassigner, NULL, si);
-}
-
 void
 be_spill_remat(const be_chordal_env_t * chordal_env)
 {
+	char            buf[256];
 	char            problem_name[256];
 	char            dump_suffix[256];
 	char            dump_suffix2[256];
@@ -3990,9 +4177,8 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 	FIRM_DBG_REGISTER(si.dbg, "firm.be.ra.spillremat");
 	DBG((si.dbg, LEVEL_1, "\n\n\t\t===== Processing %s =====\n\n", problem_name));
 
-#ifdef VERIFY_DOMINANCE
-    be_check_dominance(chordal_env->irg);
-#endif
+	if(opt_verify & VERIFY_DOMINANCE)
+		be_check_dominance(chordal_env->irg);
 
 	obstack_init(&obst);
 	si.chordal_env = chordal_env;
@@ -4001,16 +4187,12 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 	si.lpp = new_lpp(problem_name, lpp_minimize);
 	si.remat_info = new_set(cmp_remat_info, 4096);
 	si.interferences = new_set(cmp_interference, 32);
-#ifdef WITH_MEMOPERANDS
 	si.memoperands = new_set(cmp_memoperands, 128);
-#endif
 	si.all_possible_remats = pset_new_ptr_default();
 	si.spills = pset_new_ptr_default();
 	si.inverse_ops = pset_new_ptr_default();
 	si.lv = chordal_env->lv;
-#ifdef KEEPALIVE
 	si.keep = NULL;
-#endif
 	si.n_regs = get_n_regs(&si);
 
 	set_irg_link(chordal_env->irg, &si);
@@ -4021,23 +4203,23 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 
 	be_analyze_regpressure(chordal_env, "-pre");
 
-#ifdef COLLECT_REMATS
-	/* collect remats */
-	DBG((si.dbg, LEVEL_1, "Collecting remats\n"));
-	irg_walk_graph(chordal_env->irg, walker_remat_collector, NULL, &si);
-#endif
+	if(opt_remats) {
+		/* collect remats */
+		DBG((si.dbg, LEVEL_1, "Collecting remats\n"));
+		irg_walk_graph(chordal_env->irg, walker_remat_collector, NULL, &si);
+	}
 
 	/* insert possible remats */
 	DBG((si.dbg, LEVEL_1, "Inserting possible remats\n"));
 	irg_block_walk_graph(chordal_env->irg, walker_remat_insertor, NULL, &si);
 	DBG((si.dbg, LEVEL_2, " -> inserted %d possible remats\n", pset_count(si.all_possible_remats)));
 
-#ifdef KEEPALIVE
-	DBG((si.dbg, LEVEL_1, "Connecting remats with keep and dumping\n"));
-	connect_all_remats_with_keep(&si);
-	/* dump graph with inserted remats */
-	dump_graph_with_remats(chordal_env->irg, dump_suffix);
-#endif
+	if(opt_keep_alive & KEEPALIVE_REMATS) {
+		DBG((si.dbg, LEVEL_1, "Connecting remats with keep and dumping\n"));
+		connect_all_remats_with_keep(&si);
+		/* dump graph with inserted remats */
+		dump_graph_with_remats(chordal_env->irg, dump_suffix);
+	}
 
 	/* insert copies for phi arguments not in my regclass */
 	irg_walk_graph(chordal_env->irg, walker_regclass_copy_insertor, NULL, &si);
@@ -4055,29 +4237,44 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 	DBG((si.dbg, LEVEL_2, "\t blockwalker\n"));
 	irg_block_walk_graph(chordal_env->irg, luke_blockwalker, NULL, &si);
 
-#ifndef NO_MEMCOPIES
-	DBG((si.dbg, LEVEL_2, "\t memcopyhandler\n"));
-	memcopyhandler(&si);
-#endif
+	if(opt_memcopies) {
+		DBG((si.dbg, LEVEL_2, "\t memcopyhandler\n"));
+		memcopyhandler(&si);
+	}
 
-#ifdef DUMP_ILP
-	{
+	if(opt_dump_flags & DUMP_PROBLEM) {
 		FILE           *f;
-		char            buf[256];
-
 		ir_snprintf(buf, sizeof(buf), "%s-spillremat.ilp", problem_name);
 		if ((f = fopen(buf, "wt")) != NULL) {
 			lpp_dump_plain(si.lpp, f);
 			fclose(f);
 		}
 	}
-#endif
+
+	if(opt_dump_flags & DUMP_MPS) {
+		FILE *f;
+
+		ir_snprintf(buf, sizeof(buf), "%s-spillremat.mps", problem_name);
+		if((f = fopen(buf, "wt")) != NULL) {
+			mps_write_mps(si.lpp, s_mps_fixed, f);
+			fclose(f);
+		}
+
+		ir_snprintf(buf, sizeof(buf), "%s-spillremat.mst", problem_name);
+		if((f = fopen(buf, "wt")) != NULL) {
+			mps_write_mst(si.lpp, s_mps_fixed, f);
+			fclose(f);
+		}
+	}
+
+	lpp_check_startvals(si.lpp);
 
 #ifdef SOLVE
-	DBG((si.dbg, LEVEL_1, "\tSolving %F\n", chordal_env->irg));
-#ifdef ILP_TIMEOUT
-	lpp_set_time_limit(si.lpp, ILP_TIMEOUT);
-#endif
+	DBG((si.dbg, LEVEL_1, "\tSolving %s (%d variables, %d constraints)\n", problem_name, si.lpp->var_next, si.lpp->cst_next));
+	lpp_set_time_limit(si.lpp, opt_timeout);
+
+	if(opt_log)
+		lpp_set_log(si.lpp, stdout);
 
 #ifdef SOLVE_LOCAL
 	lpp_solve_cplex(si.lpp);
@@ -4089,8 +4286,7 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 
 	DBG((si.dbg, LEVEL_1, "\t%s: iterations: %d, solution time: %g, objective function: %g\n", problem_name, si.lpp->iterations, si.lpp->sol_time, is_zero(si.lpp->objval)?0.0:si.lpp->objval));
 
-#ifdef DUMP_SOLUTION
-	{
+	if(opt_dump_flags & DUMP_SOLUTION) {
 		FILE           *f;
 		char            buf[256];
 
@@ -4104,7 +4300,6 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 			fclose(f);
 		}
 	}
-#endif
 
 	writeback_results(&si);
 
@@ -4112,19 +4307,17 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 
 	kill_all_unused_values_in_schedule(&si);
 
-#if defined(KEEPALIVE_SPILLS) || defined(KEEPALIVE_RELOADS)
-	be_dump(chordal_env->irg, "-spills-placed", dump_ir_block_graph);
-#endif
+	if(opt_keep_alive & (KEEPALIVE_SPILLS | KEEPALIVE_RELOADS))
+		be_dump(chordal_env->irg, "-spills-placed", dump_ir_block_graph);
 
 	// move reloads upwards
 	be_liveness_recompute(si.lv);
 	irg_block_walk_graph(chordal_env->irg, walker_pressure_annotator, NULL, &si);
 	move_reloads_upward(&si);
 
-#ifndef NO_MEMCOPIES
-	verify_phiclasses(&si);
-	assign_spillslots(&si);
-#endif
+	if(opt_memcopies) {
+		verify_phiclasses(&si);
+	}
 
 	irg_block_walk_graph(chordal_env->irg, walker_pressure_annotator, NULL, &si);
 
@@ -4132,17 +4325,14 @@ be_spill_remat(const be_chordal_env_t * chordal_env)
 
 	be_analyze_regpressure(chordal_env, "-post");
 
-#ifdef VERIFY_DOMINANCE
-	be_check_dominance(chordal_env->irg);
-#endif
+	if(opt_verify & VERIFY_DOMINANCE)
+		be_check_dominance(chordal_env->irg);
 
 	free_dom(chordal_env->irg);
 	del_set(si.interferences);
 	del_pset(si.inverse_ops);
 	del_pset(si.all_possible_remats);
-#ifdef WITH_MEMOPERANDS
 	del_set(si.memoperands);
-#endif
 	del_pset(si.spills);
 	free_lpp(si.lpp);
 	obstack_free(&obst, NULL);