* @brief Spillslot coalescer.
* @author Matthias Braun
* @date 26.07.2006
- * @version $Id$
*/
#include "config.h"
affinity_edge_t **affinity_edges;
set *memperms;
set_frame_entity_func set_frame_entity;
+ bool at_begin; /**< frame entities should be allocate at
+ the beginning of the stackframe */
};
/** Compare 2 affinity edges (used in quicksort) */
static int cmp_affinity(const void *d1, const void *d2)
{
- const affinity_edge_t * const *e1 = d1;
- const affinity_edge_t * const *e2 = d2;
+ const affinity_edge_t * const *e1 = (const affinity_edge_t**)d1;
+ const affinity_edge_t * const *e2 = (const affinity_edge_t**)d2;
/* sort in descending order */
return (*e1)->affinity < (*e2)->affinity ? 1 : -1;
static int cmp_spill(const void* d1, const void* d2, size_t size)
{
- const spill_t* s1 = d1;
- const spill_t* s2 = d2;
+ const spill_t* s1 = (const spill_t*)d1;
+ const spill_t* s2 = (const spill_t*)d2;
(void) size;
return s1->spill != s2->spill;
int hash = hash_irn(node);
spill.spill = node;
- res = set_find(env->spills, &spill, sizeof(spill), hash);
+ res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
return res;
}
/* insert into set of spills if not already there */
spill.spill = node;
- res = set_find(env->spills, &spill, sizeof(spill), hash);
+ res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
if (res == NULL) {
spill.spillslot = set_count(env->spills);
spill.mode = mode;
spill.alignment = align;
- res = set_insert(env->spills, &spill, sizeof(spill), hash);
+ res = (spill_t*)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(is_Phi(node));
spill.spill = node;
- res = set_find(env->spills, &spill, sizeof(spill), hash);
+ res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
if (res != NULL) {
assert(res->mode == mode);
assert(res->alignment == align);
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);
+ res = (spill_t*)set_insert(env->spills, &spill, sizeof(spill), hash);
/* collect attached spills and mem-phis */
arity = get_irn_arity(node);
const ir_mode *mode, int align)
{
ir_node *spillnode = get_memory_edge(node);
- spill_t *spill;
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);
+ collect_memphi(env, spillnode, mode, align);
} else {
- spill = collect_spill(env, spillnode, mode, align);
+ collect_spill(env, spillnode, mode, align);
}
ARR_APP1(ir_node *, env->reloads, node);
DEBUG_ONLY(
memset(spilllist, 0, spillcount * sizeof(spilllist[0]));
- );
+ )
- for (spill = set_first(env->spills), i = 0; spill != NULL;
- spill = set_next(env->spills), ++i) {
+ i = 0;
+ foreach_set(env->spills, spill_t*, spill) {
assert(spill->spillslot < spillcount);
spilllist[spill->spillslot] = spill;
+ ++i;
}
for (i = 0; i < spillcount; ++i) {
static int cmp_memperm(const void* d1, const void* d2, size_t size)
{
- const memperm_t* e1 = d1;
- const memperm_t* e2 = d2;
+ const memperm_t* e1 = (const memperm_t*)d1;
+ const memperm_t* e2 = (const memperm_t*)d2;
(void) size;
return e1->block != e2->block;
entry.block = block;
hash = hash_irn(block);
- res = set_find(env->memperms, &entry, sizeof(entry), hash);
+ res = (memperm_t*)set_find(env->memperms, &entry, sizeof(entry), hash);
if (res == NULL) {
entry.entrycount = 0;
entry.entries = NULL;
- res = set_insert(env->memperms, &entry, sizeof(entry), hash);
+ res = (memperm_t*)set_insert(env->memperms, &entry, sizeof(entry), hash);
}
return res;
static ir_entity* create_stack_entity(be_fec_env_t *env, spill_slot_t *slot)
{
- ir_graph *irg = env->irg;
- ir_type *frame = get_irg_frame_type(irg);
- /* 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);
- set_type_size_bytes(enttype, slot->size);
-
+ ir_graph *irg = env->irg;
+ ir_type *frame = get_irg_frame_type(irg);
+ ir_entity *res = frame_alloc_area(frame, slot->size, slot->align,
+ env->at_begin);
slot->entity = res;
return res;
int spillcount = set_count(env->spills);
spill_slot_t *spillslots = ALLOCANZ(spill_slot_t, spillcount);
spill_t *spill;
- int i;
+ size_t i;
/* construct spillslots */
- for (spill = set_first(env->spills); spill != NULL;
- spill = set_next(env->spills)) {
-
+ foreach_set(env->spills, spill_t*, spill) {
int slotid = spill->spillslot;
const ir_mode *mode = spill->mode;
spill_slot_t *slot = & (spillslots[slotid]);
}
}
- for (spill = set_first(env->spills); spill != NULL;
- spill = set_next(env->spills)) {
-
+ foreach_set(env->spills, spill_t*, spill) {
ir_node *node = spill->spill;
int slotid = spill->spillslot;
spill_slot_t *slot;
ir_node *block = get_nodes_block(node);
/* should be a PhiM */
- assert(is_Phi(node));
+ assert(get_irn_mode(node) == mode_M);
for (i = 0, arity = get_irn_arity(node); i < arity; ++i) {
ir_node *arg = get_irn_n(node, i);
static void create_memperms(be_fec_env_t *env)
{
- ir_graph *irg = env->irg;
- memperm_t *memperm;
+ memperm_t *memperm;
- for (memperm = set_first(env->memperms); memperm != NULL; memperm = set_next(env->memperms)) {
+ foreach_set(env->memperms, memperm_t*, memperm) {
ir_node **nodes = ALLOCAN(ir_node*, memperm->entrycount);
memperm_entry_t *entry;
ir_node *blockend;
be_set_MemPerm_in_entity(mempermnode, i, entry->in);
be_set_MemPerm_out_entity(mempermnode, i, entry->out);
- set_irg_current_block(irg, memperm->block);
- proj = new_Proj(mempermnode, get_irn_mode(arg), i);
+ proj = new_r_Proj(mempermnode, get_irn_mode(arg), i);
set_irn_n(entry->node, entry->pos, proj);
}
int slotcount;
slotcount = 0;
- for (spill = set_first(env->spills); spill != NULL;
- spill = set_next(env->spills)) {
+ foreach_set(env->spills, spill_t*, spill) {
int spillslot = spill->spillslot;
if (!bitset_is_set(counted, spillslot)) {
slotcount++;
{
be_fec_env_t *env = XMALLOCZ(be_fec_env_t);
- be_liveness_assure_chk(be_assure_liveness(irg));
+ be_assure_live_chk(irg);
obstack_init(&env->obst);
env->irg = irg;
}
void be_assign_entities(be_fec_env_t *env,
- set_frame_entity_func set_frame_entity)
+ set_frame_entity_func set_frame_entity,
+ bool alloc_entities_at_begin)
{
env->set_frame_entity = set_frame_entity;
+ env->at_begin = alloc_entities_at_begin;
stat_ev_dbl("spillslots", set_count(env->spills));
create_memperms(env);
}
-/**
- * This walker function searches for reloads and collects all the spills
- * and memphis attached to them.
- */
-static void collect_spills_walker(ir_node *node, void *data)
-{
- be_fec_env_t *env = data;
- const ir_mode *mode;
- const arch_register_class_t *cls;
- int align;
- ir_graph *irg;
- const arch_env_t *arch_env;
-
- if (! (arch_irn_classify(node) & arch_irn_class_reload))
- return;
-
- mode = get_irn_mode(node);
- cls = arch_get_irn_reg_class_out(node);
- irg = get_irn_irg(node);
- arch_env = be_get_irg_arch_env(irg);
- align = arch_env_get_reg_class_alignment(arch_env, cls);
-
- be_node_needs_frame_entity(env, node, mode, align);
-}
-
-void be_coalesce_spillslots(ir_graph *irg)
-{
- be_fec_env_t *env = be_new_frame_entity_coalescer(irg);
-
- /* collect reloads */
- irg_walk_graph(irg, NULL, collect_spills_walker, env);
-
- be_assign_entities(env, be_node_set_frame_entity);
-
- be_free_frame_entity_coalescer(env);
-}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillslots);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillslots)
void be_init_spillslots(void)
{
FIRM_DBG_REGISTER(dbg, "firm.be.spillslots");