X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=f6084da05e6b074a7a733d7dda2984fcda30132b;hb=34e3b8d50bce639e760da7233524a4db85c80290;hp=df59ba00368246c223ae70749a219daa38bdaa7b;hpb=31d36dd3e8a2b7b513958f005cc555e01b9c3d5b;p=libfirm

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index df59ba003..f6084da05 100644
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -1,20 +1,6 @@
 /*
- * Copyright (C) 1995-2011 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.
+ * Copyright (C) 2012 University of Karlsruhe.
  */
 
 /**
@@ -27,9 +13,9 @@
  * - supports all Firm direct (by a data edge) identities except Mux
  *   (Mux can be a 2-input or 1-input identity, only 2-input is implemented yet)
  * - supports Confirm nodes (handle them like Copies but do NOT remove them)
- * - let Cmp nodes calculate Top like all othe data nodes: this would let
+ * - let Cmp nodes calculate Top like all other data nodes: this would let
  *   Mux nodes to calculate Unknown instead of taking the true result
- * - let Cond(Top) always select FALSE/default: This is tricky. Nodes are only reavaluated
+ * - let Cond(Top) always select FALSE/default: This is tricky. Nodes are only reevaluated
  *   IFF the predecessor changed its type. Because nodes are initialized with Top
  *   this never happens, let all Proj(Cond) be unreachable.
  *   We avoid this condition by the same way we work around Phi: whenever a Block
@@ -83,6 +69,7 @@
 #include "irpass.h"
 #include "tv_t.h"
 #include "irtools.h"
+#include "firmstat_t.h"
 
 #include "irprintf.h"
 #include "irdump.h"
@@ -144,8 +131,8 @@ struct node_t {
 	node_t          *race_next;     /**< Next node on race list. */
 	lattice_elem_t  type;           /**< The associated lattice element "type". */
 	int             max_user_input; /**< Maximum input number of Def-Use edges. */
-	int             next_edge;      /**< Index of the next Def-Use edge to use. */
-	int             n_followers;    /**< Number of Follower in the outs set. */
+	unsigned        next_edge;      /**< Index of the next Def-Use edge to use. */
+	unsigned        n_followers;    /**< Number of Follower in the outs set. */
 	unsigned        on_touched:1;   /**< Set, if this node is on the partition.touched set. */
 	unsigned        on_cprop:1;     /**< Set, if this node is on the partition.cprop list. */
 	unsigned        on_fallen:1;    /**< Set, if this node is on the fallen list. */
@@ -259,7 +246,7 @@ static int cmp_irn_opcode(const ir_node *a, const ir_node *b)
 		return a->op->ops.node_cmp_attr(a, b);
 
 	return 0;
-}  /* cmp_irn_opcode */
+}
 
 #ifdef CHECK_PARTITIONS
 /**
@@ -267,7 +254,6 @@ static int cmp_irn_opcode(const ir_node *a, const ir_node *b)
  */
 static void check_partition(const partition_t *T)
 {
-	node_t   *node;
 	unsigned n = 0;
 
 	list_for_each_entry(node_t, node, &T->Leader, node_list) {
@@ -283,14 +269,13 @@ static void check_partition(const partition_t *T)
 		assert(node->flagged == 0);
 		assert(node->part == T);
 	}
-}  /* check_partition */
+}
 
 /**
  * check that all leader nodes in the partition have the same opcode.
  */
 static void check_opcode(const partition_t *Z)
 {
-	node_t        *node;
 	const ir_node *repr = NULL;
 
 	list_for_each_entry(node_t, node, &Z->Leader, node_list) {
@@ -302,13 +287,12 @@ static void check_opcode(const partition_t *Z)
 			assert(cmp_irn_opcode(repr, irn) == 0);
 		}
 	}
-}  /* check_opcode */
+}
 
 static void check_all_partitions(environment_t *env)
 {
 #ifdef DEBUG_libfirm
 	partition_t *P;
-	node_t      *node;
 
 	for (P = env->dbg_list; P != NULL; P = P->dbg_next) {
 		check_partition(P);
@@ -343,7 +327,7 @@ static void do_check_list(const node_t *list, int ofs, const partition_t *Z)
 	(void) ofs;
 	(void) Z;
 #endif
-}  /* ido_check_list */
+}
 
 /**
  * Check a local list.
@@ -351,7 +335,7 @@ static void do_check_list(const node_t *list, int ofs, const partition_t *Z)
 static void check_list(const node_t *list, const partition_t *Z)
 {
 	do_check_list(list, offsetof(node_t, next), Z);
-}  /* check_list */
+}
 
 #else
 #define check_partition(T)
@@ -367,7 +351,6 @@ static inline lattice_elem_t get_partition_type(const partition_t *X);
  */
 static void dump_partition(const char *msg, const partition_t *part)
 {
-	const node_t   *node;
 	int            first = 1;
 	lattice_elem_t type = get_partition_type(part);
 
@@ -387,7 +370,7 @@ static void dump_partition(const char *msg, const partition_t *part)
 		}
 	}
 	DB((dbg, LEVEL_2, "\n}\n"));
-}  /* dump_partition */
+}
 
 /**
  * Dumps a list.
@@ -407,7 +390,7 @@ static void do_dump_list(const char *msg, const node_t *node, int ofs)
 	DB((dbg, LEVEL_3, "\n}\n"));
 
 #undef GET_LINK
-}  /* do_dump_list */
+}
 
 /**
  * Dumps a race list.
@@ -415,7 +398,7 @@ static void do_dump_list(const char *msg, const node_t *node, int ofs)
 static void dump_race_list(const char *msg, const node_t *list)
 {
 	do_dump_list(msg, list, offsetof(node_t, race_next));
-}  /* dump_race_list */
+}
 
 /**
  * Dumps a local list.
@@ -423,7 +406,7 @@ static void dump_race_list(const char *msg, const node_t *list)
 static void dump_list(const char *msg, const node_t *list)
 {
 	do_dump_list(msg, list, offsetof(node_t, next));
-}  /* dump_list */
+}
 
 /**
  * Dump all partitions.
@@ -435,7 +418,7 @@ static void dump_all_partitions(const environment_t *env)
 	DB((dbg, LEVEL_2, "All partitions\n===============\n"));
 	for (P = env->dbg_list; P != NULL; P = P->dbg_next)
 		dump_partition("", P);
-}  /* dump_all_partitions */
+}
 
 /**
  * Sump a split list.
@@ -443,12 +426,15 @@ static void dump_all_partitions(const environment_t *env)
 static void dump_split_list(const partition_t *list)
 {
 	const partition_t *p;
+	char               split = ' ';
 
 	DB((dbg, LEVEL_2, "Split by %s produced = {\n", what_reason));
-	for (p = list; p != NULL; p = p->split_next)
-		DB((dbg, LEVEL_2, "part%u, ", p->nr));
+	for (p = list; p != NULL; p = p->split_next) {
+		DB((dbg, LEVEL_2, "%c part%u", split, p->nr));
+		split = ',';
+	}
 	DB((dbg, LEVEL_2, "\n}\n"));
-}  /* dump_split_list */
+}
 
 /**
  * Dump partition and type for a node.
@@ -460,7 +446,7 @@ static int dump_partition_hook(FILE *F, const ir_node *n, const ir_node *local)
 
 	ir_fprintf(F, "info2 : \"partition %u type %+F\"\n", node->part->nr, node->type);
 	return 1;
-}  /* dump_partition_hook */
+}
 
 #else
 #define dump_partition(msg, part)
@@ -488,8 +474,8 @@ static void verify_type(const lattice_elem_t old_type, node_t *node)
 		/* bottom reached */
 		return;
 	}
-	panic("combo: wrong translation from %+F to %+F on node %+F", old_type, node->type, node->node);
-}  /* verify_type */
+	panic("wrong translation from %+F to %+F on node %+F", old_type, node->type, node->node);
+}
 
 #else
 #define verify_type(old_type, node)
@@ -505,7 +491,7 @@ static int listmap_cmp_ptr(const void *elt, const void *key, size_t size)
 
 	(void) size;
 	return e1->id != e2->id;
-}  /* listmap_cmp_ptr */
+}
 
 /**
  * Initializes a listmap.
@@ -516,7 +502,7 @@ static void listmap_init(listmap_t *map)
 {
 	map->map    = new_set(listmap_cmp_ptr, 16);
 	map->values = NULL;
-}  /* listmap_init */
+}
 
 /**
  * Terminates a listmap.
@@ -526,7 +512,7 @@ static void listmap_init(listmap_t *map)
 static void listmap_term(listmap_t *map)
 {
 	del_set(map->map);
-}  /* listmap_term */
+}
 
 /**
  * Return the associated listmap entry for a given id.
@@ -543,7 +529,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id)
 	key.id   = id;
 	key.list = NULL;
 	key.next = NULL;
-	entry = (listmap_entry_t*)set_insert(map->map, &key, sizeof(key), hash_ptr(id));
+	entry = set_insert(listmap_entry_t, map->map, &key, sizeof(key), hash_ptr(id));
 
 	if (entry->list == NULL) {
 		/* a new entry, put into the list */
@@ -551,7 +537,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id)
 		map->values = entry;
 	}
 	return entry;
-}  /* listmap_find */
+}
 
 /**
  * Calculate the hash value for an opcode map entry.
@@ -574,7 +560,7 @@ static unsigned opcode_hash(const opcode_key_t *entry)
 	else if (code == iro_Proj)
 		hash += (unsigned)get_Proj_proj(n);
 	return hash;
-}  /* opcode_hash */
+}
 
 /**
  * Compare two entries in the opcode map.
@@ -587,7 +573,7 @@ static int cmp_opcode(const void *elt, const void *key, size_t size)
 	(void) size;
 
 	return cmp_irn_opcode(o1->irn, o2->irn);
-}  /* cmp_opcode */
+}
 
 /**
  * Compare two Def-Use edges for input position.
@@ -599,7 +585,7 @@ static int cmp_def_use_edge(const void *a, const void *b)
 
 	/* no overrun, because range is [-1, MAXINT] */
 	return ea->pos - eb->pos;
-}  /* cmp_def_use_edge */
+}
 
 /**
  * We need the Def-Use edges sorted.
@@ -607,13 +593,11 @@ static int cmp_def_use_edge(const void *a, const void *b)
 static void sort_irn_outs(node_t *node)
 {
 	ir_node *irn = node->node;
-	int n_outs = get_irn_n_outs(irn);
-
-	if (n_outs > 1) {
-		qsort(&irn->out[1], n_outs, sizeof(irn->out[0]), cmp_def_use_edge);
-	}
-	node->max_user_input = irn->out[n_outs].pos;
-}  /* sort_irn_outs */
+	unsigned n_outs = get_irn_n_outs(irn);
+	qsort(irn->o.out->edges, n_outs, sizeof(irn->o.out->edges[0]),
+		  cmp_def_use_edge);
+	node->max_user_input = n_outs > 0 ? irn->o.out->edges[n_outs-1].pos : -1;
+}
 
 /**
  * Return the type of a node.
@@ -625,7 +609,7 @@ static void sort_irn_outs(node_t *node)
 static inline lattice_elem_t get_node_type(const ir_node *irn)
 {
 	return get_irn_node(irn)->type;
-}  /* get_node_type */
+}
 
 /**
  * Return the tarval of a node.
@@ -641,7 +625,7 @@ static inline ir_tarval *get_node_tarval(const ir_node *irn)
 	if (is_tarval(type.tv))
 		return type.tv;
 	return tarval_bottom;
-}  /* get_node_type */
+}
 
 /**
  * Add a partition to the worklist.
@@ -653,7 +637,7 @@ static inline void add_to_worklist(partition_t *X, environment_t *env)
 	X->wl_next     = env->worklist;
 	X->on_worklist = 1;
 	env->worklist  = X;
-}  /* add_to_worklist */
+}
 
 /**
  * Create a new empty partition.
@@ -689,7 +673,7 @@ static inline partition_t *new_partition(environment_t *env)
 #endif
 
 	return part;
-}  /* new_partition */
+}
 
 /**
  * Get the first node from a partition.
@@ -697,7 +681,7 @@ static inline partition_t *new_partition(environment_t *env)
 static inline node_t *get_first_node(const partition_t *X)
 {
 	return list_entry(X->Leader.next, node_t, node_list);
-}  /* get_first_node */
+}
 
 /**
  * Return the type of a partition (assuming partition is non-empty and
@@ -711,7 +695,7 @@ static inline lattice_elem_t get_partition_type(const partition_t *X)
 {
 	const node_t *first = get_first_node(X);
 	return first->type;
-}  /* get_partition_type */
+}
 
 /**
  * Creates a partition node for the given IR-node and place it
@@ -749,7 +733,7 @@ static node_t *create_partition_node(ir_node *irn, partition_t *part, environmen
 	++part->n_leader;
 
 	return node;
-}  /* create_partition_node */
+}
 
 /**
  * Pre-Walker, initialize all Nodes' type to U or top and place
@@ -769,7 +753,7 @@ static void create_initial_partitions(ir_node *irn, void *ctx)
 	if (is_Block(irn)) {
 		set_Block_phis(irn, NULL);
 	}
-}  /* create_initial_partitions */
+}
 
 /**
  * Post-Walker, collect  all Block-Phi lists, set Cond.
@@ -782,7 +766,7 @@ static void init_block_phis(ir_node *irn, void *ctx)
 		ir_node *block = get_nodes_block(irn);
 		add_Block_phi(block, irn);
 	}
-}  /* init_block_phis */
+}
 
 /**
  * Add a node to the entry.partition.touched set and
@@ -809,7 +793,7 @@ static inline void add_to_touched(node_t *y, environment_t *env)
 
 		check_list(part->touched, part);
 	}
-}  /* add_to_touched */
+}
 
 /**
  * Place a node on the cprop list.
@@ -847,9 +831,7 @@ static void add_to_cprop(node_t *y, environment_t *env)
 	if (get_irn_mode(irn) == mode_T) {
 		/* mode_T nodes always produce tarval_bottom, so we must explicitly
 		 * add its Projs to get constant evaluation to work */
-		int i;
-
-		for (i = get_irn_n_outs(irn) - 1; i >= 0; --i) {
+		for (unsigned i = get_irn_n_outs(irn); i-- > 0; ) {
 			node_t *proj = get_irn_node(get_irn_out(irn, i));
 
 			add_to_cprop(proj, env);
@@ -864,7 +846,7 @@ static void add_to_cprop(node_t *y, environment_t *env)
 			add_to_cprop(p, env);
 		}
 	}
-}  /* add_to_cprop */
+}
 
 /**
  * Update the worklist: If Z is on worklist then add Z' to worklist.
@@ -881,7 +863,7 @@ static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t
 	} else {
 		add_to_worklist(Z, env);
 	}
-}  /* update_worklist */
+}
 
 /**
  * Make all inputs to x no longer be F.def_use edges.
@@ -890,40 +872,35 @@ static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t
  */
 static void move_edges_to_leader(node_t *x)
 {
-	ir_node     *irn = x->node;
-	int         i, j, k;
-
-	for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
+	ir_node *irn = x->node;
+	for (int i = get_irn_arity(irn) - 1; i >= 0; --i) {
 		node_t  *pred = get_irn_node(get_irn_n(irn, i));
-		ir_node *p;
-		int     n;
-
-		p = pred->node;
-		n = get_irn_n_outs(p);
-		for (j = 1; j <= pred->n_followers; ++j) {
-			if (p->out[j].pos == i && p->out[j].use == irn) {
+		ir_node *p    = pred->node;
+		unsigned n    = get_irn_n_outs(p);
+		for (unsigned j = 0; j < pred->n_followers; ++j) {
+			ir_def_use_edge edge = p->o.out->edges[j];
+			if (edge.pos == i && edge.use == irn) {
 				/* found a follower edge to x, move it to the Leader */
-				ir_def_use_edge edge = p->out[j];
-
 				/* remove this edge from the Follower set */
-				p->out[j] = p->out[pred->n_followers];
 				--pred->n_followers;
+				p->o.out->edges[j] = p->o.out->edges[pred->n_followers];
 
 				/* sort it into the leader set */
-				for (k = pred->n_followers + 2; k <= n; ++k) {
-					if (p->out[k].pos >= edge.pos)
+				unsigned k;
+				for (k = pred->n_followers+1; k < n; ++k) {
+					if (p->o.out->edges[k].pos >= edge.pos)
 						break;
-					p->out[k - 1] = p->out[k];
+					p->o.out->edges[k-1] = p->o.out->edges[k];
 				}
 				/* place the new edge here */
-				p->out[k - 1] = edge;
+				p->o.out->edges[k-1] = edge;
 
 				/* edge found and moved */
 				break;
 			}
 		}
 	}
-}  /* move_edges_to_leader */
+}
 
 /**
  * Split a partition that has NO followers by a local list.
@@ -973,12 +950,13 @@ static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t
 	/* for now, copy the type info tag, it will be adjusted in split_by(). */
 	Z_prime->type_is_T_or_C = Z->type_is_T_or_C;
 
-	update_worklist(Z, Z_prime, env);
-
 	dump_partition("Now ", Z);
 	dump_partition("Created new ", Z_prime);
+
+	update_worklist(Z, Z_prime, env);
+
 	return Z_prime;
-}  /* split_no_followers */
+}
 
 /**
  * Make the Follower -> Leader transition for a node.
@@ -995,7 +973,7 @@ static void follower_to_leader(node_t *n)
 	list_del(&n->node_list);
 	list_add_tail(&n->node_list, &n->part->Leader);
 	++n->part->n_leader;
-}  /* follower_to_leader */
+}
 
 /**
  * The environment for one race step.
@@ -1004,7 +982,7 @@ typedef struct step_env {
 	node_t   *initial;    /**< The initial node list. */
 	node_t   *unwalked;   /**< The unwalked node list. */
 	node_t   *walked;     /**< The walked node list. */
-	int      index;       /**< Next index of Follower use_def edge. */
+	unsigned index;       /**< Next index of Follower use_def edge. */
 	unsigned side;        /**< side number. */
 } step_env;
 
@@ -1072,7 +1050,7 @@ static int is_real_follower(const ir_node *irn, int input)
 		break;
 	}
 	return 1;
-}  /* is_real_follower */
+}
 
 /**
  * Do one step in the race.
@@ -1096,7 +1074,7 @@ static int step(step_env *env)
 		/* let n be the first node in unwalked */
 		n = env->unwalked;
 		while (env->index < n->n_followers) {
-			const ir_def_use_edge *edge = &n->node->out[1 + env->index];
+			const ir_def_use_edge *edge = &n->node->o.out->edges[env->index];
 
 			/* let m be n.F.def_use[index] */
 			node_t *m = get_irn_node(edge->use);
@@ -1137,7 +1115,7 @@ static int step(step_env *env)
 		env->index    = 0;
 	}
 	return 1;
-}  /* step */
+}
 
 /**
  * Clear the flags from a list and check for
@@ -1160,7 +1138,7 @@ static int clear_flags(node_t *list)
 		n->flagged = 0;
 	}
 	return res;
-}  /* clear_flags */
+}
 
 /**
  * Split a partition by a local list using the race.
@@ -1177,7 +1155,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 	partition_t *X_prime;
 	list_head   tmp;
 	step_env    senv[2];
-	node_t      *g, *h, *node, *t;
+	node_t      *g, *h;
 	int         max_input, transitions, winner, shf;
 	unsigned    n;
 	DEBUG_ONLY(static int run = 0;)
@@ -1197,7 +1175,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 
 	/* Remove gg from X.Leader and put into g */
 	g = NULL;
-	for (node = gg; node != NULL; node = node->next) {
+	for (node_t *node = gg; node != NULL; node = node->next) {
 		assert(node->part == X);
 		assert(node->is_follower == 0);
 
@@ -1231,7 +1209,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 	 * Some informations on the race that are not stated clearly in Click's
 	 * thesis.
 	 * 1) A follower stays on the side that reach him first.
-	 * 2) If the other side reches a follower, if will be converted to
+	 * 2) If the other side reaches a follower, if will be converted to
 	 *    a leader. /This must be done after the race is over, else the
 	 *    edges we are iterating on are renumbered./
 	 * 3) /New leader might end up on both sides./
@@ -1268,7 +1246,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 	X_prime   = new_partition(env);
 	max_input = 0;
 	n         = 0;
-	for (node = senv[winner].walked; node != NULL; node = node->race_next) {
+	for (node_t *node = senv[winner].walked; node != NULL; node = node->race_next) {
 		list_del(&node->node_list);
 		node->part = X_prime;
 		if (node->is_follower) {
@@ -1301,6 +1279,9 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 	check_partition(X);
 	check_partition(X_prime);
 
+	dump_partition("Now ", X);
+	dump_partition("Created new ", X_prime);
+
 	/* X' is the smaller part */
 	add_to_worklist(X_prime, env);
 
@@ -1325,9 +1306,6 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 		}
 	}
 
-	dump_partition("Now ", X);
-	dump_partition("Created new ", X_prime);
-
 	/* we have to ensure that the partition containing g is returned */
 	if (winner != 0) {
 		*pX = X_prime;
@@ -1335,7 +1313,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
 	}
 
 	return X_prime;
-}  /* split */
+}
 
 /**
  * Returns non-zero if the i'th input of a Phi node is live.
@@ -1356,7 +1334,7 @@ static int is_live_input(ir_node *phi, int i)
 	}
 	/* else it's the control input, always live */
 	return 1;
-}  /* is_live_input */
+}
 
 /**
  * Return non-zero if a type is a constant.
@@ -1366,7 +1344,7 @@ static int is_constant_type(lattice_elem_t type)
 	if (type.tv != tarval_bottom && type.tv != tarval_top)
 		return 1;
 	return 0;
-}  /* is_constant_type */
+}
 
 /**
  * Check whether a type is neither Top or a constant.
@@ -1386,7 +1364,7 @@ static int type_is_neither_top_nor_const(const lattice_elem_t type)
 		return 0;
 	}
 	return 1;
-}  /* type_is_neither_top_nor_const */
+}
 
 /**
  * Collect nodes to the touched list.
@@ -1397,21 +1375,19 @@ static int type_is_neither_top_nor_const(const lattice_elem_t type)
  */
 static void collect_touched(list_head *list, int idx, environment_t *env)
 {
-	node_t  *x, *y;
+	node_t *y;
 	int     end_idx = env->end_idx;
 
 	list_for_each_entry(node_t, x, list, node_list) {
-		int num_edges;
-
 		if (idx == -1) {
 			/* leader edges start AFTER follower edges */
-			x->next_edge = x->n_followers + 1;
+			x->next_edge = x->n_followers;
 		}
-		num_edges = get_irn_n_outs(x->node);
+		unsigned num_edges = get_irn_n_outs(x->node);
 
 		/* for all edges in x.L.def_use_{idx} */
-		while (x->next_edge <= num_edges) {
-			const ir_def_use_edge *edge = &x->node->out[x->next_edge];
+		while (x->next_edge < num_edges) {
+			const ir_def_use_edge *edge = &x->node->o.out->edges[x->next_edge];
 			ir_node               *succ;
 
 			/* check if we have necessary edges */
@@ -1453,7 +1429,7 @@ static void collect_touched(list_head *list, int idx, environment_t *env)
 			}
 		}
 	}
-}  /* collect_touched */
+}
 
 /**
  * Collect commutative nodes to the touched list.
@@ -1463,18 +1439,16 @@ static void collect_touched(list_head *list, int idx, environment_t *env)
  */
 static void collect_commutative_touched(list_head *list, environment_t *env)
 {
-	node_t  *x, *y;
+	node_t *y;
 
 	list_for_each_entry(node_t, x, list, node_list) {
-		int num_edges;
+		unsigned num_edges = get_irn_n_outs(x->node);
 
-		num_edges = get_irn_n_outs(x->node);
-
-		x->next_edge = x->n_followers + 1;
+		x->next_edge = x->n_followers;
 
 		/* for all edges in x.L.def_use_{idx} */
-		while (x->next_edge <= num_edges) {
-			const ir_def_use_edge *edge = &x->node->out[x->next_edge];
+		while (x->next_edge < num_edges) {
+			const ir_def_use_edge *edge = &x->node->o.out->edges[x->next_edge];
 			ir_node               *succ;
 
 			/* check if we have necessary edges */
@@ -1505,7 +1479,7 @@ static void collect_commutative_touched(list_head *list, environment_t *env)
 			}
 		}
 	}
-}  /* collect_commutative_touched */
+}
 
 /**
  * Split the partitions if caused by the first entry on the worklist.
@@ -1628,7 +1602,7 @@ static void cause_splits(environment_t *env)
 				assert(n_touched <= Z->n_leader);
 		}
 	}
-}  /* cause_splits */
+}
 
 /**
  * Implements split_by_what(): Split a partition by characteristics given
@@ -1644,7 +1618,7 @@ static void cause_splits(environment_t *env)
 static partition_t *split_by_what(partition_t *X, what_func What,
                                   partition_t **P, environment_t *env)
 {
-	node_t          *x, *S;
+	node_t          *S;
 	listmap_t       map;
 	listmap_entry_t *iter;
 	partition_t     *R;
@@ -1686,14 +1660,14 @@ static partition_t *split_by_what(partition_t *X, what_func What,
 
 	listmap_term(&map);
 	return *P;
-}  /* split_by_what */
+}
 
 /** lambda n.(n.type) */
 static void *lambda_type(const node_t *node, environment_t *env)
 {
 	(void)env;
 	return node->type.tv;
-}  /* lambda_type */
+}
 
 /** lambda n.(n.opcode) */
 static void *lambda_opcode(const node_t *node, environment_t *env)
@@ -1702,9 +1676,9 @@ static void *lambda_opcode(const node_t *node, environment_t *env)
 
 	key.irn = node->node;
 
-	entry = (opcode_key_t*)set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
+	entry = set_insert(opcode_key_t, env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
 	return entry;
-}  /* lambda_opcode */
+}
 
 /** lambda n.(n[i].partition) */
 static void *lambda_partition(const node_t *node, environment_t *env)
@@ -1733,7 +1707,7 @@ static void *lambda_partition(const node_t *node, environment_t *env)
 	pred = i == -1 ? get_irn_n(skipped, i) : get_irn_n(node->node, i);
 	p    = get_irn_node(pred);
 	return p->part;
-}  /* lambda_partition */
+}
 
 /** lambda n.(n[i].partition) for commutative nodes */
 static void *lambda_commutative_partition(const node_t *node, environment_t *env)
@@ -1786,7 +1760,7 @@ static void *lambda_commutative_partition(const node_t *node, environment_t *env
 
 		return p->part;
 	}
-}  /* lambda_commutative_partition */
+}
 
 /**
  * Returns true if a type is a constant (and NOT Top
@@ -1798,7 +1772,7 @@ static int is_con(const lattice_elem_t type)
 	if (is_tarval(type.tv))
 		return tarval_is_constant(type.tv);
 	return is_entity(type.sym.entity_p);
-}  /* is_con */
+}
 
 /**
  * Implements split_by().
@@ -1889,7 +1863,7 @@ static void split_by(partition_t *X, environment_t *env)
 			}
 		}
 	} while (P != NULL);
-}  /* split_by */
+}
 
 /**
  * (Re-)compute the type for a given node.
@@ -1916,7 +1890,7 @@ static void default_compute(node_t *node)
 		node->type.tv = tarval_reachable;
 	else
 		node->type.tv = computed_value(irn);
-}  /* default_compute */
+}
 
 /**
  * (Re-)compute the type for a Block node.
@@ -1928,7 +1902,8 @@ static void compute_Block(node_t *node)
 	int     i;
 	ir_node *block = node->node;
 
-	if (block == get_irg_start_block(current_ir_graph) || get_Block_entity(block) != NULL) {
+	ir_graph *const irg = get_Block_irg(block);
+	if (block == get_irg_start_block(irg) || get_Block_entity(block) != NULL) {
 		/* start block and labelled blocks are always reachable */
 		node->type.tv = tarval_reachable;
 		return;
@@ -1944,7 +1919,7 @@ static void compute_Block(node_t *node)
 		}
 	}
 	node->type.tv = tarval_top;
-}  /* compute_Block */
+}
 
 /**
  * (Re-)compute the type for a Bad node.
@@ -1955,7 +1930,7 @@ static void compute_Bad(node_t *node)
 {
 	/* Bad nodes ALWAYS compute Top */
 	node->type.tv = tarval_top;
-}  /* compute_Bad */
+}
 
 /**
  * (Re-)compute the type for an Unknown node.
@@ -1975,7 +1950,7 @@ static void compute_Unknown(node_t *node)
 	 * (jump threading for instance) might replace them by Phib's...
 	 */
 	node->type.tv = tarval_UNKNOWN;
-}  /* compute_Unknown */
+}
 
 /**
  * (Re-)compute the type for a Jmp node.
@@ -1987,7 +1962,7 @@ static void compute_Jmp(node_t *node)
 	node_t *block = get_irn_node(get_nodes_block(node->node));
 
 	node->type = block->type;
-}  /* compute_Jmp */
+}
 
 /**
  * (Re-)compute the type for the Return node.
@@ -2000,7 +1975,7 @@ static void compute_Return(node_t *node)
 	 * This is already checked in compute(). so we can return
 	 * Reachable here. */
 	node->type.tv = tarval_reachable;
-}  /* compute_Return */
+}
 
 /**
  * (Re-)compute the type for the End node.
@@ -2011,7 +1986,7 @@ static void compute_End(node_t *node)
 {
 	/* the End node is NOT dead of course */
 	node->type.tv = tarval_reachable;
-}  /* compute_End */
+}
 
 /**
  * (Re-)compute the type for a Call.
@@ -2025,7 +2000,7 @@ static void compute_Call(node_t *node)
 	 * predecessors.
 	 */
 	node->type.tv = tarval_bottom;
-}  /* compute_Call */
+}
 
 /**
  * (Re-)compute the type for a SymConst node.
@@ -2048,7 +2023,7 @@ static void compute_SymConst(node_t *node)
 	default:
 		node->type.tv = computed_value(irn);
 	}
-}  /* compute_SymConst */
+}
 
 /**
  * (Re-)compute the type for a Phi node.
@@ -2096,7 +2071,7 @@ static void compute_Phi(node_t *node)
 		/* else nothing, constants are the same */
 	}
 	node->type = type;
-}  /* compute_Phi */
+}
 
 /**
  * (Re-)compute the type for an Add. Special case: one nodes is a Zero Const.
@@ -2138,7 +2113,7 @@ static void compute_Add(node_t *node)
 		}
 		node->type.tv = tarval_bottom;
 	}
-}  /* compute_Add */
+}
 
 /**
  * (Re-)compute the type for a Sub. Special case: both nodes are congruent.
@@ -2185,7 +2160,7 @@ static void compute_Sub(node_t *node)
 	} else {
 		node->type.tv = tarval_bottom;
 	}
-}  /* compute_Sub */
+}
 
 /**
  * (Re-)compute the type for an Eor. Special case: both nodes are congruent.
@@ -2227,7 +2202,7 @@ static void compute_Eor(node_t *node)
 	} else {
 		node->type.tv = tarval_bottom;
 	}
-}  /* compute_Eor */
+}
 
 /**
  * (Re-)compute the type for Cmp.
@@ -2372,7 +2347,7 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond)
 			}
 		}
 	}
-}  /* compute_Proj_Cond */
+}
 
 static void compute_Proj_Switch(node_t *node, ir_node *switchn)
 {
@@ -2475,7 +2450,7 @@ ir_node *proj = node->node;
 	}
 
 	default_compute(node);
-}  /* compute_Proj */
+}
 
 /**
  * (Re-)compute the type for a Confirm.
@@ -2498,7 +2473,7 @@ static void compute_Confirm(node_t *node)
 	}
 	/* a Confirm is a copy OR a Const */
 	node->type = pred->type;
-}  /* compute_Confirm */
+}
 
 /**
  * (Re-)compute the type for a given node.
@@ -2536,7 +2511,7 @@ static void compute(node_t *node)
 	func = (compute_func)node->node->op->ops.generic;
 	if (func != NULL)
 		func(node);
-}  /* compute */
+}
 
 /*
  * Identity functions: Note that one might think that identity() is just a
@@ -2574,7 +2549,7 @@ static node_t *identity_Phi(node_t *node)
 	 * tarval_top, is in the TOP partition and should NOT being split! */
 	assert(n_part != NULL);
 	return n_part;
-}  /* identity_Phi */
+}
 
 /**
  * Calculates the Identity for commutative 0 neutral nodes.
@@ -2599,7 +2574,7 @@ static node_t *identity_comm_zero_binop(node_t *node)
 	if (b->type.tv == zero)
 		return a;
 	return node;
-}  /* identity_comm_zero_binop */
+}
 
 /**
  * Calculates the Identity for Shift nodes.
@@ -2617,7 +2592,7 @@ static node_t *identity_shift(node_t *node)
 	if (b->type.tv == zero)
 		return get_irn_node(get_binop_left(op));
 	return node;
-}  /* identity_shift */
+}
 
 /**
  * Calculates the Identity for Mul nodes.
@@ -2642,7 +2617,7 @@ static node_t *identity_Mul(node_t *node)
 	if (b->type.tv == one)
 		return a;
 	return node;
-}  /* identity_Mul */
+}
 
 /**
  * Calculates the Identity for Sub nodes.
@@ -2662,7 +2637,7 @@ static node_t *identity_Sub(node_t *node)
 	if (b->type.tv == get_mode_null(mode))
 		return get_irn_node(get_Sub_left(sub));
 	return node;
-}  /* identity_Sub */
+}
 
 /**
  * Calculates the Identity for And nodes.
@@ -2681,7 +2656,7 @@ static node_t *identity_And(node_t *node)
 	if (b->type.tv == neutral)
 		return a;
 	return node;
-}  /* identity_And */
+}
 
 /**
  * Calculates the Identity for Confirm nodes.
@@ -2692,7 +2667,7 @@ static node_t *identity_Confirm(node_t *node)
 
 	/* a Confirm is always a Copy */
 	return get_irn_node(get_Confirm_value(confirm));
-}  /* identity_Confirm */
+}
 
 /**
  * Calculates the Identity for Mux nodes.
@@ -2708,17 +2683,8 @@ static node_t *identity_Mux(node_t *node)
 		return t;
 
 	/* for now, the 1-input identity is not supported */
-#if 0
-	sel = get_irn_node(get_Mux_sel(mux));
-
-	/* Mux sel input is mode_b, so it is always a tarval */
-	if (sel->type.tv == tarval_b_true)
-		return t;
-	if (sel->type.tv == tarval_b_false)
-		return f;
-#endif
 	return node;
-}  /* identity_Mux */
+}
 
 /**
  * Calculates the Identity for nodes.
@@ -2752,7 +2718,7 @@ static node_t *identity(node_t *node)
 	default:
 		return node;
 	}
-}  /* identity */
+}
 
 /**
  * Node follower is a (new) follower of leader, segregate Leader
@@ -2760,24 +2726,23 @@ static node_t *identity(node_t *node)
  */
 static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader)
 {
-	ir_node *l   = leader->node;
-	int     j, i, n = get_irn_n_outs(l);
-
 	DB((dbg, LEVEL_2, "%+F is a follower of %+F\n", follower, leader->node));
 	/* The leader edges must remain sorted, but follower edges can
 	   be unsorted. */
-	for (i = leader->n_followers + 1; i <= n; ++i) {
-		if (l->out[i].use == follower) {
-			ir_def_use_edge t = l->out[i];
-
-			for (j = i - 1; j >= leader->n_followers + 1; --j)
-				l->out[j + 1] = l->out[j];
+	ir_node *l = leader->node;
+	unsigned n = get_irn_n_outs(l);
+	for (unsigned i = leader->n_followers; i < n; ++i) {
+		if (l->o.out->edges[i].use == follower) {
+			ir_def_use_edge t = l->o.out->edges[i];
+
+			for (unsigned j = i; j-- > leader->n_followers; )
+				l->o.out->edges[j+1] = l->o.out->edges[j];
+			l->o.out->edges[leader->n_followers] = t;
 			++leader->n_followers;
-			l->out[leader->n_followers] = t;
 			break;
 		}
 	}
-}  /* segregate_def_use_chain_1 */
+}
 
 /**
  * Node follower is a (new) follower segregate its Leader
@@ -2794,7 +2759,7 @@ static void segregate_def_use_chain(const ir_node *follower)
 
 		segregate_def_use_chain_1(follower, pred);
 	}
-}  /* segregate_def_use_chain */
+}
 
 /**
  * Propagate constant evaluation.
@@ -2808,7 +2773,6 @@ static void propagate(environment_t *env)
 	lattice_elem_t old_type;
 	node_t         *fallen;
 	unsigned       n_fallen, old_type_was_T_or_C;
-	int            i;
 
 	while (env->cprop != NULL) {
 		void *oldopcode = NULL;
@@ -2866,6 +2830,17 @@ static void propagate(environment_t *env)
 
 				/* x will make the follower -> leader transition */
 				follower_to_leader(x);
+
+				/* In case of a follower -> leader transition of a Phi node
+				 * we have to ensure that the current partition will be split
+				 * by lambda n.(n[i].partition).
+				 *
+				 * This split may already happened before when some predecessors
+				 * of the Phi's Block are unreachable. Thus, we have to put the
+				 * current partition in the worklist to repeat the check.
+				 */
+				if (is_Phi(x->node) && ! x->part->on_worklist)
+					add_to_worklist(x->part, env);
 			}
 
 			/* compute a new type for x */
@@ -2885,7 +2860,7 @@ static void propagate(environment_t *env)
 					++n_fallen;
 					DB((dbg, LEVEL_2, "Add node %+F to fallen\n", x->node));
 				}
-				for (i = get_irn_n_outs(x->node) - 1; i >= 0; --i) {
+				for (unsigned i = get_irn_n_outs(x->node); i-- > 0; ) {
 					ir_node *succ = get_irn_out(x->node, i);
 					node_t  *y    = get_irn_node(succ);
 
@@ -2911,8 +2886,6 @@ static void propagate(environment_t *env)
 			x->on_fallen = 0;
 
 		if (old_type_was_T_or_C) {
-			node_t *y, *tmp;
-
 			/* check if some nodes will make the leader -> follower transition */
 			list_for_each_entry_safe(node_t, y, tmp, &Y->Leader, node_list) {
 				if (y->type.tv != tarval_top && ! is_con(y->type)) {
@@ -2933,7 +2906,7 @@ static void propagate(environment_t *env)
 		}
 		split_by(Y, env);
 	}
-}  /* propagate */
+}
 
 /**
  * Get the leader for a given node from its congruence class.
@@ -2954,16 +2927,16 @@ static ir_node *get_leader(node_t *node)
 		return get_first_node(part)->node;
 	}
 	return node->node;
-}  /* get_leader */
+}
 
 /**
  * Returns non-zero if a mode_T node has only one reachable output.
  */
 static int only_one_reachable_proj(ir_node *n)
 {
-	int i, k = 0;
+	int k = 0;
 
-	for (i = get_irn_n_outs(n) - 1; i >= 0; --i) {
+	for (unsigned i = get_irn_n_outs(n); i-- > 0; ) {
 		ir_node *proj = get_irn_out(n, i);
 		node_t  *node;
 
@@ -2978,7 +2951,7 @@ static int only_one_reachable_proj(ir_node *n)
 		}
 	}
 	return 1;
-}  /* only_one_reachable_proj */
+}
 
 /**
  * Return non-zero if the control flow predecessor node pred
@@ -3004,7 +2977,7 @@ static int can_exchange(ir_node *pred, ir_node *block)
 		return only_one_reachable_proj(pred);
 	}
 	return 0;
-}  /* can_exchange */
+}
 
 /**
  * Block Post-Walker, apply the analysis results on control flow by
@@ -3047,7 +3020,8 @@ static void apply_cf(ir_node *block, void *ctx)
 			}
 		}
 
-		if (block == get_irg_end_block(current_ir_graph)) {
+		ir_graph *const irg = get_Block_irg(block);
+		if (block == get_irg_end_block(irg)) {
 			/* Analysis found out that the end block is unreachable,
 			 * hence we remove all its control flow predecessors. */
 			set_irn_in(block, 0, NULL);
@@ -3164,7 +3138,7 @@ static void apply_cf(ir_node *block, void *ctx)
 	}
 	set_irn_in(block, k, in_X);
 	env->modified = 1;
-}  /* apply_cf */
+}
 
 /**
  * Exchange a node by its leader.
@@ -3198,7 +3172,7 @@ static void exchange_leader(ir_node *irn, ir_node *leader)
 		}
 	}
 	exchange(irn, leader);
-}  /* exchange_leader */
+}
 
 /**
  * Check, if all users of a mode_M node are dead. Use
@@ -3207,10 +3181,9 @@ static void exchange_leader(ir_node *irn, ir_node *leader)
  */
 static int all_users_are_dead(const ir_node *irn)
 {
-	int i, n = get_irn_n_outs(irn);
-
-	for (i = 1; i <= n; ++i) {
-		const ir_node *succ  = irn->out[i].use;
+	unsigned n = get_irn_n_outs(irn);
+	for (unsigned i = 0; i < n; ++i) {
+		const ir_node *succ  = get_irn_out(irn, i);
 		const node_t  *block = get_irn_node(get_nodes_block(succ));
 		const node_t  *node;
 
@@ -3226,7 +3199,7 @@ static int all_users_are_dead(const ir_node *irn)
 	}
 	/* all users are unreachable */
 	return 1;
-}  /* all_user_are_dead */
+}
 
 /**
  * Walker: Find reachable mode_M nodes that have only
@@ -3253,7 +3226,7 @@ static void find_kept_memory(ir_node *irn, void *ctx)
 		DB((dbg, LEVEL_1, "%+F must be kept\n", irn));
 		ARR_APP1(ir_node *, env->kept_memory, irn);
 	}
-}  /* find_kept_memory */
+}
 
 /**
  * Post-Walker, apply the analysis results;
@@ -3413,7 +3386,7 @@ static void apply_result(ir_node *irn, void *ctx)
 			}
 		}
 	}
-}  /* apply_result */
+}
 
 /**
  * Fix the keep-alives by deleting unreachable ones.
@@ -3450,7 +3423,7 @@ static void apply_end(ir_node *end, environment_t *env)
 		set_End_keepalives(end, j, in);
 		env->modified = 1;
 	}
-}  /* apply_end */
+}
 
 #define SET(code) op_##code->ops.generic = (op_func)compute_##code
 
@@ -3483,7 +3456,7 @@ static void set_compute_functions(void)
 	SET(Return);
 	SET(End);
 	SET(Call);
-}  /* set_compute_functions */
+}
 
 /**
  * Add memory keeps.
@@ -3509,7 +3482,7 @@ static void add_memory_keeps(ir_node **kept_memory, size_t len)
 		}
 	}
 	ir_nodeset_destroy(&set);
-}  /* add_memory_keeps */
+}
 
 void combo(ir_graph *irg)
 {
@@ -3588,10 +3561,6 @@ void combo(ir_graph *irg)
 	dump_all_partitions(&env);
 	check_all_partitions(&env);
 
-#if 0
-	dump_ir_block_graph(irg, "-partition");
-#endif
-
 	/* apply the result */
 
 	/* check, which nodes must be kept */
@@ -3627,10 +3596,10 @@ void combo(ir_graph *irg)
 	current_ir_graph = rem;
 
 	confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE);
-}  /* combo */
+}
 
 /* Creates an ir_graph pass for combo. */
 ir_graph_pass_t *combo_pass(const char *name)
 {
 	return def_graph_pass(name ? name : "combo", combo);
-}  /* combo_pass */
+}