X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbepeephole.c;h=6dc95ed61b2835875e5f458fe102e4e80967bd35;hb=ccdf802c598f7adc5e35fff42fed029c59f48a57;hp=afb7d018fb0c826e2f2cf8a68552d6f79b73b6a3;hpb=bce5f15071a9be1f7cdc5e66436dd54cb29900df;p=libfirm

diff --git a/ir/be/bepeephole.c b/ir/be/bepeephole.c
index afb7d018f..6dc95ed61 100644
--- a/ir/be/bepeephole.c
+++ b/ir/be/bepeephole.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -32,11 +32,14 @@
 #include "iredges_t.h"
 #include "irgwalk.h"
 #include "irprintf.h"
+#include "ircons.h"
+#include "irgmod.h"
 #include "error.h"
 
 #include "beirg_t.h"
 #include "belive_t.h"
 #include "bearch_t.h"
+#include "benode_t.h"
 #include "besched_t.h"
 #include "bemodule.h"
 
@@ -59,7 +62,7 @@ static void clear_reg_value(ir_node *node)
 
 	reg     = arch_get_irn_register(arch_env, node);
 	if(reg == NULL) {
-		panic("No register assigned at %+F\n", node);
+		panic("No register assigned at %+F", node);
 	}
 	if(arch_register_type_is(reg, virtual))
 		return;
@@ -84,7 +87,7 @@ static void set_reg_value(ir_node *node)
 
 	reg = arch_get_irn_register(arch_env, node);
 	if(reg == NULL) {
-		panic("No register assigned at %+F\n", node);
+		panic("No register assigned at %+F", node);
 	}
 	if(arch_register_type_is(reg, virtual))
 		return;
@@ -92,12 +95,6 @@ static void set_reg_value(ir_node *node)
 	reg_idx = arch_register_get_index(reg);
 	cls_idx = arch_register_class_index(cls);
 
-#ifdef DEBUG_libfirm
-	{
-		ir_node *old_value = register_values[cls_idx][reg_idx];
-		assert(old_value == NULL || old_value == node);
-	}
-#endif
 	DBG((dbg, LEVEL_1, "Set Register %s: %+F\n", reg->name, node));
 	register_values[cls_idx][reg_idx] = node;
 }
@@ -128,6 +125,19 @@ static void set_uses(ir_node *node)
 	}
 }
 
+void be_peephole_new_node(ir_node * nw)
+{
+	be_liveness_introduce(lv, nw);
+}
+
+/**
+ * must be called from peephole optimisations before a node will be killed
+ * and its users will be redirected to new_node.
+ * so bepeephole can update it's internal state.
+ *
+ * Note: killing a node and rewiring os only allowed if new_node produces
+ * the same registers as old_node.
+ */
 void be_peephole_before_exchange(const ir_node *old_node, ir_node *new_node)
 {
 	const arch_register_t       *reg;
@@ -135,46 +145,58 @@ void be_peephole_before_exchange(const ir_node *old_node, ir_node *new_node)
 	unsigned                     reg_idx;
 	unsigned                     cls_idx;
 
-	DBG((dbg, LEVEL_1, "About to exchange %+F with %+F\n", old_node, new_node));
+	DBG((dbg, LEVEL_1, "About to exchange and kill %+F with %+F\n", old_node, new_node));
 
-	if(old_node == current_node)
-		current_node = new_node;
+	if (current_node == old_node) {
+		/* next node to be processed will be killed. Its scheduling predecessor
+		 * must be processed next. */
+		current_node = sched_next(current_node);
+		assert (!is_Bad(current_node));
+	}
 
-	if(!mode_is_data(get_irn_mode(old_node)))
+	if (!mode_is_data(get_irn_mode(old_node)))
 		return;
 
 	reg = arch_get_irn_register(arch_env, old_node);
-	if(reg == NULL) {
-		panic("No register assigned at %+F\n", old_node);
+	if (reg == NULL) {
+		panic("No register assigned at %+F", old_node);
 	}
+	assert(reg == arch_get_irn_register(arch_env, new_node) &&
+	      "KILLING a node and replacing by different register is not allowed");
+
 	cls     = arch_register_get_class(reg);
 	reg_idx = arch_register_get_index(reg);
 	cls_idx = arch_register_class_index(cls);
 
-	if(register_values[cls_idx][reg_idx] == old_node) {
+	if (register_values[cls_idx][reg_idx] == old_node) {
 		register_values[cls_idx][reg_idx] = new_node;
 	}
 
 	be_liveness_remove(lv, old_node);
 }
 
-void be_peephole_after_exchange(ir_node *new_node)
+void be_peephole_exchange(ir_node *old, ir_node *nw)
 {
-	be_liveness_introduce(lv, new_node);
+	be_peephole_before_exchange(old, nw);
+	sched_remove(old);
+	exchange(old, nw);
+	be_peephole_new_node(nw);
 }
 
+/**
+ * block-walker: run peephole optimization on the given block.
+ */
 static void process_block(ir_node *block, void *data)
 {
-	arch_isa_t *isa = arch_env->isa;
 	unsigned n_classes;
 	unsigned i;
 	int l;
 	(void) data;
 
 	/* construct initial register assignment */
-	n_classes = arch_isa_get_n_reg_class(isa);
+	n_classes = arch_env_get_n_reg_class(arch_env);
 	for(i = 0; i < n_classes; ++i) {
-		const arch_register_class_t *cls    = arch_isa_get_reg_class(isa, i);
+		const arch_register_class_t *cls    = arch_env_get_reg_class(arch_env, i);
 		unsigned                     n_regs = arch_register_class_n_regs(cls);
 		memset(register_values[i], 0, sizeof(ir_node*) * n_regs);
 	}
@@ -192,36 +214,146 @@ static void process_block(ir_node *block, void *data)
 	for( ; !sched_is_begin(current_node);
 			current_node = sched_prev(current_node)) {
 		ir_op             *op;
-		ir_node           *last;
-		peephole_opt_func  func;
+		peephole_opt_func  peephole_node;
 
-		if(is_Phi(current_node))
+		assert(!is_Bad(current_node));
+		if (is_Phi(current_node))
 			break;
 
 		clear_defs(current_node);
 		set_uses(current_node);
 
-		op   = get_irn_op(current_node);
-		func = (peephole_opt_func) op->ops.generic;
-		if(func == NULL)
+		op            = get_irn_op(current_node);
+		peephole_node = (peephole_opt_func)op->ops.generic;
+		if (peephole_node == NULL)
+			continue;
+
+		peephole_node(current_node);
+		assert(!is_Bad(current_node));
+	}
+}
+
+static void kill_node_and_preds(ir_node *node)
+{
+	int arity, i;
+
+	arity = get_irn_arity(node);
+	for (i = 0; i < arity; ++i) {
+		ir_node *pred = get_irn_n(node, i);
+
+		set_irn_n(node, i, new_Bad());
+		if (get_irn_n_edges(pred) != 0)
 			continue;
 
-		last = current_node;
-		func(current_node);
-		/* was the current node replaced? */
-		if(current_node != last) {
-			set_uses(current_node);
+		kill_node_and_preds(pred);
+	}
+
+	if (!is_Proj(node))
+		sched_remove(node);
+	kill_node(node);
+}
+
+/**
+ * Walk through the block schedule and skip all barrier nodes.
+ */
+static void skip_barrier(ir_node *ret_blk, ir_graph *irg) {
+	ir_node *irn;
+
+	sched_foreach_reverse(ret_blk, irn) {
+		const ir_edge_t *edge, *next;
+
+		if (!be_is_Barrier(irn))
+			continue;
+
+		foreach_out_edge_safe(irn, edge, next) {
+			ir_node *proj = get_edge_src_irn(edge);
+			int      pn   = (int)get_Proj_proj(proj);
+			ir_node *pred = get_irn_n(irn, pn);
+
+			edges_reroute_kind(proj, pred, EDGE_KIND_NORMAL, irg);
+			edges_reroute_kind(proj, pred, EDGE_KIND_DEP, irg);
 		}
+
+		kill_node_and_preds(irn);
+		break;
 	}
 }
 
+/**
+ * Kill the Barrier nodes for better peephole optimization.
+ */
+static void	kill_barriers(ir_graph *irg) {
+	ir_node *end_blk = get_irg_end_block(irg);
+	ir_node *start_blk;
+	int i;
+
+	/* skip the barrier on all return blocks */
+	for (i = get_Block_n_cfgpreds(end_blk) - 1; i >= 0; --i) {
+		ir_node *be_ret = get_Block_cfgpred(end_blk, i);
+		ir_node *ret_blk = get_nodes_block(be_ret);
+
+		skip_barrier(ret_blk, irg);
+	}
+
+	/* skip the barrier on the start block */
+	start_blk = get_irg_start_block(irg);
+	skip_barrier(start_blk, irg);
+}
+
+/*
+ * Tries to optimize a beIncSp node with it's previous IncSP node.
+ * Must be run from a be_peephole_opt() context.
+ */
+ir_node *be_peephole_IncSP_IncSP(ir_node *node)
+{
+	int      pred_offs;
+	int      curr_offs;
+	int      offs;
+	ir_node *pred = be_get_IncSP_pred(node);
+
+	if (!be_is_IncSP(pred))
+		return node;
+
+	if (get_irn_n_edges(pred) > 1)
+		return node;
+
+	pred_offs = be_get_IncSP_offset(pred);
+	curr_offs = be_get_IncSP_offset(node);
+
+	if (pred_offs == BE_STACK_FRAME_SIZE_EXPAND) {
+		if (curr_offs != BE_STACK_FRAME_SIZE_SHRINK) {
+			return node;
+		}
+		offs = 0;
+	} else if (pred_offs == BE_STACK_FRAME_SIZE_SHRINK) {
+		if (curr_offs != BE_STACK_FRAME_SIZE_EXPAND) {
+			return node;
+		}
+		offs = 0;
+	} else if (curr_offs == BE_STACK_FRAME_SIZE_EXPAND ||
+	           curr_offs == BE_STACK_FRAME_SIZE_SHRINK) {
+		return node;
+	} else {
+		offs = curr_offs + pred_offs;
+	}
+
+	/* add node offset to pred and remove our IncSP */
+	be_set_IncSP_offset(pred, offs);
+
+	be_peephole_exchange(node, pred);
+	return pred;
+}
+
 void be_peephole_opt(be_irg_t *birg)
 {
-	arch_isa_t *isa;
 	ir_graph   *irg = be_get_birg_irg(birg);
 	unsigned n_classes;
 	unsigned i;
 
+	/* barrier nodes are used for register allocations. They hinders
+	 * peephole optimizations, so remove them here. */
+	kill_barriers(irg);
+
 	/* we sometimes find BadE nodes in float apps like optest_float.c or
 	 * kahansum.c for example... */
 	be_liveness_invalidate(birg->lv);
@@ -229,12 +361,11 @@ void be_peephole_opt(be_irg_t *birg)
 
 	arch_env = be_get_birg_arch_env(birg);
 	lv       = be_get_birg_liveness(birg);
-	isa      = arch_env->isa;
 
-	n_classes = arch_isa_get_n_reg_class(isa);
+	n_classes = arch_env_get_n_reg_class(arch_env);
 	register_values = alloca(sizeof(register_values[0]) * n_classes);
 	for(i = 0; i < n_classes; ++i) {
-		const arch_register_class_t *cls    = arch_isa_get_reg_class(isa, i);
+		const arch_register_class_t *cls    = arch_env_get_reg_class(arch_env, i);
 		unsigned                     n_regs = arch_register_class_n_regs(cls);
 		register_values[i] = alloca(sizeof(ir_node*) * n_regs);
 	}