X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillslots.c;h=bba1a81898f655f3b01a3f7919b75f34a752c4dc;hb=81d44459b367b64abbb26feeb7c2f31738f542c0;hp=c69ecd013494c27f4fd704cc1100f35e9f7ea0d1;hpb=294764ce7bb590e7714ef1378d7eda9608dbef6e;p=libfirm diff --git a/ir/be/bespillslots.c b/ir/be/bespillslots.c index c69ecd013..bba1a8189 100644 --- a/ir/be/bespillslots.c +++ b/ir/be/bespillslots.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -24,9 +24,7 @@ * @date 26.07.2006 * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include @@ -43,7 +41,6 @@ #include "besched.h" #include "bespillslots.h" #include "bechordal_t.h" -#include "bejavacoal.h" #include "bestatevent.h" #include "bespilloptions.h" #include "bemodule.h" @@ -54,18 +51,13 @@ #define DBG_COALESCING 1 #define DBG_INTERFERENCES 2 -DEBUG_ONLY( -static firm_dbg_module_t *dbg = NULL; -) +DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) typedef struct _spill_t { ir_node *spill; - /** mode of the spilled value */ - const ir_mode *mode; - /** alignment for the spilled value */ - int alignment; - /** index into spillslot_unionfind unionfind structure */ - int spillslot; + const ir_mode *mode; /**< mode of the spilled value */ + int alignment; /**< alignment for the spilled value */ + int spillslot; /**< index into spillslot_unionfind structure */ } spill_t; typedef struct _affinity_edge_t { @@ -89,7 +81,7 @@ static int cmp_affinity(const void *d1, const void *d2) const affinity_edge_t * const *e1 = d1; const affinity_edge_t * const *e2 = d2; - // sort in descending order + /* sort in descending order */ return (*e1)->affinity < (*e2)->affinity ? 1 : -1; } @@ -113,16 +105,8 @@ static spill_t *get_spill(be_fec_env_t *env, ir_node *node) return res; } -/* - * ____ _ _ _ ____ _ _ _ - * / ___|___ | | | ___ ___| |_ / ___| _ __ (_) | |___ - * | | / _ \| | |/ _ \/ __| __| \___ \| '_ \| | | / __| - * | |__| (_) | | | __/ (__| |_ ___) | |_) | | | \__ \ - * \____\___/|_|_|\___|\___|\__| |____/| .__/|_|_|_|___/ - * |_| - */ -static INLINE ir_node *get_memory_edge(const ir_node *node) +static inline ir_node *get_memory_edge(const ir_node *node) { int i, arity; @@ -140,7 +124,7 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node, const ir_mode *mode, int align) { spill_t spill, *res; - int hash = hash_irn(node); + int hash = hash_irn(node); /* insert into set of spills if not already there */ spill.spill = node; @@ -151,6 +135,7 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node, spill.mode = mode; spill.alignment = align; res = set_insert(env->spills, &spill, sizeof(spill), hash); + DB((dbg, DBG_COALESCING, "Slot %d: %+F\n", spill.spillslot, node)); } else { assert(res->mode == mode); assert(res->alignment == align); @@ -180,9 +165,10 @@ static spill_t *collect_memphi(be_fec_env_t *env, ir_node *node, spill.spillslot = set_count(env->spills); spill.mode = mode; spill.alignment = align; + DB((dbg, DBG_COALESCING, "Slot %d: %+F\n", spill.spillslot, node)); res = set_insert(env->spills, &spill, sizeof(spill), hash); - // collect attached spills and mem-phis + /* collect attached spills and mem-phis */ arity = get_irn_arity(node); for(i = 0; i < arity; ++i) { affinity_edge_t *affinty_edge; @@ -195,7 +181,7 @@ static spill_t *collect_memphi(be_fec_env_t *env, ir_node *node, arg_spill = collect_spill(env, arg, mode, align); } - // add an affinity edge + /* add an affinity edge */ affinty_edge = obstack_alloc(&env->obst, sizeof(affinty_edge[0])); affinty_edge->affinity = get_block_execfreq(exec_freq, get_nodes_block(arg)); affinty_edge->slot1 = res->spillslot; @@ -214,6 +200,7 @@ void be_node_needs_frame_entity(be_fec_env_t *env, ir_node *node, assert(spillnode != NULL); + /* walk upwards and collect all phis and spills on this way */ if (is_Phi(spillnode)) { spill = collect_memphi(env, spillnode, mode, align); } else { @@ -223,13 +210,7 @@ void be_node_needs_frame_entity(be_fec_env_t *env, ir_node *node, ARR_APP1(ir_node *, env->reloads, node); } -/* - * ____ _ ____ _ _ - * / ___|___ __ _| | ___ ___ ___ ___ / ___|| | ___ | |_ ___ - * | | / _ \ / _` | |/ _ \/ __|/ __/ _ \ \___ \| |/ _ \| __/ __| - * | |__| (_) | (_| | | __/\__ \ (_| __/ ___) | | (_) | |_\__ \ - * \____\___/ \__,_|_|\___||___/\___\___| |____/|_|\___/ \__|___/ - */ + static int merge_interferences(be_fec_env_t *env, bitset_t** interferences, int* spillslot_unionfind, int s1, int s2) @@ -238,9 +219,9 @@ static int merge_interferences(be_fec_env_t *env, bitset_t** interferences, int i; int spillcount; - // merge spillslots and interferences + /* merge spillslots and interferences */ res = uf_union(spillslot_unionfind, s1, s2); - // we assume that we always merge s2 to s1 so swap s1, s2 if necessary + /* we assume that we always merge s2 to s1 so swap s1, s2 if necessary */ if(res != 0) { int t = s1; s1 = s2; @@ -249,7 +230,7 @@ static int merge_interferences(be_fec_env_t *env, bitset_t** interferences, bitset_or(interferences[s1], interferences[s2]); - // update other interferences + /* update other interferences */ spillcount = set_count(env->spills); for(i = 0; i < spillcount; ++i) { bitset_t *intfs = interferences[i]; @@ -372,11 +353,11 @@ static void do_greedy_coalescing(be_fec_env_t *env) if(spillcount == 0) return; - DBG((dbg, DBG_COALESCING, "Coalescing %d spillslots\n", spillcount)); + DB((dbg, DBG_COALESCING, "Coalescing %d spillslots\n", spillcount)); - interferences = alloca(spillcount * sizeof(interferences[0])); - spillslot_unionfind = alloca(spillcount * sizeof(spillslot_unionfind[0])); - spilllist = alloca(spillcount * sizeof(spilllist[0])); + interferences = ALLOCAN(bitset_t*, spillcount); + spillslot_unionfind = ALLOCAN(int, spillcount); + spilllist = ALLOCAN(spill_t*, spillcount); uf_init(spillslot_unionfind, 0, spillcount); @@ -384,7 +365,8 @@ static void do_greedy_coalescing(be_fec_env_t *env) memset(spilllist, 0, spillcount * sizeof(spilllist[0])); ); - for(spill = set_first(env->spills), i = 0; spill != NULL; spill = set_next(env->spills), ++i) { + for(spill = set_first(env->spills), i = 0; spill != NULL; + spill = set_next(env->spills), ++i) { assert(spill->spillslot < spillcount); spilllist[spill->spillslot] = spill; } @@ -407,7 +389,9 @@ static void do_greedy_coalescing(be_fec_env_t *env) continue; if (my_values_interfere(env->birg, spill1, spill2)) { - DBG((dbg, DBG_INTERFERENCES, "Slot %d and %d interfere\n", i, i2)); + DB((dbg, DBG_INTERFERENCES, + "Slot %d and %d interfere\n", i, i2)); + bitset_set(interferences[i], i2); bitset_set(interferences[i2], i); } @@ -416,9 +400,10 @@ static void do_greedy_coalescing(be_fec_env_t *env) /* sort affinity edges */ affinity_edge_count = ARR_LEN(env->affinity_edges); - qsort(env->affinity_edges, affinity_edge_count, sizeof(env->affinity_edges[0]), cmp_affinity); + qsort(env->affinity_edges, affinity_edge_count, + sizeof(env->affinity_edges[0]), cmp_affinity); - //dump_interference_graph(env, interferences, "before"); + /*dump_interference_graph(env, interferences, "before"); */ /* try to merge affine nodes */ for(i = 0; i < affinity_edge_count; ++i) { @@ -432,12 +417,13 @@ static void do_greedy_coalescing(be_fec_env_t *env) continue; } - DBG((dbg, DBG_COALESCING, "Merging %d and %d because of affinity edge\n", s1, s2)); + DB((dbg, DBG_COALESCING, + "Merging %d and %d because of affinity edge\n", s1, s2)); merge_interferences(env, interferences, spillslot_unionfind, s1, s2); } - // try to merge as much remaining spillslots as possible + /* try to merge as much remaining spillslots as possible */ for(i = 0; i < spillcount; ++i) { int s1 = uf_find(spillslot_unionfind, i); if(s1 != i) @@ -457,34 +443,28 @@ static void do_greedy_coalescing(be_fec_env_t *env) continue; } - DBG((dbg, DBG_COALESCING, "Merging %d and %d because it is possible\n", s1, s2)); + DB((dbg, DBG_COALESCING, + "Merging %d and %d because it is possible\n", s1, s2)); if(merge_interferences(env, interferences, spillslot_unionfind, s1, s2) != 0) { - // we can break the loop here, because s2 is the new supernode now - // and we'll test s2 again later anyway + /* we can break the loop here, because s2 is the new supernode + * now and we'll test s2 again later anyway */ break; } } } - // assign spillslots to spills + /* assign spillslots to spills */ for(i = 0; i < spillcount; ++i) { spill_t *spill = spilllist[i]; spill->spillslot = uf_find(spillslot_unionfind, i); } - //dump_interference_graph(env, interferences, "after"); + /*dump_interference_graph(env, interferences, "after");*/ } -/* - * _ _ _____ _ _ _ _ - * / \ ___ ___(_) __ _ _ __ | ____|_ __ | |_(_) |_(_) ___ ___ - * / _ \ / __/ __| |/ _` | '_ \ | _| | '_ \| __| | __| |/ _ \/ __| - * / ___ \\__ \__ \ | (_| | | | | | |___| | | | |_| | |_| | __/\__ \ - * /_/ \_\___/___/_|\__, |_| |_| |_____|_| |_|\__|_|\__|_|\___||___/ - * |___/ - */ + typedef struct _spill_slot_t { int size; @@ -538,7 +518,10 @@ static ir_entity* create_stack_entity(be_fec_env_t *env, spill_slot_t *slot) { ir_graph *irg = be_get_birg_irg(env->birg); ir_type *frame = get_irg_frame_type(irg); - ir_entity *res = frame_alloc_area(frame, slot->size, slot->align, 0); + /* TODO: backend should be able to specify wether we want spill slots + * at begin or end of frame */ + int at_start = 1; + ir_entity *res = frame_alloc_area(frame, slot->size, slot->align, at_start); /* adjust size of the entity type... */ ir_type *enttype = get_entity_type(res); @@ -569,7 +552,7 @@ static void enlarge_spillslot(spill_slot_t *slot, int otheralign, int othersize) } -static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node, ir_entity *entity) +static void assign_spill_entity(ir_node *node, ir_entity *entity) { if(is_NoMem(node)) return; @@ -581,13 +564,15 @@ static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node, ir_en ir_node *in = get_irn_n(node, i); assert(!is_Phi(in)); - assign_spill_entity(arch_env, in, entity); + assign_spill_entity(in, entity); } return; } - assert(arch_get_frame_entity(arch_env, node) == NULL); - arch_set_frame_entity(arch_env, node, entity); + /* beware: we might have Stores with Memory Proj's, ia32 fisttp for instance */ + node = skip_Proj(node); + assert(arch_get_frame_entity(node) == NULL); + arch_set_frame_entity(node, entity); } /** @@ -596,19 +581,15 @@ static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node, ir_en */ static void assign_spillslots(be_fec_env_t *env) { - const arch_env_t *arch_env = env->arch_env; - int i; - int spillcount; - spill_t *spill; - spill_slot_t* spillslots; + int spillcount = set_count(env->spills); + spill_slot_t *spillslots = ALLOCANZ(spill_slot_t, spillcount); + spill_t *spill; + int i; - spillcount = set_count(env->spills); - spillslots = alloca(spillcount * sizeof(spillslots[0])); - - memset(spillslots, 0, spillcount * sizeof(spillslots[0])); + /* construct spillslots */ + for(spill = set_first(env->spills); spill != NULL; + spill = set_next(env->spills)) { - // construct spillslots - for(spill = set_first(env->spills); spill != NULL; spill = set_next(env->spills)) { int slotid = spill->spillslot; const ir_mode *mode = spill->mode; spill_slot_t *slot = & (spillslots[slotid]); @@ -623,10 +604,12 @@ static void assign_spillslots(be_fec_env_t *env) } } - for(spill = set_first(env->spills); spill != NULL; spill = set_next(env->spills)) { + for(spill = set_first(env->spills); spill != NULL; + spill = set_next(env->spills)) { + + ir_node *node = spill->spill; + int slotid = spill->spillslot; spill_slot_t *slot; - ir_node *node = spill->spill; - int slotid = spill->spillslot; slot = &spillslots[slotid]; if(slot->entity == NULL) { @@ -637,7 +620,7 @@ static void assign_spillslots(be_fec_env_t *env) int i, arity; ir_node *block = get_nodes_block(node); - // should be a PhiM + /* should be a PhiM */ assert(is_Phi(node)); for(i = 0, arity = get_irn_arity(node); i < arity; ++i) { @@ -671,19 +654,19 @@ static void assign_spillslots(be_fec_env_t *env) } } } else { - assign_spill_entity(arch_env, node, slot->entity); + assign_spill_entity(node, slot->entity); } } for(i = 0; i < ARR_LEN(env->reloads); ++i) { - ir_node* reload = env->reloads[i]; - ir_node* spillnode = get_memory_edge(reload); - spill_t *spill = get_spill(env, spillnode); - const spill_slot_t *slot = & spillslots[spill->spillslot]; + ir_node *reload = env->reloads[i]; + ir_node *spillnode = get_memory_edge(reload); + spill_t *spill = get_spill(env, spillnode); + const spill_slot_t *slot = & spillslots[spill->spillslot]; assert(slot->entity != NULL); - arch_set_frame_entity(arch_env, reload, slot->entity); + arch_set_frame_entity(reload, slot->entity); } } @@ -717,11 +700,11 @@ static void create_memperms(be_fec_env_t *env) memperm_t *memperm; for(memperm = set_first(env->memperms); memperm != NULL; memperm = set_next(env->memperms)) { - int i; - memperm_entry_t *entry; - ir_node *blockend; - ir_node** nodes = alloca(memperm->entrycount * sizeof(nodes[0])); - ir_node* mempermnode; + ir_node **nodes = ALLOCAN(ir_node*, memperm->entrycount); + memperm_entry_t *entry; + ir_node *blockend; + ir_node *mempermnode; + int i; assert(memperm->entrycount > 0); @@ -733,7 +716,7 @@ static void create_memperms(be_fec_env_t *env) mempermnode = be_new_MemPerm(arch_env, irg, memperm->block, memperm->entrycount, nodes); - // insert node into schedule + /* insert node into schedule */ blockend = get_end_of_block_insertion_point(memperm->block); sched_add_before(blockend, mempermnode); stat_ev_dbl("mem_perm", memperm->entrycount); @@ -776,7 +759,7 @@ static int count_spillslots(const be_fec_env_t *env) be_fec_env_t *be_new_frame_entity_coalescer(be_irg_t *birg) { const arch_env_t *arch_env = birg->main_env->arch_env; - be_fec_env_t *env = xmalloc(sizeof(env[0])); + be_fec_env_t *env = XMALLOC(be_fec_env_t); be_liveness_assure_chk(be_assure_liveness(birg)); @@ -824,7 +807,6 @@ void be_assign_entities(be_fec_env_t *env) static void collect_spills_walker(ir_node *node, void *data) { be_fec_env_t *env = data; - const arch_env_t *arch_env = env->arch_env; const ir_mode *mode; const arch_register_class_t *cls; int align; @@ -833,12 +815,12 @@ static void collect_spills_walker(ir_node *node, void *data) if (is_Proj(node)) return; - if (!arch_irn_class_is(arch_env, node, reload)) + if (!arch_irn_class_is(node, reload)) return; mode = get_irn_mode(node); - cls = arch_get_irn_reg_class(arch_env, node, -1); - align = arch_isa_get_reg_class_alignment(arch_env_get_isa(arch_env), cls); + cls = arch_get_irn_reg_class_out(node); + align = arch_env_get_reg_class_alignment(env->arch_env, cls); be_node_needs_frame_entity(env, node, mode, align); }