X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespill.c;h=b15f46e49bba3421b2a79ed02f85b36f84317146;hb=44e06c719bc59348c183e041947461b49e48c79f;hp=016a2d776de04a402bdb83afe03d0bfea7d3c99a;hpb=3767f52182607e5de9f0ed7e48d88132317c12d8;p=libfirm diff --git a/ir/be/bespill.c b/ir/be/bespill.c index 016a2d776..b15f46e49 100644 --- a/ir/be/bespill.c +++ b/ir/be/bespill.c @@ -78,7 +78,7 @@ DEBUG_ONLY( void be_set_spill_env_dbg_module(spill_env_t *env, firm_dbg_module_t *dbg) { env->dbg = dbg; } -); +) spill_env_t *be_new_spill_env(const be_chordal_env_t *chordal_env, decide_irn_t is_mem_phi, void *data) { spill_env_t *env = xmalloc(sizeof(env[0])); @@ -395,6 +395,7 @@ typedef struct _ss_env_t { DEBUG_ONLY(firm_dbg_module_t *dbg;) } ss_env_t; + /** * Walker: compute the spill slots */ @@ -413,9 +414,7 @@ static void compute_spill_slots_walker(ir_node *spill, void *env) { if (!entry) { struct _arch_env_t *arch_env = ssenv->cenv->birg->main_env->arch_env; - ir_node *spilled = get_irn_n(spill, be_pos_Spill_val); - const arch_register_t *reg = arch_get_irn_register(arch_env, spilled); - const arch_register_class_t *cls = arch_register_get_class(reg); + const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, spill, be_pos_Spill_val); ir_mode *largest_mode = arch_register_class_mode(cls); /* this is a new spill context */ @@ -426,20 +425,32 @@ static void compute_spill_slots_walker(ir_node *spill, void *env) { ss->align = arch_isa_get_reg_class_alignment(arch_env->isa, cls); pmap_insert(ssenv->slots, ctx, ss); } else { - ir_node *irn; /* values with the same spill_ctx must go into the same spill slot */ ss = entry->value; - assert(ss->size == (unsigned)get_mode_size_bytes(get_irn_mode(get_irn_n(spill, be_pos_Spill_val))) && "Different sizes for the same spill slot are not allowed yet."); - for (irn = pset_first(ss->members); irn; irn = pset_next(ss->members)) { - /* use values_interfere here, because it uses the dominance check, - which does work for values in memory */ - assert(!values_interfere(spill, irn) && "Spills for the same spill slot must not interfere!"); + +#ifndef NDEBUG + /* ugly mega assert :-) */ + { + ir_node *irn; + struct _arch_env_t *arch_env = ssenv->cenv->birg->main_env->arch_env; + const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, spill, be_pos_Spill_val); + int size = get_mode_size_bytes(arch_register_class_mode(cls)); + assert(ss->size == size && "Different sizes for the same spill slot are not allowed."); + for (irn = pset_first(ss->members); irn; irn = pset_next(ss->members)) { + /* use values_interfere here, because it uses the dominance check, + which does work for values in memory */ + assert(!values_interfere(spill, irn) && "Spills for the same spill slot must not interfere!"); + } } +#endif /* NDEBUG */ } pset_insert_ptr(ss->members, spill); } +/** + * qsort compare function, sort spill slots by size. + */ static int ss_sorter(const void *v1, const void *v2) { const spill_slot_t *ss1 = v1; const spill_slot_t *ss2 = v2; @@ -530,24 +541,41 @@ interf_detected: /*nothing*/ ; /** * Returns a spill type for a mode. Keep them in a map to reduce * the number of types. + * + * @param types a map containing all created types + * @param ss the spill slot + * + * Note that type types should are identical for every mode. + * This rule might break if two different register classes return the same + * mode but different alignments. */ -static ir_type *get_spill_type(pmap *types, ir_mode *mode) { - pmap_entry *e = pmap_find(types, mode); +static ir_type *get_spill_type(pmap *types, spill_slot_t *ss) { + pmap_entry *e = pmap_find(types, ss->largest_mode); ir_type *res; if (! e) { char buf[64]; - snprintf(buf, sizeof(buf), "spill_slot_type_%s", get_mode_name(mode)); - res = new_type_primitive(new_id_from_str(buf), mode); - pmap_insert(types, mode, res); + snprintf(buf, sizeof(buf), "spill_slot_type_%s", get_mode_name(ss->largest_mode)); + res = new_type_primitive(new_id_from_str(buf), ss->largest_mode); + set_type_alignment_bytes(res, ss->align); + pmap_insert(types, ss->largest_mode, res); } - else + else { res = e->value; + assert(get_type_alignment_bytes(res) == (int)ss->align); + } return res; } -static void assign_entities(ss_env_t *ssenv, int n, spill_slot_t **ss) { - int i, offset; +/** + * Create spill slot entities on the frame type. + * + * @param ssenv the spill environment + * @param n number of spill slots + * @param ss array of spill slots + */ +static void assign_entities(ss_env_t *ssenv, int n_slots, spill_slot_t *ss[]) { + int i, offset, frame_align; ir_type *frame = get_irg_frame_type(ssenv->cenv->irg); /* aligning by increasing frame size */ @@ -556,7 +584,7 @@ static void assign_entities(ss_env_t *ssenv, int n, spill_slot_t **ss) { set_type_size_bytes(frame, -1); /* create entities and assign offsets according to size and alignment*/ - for (i=0; itypes, ss[i]->largest_mode)); + spill_ent = new_entity(frame, name, get_spill_type(ssenv->types, ss[i])); /* align */ offset = round_up2(offset, ss[i]->align); /* set */ set_entity_offset_bytes(spill_ent, offset); /* next possible offset */ - offset += ss[i]->size; + offset += round_up2(ss[i]->size, ss[i]->align); pset_foreach(ss[i]->members, irn) be_set_Spill_entity(irn, spill_ent); } /* set final size of stack frame */ - set_type_size_bytes(frame, offset); + frame_align = get_type_alignment_bytes(frame); + set_type_size_bytes(frame, round_up2(offset, frame_align)); } void be_compute_spill_offsets(be_chordal_env_t *cenv) {