+/*
+ * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
/**
- * Interblock liveness analysis.
- * @author Sebastian Hack
- * @date 6.12.2004
+ * @file
+ * @brief Interblock liveness analysis.
+ * @author Sebastian Hack
+ * @date 06.12.2004
+ * @version $Id$
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "irprintf_t.h"
#include "irbitset.h"
#include "irdump_t.h"
+#include "irnodeset.h"
#include "beutil.h"
#include "belive_t.h"
+#include "beirg_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
#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);
}
}
}
-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;
lv->hook_info.hook._hook_node_info = lv_dump_block;
register_hook(hook_node_info, &lv->hook_info);
- phase_init(&lv->ph, "liveness", irg, PHASE_DEFAULT_GROWTH, lv_phase_data_init);
+ phase_init(&lv->ph, "liveness", irg, PHASE_DEFAULT_GROWTH, lv_phase_data_init, NULL);
compute_liveness(lv);
return lv;
bitset_clear_all(lv->nodes);
phase_free(&lv->ph);
- phase_init(&lv->ph, "liveness", lv->irg, PHASE_DEFAULT_GROWTH, lv_phase_data_init);
+ phase_init(&lv->ph, "liveness", lv->irg, PHASE_DEFAULT_GROWTH, lv_phase_data_init, NULL);
compute_liveness(lv);
}
w.lv = lv;
w.data = irn;
dom_tree_walk(get_nodes_block(irn), lv_remove_irn_walker, NULL, &w);
- if(idx <= bitset_size(lv->nodes))
+ if(idx < bitset_size(lv->nodes))
bitset_clear(lv->nodes, idx);
}
pset *be_liveness_transfer(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_node *irn, pset *live)
{
int i, n;
- FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
-
- DEBUG_ONLY(
- const ir_node *x;
- 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;
}
+void be_liveness_transfer_ir_nodeset(const arch_env_t *arch_env,
+ const arch_register_class_t *cls,
+ ir_node *node, ir_nodeset_t *nodeset)
+{
+ int i, arity;
+
+ /* You should better break out of your loop when hitting the first phi
+ * function. */
+ assert(!is_Phi(node) && "liveness_transfer produces invalid results for phi nodes");
+
+ if(arch_irn_consider_in_reg_alloc(arch_env, cls, node)) {
+ ir_nodeset_remove(nodeset, node);
+ }
+
+ arity = get_irn_arity(node);
+ for(i = 0; i < arity; ++i) {
+ ir_node *op = get_irn_n(node, i);
+
+ if(arch_irn_consider_in_reg_alloc(arch_env, cls, op))
+ ir_nodeset_insert(nodeset, op);
+ }
+}
+
+
+
pset *be_liveness_end_of_block(const be_lv_t *lv, const arch_env_t *arch_env, const arch_register_class_t *cls, const ir_node *bl, pset *live)
{
int i;
return live;
}
+void be_liveness_end_of_block_ir_nodeset(const be_lv_t *lv,
+ const arch_env_t *arch_env,
+ const arch_register_class_t *cls,
+ const ir_node *block,
+ ir_nodeset_t *live)
+{
+ int i;
+
+ be_lv_foreach(lv, block, be_lv_state_end, i) {
+ ir_node *node = be_lv_get_irn(lv, block, i);
+ if(!arch_irn_consider_in_reg_alloc(arch_env, cls, node))
+ continue;
+
+ ir_nodeset_insert(live, node);
+ }
+}
+
+
+
pset *be_liveness_nodes_live_at(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);
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;
+}
+
+static void collect_node(ir_node *irn, void *data)
+{
+ struct obstack *obst = data;
+ obstack_ptr_grow(obst, irn);
+}
+
+void be_live_chk_compare(be_irg_t *birg)
+{
+ ir_graph *irg = be_get_birg_irg(birg);
+
+ struct obstack obst;
+ ir_node **nodes;
+ ir_node **blocks;
+ be_lv_t *lv;
+ lv_chk_t *lvc;
+ int i, j;
+
+ be_assure_liveness(birg);
+ be_assure_liveness_chk(birg);
+ lv = be_get_birg_liveness(birg);
+ lvc = be_get_birg_liveness_chk(birg);
+
+ obstack_init(&obst);
+
+ irg_block_walk_graph(irg, collect_node, NULL, &obst);
+ obstack_ptr_grow(&obst, NULL);
+ blocks = obstack_finish(&obst);
+
+ irg_walk_graph(irg, collect_node, NULL, &obst);
+ obstack_ptr_grow(&obst, NULL);
+ nodes = obstack_finish(&obst);
+
+ for (i = 0; blocks[i]; ++i) {
+ ir_node *bl = blocks[i];
+
+ for (j = 0; nodes[j]; ++j) {
+ ir_node *irn = nodes[j];
+ if (!is_Block(irn)) {
+ int lvr_in = be_is_live_in (lv, bl, irn);
+ int lvr_out = be_is_live_out(lv, bl, irn);
+ int lvr_end = be_is_live_end(lv, bl, irn);
+
+ int lvc_in = lv_chk_bl_in (lvc, bl, irn);
+ int lvc_out = lv_chk_bl_out(lvc, bl, irn);
+ int lvc_end = lv_chk_bl_end(lvc, bl, irn);
+
+ if (lvr_in - lvc_in != 0)
+ ir_fprintf(stderr, "live in info for %+F at %+F differs: nml: %d, chk: %d\n", irn, bl, lvr_in, lvc_in);
+
+ if (lvr_end - lvc_end != 0)
+ ir_fprintf(stderr, "live end info for %+F at %+F differs: nml: %d, chk: %d\n", irn, bl, lvr_end, lvc_end);
+
+ if (lvr_out - lvc_out != 0)
+ ir_fprintf(stderr, "live out info for %+F at %+F differs: nml: %d, chk: %d\n", irn, bl, lvr_out, lvc_out);
+ }
+ }
+ }
+
+
+ obstack_free(&obst, NULL);
+}
+
+void be_init_live(void)
+{
+ FIRM_DBG_REGISTER(dbg, "firm.be.liveness");
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_live);