X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbetranshlp.c;h=085ab7420ea3e76beb91f34da30859935adf0601;hb=438580abed840c55e82a03b47daeacfe2da8040f;hp=0c098b53d22a4cb8d5341dc0800359e1c9fec5b7;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm

diff --git a/ir/be/betranshlp.c b/ir/be/betranshlp.c
index 0c098b53d..085ab7420 100644
--- a/ir/be/betranshlp.c
+++ b/ir/be/betranshlp.c
@@ -40,6 +40,7 @@
 #include "debug.h"
 
 #include "beirg.h"
+#include "beabi.h"
 #include "betranshlp.h"
 #include "belive.h"
 #include "benode.h"
@@ -56,8 +57,11 @@ static be_transform_env_t env;
 
 void be_set_transformed_node(ir_node *old_node, ir_node *new_node)
 {
+	ir_graph *irg = get_irn_irg(old_node);
+
 	set_irn_link(old_node, new_node);
 	mark_irn_visited(old_node);
+	hook_dead_node_elim_subst(irg, old_node, new_node);
 }
 
 int be_is_transformed(const ir_node *node)
@@ -88,14 +92,6 @@ void be_duplicate_deps(ir_node *old_node, ir_node *new_node)
 	}
 }
 
-void be_dep_on_frame(ir_node* node)
-{
-	ir_graph *const irg = current_ir_graph;
-
-	if (get_irg_start_block(irg) == get_nodes_block(node))
-		add_irn_dep(node, get_irg_frame(irg));
-}
-
 void be_set_transform_function(ir_op *op, be_transform_func func)
 {
 	/* shouldn't be assigned twice (except for exchanging the default
@@ -105,18 +101,66 @@ void be_set_transform_function(ir_op *op, be_transform_func func)
 	op->ops.generic = (op_func) func;
 }
 
+/**
+ * Transform helper for blocks.
+ */
+static ir_node *transform_block(ir_node *node)
+{
+	ir_graph *irg  = get_irn_irg(node);
+	dbg_info *dbgi = get_irn_dbg_info(node);
+	ir_node  *block;
+
+	block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), get_irn_mode(node),
+	                    get_irn_arity(node), get_irn_in(node) + 1);
+	copy_node_attr(irg, node, block);
+	block->node_nr = node->node_nr;
+
+	/* put the preds in the worklist */
+	be_enqueue_preds(node);
+
+	return block;
+}
+
+static ir_node *transform_end(ir_node *node)
+{
+	/* end has to be duplicated manually because we need a dynamic in array */
+	ir_graph *irg   = get_irn_irg(node);
+	dbg_info *dbgi  = get_irn_dbg_info(node);
+	ir_node  *block = be_transform_node(get_nodes_block(node));
+	int      i, arity;
+	ir_node  *new_end;
+
+	new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL);
+	copy_node_attr(irg, node, new_end);
+	be_duplicate_deps(node, new_end);
+
+	set_irg_end(irg, new_end);
+
+	/* do not transform predecessors yet to keep the pre-transform
+	 * phase from visiting all the graph */
+	arity = get_irn_arity(node);
+	for (i = 0; i < arity; ++i) {
+		ir_node *in = get_irn_n(node, i);
+		add_End_keepalive(new_end, in);
+	}
+	be_enqueue_preds(node);
+
+	return new_end;
+}
+
 void be_start_transform_setup(void)
 {
 	clear_irp_opcodes_generic_func();
 
 	be_set_transform_function(op_Bad,         be_duplicate_node);
-	be_set_transform_function(op_be_Barrier,  be_duplicate_node);
 	be_set_transform_function(op_be_Copy,     be_duplicate_node);
 	be_set_transform_function(op_be_CopyKeep, be_duplicate_node);
 	be_set_transform_function(op_be_IncSP,    be_duplicate_node);
 	be_set_transform_function(op_be_Keep,     be_duplicate_node);
 	be_set_transform_function(op_be_Return,   be_duplicate_node);
 	be_set_transform_function(op_be_Start,    be_duplicate_node);
+	be_set_transform_function(op_Block,       transform_block);
+	be_set_transform_function(op_End,         transform_end);
 	be_set_transform_function(op_NoMem,       be_duplicate_node);
 	be_set_transform_function(op_Pin,         be_duplicate_node);
 	be_set_transform_function(op_Start,       be_duplicate_node);
@@ -179,7 +223,6 @@ ir_node *be_transform_node(ir_node *node)
 	assert(new_node != NULL);
 
 	be_set_transformed_node(node, new_node);
-	hook_dead_node_elim_subst(current_ir_graph, node, new_node);
 	return new_node;
 }
 
@@ -268,37 +311,11 @@ ir_node *be_pre_transform_node(ir_node *place)
 	return be_transform_node(place);
 }
 
-static void pre_transform_anchor(int anchor)
+static void pre_transform_anchor(ir_graph *irg, int anchor)
 {
 	ir_node *old_anchor_node = get_irn_n(env.old_anchor, anchor);
 	ir_node *transformed     = be_transform_node(old_anchor_node);
-	set_irg_anchor(current_ir_graph, anchor, transformed);
-}
-
-static void kill_unused_anchor(int anchor)
-{
-	ir_node *old_anchor_node = get_irn_n(env.old_anchor, anchor);
-	ir_node *old_bad         = get_irn_n(env.old_anchor, anchor_bad);
-	if (old_anchor_node != NULL && get_irn_n_edges(old_anchor_node) <= 1) {
-		set_irn_n(env.old_anchor, anchor, old_bad);
-	}
-}
-
-static ir_node *new_be_Anchor(ir_graph *irg)
-{
-	struct obstack *obst = be_get_be_obst(irg);
-	backend_info_t *info;
-	ir_node        *new_anchor;
-
-	/* Hack: some places in the code ask the Anchor for its register
-	   requirements */
-	new_anchor = new_r_Anchor(irg);
-	info = be_get_info(new_anchor);
-	info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1);
-	memset(info->out_infos, 0, 1 * sizeof(info->out_infos[0]));
-	info->out_infos[0].req = arch_no_register_req;
-
-	return new_anchor;
+	set_irg_anchor(irg, anchor, transformed);
 }
 
 /**
@@ -313,9 +330,9 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 
 	inc_irg_visited(irg);
 
-	env.irg         = irg;
-	env.worklist    = new_waitq();
-	env.old_anchor  = irg->anchor;
+	env.irg        = irg;
+	env.worklist   = new_waitq();
+	env.old_anchor = irg->anchor;
 
 	old_end = get_irg_end(irg);
 
@@ -328,17 +345,17 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 		waitq_put(env.worklist, anchor);
 	}
 
-	new_anchor  = new_be_Anchor(irg);
+	new_anchor  = new_r_Anchor(irg);
 	irg->anchor = new_anchor;
 
 	/* pre transform some anchors (so they are available in the other transform
 	 * functions) */
-	pre_transform_anchor(anchor_bad);
-	pre_transform_anchor(anchor_no_mem);
-	pre_transform_anchor(anchor_start_block);
-	pre_transform_anchor(anchor_start);
-	pre_transform_anchor(anchor_frame);
-	kill_unused_anchor(anchor_tls);
+	pre_transform_anchor(irg, anchor_no_mem);
+	pre_transform_anchor(irg, anchor_end_block);
+	pre_transform_anchor(irg, anchor_end);
+	pre_transform_anchor(irg, anchor_start_block);
+	pre_transform_anchor(irg, anchor_start);
+	pre_transform_anchor(irg, anchor_frame);
 
 	if (pre_transform)
 		pre_transform();
@@ -367,53 +384,6 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 	hook_dead_node_elim(irg, 0);
 }
 
-/**
- * Transform helper for blocks.
- */
-static ir_node *gen_Block(ir_node *node)
-{
-	ir_graph *irg             = current_ir_graph;
-	dbg_info *dbgi            = get_irn_dbg_info(node);
-	ir_node  *block;
-
-	block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), get_irn_mode(node),
-	                    get_irn_arity(node), get_irn_in(node) + 1);
-	copy_node_attr(irg, node, block);
-	block->node_nr = node->node_nr;
-
-	/* put the preds in the worklist */
-	be_enqueue_preds(node);
-
-	return block;
-}
-
-static ir_node *gen_End(ir_node *node)
-{
-	/* end has to be duplicated manually because we need a dynamic in array */
-	ir_graph *irg   = current_ir_graph;
-	dbg_info *dbgi  = get_irn_dbg_info(node);
-	ir_node  *block = be_transform_node(get_nodes_block(node));
-	int      i, arity;
-	ir_node  *new_end;
-
-	new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL);
-	copy_node_attr(irg, node, new_end);
-	be_duplicate_deps(node, new_end);
-
-	set_irg_end(irg, new_end);
-
-	/* transform preds */
-	arity = get_irn_arity(node);
-	for (i = 0; i < arity; ++i) {
-		ir_node *in     = get_irn_n(node, i);
-		ir_node *new_in = be_transform_node(in);
-
-		add_End_keepalive(new_end, new_in);
-	}
-
-	return new_end;
-}
-
 void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func)
 {
 	ir_graph *old_current_ir_graph = current_ir_graph;
@@ -437,10 +407,6 @@ void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func)
 	/* create new value table for CSE */
 	new_identities(irg);
 
-	/* enter special helper */
-	op_Block->ops.generic = (op_func)gen_Block;
-	op_End->ops.generic   = (op_func)gen_End;
-
 	/* do the main transformation */
 	transform_nodes(irg, func);
 
@@ -470,16 +436,12 @@ void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func)
 
 int be_mux_is_abs(ir_node *sel, ir_node *mux_true, ir_node *mux_false)
 {
-	ir_node *cmp_left;
-	ir_node *cmp_right;
-	ir_node *cmp;
-	ir_mode *mode;
-	pn_Cmp   pnc;
+	ir_node    *cmp_left;
+	ir_node    *cmp_right;
+	ir_mode    *mode;
+	ir_relation relation;
 
-	if (!is_Proj(sel))
-		return 0;
-	cmp = get_Proj_pred(sel);
-	if (!is_Cmp(cmp))
+	if (!is_Cmp(sel))
 		return 0;
 
 	/**
@@ -493,42 +455,31 @@ int be_mux_is_abs(ir_node *sel, ir_node *mux_true, ir_node *mux_false)
 		return 0;
 
 	/* must be <, <=, >=, > */
-	pnc = get_Proj_pn_cmp(sel);
-	switch (pnc) {
-	case pn_Cmp_Ge:
-	case pn_Cmp_Gt:
-	case pn_Cmp_Le:
-	case pn_Cmp_Lt:
-	case pn_Cmp_Uge:
-	case pn_Cmp_Ug:
-	case pn_Cmp_Ul:
-	case pn_Cmp_Ule:
-		break;
-	default:
+	relation = get_Cmp_relation(sel);
+	if ((relation & ir_relation_less_greater) == 0)
 		return 0;
-	}
 
-	if (!is_negated_value(mux_true, mux_false))
+	if (!ir_is_negated_value(mux_true, mux_false))
 		return 0;
 
 	/* must be x cmp 0 */
-	cmp_right = get_Cmp_right(cmp);
+	cmp_right = get_Cmp_right(sel);
 	if (!is_Const(cmp_right) || !is_Const_null(cmp_right))
 		return 0;
 
-	cmp_left = get_Cmp_left(cmp);
+	cmp_left = get_Cmp_left(sel);
 	if (cmp_left == mux_false) {
-		if (pnc & pn_Cmp_Lt) {
+		if (relation & ir_relation_less) {
 			return 1;
 		} else {
-			assert(pnc & pn_Cmp_Gt);
+			assert(relation & ir_relation_greater);
 			return -1;
 		}
 	} else if (cmp_left == mux_true) {
-		if (pnc & pn_Cmp_Lt) {
+		if (relation & ir_relation_less) {
 			return -1;
 		} else {
-			assert(pnc & pn_Cmp_Gt);
+			assert(relation & ir_relation_greater);
 			return 1;
 		}
 	}
@@ -538,7 +489,6 @@ int be_mux_is_abs(ir_node *sel, ir_node *mux_true, ir_node *mux_false)
 
 ir_node *be_get_abs_op(ir_node *sel)
 {
-	ir_node *cmp      = get_Proj_pred(sel);
-	ir_node *cmp_left = get_Cmp_left(cmp);
+	ir_node *cmp_left = get_Cmp_left(sel);
 	return cmp_left;
 }