X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeirgmod.c;h=071571689d96e35d6da76f172205c8a9735c2329;hb=4ed245f5007168dab7850942a7ee6b6b29a19817;hp=f0e64f33de6ed7c44a2848a7dc7656838b73fb86;hpb=b1ba3383b1807b7b506b394eb5b3e0992ad60f34;p=libfirm

diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c
index f0e64f33d..071571689 100644
--- a/ir/be/beirgmod.c
+++ b/ir/be/beirgmod.c
@@ -26,13 +26,17 @@
 #include "irdom_t.h"
 #include "iredges_t.h"
 #include "irgopt.h"
+#include "irprintf_t.h"
+#include "irgwalk.h"
 
 #include "be_t.h"
+#include "bechordal_t.h"
 #include "bearch.h"
 #include "besched_t.h"
 #include "belive_t.h"
 #include "benode_t.h"
 #include "beutil.h"
+#include "beinsn_t.h"
 
 #include "beirgmod.h"
 
@@ -173,7 +177,6 @@ static void determine_phi_blocks(pset *copies, pset *copy_blocks, pset *phi_bloc
 
 				if(!pset_find_ptr(copy_blocks, y))
 					pdeq_putr(worklist, y);
-
 			}
 		}
 	}
@@ -225,9 +228,9 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo
 
 	DBG((dbg, LEVEL_1, "Searching valid def for use %+F at pos %d\n", usage, pos));
 	/*
-	* If the usage is in a phi node, search the copy in the
-	* predecessor denoted by pos.
-	*/
+	 * If the usage is in a phi node, search the copy in the
+	 * predecessor denoted by pos.
+	 */
 	if(is_Phi(usage)) {
 		curr_bl = get_Block_cfgpred_block(curr_bl, pos);
 		start_irn = sched_last(curr_bl);
@@ -297,7 +300,7 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo
 	return NULL;
 }
 
-static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *phis, pset *ignore_uses, pset *uses)
+static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *phis, pset *ignore_uses)
 {
 	int n_outs = 0;
 	struct obstack obst;
@@ -320,14 +323,12 @@ static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *
 	for (irn = pset_first(copies); irn; irn = pset_next(copies)) {
 		const ir_edge_t *edge;
 		foreach_out_edge(irn, edge) {
-			if(!uses || pset_find_ptr(uses, get_edge_src_irn(edge))) {
-				if (!pset_find_ptr(ignore_uses, get_edge_src_irn(edge)) ) {
-					struct out tmp;
-					tmp.irn = get_edge_src_irn(edge);
-					tmp.pos = get_edge_src_pos(edge);
-					obstack_grow(&obst, &tmp, sizeof(tmp));
-					n_outs++;
-				}
+			if (!pset_find_ptr(ignore_uses, get_edge_src_irn(edge))) {
+				struct out tmp;
+				tmp.irn = get_edge_src_irn(edge);
+				tmp.pos = get_edge_src_pos(edge);
+				obstack_grow(&obst, &tmp, sizeof(tmp));
+				n_outs++;
 			}
 		}
 	}
@@ -386,39 +387,46 @@ static void remove_odd_phis(pset *copies, pset *unused_copies)
 	}
 }
 
-void be_ssa_constr_phis_ignore(dom_front_info_t *info, int n, ir_node *nodes[], pset *phis, pset *ignore_uses, pset *uses)
+void be_ssa_constr_phis_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *phis, pset *ignore_uses)
 {
 	pset *irns = pset_new_ptr(n);
 	int i;
 
 	for(i = 0; i < n; ++i)
 		pset_insert_ptr(irns, nodes[i]);
-	be_ssa_constr_set_phis_ignore(info, irns, phis, ignore_uses, uses);
+	be_ssa_constr_set_phis_ignore(info, lv, irns, phis, ignore_uses);
 	del_pset(irns);
 }
 
-void be_ssa_constr_ignore(dom_front_info_t *info, int n, ir_node *nodes[], pset *ignore_uses)
+void be_ssa_constr_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *ignore_uses)
 {
-	be_ssa_constr_phis_ignore(info, n, nodes, NULL, ignore_uses, NULL);
+	be_ssa_constr_phis_ignore(info, lv, n, nodes, NULL, ignore_uses);
 }
 
-void be_ssa_constr(dom_front_info_t *info, int n, ir_node *nodes[])
+void be_ssa_constr(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[])
 {
 	pset *empty_set = be_empty_set();
-	be_ssa_constr_ignore(info, n, nodes, empty_set);
+	be_ssa_constr_ignore(info, lv, n, nodes, empty_set);
 }
 
-void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis, pset *ignore_uses, pset *uses)
+void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis, pset *ignore_uses)
 {
 	int n                  = pset_count(nodes);
 	pset *blocks           = pset_new_ptr(n);
 	pset *phi_blocks       = pset_new_ptr(n);
 	int save_optimize      = get_optimize();
 	int save_normalize     = get_opt_normalize();
+	int phis_set_created   = 0;
 	FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
 	ir_node *irn;
 
+	/* We need to collect the phi functions to compute their liveness. */
+	if(lv && !phis) {
+		phis_set_created = 1;
+		phis = pset_new_ptr_default();
+	}
+
 	DBG((dbg, LEVEL_1, "Introducing following copies for:\n"));
 
 	/* Fill the sets. */
@@ -439,7 +447,7 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis
 	 * Place the phi functions and reroute the usages.
 	 */
 	determine_phi_blocks(nodes, blocks, phi_blocks, df);
-	fix_usages(nodes, blocks, phi_blocks, phis, ignore_uses, uses);
+	fix_usages(nodes, blocks, phi_blocks, phis, ignore_uses);
 
 	/* reset the optimizations */
 	set_optimize(save_optimize);
@@ -448,29 +456,40 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis
 	del_pset(phi_blocks);
 	del_pset(blocks);
 
-}
+	/* Recompute the liveness (if wanted) of the original nodes, the copies and the inserted phis. */
+	if(lv) {
+#if 1
+		foreach_pset(nodes, irn)
+			be_liveness_update(lv, irn);
+
+		foreach_pset(phis, irn)
+			be_liveness_introduce(lv, irn);
+#else
+		be_liveness_recompute(lv);
+#endif
+	}
+
+	/* Free the phi set of we created it. */
+	if(phis_set_created)
+		del_pset(phis);
 
-void be_ssa_constr_set_phis(dom_front_info_t *df, pset *nodes, pset *phis)
-{
-	pset *empty_set = be_empty_set();
-	be_ssa_constr_set_phis_ignore(df, nodes, phis, empty_set, NULL);
 }
 
-void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_uses)
+void be_ssa_constr_set_phis(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis)
 {
-	be_ssa_constr_set_phis_ignore(df, nodes, NULL, ignore_uses, NULL);
+	pset *empty_set = be_empty_set();
+	be_ssa_constr_set_phis_ignore(df, lv, nodes, phis, empty_set);
 }
 
-void be_ssa_constr_set(dom_front_info_t *info, pset *nodes)
+void be_ssa_constr_set_ignore(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *ignore_uses)
 {
-	pset *empty_set = be_empty_set();
-	be_ssa_constr_set_ignore(info, nodes, empty_set);
+	be_ssa_constr_set_phis_ignore(df, lv, nodes, NULL, ignore_uses);
 }
 
-void be_ssa_constr_set_uses(dom_front_info_t *info, pset *nodes, pset *uses)
+void be_ssa_constr_set(dom_front_info_t *info, be_lv_t *lv, pset *nodes)
 {
 	pset *empty_set = be_empty_set();
-	be_ssa_constr_set_phis_ignore(info, nodes, NULL, empty_set, uses);
+	be_ssa_constr_set_ignore(info, lv, nodes, empty_set);
 }
 
 /*
@@ -483,13 +502,14 @@ void be_ssa_constr_set_uses(dom_front_info_t *info, pset *nodes, pset *uses)
 */
 
 ir_node *insert_Perm_after(const arch_env_t *arch_env,
+						   be_lv_t *lv,
 						   const arch_register_class_t *cls,
 						   dom_front_info_t *dom_front,
 						   ir_node *pos)
 {
-	ir_node *bl                 = is_Block(pos) ? pos : get_nodes_block(pos);
-	ir_graph *irg               = get_irn_irg(bl);
-	pset *live                  = pset_new_ptr_default();
+	ir_node *bl     = is_Block(pos) ? pos : get_nodes_block(pos);
+	ir_graph *irg   = get_irn_irg(bl);
+	pset *live      = pset_new_ptr_default();
 	FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, "be.node");
 
 	ir_node *curr, *irn, *perm, **nodes;
@@ -497,7 +517,7 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env,
 
 	DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos));
 
-	if(!be_liveness_nodes_live_at(arch_env, cls, pos, live));
+	be_liveness_nodes_live_at(lv, arch_env, cls, pos, live);
 
 	n = pset_count(live);
 
@@ -534,7 +554,44 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env,
 
 		copies[0] = perm_op;
 		copies[1] = proj;
-		be_ssa_constr(dom_front, 2, copies);
+
+		be_ssa_constr(dom_front, lv, 2, copies);
 	}
+
 	return perm;
 }
+
+struct _elr_closure_t {
+	struct obstack obst;
+	const be_chordal_env_t *cenv;
+};
+
+static void elr_split_walker(ir_node *bl, void *data)
+{
+	struct _elr_closure_t *c     = data;
+	const be_chordal_env_t *cenv = c->cenv;
+	const arch_env_t *aenv       = cenv->birg->main_env->arch_env;
+	be_insn_t *insn;
+	be_insn_env_t ie;
+
+	be_insn_env_init(&ie, cenv->birg, cenv->cls, &c->obst);
+
+	for(insn = be_scan_insn(&ie, sched_first(bl)); !is_Block(insn->irn); insn = be_scan_insn(&ie, insn->next_insn)) {
+		ir_node *pred = sched_prev(insn->irn);
+		ir_printf("curr: %+F next: %+F, prev: %+F\n", insn->irn, insn->next_insn, pred);
+		if(!is_Block(pred) && !is_Phi(insn->irn))
+			insert_Perm_after(aenv, cenv->lv, cenv->cls, cenv->dom_front, insn->irn);
+	}
+}
+
+void extreme_liverange_splitting(struct _be_chordal_env_t *cenv)
+{
+	struct _elr_closure_t c;
+
+	c.cenv = cenv;
+	obstack_init(&c.obst);
+	be_liveness_recompute(cenv->lv);
+	irg_block_walk_graph(cenv->irg, elr_split_walker, NULL, &c);
+	be_liveness_recompute(cenv->lv);
+	obstack_free(&c.obst, NULL);
+}