#include "irgwalk.h"
#include "irprintf_t.h"
#include "irbitset.h"
+#include "irdump_t.h"
#include "beutil.h"
#include "belive_t.h"
#include "besched_t.h"
+#include "bemodule.h"
-#define DBG_MODULE "firm.be.liveness"
+DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
#define LV_STD_SIZE 128
#define LV_USE_BINARY_SEARCH
static INLINE int is_liveness_node(const ir_node *irn)
{
- return is_Phi(irn) || is_data_node(irn);
+ switch(get_irn_opcode(irn)) {
+ case iro_Block:
+ case iro_Bad:
+ case iro_End:
+ return 0;
+ default:;
+ }
+
+ return 1;
}
int (be_lv_next_irn)(const struct _be_lv_t *lv, const ir_node *bl, unsigned flags, int i)
#else
/**
- * This function searches linearily for the node in the array.
+ * This function searches linearly for the node in the array.
*/
static INLINE unsigned _be_liveness_bsearch(struct _be_lv_info_t *arr, unsigned idx) {
unsigned n = arr[0].u.head.n_members;
payload[n - 1].u.node.flags = 0;
--irn_live[0].u.head.n_members;
- DBG((li->dbg, LEVEL_3, "\tdeleting %+F from %+F at pos %d\n", irn, bl, pos));
+ DBG((dbg, LEVEL_3, "\tdeleting %+F from %+F at pos %d\n", irn, bl, pos));
return 1;
}
}
static INLINE void mark_live_in(be_lv_t *lv, ir_node *block, ir_node *irn)
{
struct _be_lv_info_node_t *n = be_lv_get_or_set(lv, block, irn);
- DBG((lv->dbg, LEVEL_2, "marking %+F live in at %+F\n", irn, block));
+ DBG((dbg, LEVEL_2, "marking %+F live in at %+F\n", irn, block));
n->flags |= be_lv_state_in;
register_node(lv, irn);
}
static INLINE void mark_live_out(be_lv_t *lv, ir_node *block, ir_node *irn)
{
struct _be_lv_info_node_t *n = be_lv_get_or_set(lv, block, irn);
- DBG((lv->dbg, LEVEL_2, "marking %+F live out at %+F\n", irn, block));
+ DBG((dbg, LEVEL_2, "marking %+F live out at %+F\n", irn, block));
n->flags |= be_lv_state_out | be_lv_state_end;
register_node(lv, irn);
}
static INLINE void mark_live_end(be_lv_t *lv, ir_node *block, ir_node *irn)
{
struct _be_lv_info_node_t *n = be_lv_get_or_set(lv, block, irn);
- DBG((lv->dbg, LEVEL_2, "marking %+F live end at %+F\n", irn, block));
+ DBG((dbg, LEVEL_2, "marking %+F live end at %+F\n", irn, block));
n->flags |= be_lv_state_end;
register_node(lv, irn);
}
ir_node *use_block;
/*
- * If the usage is no data node, skip this use, since it does not
- * affect the liveness of the node.
- */
+ * If the usage is no data node, skip this use, since it does not
+ * affect the liveness of the node.
+ */
if(!is_liveness_node(use))
continue;
use_block = get_nodes_block(use);
/*
- * If the use is a phi function, determine the corresponding block
- * through which the value reaches the phi function and mark the
- * value as live out of that block.
- */
+ * If the use is a phi function, determine the corresponding block
+ * through which the value reaches the phi function and mark the
+ * value as live out of that block.
+ */
if(is_Phi(use)) {
ir_node *pred_block = get_Block_cfgpred_block(use_block, edge->pos);
live_end_at_block(lv, irn, pred_block, visited, 0);
}
/*
- * Else, the value is live in at this block. Mark it and call live
- * out on the predecessors.
- */
+ * Else, the value is live in at this block. Mark it and call live
+ * out on the predecessors.
+ */
else if(def_block != use_block) {
int i, n;
}
}
-static void *lv_phase_data_init(phase_t *phase, ir_node *irn, void *old)
+static void *lv_phase_data_init(ir_phase *phase, ir_node *irn, void *old)
{
struct _be_lv_info_t *info = phase_alloc(phase, LV_STD_SIZE * sizeof(info[0]));
memset(info, 0, LV_STD_SIZE * sizeof(info[0]));
be_lv_t *lv = xmalloc(sizeof(lv[0]));
memset(lv, 0, sizeof(lv[0]));
- FIRM_DBG_REGISTER(lv->dbg, DBG_MODULE);
lv->irg = irg;
lv->nodes = bitset_malloc(2 * get_irg_last_idx(irg));
lv->hook_info.context = lv;
*/
static void dom_check(ir_node *irn, void *data)
{
+ int *problem_found = data;
+
if(!is_Block(irn) && irn != get_irg_end(get_irn_irg(irn))) {
int i, n;
ir_node *bl = get_nodes_block(irn);
if(is_Phi(irn))
use_bl = get_Block_cfgpred_block(bl, i);
- if(!block_dominates(def_bl, use_bl)) {
- ir_fprintf(stderr, "%+F in %+F must dominate %+F for user %+F\n", op, def_bl, use_bl, irn);
- assert(0);
+ if(get_irn_opcode(use_bl) != iro_Bad
+ && get_irn_opcode(def_bl) != iro_Bad
+ && !block_dominates(def_bl, use_bl)) {
+ ir_fprintf(stderr, "Verify warning: %+F in %+F must dominate %+F for user %+F (%s)\n", op, def_bl, use_bl, irn, get_irg_dump_name(get_irn_irg(op)));
+ *problem_found = 1;
}
}
}
}
/* Check, if the SSA dominance property is fulfilled. */
-void be_check_dominance(ir_graph *irg)
+int be_check_dominance(ir_graph *irg)
{
- irg_walk_graph(irg, dom_check, NULL, NULL);
+ int problem_found = 0;
+
+ assure_doms(irg);
+ irg_walk_graph(irg, dom_check, NULL, &problem_found);
+
+ return !problem_found;
}
pset *be_liveness_transfer(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_node *irn, pset *live)
{
int i, n;
- ir_node *x;
- FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
-
- DEBUG_ONLY(
- DBG((dbg, LEVEL_1, "%+F\n", irn));
- for(x = pset_first(live); x; x = pset_next(live))
- DBG((dbg, LEVEL_1, "\tlive: %+F\n", x));
- )
/* You should better break out of your loop when hitting the first phi function. */
assert(!is_Phi(irn) && "liveness_transfer produces invalid results for phi nodes");
if(arch_irn_consider_in_reg_alloc(arch_env, cls, irn)) {
ir_node *del = pset_remove_ptr(live, irn);
+ (void) del;
assert(irn == del);
}
return live;
}
+
+pset *be_liveness_nodes_live_at_input(const be_lv_t *lv, const arch_env_t *arch_env, const arch_register_class_t *cls, const ir_node *pos, pset *live)
+{
+ const ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos);
+ ir_node *irn;
+
+ be_liveness_end_of_block(lv, arch_env, cls, bl, live);
+ sched_foreach_reverse(bl, irn) {
+ be_liveness_transfer(arch_env, cls, irn, live);
+ if(irn == pos)
+ return live;
+ }
+
+ return live;
+}
+
+void be_init_live(void)
+{
+ FIRM_DBG_REGISTER(dbg, "firm.be.liveness");
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_live);