X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelower.c;h=3b2b47ae7cce78dc89d82f335226f6f5d32dd762;hb=93da909d12b7bec51aa36ee5f05966c331f90fb9;hp=3be7fda601ee7a5d7a5a077064682ffb71c8e0f5;hpb=324699d0c76cdc0270d418fdcdfa252bf8cd6adb;p=libfirm

diff --git a/ir/be/belower.c b/ir/be/belower.c
index 3be7fda60..3b2b47ae7 100644
--- a/ir/be/belower.c
+++ b/ir/be/belower.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.
  *
@@ -45,19 +45,18 @@
 #include "besched_t.h"
 #include "bestat.h"
 #include "bessaconstr.h"
-#include "benodesets.h"
 #include "beintlive_t.h"
 
 #undef KEEP_ALIVE_COPYKEEP_HACK
 
-/* associates op with it's copy and CopyKeep */
+/** Associates an op with it's copy and CopyKeep. */
 typedef struct {
-	ir_node *op;         /* an irn which must be different */
-	ir_nodeset_t copies; /* all non-spillable copies of this irn */
+	ir_node *op;         /**< an irn which must be different */
+	ir_nodeset_t copies; /**< all non-spillable copies of this irn */
 	const arch_register_class_t *cls;
 } op_copy_assoc_t;
 
-/* environment for constraints */
+/** Environment for constraints. */
 typedef struct {
 	be_irg_t       *birg;
 	pset           *op_set;
@@ -65,7 +64,7 @@ typedef struct {
 	DEBUG_ONLY(firm_dbg_module_t *dbg;)
 } constraint_env_t;
 
-/* lowering walker environment */
+/** Lowering walker environment. */
 typedef struct _lower_env_t {
 	be_irg_t         *birg;
 	const arch_env_t *arch_env;
@@ -73,7 +72,7 @@ typedef struct _lower_env_t {
 	DEBUG_ONLY(firm_dbg_module_t *dbg_module;)
 } lower_env_t;
 
-/* holds a perm register pair */
+/** Holds a Perm register pair. */
 typedef struct _reg_pair_t {
 	const arch_register_t *in_reg;    /**< a perm IN register */
 	ir_node               *in_node;   /**< the in node to which the register belongs */
@@ -91,15 +90,14 @@ typedef enum _perm_type_t {
 	PERM_COPY
 } perm_type_t;
 
-/* structure to represent cycles or chains in a perm */
+/** Structure to represent cycles or chains in a Perm. */
 typedef struct _perm_cycle_t {
 	const arch_register_t **elems;       /**< the registers in the cycle */
 	int                     n_elems;     /**< number of elements in the cycle */
 	perm_type_t             type;        /**< type (CHAIN or CYCLE) */
 } perm_cycle_t;
 
-//
-/* Compare the two operands */
+/** Compare the two operands. */
 static int cmp_op_copy_assoc(const void *a, const void *b) {
 	const op_copy_assoc_t *op1 = a;
 	const op_copy_assoc_t *op2 = b;
@@ -107,7 +105,7 @@ static int cmp_op_copy_assoc(const void *a, const void *b) {
 	return op1->op != op2->op;
 }
 
-/* Compare the in registers of two register pairs */
+/** Compare the in registers of two register pairs. */
 static int compare_reg_pair(const void *a, const void *b) {
 	const reg_pair_t *pair_a = a;
 	const reg_pair_t *pair_b = b;
@@ -118,7 +116,7 @@ static int compare_reg_pair(const void *a, const void *b) {
 		return -1;
 }
 
-/* returns the number register pairs marked as checked */
+/** returns the number register pairs marked as checked. */
 static int get_n_checked_pairs(reg_pair_t *pairs, int n) {
 	int i, n_checked = 0;
 
@@ -506,23 +504,19 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 	/* remove the perm from schedule */
 	if (! keep_perm) {
 		sched_remove(irn);
-		be_kill_node(irn);
+		kill_node(irn);
 	}
 }
 
 
 
-static int get_n_out_edges(const ir_node *irn) {
-	const ir_edge_t *edge;
-	int cnt = 0;
-
-	foreach_out_edge(irn, edge) {
-		cnt++;
-	}
-
-	return cnt;
+static int has_irn_users(const ir_node *irn) {
+	return get_irn_out_edge_first_kind(irn, EDGE_KIND_NORMAL) != 0;
 }
 
+/**
+ * Skip all Proj nodes.
+ */
 static INLINE ir_node *belower_skip_proj(ir_node *irn) {
 	while(is_Proj(irn))
 		irn = get_Proj_pred(irn);
@@ -566,7 +560,7 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
 	/* in block far far away                             */
 	/* The copy is optimized later if not needed         */
 
-	/* check if already exists such a copy in the schedule immediatly before */
+	/* check if already exists such a copy in the schedule immediately before */
 	cpy = find_copy(env, belower_skip_proj(irn), other_different);
 	if (! cpy) {
 		cpy = be_new_Copy(cls, irg, block, other_different);
@@ -582,13 +576,13 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
 
 	/* Add the Keep resp. CopyKeep and reroute the users */
 	/* of the other_different irn in case of CopyKeep.   */
-	if (get_n_out_edges(other_different) == 0) {
-		keep = be_new_Keep(cls, irg, block, 2, in);
-	}
-	else {
+	if (has_irn_users(other_different)) {
 		keep = be_new_CopyKeep_single(cls, irg, block, cpy, irn, get_irn_mode(other_different));
 		be_node_set_reg_class(keep, 1, cls);
 	}
+	else {
+		keep = be_new_Keep(cls, irg, block, 2, in);
+	}
 
 	DBG((mod, LEVEL_1, "created %+F(%+F, %+F)\n\n", keep, irn, cpy));
 
@@ -599,8 +593,8 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
 	sched_add_after(irn, keep);
 
 	/* insert the other different and it's copies into the set */
-	key.op         = other_different;
-	entry          = pset_find(op_set, &key, nodeset_hash(other_different));
+	key.op = other_different;
+	entry  = pset_find(op_set, &key, hash_irn(other_different));
 
 	if (! entry) {
 		entry         = obstack_alloc(&env->obst, sizeof(*entry));
@@ -617,12 +611,12 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
 		ir_nodeset_insert(&entry->copies, keep);
 	}
 
-	pset_insert(op_set, entry, nodeset_hash(other_different));
+	pset_insert(op_set, entry, hash_irn(other_different));
 }
 
 /**
- * Checks if node has a should_be_different constraint in output
- * and adds a Keep then to assure the constraint.
+ * Checks if node has a must_be_different constraint in output and adds a Keep
+ * then to assure the constraint.
  */
 static void assure_different_constraints(ir_node *irn, constraint_env_t *env) {
 	const arch_register_req_t *req;
@@ -630,19 +624,35 @@ static void assure_different_constraints(ir_node *irn, constraint_env_t *env) {
 
 	req = arch_get_register_req(arch_env, irn, -1);
 
-	if (arch_register_req_is(req, should_be_different)) {
-		ir_node *different_from = get_irn_n(belower_skip_proj(irn), req->other_different);
-		gen_assure_different_pattern(irn, different_from, env);
-	} else if (arch_register_req_is(req, should_be_different_from_all)) {
-		int i, n = get_irn_arity(belower_skip_proj(irn));
-		for (i = 0; i < n; i++) {
-			gen_assure_different_pattern(irn, get_irn_n(belower_skip_proj(irn), i), env);
+	if (arch_register_req_is(req, must_be_different)) {
+		const unsigned other = req->other_different;
+		int i;
+
+		if (arch_register_req_is(req, should_be_same)) {
+			const unsigned same = req->other_same;
+
+			if (is_po2(other) && is_po2(same)) {
+				int idx_other = ntz(other);
+				int idx_same  = ntz(same);
+
+				/*
+				 * We can safely ignore a should_be_same x must_be_different y
+				 * IFF both inputs are equal!
+				 */
+				if (get_irn_n(irn, idx_other) == get_irn_n(irn, idx_same)) {
+					return;
+				}
+			}
+		}
+		for (i = 0; 1U << i <= other; ++i) {
+			if (other & (1U << i)) {
+				ir_node *different_from = get_irn_n(belower_skip_proj(irn), i);
+				gen_assure_different_pattern(irn, different_from, env);
+			}
 		}
 	}
 }
 
-
-
 /**
  * Calls the functions to assure register constraints.
  *
@@ -655,8 +665,6 @@ static void assure_constraints_walker(ir_node *irn, void *walk_env) {
 
 	if (sched_is_scheduled(irn) && mode_is_datab(get_irn_mode(irn)))
 		assure_different_constraints(irn, walk_env);
-
-	return;
 }
 
 /**
@@ -744,7 +752,7 @@ static void melt_copykeeps(constraint_env_t *cenv) {
 					/* now, we can kill the melted keep, except the */
 					/* ref one, we still need some information      */
 					if (melt_arr[j] != ref)
-						be_kill_node(melt_arr[j]);
+						kill_node(melt_arr[j]);
 				}
 
 #ifdef KEEP_ALIVE_COPYKEEP_HACK
@@ -761,16 +769,17 @@ static void melt_copykeeps(constraint_env_t *cenv) {
 				ir_nodeset_insert(&entry->copies, new_ck);
 
 				/* find scheduling point */
+				sched_pt = ref_mode_T;
 				do {
 					/* just walk along the schedule until a non-Keep/CopyKeep node is found */
-					sched_pt = sched_next(ref_mode_T);
+					sched_pt = sched_next(sched_pt);
 				} while (be_is_Keep(sched_pt) || be_is_CopyKeep(sched_pt));
 
 				sched_add_before(sched_pt, new_ck);
 				DBG((cenv->dbg, LEVEL_1, "created %+F, scheduled before %+F\n", new_ck, sched_pt));
 
 				/* finally: kill the reference copykeep */
-				be_kill_node(ref);
+				kill_node(ref);
 			}
 		}
 
@@ -842,12 +851,12 @@ void assure_constraints(be_irg_t *birg) {
 				int     n = get_irn_arity(cp);
 
 				keep = be_new_Keep(arch_get_irn_reg_class(arch_env, cp, -1),
-					irg, get_nodes_block(cp), n, (ir_node **)&get_irn_in(cp)[1]);
+					irg, get_nodes_block(cp), n, get_irn_in(cp) + 1);
 				sched_add_before(cp, keep);
 
 				/* Set all ins (including the block) of the CopyKeep BAD to keep the verifier happy. */
 				sched_remove(cp);
-				be_kill_node(cp);
+				kill_node(cp);
 			}
 		}
 
@@ -885,35 +894,36 @@ static int push_through_perm(ir_node *perm, void *data)
 	bitset_t *moved   = bitset_alloca(arity);
 	int n_moved;
 	int new_size;
-	ir_node *frontier = sched_first(bl);
+	ir_node *frontier = bl;
 	FIRM_DBG_REGISTER(firm_dbg_module_t *mod, "firm.be.lower.permmove");
 
 	int i, n;
 	const ir_edge_t *edge;
-	ir_node *last_proj = NULL, *irn;
+	ir_node *one_proj = NULL, *irn;
 	const arch_register_class_t *cls = NULL;
 
 	DBG((mod, LEVEL_1, "perm move %+F irg %+F\n", perm, irg));
 
-	/* get some proj and find out the register class of the proj. */
-	foreach_out_edge (perm, edge) {
-		last_proj  = get_edge_src_irn(edge);
-		cls = arch_get_irn_reg_class(aenv, last_proj, -1);
-		assert(is_Proj(last_proj));
-		break;
-	}
+	/* get some Proj and find out the register class of that Proj. */
+	edge     = get_irn_out_edge_first_kind(perm, EDGE_KIND_NORMAL);
+	one_proj = get_edge_src_irn(edge);
+	assert(is_Proj(one_proj));
+	cls      = arch_get_irn_reg_class(aenv, one_proj, -1);
 
-	/* find the point in the schedule after which the
+	/* Find the point in the schedule after which the
 	 * potentially movable nodes must be defined.
-	 * A perm will only be pushed up to first instruction
-	 * which lets an operand of itself die.  */
-
+	 * A Perm will only be pushed up to first instruction
+	 * which lets an operand of itself die.
+	 * If we would allow to move the Perm above this instruction,
+	 * the former dead operand would be live now at the point of
+	 * the Perm, increasing the register pressure by one.
+	 */
 	sched_foreach_reverse_from (sched_prev(perm), irn) {
-		for(i = get_irn_arity(irn) - 1; i >= 0; --i) {
+		for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
 			ir_node *op = get_irn_n(irn, i);
-			if(arch_irn_consider_in_reg_alloc(aenv, cls, op)
-				&& !values_interfere(env->birg, op, last_proj)) {
-				frontier = sched_next(irn);
+			if (arch_irn_consider_in_reg_alloc(aenv, cls, op) &&
+			    !values_interfere(env->birg, op, one_proj)) {
+				frontier = irn;
 				goto found_front;
 			}
 		}
@@ -929,11 +939,12 @@ found_front:
 		int                        input = -1;
 		ir_node                   *proj;
 
+		/* search if node is a INPUT of Perm */
 		foreach_out_edge(perm, edge) {
 			ir_node *out = get_edge_src_irn(edge);
 			int      pn  = get_Proj_proj(out);
 			ir_node *in  = get_irn_n(perm, pn);
-			if(node == in) {
+			if (node == in) {
 				proj  = out;
 				input = pn;
 				break;
@@ -977,7 +988,7 @@ found_front:
 
 		/* and kill it */
 		set_Proj_pred(proj, new_Bad());
-		be_kill_node(proj);
+		kill_node(proj);
 
 		bitset_set(moved, input);
 		n_moved++;