//#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 COLLECT_REMATS /* enable rematerialization */
+//#define COLLECT_INVERSE_REMATS /* enable placement of inverse remats */
//#define ONLY_BRIGGS_REMATS /* only remats without parameters (or only with ignored params) */
#define REMAT_WHILE_LIVE /* only remat values that are live */
//#define NO_ENLARGE_L1V3N355 /* do not remat after the death of some operand */
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);
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);
spill_cost = is_Unknown(irn)?0.0001:COST_STORE*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, 0.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 */
+ be_is_live_in(si->lv, bb, irn) {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 0.0);
+ } else {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 1.0);
+ }
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, COST_LOAD*execution_frequency(si, bb), 0.0);
set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
/* reload <= mem_out */
spill_cost = is_Unknown(irn)?0.0001:COST_STORE*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);
/* 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);
+ be_is_live_in(si->lv, bb, irn) {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 0.0);
+ } else {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 1.0);
+ }
+ /* 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, COST_LOAD*execution_frequency(si, bb), 1.0);
set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
/* reload <= mem_out */
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);
+ be_is_live_in(si->lv, bb, irn) {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 0.0);
+ } else {
+ spill->spill = lpp_add_var_default(si->lpp, buf, lpp_binary, spill_cost, 1.0);
+ }
}
return spill;
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);
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);
/* 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;
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);
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;
/* 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, 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);
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));
+ memoperand = lpp_add_var_default(si->lpp, buf, lpp_binary, 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);
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, COST_LOAD*execution_frequency(si, bb), 1.0);
/* reload <= mem_out */
ir_snprintf(buf, sizeof(buf), "req_reload_%N_%N", arg, irn);
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);
+ spill->mem_in = lpp_add_var_default(si->lpp, buf, lpp_binary, 0.0, 1.0);
lpp_set_factor_fast(si->lpp, cst, spill->mem_in, -1.0);
if(is_Phi(spill->irn) && get_nodes_block(spill->irn) == bb) {
/* 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, COST_STORE * freq, 1.0);
for(m=n; m>=0; --m) {
const ir_node *arg2 = get_irn_n(spill->irn, m);
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, 1.0);
lpp_set_factor_fast(si->lpp, cst, spill->reg_in, 1.0);
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)
+ 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)
+ 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);
/* 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);
/* 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);
}
/** 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);
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
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);
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;
}
if(!be_is_Spill(irn)) return;
/* set spill context to phi class if it has one ;) */
-
+ (void) cls;
+#if 0
+ // Matze: not needed anymore
cls = get_phi_class(irn);
if(cls)
be_set_Spill_context(irn, cls);
else
be_set_Spill_context(irn, irn);
+#endif
}
lpp_set_time_limit(si.lpp, ILP_TIMEOUT);
#endif
+ lpp_set_log(si.lpp, stdout);
+
#ifdef SOLVE_LOCAL
lpp_solve_cplex(si.lpp);
#else
projects / libfirm / blobdiff