/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
processing a block. */
static be_uses_t *uses; /**< env for the next-use magic */
static ir_node *instr; /**< current instruction */
-static unsigned instr_nr; /**< current instruction number
- (relative to block start) */
static spill_env_t *senv; /**< see bespill.h */
static ir_node **blocklist;
static int loc_compare(const void *a, const void *b)
{
- const loc_t *p = a;
- const loc_t *q = b;
+ const loc_t *p = (const loc_t*)a;
+ const loc_t *q = (const loc_t*)b;
return p->time - q->time;
}
* @p v A variable to put the current value in
* @p i An integer for internal use
*/
-#define workset_foreach(ws, v, i) \
+#define workset_foreach(ws, v, i) \
for (i=0; v=(i < ws->len) ? ws->vals[i].node : NULL, i < ws->len; ++i)
typedef struct block_info_t {
static inline block_info_t *get_block_info(const ir_node *block)
{
- return get_irn_link(block);
+ return (block_info_t*)get_irn_link(block);
}
static inline void set_block_info(ir_node *block, block_info_t *info)
/**
* @return The distance to the next use or 0 if irn has dont_spill flag set
*/
-static unsigned get_distance(ir_node *from, unsigned from_step,
- const ir_node *def, int skip_from_uses)
+static unsigned get_distance(ir_node *from, const ir_node *def, int skip_from_uses)
{
be_next_use_t use;
unsigned costs;
assert(!arch_irn_is_ignore(def));
- use = be_get_next_use(uses, from, from_step, def, skip_from_uses);
+ use = be_get_next_use(uses, from, def, skip_from_uses);
time = use.time;
if (USES_IS_INFINITE(time))
return USES_INFINITY;
/* calculate current next-use distance for live values */
for (i = 0; i < len; ++i) {
ir_node *val = workset_get_val(ws, i);
- unsigned dist = get_distance(instr, instr_nr, val, !is_usage);
+ unsigned dist = get_distance(instr, val, !is_usage);
workset_set_time(ws, i, dist);
}
return loc;
}
- next_use = be_get_next_use(uses, first, 0, node, 0);
+ next_use = be_get_next_use(uses, first, node, 0);
if (USES_IS_INFINITE(next_use.time)) {
/* the nodes marked as live in shouldn't be dead, so it must be a phi */
assert(is_Phi(node));
unsigned i;
int in;
unsigned ws_count;
- int free_slots, free_pressure_slots;
+ int free_slots, free_pressure_slots;
unsigned pressure;
int arity;
workset_t **pred_worksets;
}
pressure = be_get_loop_pressure(loop_ana, cls, loop);
- assert(ARR_LEN(delayed) <= (signed)pressure);
+ assert(ARR_LEN(delayed) <= pressure);
free_slots = n_regs - ARR_LEN(starters);
free_pressure_slots = n_regs - (pressure - ARR_LEN(delayed));
free_slots = MIN(free_slots, free_pressure_slots);
DB((dbg, DBG_START, "Loop pressure %d, taking %d delayed vals\n",
pressure, free_slots));
if (free_slots > 0) {
- int i;
+ size_t i;
+
qsort(delayed, ARR_LEN(delayed), sizeof(delayed[0]), loc_compare);
for (i = 0; i < ARR_LEN(delayed) && free_slots > 0; ++i) {
/* no predecessor -> empty set */
workset_clear(ws);
} else if (arity == 1) {
- /* one predecessor, copy it's end workset */
+ /* one predecessor, copy its end workset */
ir_node *pred_block = get_Block_cfgpred_block(block, 0);
block_info_t *pred_info = get_block_info(pred_block);
/* process the block from start to end */
DB((dbg, DBG_WSETS, "Processing...\n"));
- instr_nr = 0;
/* TODO: this leaks (into the obstack)... */
new_vals = new_workset();
workset_insert(new_vals, value, false);
);
displace(new_vals, 0);
-
- instr_nr++;
}
/* Remember end-workset for this block */
obstack_init(&obst);
cls = rcls;
lv = be_get_irg_liveness(irg);
- n_regs = cls->n_regs - be_put_ignore_regs(irg, cls, NULL);
+ n_regs = be_get_n_allocatable_regs(irg, cls);
ws = new_workset();
uses = be_begin_uses(irg, lv);
loop_ana = be_new_loop_pressure(irg, cls);
obstack_free(&obst, NULL);
}
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillbelady);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillbelady)
void be_init_spillbelady(void)
{
static be_spiller_t belady_spiller = {