#define DUMP_INTERVALS
-/* new style assign routine without borders. */
-#undef NEW_STYLE_ASSIGN
-
typedef struct _be_chordal_alloc_env_t {
be_chordal_env_t *chordal_env;
if (smallest >= 0) {
be_operand_t *partner = &insn->ops[smallest];
-
for(i = insn->use_start; i < insn->n_ops; ++i) {
if(insn->ops[i].carrier == partner->carrier)
insn->ops[i].partner = out_op;
the Perm. Recomputing liveness is also a good idea if a Perm is inserted, since
the live sets may change.
*/
- // be_liveness_recompute(lv);
obstack_free(env->obst, insn);
*the_insn = insn = chordal_scan_insn(env, insn->irn);
bitset_pos_t col;
const ir_edge_t *edge;
ir_node *perm = NULL;
- int match_res, cost;
+ //int match_res, cost;
be_chordal_env_t *env = alloc_env->chordal_env;
void *base = obstack_base(env->obst);
be_insn_t *insn = chordal_scan_insn(env, irn);
ir_node *res = insn->next_insn;
int be_silent = *silent;
be_irg_t *birg = env->birg;
+ bipartite_t *bp;
if(insn->pre_colored) {
int i;
bs = bitset_alloca(n_regs);
alloc_nodes = alloca(n_regs * sizeof(alloc_nodes[0]));
//bp = hungarian_new(n_regs, n_regs, 2, HUNGARIAN_MATCH_PERFECT);
- bipartite_t *bp = bipartite_new(n_regs, n_regs);
+ bp = bipartite_new(n_regs, n_regs);
assignment = alloca(n_regs * sizeof(assignment[0]));
partners = pmap_create();
/* Assign colors obtained from the matching. */
for(i = 0; i < n_alloc; ++i) {
const arch_register_t *reg;
- ir_node *nodes[2];
- int j;
+ ir_node *irn;
assert(assignment[i] >= 0 && "there must have been a register assigned");
reg = arch_register_for_index(env->cls, assignment[i]);
+ assert(! (reg->type & arch_register_type_ignore));
- nodes[0] = alloc_nodes[i];
- nodes[1] = pmap_get(partners, alloc_nodes[i]);
-
- for(j = 0; j < 2; ++j) {
- if(!nodes[j])
- continue;
+ irn = alloc_nodes[i];
+ if (irn != NULL) {
+ arch_set_irn_register(aenv, irn, reg);
+ (void) pset_hinsert_ptr(alloc_env->pre_colored, irn);
+ DBG((dbg, LEVEL_2, "\tsetting %+F to register %s\n", irn, reg->name));
+ }
- assert(! (reg->type & arch_register_type_ignore));
- arch_set_irn_register(aenv, nodes[j], reg);
- (void) pset_hinsert_ptr(alloc_env->pre_colored, nodes[j]);
- DBG((dbg, LEVEL_2, "\tsetting %+F to register %s\n", nodes[j], reg->name));
+ irn = pmap_get(partners, alloc_nodes[i]);
+ if (irn != NULL) {
+ arch_set_irn_register(aenv, irn, reg);
+ (void) pset_hinsert_ptr(alloc_env->pre_colored, irn);
+ DBG((dbg, LEVEL_2, "\tsetting %+F to register %s\n", irn, reg->name));
}
}
DBG((dbg, LEVEL_1, "\tinsn: %+F, pressure: %d\n", irn, pressure));
DBG((dbg, LEVEL_2, "\tlive: %B\n", live));
-#ifndef SCHEDULE_PROJS
if (get_irn_mode(irn) == mode_T) {
const ir_edge_t *edge;
}
}
}
-#endif
+
/*
* If the node defines some value, which can put into a
* register of the current class, make a border for it.
const arch_env_t *arch_env = env->birg->main_env->arch_env;
struct list_head *head = get_block_border_head(env, block);
be_lv_t *lv = env->birg->lv;
- pset *live_in = be_lv_pset_put_in(lv, block, pset_new_ptr_default());
const ir_node *irn;
border_t *b;
+ int idx;
bitset_clear_all(colors);
bitset_clear_all(live);
* Since their colors have already been assigned (The dominators were
* allocated before), we have to mark their colors as used also.
*/
- foreach_pset(live_in, irn) {
+ be_lv_foreach(lv, block, be_lv_state_in, idx) {
+ irn = be_lv_get_irn(lv, block, idx);
if(has_reg_class(env, irn)) {
const arch_register_t *reg = arch_get_irn_register(arch_env, irn);
int col;
bitset_clear(live, nr);
}
}
-
- del_pset(live_in);
-}
-
-/**
- * A new assign...
- */
-static void assign_new(ir_node *block, be_chordal_alloc_env_t *alloc_env, bitset_t *live_end_dom)
-{
- be_chordal_env_t *env = alloc_env->chordal_env;
- bitset_t *colors = alloc_env->colors;
- bitset_t *in_colors = alloc_env->in_colors;
- bitset_t *live = bitset_irg_malloc(env->irg);
- const arch_env_t *arch_env = env->birg->main_env->arch_env;
- be_irg_t *birg = env->birg;
-
- bitset_pos_t elm;
- ir_node *irn;
-
- bitset_clear_all(colors);
- bitset_clear_all(in_colors);
-
- /*
- * All variables which are live in to this block are live out
- * of the immediate dominator thanks to SSA properties. As we
- * have already visited the immediate dominator, we know these
- * variables. The only tjing left is to check wheather they are live
- * in here (they also could be phi arguments to some ohi not
- * in this block, hence we have to check).
- */
- bitset_foreach (live_end_dom, elm) {
- ir_node *irn = get_idx_irn(env->irg, elm);
- if (be_is_live_in(birg->lv, block, irn)) {
- const arch_register_t *reg = arch_get_irn_register(arch_env, irn);
- int col;
-
- assert(be_is_live_in(env->birg->lv, block, irn));
- assert(reg && "Node must have been assigned a register");
- col = arch_register_get_index(reg);
-
- DBG((dbg, LEVEL_4, "%+F has reg %s\n", irn, reg->name));
-
- /* Mark the color of the live in value as used. */
- bitset_set(colors, col);
- bitset_set(in_colors, col);
-
- /* Mark the value live in. */
- bitset_set(live, elm);
- }
-
- else {
- assert(!be_is_live_in(env->birg->lv, block, irn));
- }
- }
-
- /*
- * Mind that the sequence of defs from back to front defines a perfect
- * elimination order. So, coloring the definitions from first to last
- * will work.
- */
- sched_foreach (block, irn) {
- int nr = get_irn_idx(irn);
- int ignore = arch_irn_is(arch_env, irn, ignore);
-
- /* Clear the color upon a last use. */
- if(!is_Phi(irn)) {
- int i;
- for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
- ir_node *op = get_irn_n(irn, i);
-
- /*
- * If the reg class matches and the operand is not live after
- * the node, irn is a last use of op and the register can
- * be freed.
- */
- if (has_reg_class(env, op)) {
- if (!be_lv_chk_after_irn(birg, op, irn)) {
- const arch_register_t *reg = arch_get_irn_register(arch_env, op);
- int col;
-
- assert(reg && "Register must have been assigned");
- col = arch_register_get_index(reg);
- bitset_clear(colors, col);
- bitset_clear(live, nr);
- }
- }
- }
- }
-
- if (has_reg_class(env, irn)) {
- const arch_register_t *reg;
- int col = NO_COLOR;
-
- /*
- * Assign a color, if it is a local def. Global defs already have a
- * color.
- */
- if(ignore || pset_find_ptr(alloc_env->pre_colored, irn)) {
- reg = arch_get_irn_register(arch_env, irn);
- col = reg->index;
- assert(!bitset_is_set(colors, col) && "pre-colored register must be free");
- } else {
- col = get_next_free_reg(alloc_env, colors);
- reg = arch_register_for_index(env->cls, col);
- assert(arch_get_irn_register(arch_env, irn) == NULL && "This node must not have been assigned a register yet");
- assert(!arch_register_type_is(reg, ignore) && "Must not assign ignore register");
- }
-
- bitset_set(colors, col);
- arch_set_irn_register(arch_env, irn, reg);
-
- DBG((dbg, LEVEL_1, "\tassigning register %s(%d) to %+F\n", arch_register_get_name(reg), col, irn));
-
- assert(!bitset_is_set(live, nr) && "Value's definition must not have been encountered");
- bitset_set(live, nr);
- }
-
- }
-
- dominates_for_each (block, irn) {
- assign_new(irn, alloc_env, live);
- }
-
- bitset_free(live);
}
void be_ra_chordal_color(be_chordal_env_t *chordal_env)
dom_tree_walk_irg(irg, pressure, NULL, &env);
/* Assign the colors */
-#ifdef NEW_STYLE_ASSIGN
- assign_new(get_irg_start_block(irg), &env, env.live);
-#else
dom_tree_walk_irg(irg, assign, NULL, &env);
-#endif
if(chordal_env->opts->dump_flags & BE_CH_DUMP_TREE_INTV) {
plotter_t *plotter;
projects / libfirm / blobdiff