X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=ad3d385116e45a1b5b78acf6f88c238e40d54dbe;hb=8fa62f7ac1fc2272ff8a64c673cfb2f4b4b98971;hp=b54f72b7307205bae604af73d3ef515faf4c7057;hpb=e1397b01aceb38b6bb62c319007146af3b922f39;p=libfirm

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index b54f72b73..ad3d38511 100644
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -81,8 +81,9 @@
 #include "array_t.h"
 #include "error.h"
 #include "irnodeset.h"
-
+#include "irpass.h"
 #include "tv_t.h"
+#include "irtools.h"
 
 #include "irprintf.h"
 #include "irdump.h"
@@ -105,17 +106,7 @@ typedef void (*compute_func)(node_t *node);
  * An opcode map key.
  */
 struct opcode_key_t {
-	ir_opcode   code;   /**< The Firm opcode. */
-	ir_mode     *mode;  /**< The mode of all nodes in the partition. */
-	int         arity;  /**< The arity of this opcode (needed for Phi etc. */
-	union {
-		long      proj;   /**< For Proj nodes, its proj number */
-		ir_entity *ent;   /**< For Sel Nodes, its entity */
-		int       intVal; /**< For Conv/Div Nodes: strict/remainderless */
-		unsigned  uintVal;/**< for Builtin: the kind */
-		ir_node   *block; /**< for Block: itself */
-		void      *ptr;   /**< generic pointer for hash/cmp */
-	} u;
+	ir_node *irn;    /**< An IR node representing this opcode. */
 };
 
 /**
@@ -138,7 +129,7 @@ typedef struct listmap_t {
  * have to use this union.
  */
 typedef union {
-	tarval          *tv;
+	ir_tarval      *tv;
 	symconst_symbol sym;
 } lattice_elem_t;
 
@@ -196,7 +187,6 @@ typedef struct environment_t {
 	partition_t     *touched;       /**< the touched set. */
 	partition_t     *initial;       /**< The initial partition. */
 	set             *opcode2id_map; /**< The opcodeMode->id map. */
-	pmap            *type2id_map;   /**< The type->id map. */
 	ir_node         **kept_memory;  /**< Array of memory nodes that must be kept. */
 	int             end_idx;        /**< -1 for local and 0 for global congruences. */
 	int             lambda_input;   /**< Captured argument for lambda_partition(). */
@@ -231,16 +221,53 @@ DEBUG_ONLY(static const char *what_reason;)
 DEBUG_ONLY(static unsigned part_nr = 0);
 
 /** The tarval returned by Unknown nodes: set to either tarval_bad OR tarval_top. */
-static tarval *tarval_UNKNOWN;
+static ir_tarval *tarval_UNKNOWN;
 
 /* forward */
 static node_t *identity(node_t *node);
 
+/**
+ * Compare two opcode representatives.
+ */
+static int cmp_irn_opcode(const ir_node *a, const ir_node *b)
+{
+	int arity;
+
+	if ((get_irn_op(a) != get_irn_op(b)) ||
+	    (get_irn_mode(a) != get_irn_mode(b)))
+		return 1;
+
+	/* compare if a's in and b's in are of equal length */
+	arity = get_irn_arity(a);
+	if (arity != get_irn_arity(b))
+		return 1;
+
+	if (is_Block(a)) {
+		/*
+		 * Some ugliness here: Two Blocks having the same
+		 * IJmp predecessor would be congruent, which of course is wrong.
+		 * We fix it by never letting blocks be congruent
+		 * which cannot be detected by combo either.
+		 */
+		return 1;
+	}
+
+	/*
+	 * here, we already know that the nodes are identical except their
+	 * attributes
+	 */
+	if (a->op->ops.node_cmp_attr)
+		return a->op->ops.node_cmp_attr(a, b);
+
+	return 0;
+}  /* cmp_irn_opcode */
+
 #ifdef CHECK_PARTITIONS
 /**
  * Check a partition.
  */
-static void check_partition(const partition_t *T) {
+static void check_partition(const partition_t *T)
+{
 	node_t   *node;
 	unsigned n = 0;
 
@@ -262,82 +289,24 @@ static void check_partition(const partition_t *T) {
 /**
  * check that all leader nodes in the partition have the same opcode.
  */
-static void check_opcode(const partition_t *Z) {
-	node_t       *node;
-	opcode_key_t key;
-	int          first = 1;
+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) {
 		ir_node *irn = node->node;
 
-		if (first) {
-			key.code   = get_irn_opcode(irn);
-			key.mode   = get_irn_mode(irn);
-			key.arity  = get_irn_arity(irn);
-			key.u.proj = 0;
-			key.u.ent  = NULL;
-
-			switch (get_irn_opcode(irn)) {
-			case iro_Proj:
-				key.u.proj = get_Proj_proj(irn);
-				break;
-			case iro_Sel:
-				key.u.ent = get_Sel_entity(irn);
-				break;
-			case iro_Conv:
-				key.u.intVal = get_Conv_strict(irn);
-				break;
-			case iro_Div:
-				key.u.intVal = get_Div_no_remainder(irn);
-				break;
-			case iro_Block:
-				key.u.block = irn;
-				break;
-			case iro_Load:
-				key.mode = get_Load_mode(irn);
-				break;
-			case iro_Builtin:
-				key.u.intVal = get_Builtin_kind(irn);
-				break;
-			default:
-				break;
-			}
-			first = 0;
+		if (repr == NULL) {
+			repr = irn;
 		} else {
-			assert((unsigned)key.code  == get_irn_opcode(irn));
-			assert(key.mode  == get_irn_mode(irn));
-			assert(key.arity == get_irn_arity(irn));
-
-			switch (get_irn_opcode(irn)) {
-			case iro_Proj:
-				assert(key.u.proj == get_Proj_proj(irn));
-				break;
-			case iro_Sel:
-				assert(key.u.ent == get_Sel_entity(irn));
-				break;
-			case iro_Conv:
-				assert(key.u.intVal == get_Conv_strict(irn));
-				break;
-			case iro_Div:
-				assert(key.u.intVal == get_Div_no_remainder(irn));
-				break;
-			case iro_Block:
-				assert(key.u.block == irn);
-				break;
-			case iro_Load:
-				assert(key.mode == get_Load_mode(irn));
-				break;
-			case iro_Builtin:
-				assert(key.u.intVal == (int) get_Builtin_kind(irn));
-				break;
-			default:
-				break;
-			}
+			assert(cmp_irn_opcode(repr, irn) == 0);
 		}
 	}
 }  /* check_opcode */
 
-static void check_all_partitions(environment_t *env) {
+static void check_all_partitions(environment_t *env)
+{
 #ifdef DEBUG_libfirm
 	partition_t *P;
 	node_t      *node;
@@ -360,7 +329,8 @@ static void check_all_partitions(environment_t *env) {
 /**
  * Check list.
  */
-static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
+static void do_check_list(const node_t *list, int ofs, const partition_t *Z)
+{
 
 #ifndef NDEBUG
 	const node_t *e;
@@ -379,7 +349,8 @@ static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
 /**
  * Check a local list.
  */
-static void check_list(const node_t *list, 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 */
 
@@ -395,7 +366,8 @@ static inline lattice_elem_t get_partition_type(const partition_t *X);
 /**
  * Dump partition to output.
  */
-static void dump_partition(const char *msg, const partition_t *part) {
+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);
@@ -421,7 +393,8 @@ static void dump_partition(const char *msg, const partition_t *part) {
 /**
  * Dumps a list.
  */
-static void do_dump_list(const char *msg, const node_t *node, int ofs) {
+static void do_dump_list(const char *msg, const node_t *node, int ofs)
+{
 	const node_t *p;
 	int          first = 1;
 
@@ -440,21 +413,24 @@ static void do_dump_list(const char *msg, const node_t *node, int ofs) {
 /**
  * Dumps a race list.
  */
-static void dump_race_list(const char *msg, const node_t *list) {
+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.
  */
-static void dump_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.
  */
-static void dump_all_partitions(const environment_t *env) {
+static void dump_all_partitions(const environment_t *env)
+{
 	const partition_t *P;
 
 	DB((dbg, LEVEL_2, "All partitions\n===============\n"));
@@ -465,7 +441,8 @@ static void dump_all_partitions(const environment_t *env) {
 /**
  * Sump a split list.
  */
-static void dump_split_list(const partition_t *list) {
+static void dump_split_list(const partition_t *list)
+{
 	const partition_t *p;
 
 	DB((dbg, LEVEL_2, "Split by %s produced = {\n", what_reason));
@@ -477,7 +454,8 @@ static void dump_split_list(const partition_t *list) {
 /**
  * Dump partition and type for a node.
  */
-static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local) {
+static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local)
+{
 	ir_node *irn = local != NULL ? local : n;
 	node_t *node = get_irn_node(irn);
 
@@ -497,7 +475,8 @@ static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local) {
 /**
  * Verify that a type transition is monotone
  */
-static void verify_type(const lattice_elem_t old_type, node_t *node) {
+static void verify_type(const lattice_elem_t old_type, node_t *node)
+{
 	if (old_type.tv == node->type.tv) {
 		/* no change */
 		return;
@@ -520,9 +499,10 @@ static void verify_type(const lattice_elem_t old_type, node_t *node) {
 /**
  * Compare two pointer values of a listmap.
  */
-static int listmap_cmp_ptr(const void *elt, const void *key, size_t size) {
-	const listmap_entry_t *e1 = elt;
-	const listmap_entry_t *e2 = key;
+static int listmap_cmp_ptr(const void *elt, const void *key, size_t size)
+{
+	const listmap_entry_t *e1 = (listmap_entry_t*)elt;
+	const listmap_entry_t *e2 = (listmap_entry_t*)key;
 
 	(void) size;
 	return e1->id != e2->id;
@@ -533,7 +513,8 @@ static int listmap_cmp_ptr(const void *elt, const void *key, size_t size) {
  *
  * @param map  the listmap
  */
-static void listmap_init(listmap_t *map) {
+static void listmap_init(listmap_t *map)
+{
 	map->map    = new_set(listmap_cmp_ptr, 16);
 	map->values = NULL;
 }  /* listmap_init */
@@ -543,7 +524,8 @@ static void listmap_init(listmap_t *map) {
  *
  * @param map  the listmap
  */
-static void listmap_term(listmap_t *map) {
+static void listmap_term(listmap_t *map)
+{
 	del_set(map->map);
 }  /* listmap_term */
 
@@ -555,13 +537,14 @@ static void listmap_term(listmap_t *map) {
  *
  * @return the associated listmap entry for the given id
  */
-static listmap_entry_t *listmap_find(listmap_t *map, void *id) {
+static listmap_entry_t *listmap_find(listmap_t *map, void *id)
+{
 	listmap_entry_t key, *entry;
 
 	key.id   = id;
 	key.list = NULL;
 	key.next = NULL;
-	entry = set_insert(map->map, &key, sizeof(key), HASH_PTR(id));
+	entry = (listmap_entry_t*)set_insert(map->map, &key, sizeof(key), HASH_PTR(id));
 
 	if (entry->list == NULL) {
 		/* a new entry, put into the list */
@@ -578,31 +561,42 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) {
  *
  * @return a hash value for the given opcode map entry
  */
-static unsigned opcode_hash(const opcode_key_t *entry) {
-	return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ptr) + entry->arity;
+static unsigned opcode_hash(const opcode_key_t *entry)
+{
+	/* we cannot use the ir ops hash function here, because it hashes the
+	 * predecessors. */
+	const ir_node *n = entry->irn;
+	ir_opcode code  = get_irn_opcode(n);
+	ir_mode   *mode = get_irn_mode(n);
+	unsigned hash = (unsigned)(PTR_TO_INT(mode) * 9 + code) + get_irn_arity(n);
+
+	if (code == iro_Const)
+		hash ^= (unsigned)HASH_PTR(get_Const_tarval(n));
+	else if (code == iro_Proj)
+		hash += (unsigned)get_Proj_proj(n);
+	return hash;
 }  /* opcode_hash */
 
 /**
  * Compare two entries in the opcode map.
  */
-static int cmp_opcode(const void *elt, const void *key, size_t size) {
-	const opcode_key_t *o1 = elt;
-	const opcode_key_t *o2 = key;
+static int cmp_opcode(const void *elt, const void *key, size_t size)
+{
+	const opcode_key_t *o1 = (opcode_key_t*)elt;
+	const opcode_key_t *o2 = (opcode_key_t*)key;
 
 	(void) size;
-	return o1->code != o2->code || o1->mode != o2->mode ||
-	       o1->arity != o2->arity ||
-	       o1->u.proj != o2->u.proj ||
-	       o1->u.intVal != o2->u.intVal || /* this already checks uIntVal */
-	       o1->u.ptr != o2->u.ptr;
+
+	return cmp_irn_opcode(o1->irn, o2->irn);
 }  /* cmp_opcode */
 
 /**
  * Compare two Def-Use edges for input position.
  */
-static int cmp_def_use_edge(const void *a, const void *b) {
-	const ir_def_use_edge *ea = a;
-	const ir_def_use_edge *eb = b;
+static int cmp_def_use_edge(const void *a, const void *b)
+{
+	const ir_def_use_edge *ea = (const ir_def_use_edge*)a;
+	const ir_def_use_edge *eb = (const ir_def_use_edge*)b;
 
 	/* no overrun, because range is [-1, MAXINT] */
 	return ea->pos - eb->pos;
@@ -611,7 +605,8 @@ static int cmp_def_use_edge(const void *a, const void *b) {
 /**
  * We need the Def-Use edges sorted.
  */
-static void sort_irn_outs(node_t *node) {
+static void sort_irn_outs(node_t *node)
+{
 	ir_node *irn = node->node;
 	int n_outs = get_irn_n_outs(irn);
 
@@ -628,7 +623,8 @@ static void sort_irn_outs(node_t *node) {
  *
  * @return the associated type of this node
  */
-static inline lattice_elem_t get_node_type(const ir_node *irn) {
+static inline lattice_elem_t get_node_type(const ir_node *irn)
+{
 	return get_irn_node(irn)->type;
 }  /* get_node_type */
 
@@ -639,7 +635,8 @@ static inline lattice_elem_t get_node_type(const ir_node *irn) {
  *
  * @return the associated type of this node
  */
-static inline tarval *get_node_tarval(const ir_node *irn) {
+static inline ir_tarval *get_node_tarval(const ir_node *irn)
+{
 	lattice_elem_t type = get_node_type(irn);
 
 	if (is_tarval(type.tv))
@@ -650,7 +647,8 @@ static inline tarval *get_node_tarval(const ir_node *irn) {
 /**
  * Add a partition to the worklist.
  */
-static inline void add_to_worklist(partition_t *X, environment_t *env) {
+static inline void add_to_worklist(partition_t *X, environment_t *env)
+{
 	assert(X->on_worklist == 0);
 	DB((dbg, LEVEL_2, "Adding part%d to worklist\n", X->nr));
 	X->wl_next     = env->worklist;
@@ -665,8 +663,9 @@ static inline void add_to_worklist(partition_t *X, environment_t *env) {
  *
  * @return a newly allocated partition
  */
-static inline partition_t *new_partition(environment_t *env) {
-	partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
+static inline partition_t *new_partition(environment_t *env)
+{
+	partition_t *part = OALLOC(&env->obst, partition_t);
 
 	INIT_LIST_HEAD(&part->Leader);
 	INIT_LIST_HEAD(&part->Follower);
@@ -696,7 +695,8 @@ static inline partition_t *new_partition(environment_t *env) {
 /**
  * Get the first node from a partition.
  */
-static inline node_t *get_first_node(const partition_t *X) {
+static inline node_t *get_first_node(const partition_t *X)
+{
 	return list_entry(X->Leader.next, node_t, node_list);
 }  /* get_first_node */
 
@@ -708,7 +708,8 @@ static inline node_t *get_first_node(const partition_t *X) {
  *
  * @return the type of the first element of the partition
  */
-static inline lattice_elem_t get_partition_type(const partition_t *X) {
+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 */
@@ -723,9 +724,10 @@ static inline lattice_elem_t get_partition_type(const partition_t *X) {
  *
  * @return the created node
  */
-static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env) {
+static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env)
+{
 	/* create a partition node and place it in the partition */
-	node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+	node_t *node = OALLOC(&env->obst, node_t);
 
 	INIT_LIST_HEAD(&node->node_list);
 	INIT_LIST_HEAD(&node->cprop_list);
@@ -754,8 +756,9 @@ static node_t *create_partition_node(ir_node *irn, partition_t *part, environmen
  * Pre-Walker, initialize all Nodes' type to U or top and place
  * all nodes into the TOP partition.
  */
-static void create_initial_partitions(ir_node *irn, void *ctx) {
-	environment_t *env  = ctx;
+static void create_initial_partitions(ir_node *irn, void *ctx)
+{
+	environment_t *env  = (environment_t*)ctx;
 	partition_t   *part = env->initial;
 	node_t        *node;
 
@@ -772,11 +775,13 @@ static void create_initial_partitions(ir_node *irn, void *ctx) {
 /**
  * Post-Walker, collect  all Block-Phi lists, set Cond.
  */
-static void init_block_phis(ir_node *irn, void *ctx) {
+static void init_block_phis(ir_node *irn, void *ctx)
+{
 	(void) ctx;
 
 	if (is_Phi(irn)) {
-		add_Block_phi(get_nodes_block(irn), irn);
+		ir_node *block = get_nodes_block(irn);
+		add_Block_phi(block, irn);
 	}
 }  /* init_block_phis */
 
@@ -787,7 +792,8 @@ static void init_block_phis(ir_node *irn, void *ctx) {
  * @param y    a node
  * @param env  the environment
  */
-static inline void add_to_touched(node_t *y, environment_t *env) {
+static inline void add_to_touched(node_t *y, environment_t *env)
+{
 	if (y->on_touched == 0) {
 		partition_t *part = y->part;
 
@@ -812,7 +818,8 @@ static inline void add_to_touched(node_t *y, environment_t *env) {
  * @param y    the node
  * @param env  the environment
  */
-static void add_to_cprop(node_t *y, environment_t *env) {
+static void add_to_cprop(node_t *y, environment_t *env)
+{
 	ir_node *irn;
 
 	/* Add y to y.partition.cprop. */
@@ -839,7 +846,7 @@ static void add_to_cprop(node_t *y, environment_t *env) {
 	irn = y->node;
 	if (get_irn_mode(irn) == mode_T) {
 		/* mode_T nodes always produce tarval_bottom, so we must explicitly
-		   add it's Proj's to get constant evaluation to work */
+		 * add its Projs to get constant evaluation to work */
 		int i;
 
 		for (i = get_irn_n_outs(irn) - 1; i >= 0; --i) {
@@ -867,7 +874,8 @@ static void add_to_cprop(node_t *y, environment_t *env) {
  * @param Z_prime  the Z' partition, a previous part of Z
  * @param env      the environment
  */
-static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t *env) {
+static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t *env)
+{
 	if (Z->on_worklist || Z_prime->n_leader < Z->n_leader) {
 		add_to_worklist(Z_prime, env);
 	} else {
@@ -880,7 +888,8 @@ static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t
  *
  * @param x  the node
  */
-static void move_edges_to_leader(node_t *x) {
+static void move_edges_to_leader(node_t *x)
+{
 	ir_node     *irn = x->node;
 	int         i, j, k;
 
@@ -925,7 +934,8 @@ static void move_edges_to_leader(node_t *x) {
  *
  * @return  a new partition containing the nodes of g
  */
-static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t *env) {
+static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t *env)
+{
 	partition_t *Z_prime;
 	node_t      *node;
 	unsigned    n = 0;
@@ -975,7 +985,8 @@ static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t
  *
  * @param n  the node
  */
-static void follower_to_leader(node_t *n) {
+static void follower_to_leader(node_t *n)
+{
 	assert(n->is_follower == 1);
 
 	DB((dbg, LEVEL_2, "%+F make the follower -> leader transition\n", n->node));
@@ -1003,7 +1014,8 @@ typedef struct step_env {
  * @param irn    the node to check
  * @param input  number of the input
  */
-static int is_real_follower(const ir_node *irn, int input) {
+static int is_real_follower(const ir_node *irn, int input)
+{
 	node_t *pred;
 
 	switch (get_irn_opcode(irn)) {
@@ -1065,7 +1077,8 @@ static int is_real_follower(const ir_node *irn, int input) {
 /**
  * Do one step in the race.
  */
-static int step(step_env *env) {
+static int step(step_env *env)
+{
 	node_t *n;
 
 	if (env->initial != NULL) {
@@ -1132,7 +1145,8 @@ static int step(step_env *env) {
  *
  * @param list  the list
  */
-static int clear_flags(node_t *list) {
+static int clear_flags(node_t *list)
+{
 	int    res = 0;
 	node_t *n;
 
@@ -1157,7 +1171,8 @@ static int clear_flags(node_t *list) {
  *
  * @return  a new partition containing the nodes of gg
  */
-static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) {
+static partition_t *split(partition_t **pX, node_t *gg, environment_t *env)
+{
 	partition_t *X = *pX;
 	partition_t *X_prime;
 	list_head   tmp;
@@ -1330,7 +1345,8 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) {
  *
  * @return non-zero if the i'th input of the given Phi node is live
  */
-static int is_live_input(ir_node *phi, int i) {
+static int is_live_input(ir_node *phi, int i)
+{
 	if (i >= 0) {
 		ir_node        *block = get_nodes_block(phi);
 		ir_node        *pred  = get_Block_cfgpred(block, i);
@@ -1345,7 +1361,8 @@ static int is_live_input(ir_node *phi, int i) {
 /**
  * Return non-zero if a type is a constant.
  */
-static int is_constant_type(lattice_elem_t type) {
+static int is_constant_type(lattice_elem_t type)
+{
 	if (type.tv != tarval_bottom && type.tv != tarval_top)
 		return 1;
 	return 0;
@@ -1357,7 +1374,8 @@ static int is_constant_type(lattice_elem_t type) {
  *
  * @param type  the type to check
  */
-static int type_is_neither_top_nor_const(const lattice_elem_t type) {
+static int type_is_neither_top_nor_const(const lattice_elem_t type)
+{
 	if (is_tarval(type.tv)) {
 		if (type.tv == tarval_top)
 			return 0;
@@ -1377,7 +1395,8 @@ static int type_is_neither_top_nor_const(const lattice_elem_t type) {
  * @param idx   the index of the def_use edge to evaluate
  * @param env   the environment
  */
-static void collect_touched(list_head *list, int idx, environment_t *env) {
+static void collect_touched(list_head *list, int idx, environment_t *env)
+{
 	node_t  *x, *y;
 	int     end_idx = env->end_idx;
 
@@ -1421,7 +1440,7 @@ static void collect_touched(list_head *list, int idx, environment_t *env) {
 				continue;
 
 			if (is_constant_type(y->type)) {
-				ir_opcode code = get_irn_opcode(succ);
+				unsigned  code = get_irn_opcode(succ);
 				if (code == iro_Sub || code == iro_Cmp)
 					add_to_cprop(y, env);
 			}
@@ -1439,13 +1458,11 @@ static void collect_touched(list_head *list, int idx, environment_t *env) {
 /**
  * Collect commutative nodes to the touched list.
  *
- * @param X     the partition of the list
  * @param list  the list which contains the nodes that must be evaluated
  * @param env   the environment
  */
-static void collect_commutative_touched(partition_t *X, list_head *list, environment_t *env) {
-	int     first      = 1;
-	int     both_input = 0;
+static void collect_commutative_touched(list_head *list, environment_t *env)
+{
 	node_t  *x, *y;
 
 	list_for_each_entry(node_t, x, list, node_list) {
@@ -1476,7 +1493,7 @@ static void collect_commutative_touched(partition_t *X, list_head *list, environ
 
 			y = get_irn_node(succ);
 			if (is_constant_type(y->type)) {
-				ir_opcode code = get_irn_opcode(succ);
+				unsigned code = get_irn_opcode(succ);
 				if (code == iro_Eor)
 					add_to_cprop(y, env);
 			}
@@ -1484,21 +1501,7 @@ static void collect_commutative_touched(partition_t *X, list_head *list, environ
 			/* Partitions of constants should not be split simply because their Nodes have unequal
 			   functions or incongruent inputs. */
 			if (type_is_neither_top_nor_const(y->type)) {
-				int    other_idx = edge->pos ^ 1;
-				node_t *other    = get_irn_node(get_irn_n(succ, other_idx));
-				int    equal     = X == other->part;
-
-				/*
-				 * Note: op(a, a) is NOT congruent to op(a, b).
-				 * So, either all touch nodes must have both inputs congruent,
-				 * or not. We decide this by the first occurred node.
-				 */
-				if (first) {
-					first      = 0;
-					both_input = equal;
-				}
-				if (both_input == equal)
-					add_to_touched(y, env);
+				add_to_touched(y, env);
 			}
 		}
 	}
@@ -1509,7 +1512,8 @@ static void collect_commutative_touched(partition_t *X, list_head *list, environ
  *
  * @param env  the environment
  */
-static void cause_splits(environment_t *env) {
+static void cause_splits(environment_t *env)
+{
 	partition_t *X, *Z, *N;
 	int         idx;
 
@@ -1526,13 +1530,16 @@ static void cause_splits(environment_t *env) {
 		/* empty the touched set: already done, just clear the list */
 		env->touched = NULL;
 
-		collect_commutative_touched(X, &X->Leader, env);
-		collect_commutative_touched(X, &X->Follower, env);
+		collect_commutative_touched(&X->Leader, env);
+		collect_commutative_touched(&X->Follower, env);
 
 		for (Z = env->touched; Z != NULL; Z = N) {
-			node_t   *e;
-			node_t   *touched  = Z->touched;
-			unsigned n_touched = Z->n_touched;
+			node_t   *e, *n;
+			node_t   *touched     = Z->touched;
+			node_t   *touched_aa  = NULL;
+			node_t   *touched_ab  = NULL;
+			unsigned n_touched_aa = 0;
+			unsigned n_touched_ab = 0;
 
 			assert(Z->touched != NULL);
 
@@ -1543,18 +1550,45 @@ static void cause_splits(environment_t *env) {
 			Z->on_touched = 0;
 
 			/* Empty local Z.touched. */
-			for (e = touched; e != NULL; e = e->next) {
+			for (e = touched; e != NULL; e = n) {
+				node_t *left  = get_irn_node(get_irn_n(e->node, 0));
+				node_t *right = get_irn_node(get_irn_n(e->node, 1));
+
 				assert(e->is_follower == 0);
 				e->on_touched = 0;
+				n = e->next;
+
+				/*
+				 * Note: op(a, a) is NOT congruent to op(a, b).
+				 * So, we must split the touched list.
+				 */
+				if (left->part == right->part) {
+					e->next = touched_aa;
+					touched_aa = e;
+					++n_touched_aa;
+				} else {
+					e->next = touched_ab;
+					touched_ab = e;
+					++n_touched_ab;
+				}
 			}
+			assert(n_touched_aa + n_touched_ab == Z->n_touched);
 			Z->touched   = NULL;
 			Z->n_touched = 0;
 
-			if (0 < n_touched && n_touched < Z->n_leader) {
-				DB((dbg, LEVEL_2, "Split part%d by touched\n", Z->nr));
-				split(&Z, touched, env);
+			if (0 < n_touched_aa && n_touched_aa < Z->n_leader) {
+				partition_t *Z_prime = Z;
+				DB((dbg, LEVEL_2, "Split part%d by touched_aa\n", Z_prime->nr));
+				split(&Z_prime, touched_aa, env);
 			} else
-				assert(n_touched <= Z->n_leader);
+				assert(n_touched_aa <= Z->n_leader);
+
+			if (0 < n_touched_ab && n_touched_ab < Z->n_leader) {
+				partition_t *Z_prime = Z;
+				DB((dbg, LEVEL_2, "Split part%d by touched_ab\n", Z_prime->nr));
+				split(&Z_prime, touched_ab, env);
+			} else
+				assert(n_touched_ab <= Z->n_leader);
 		}
 	}
 
@@ -1608,7 +1642,8 @@ static void cause_splits(environment_t *env) {
  * @return *P
  */
 static partition_t *split_by_what(partition_t *X, what_func What,
-                                  partition_t **P, environment_t *env) {
+                                  partition_t **P, environment_t *env)
+{
 	node_t          *x, *S;
 	listmap_t       map;
 	listmap_entry_t *iter;
@@ -1654,60 +1689,26 @@ static partition_t *split_by_what(partition_t *X, what_func What,
 }  /* split_by_what */
 
 /** lambda n.(n.type) */
-static void *lambda_type(const node_t *node, environment_t *env) {
+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) {
+static void *lambda_opcode(const node_t *node, environment_t *env)
+{
 	opcode_key_t key, *entry;
-	ir_node      *irn = node->node;
-
-	key.code   = get_irn_opcode(irn);
-	key.mode   = get_irn_mode(irn);
-	key.arity  = get_irn_arity(irn);
-	key.u.proj = 0;
-	key.u.ent  = NULL;
 
-	switch (get_irn_opcode(irn)) {
-	case iro_Proj:
-		key.u.proj = get_Proj_proj(irn);
-		break;
-	case iro_Sel:
-		key.u.ent = get_Sel_entity(irn);
-		break;
-	case iro_Conv:
-		key.u.intVal = get_Conv_strict(irn);
-		break;
-	case iro_Div:
-		key.u.intVal = get_Div_no_remainder(irn);
-		break;
-	case iro_Block:
-		/*
-		 * Some ugliness here: Two Blocks having the same
-		 * IJmp predecessor would be congruent, which of course is wrong.
-		 * We fix it by never letting blocks be congruent
-		 * which cannot be detected by combo either.
-		 */
-		key.u.block = irn;
-		break;
-	case iro_Load:
-		key.mode = get_Load_mode(irn);
-		break;
-	case iro_Builtin:
-		key.u.intVal = get_Builtin_kind(irn);
-		break;
-	default:
-		break;
-	}
+	key.irn = node->node;
 
-	entry = set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
+	entry = (opcode_key_t*)set_insert(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) {
+static void *lambda_partition(const node_t *node, environment_t *env)
+{
 	ir_node *skipped = skip_Proj(node->node);
 	ir_node *pred;
 	node_t  *p;
@@ -1735,7 +1736,8 @@ static void *lambda_partition(const node_t *node, environment_t *env) {
 }  /* lambda_partition */
 
 /** lambda n.(n[i].partition) for commutative nodes */
-static void *lambda_commutative_partition(const node_t *node, environment_t *env) {
+static void *lambda_commutative_partition(const node_t *node, environment_t *env)
+{
 	ir_node     *irn     = node->node;
 	ir_node     *skipped = skip_Proj(irn);
 	ir_node     *pred, *left, *right;
@@ -1790,7 +1792,8 @@ static void *lambda_commutative_partition(const node_t *node, environment_t *env
  * Returns true if a type is a constant (and NOT Top
  * or Bottom).
  */
-static int is_con(const lattice_elem_t type) {
+static int is_con(const lattice_elem_t type)
+{
 	/* be conservative */
 	if (is_tarval(type.tv))
 		return tarval_is_constant(type.tv);
@@ -1803,14 +1806,15 @@ static int is_con(const lattice_elem_t type) {
  * @param X    the partition to split
  * @param env  the environment
  */
-static void split_by(partition_t *X, environment_t *env) {
+static void split_by(partition_t *X, environment_t *env)
+{
 	partition_t *I, *P = NULL;
 	int         input;
 
 	dump_partition("split_by", X);
 
 	if (X->n_leader == 1) {
-		/* we have only one leader, no need to split, just check it's type */
+		/* we have only one leader, no need to split, just check its type */
 		node_t *x = get_first_node(X);
 		X->type_is_T_or_C = x->type.tv == tarval_top || is_con(x->type);
 		return;
@@ -1892,7 +1896,8 @@ static void split_by(partition_t *X, environment_t *env) {
  *
  * @param node  the node
  */
-static void default_compute(node_t *node) {
+static void default_compute(node_t *node)
+{
 	int     i;
 	ir_node *irn = node->node;
 
@@ -1918,7 +1923,8 @@ static void default_compute(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Block(node_t *node) {
+static void compute_Block(node_t *node)
+{
 	int     i;
 	ir_node *block = node->node;
 
@@ -1945,7 +1951,8 @@ static void compute_Block(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Bad(node_t *node) {
+static void compute_Bad(node_t *node)
+{
 	/* Bad nodes ALWAYS compute Top */
 	node->type.tv = tarval_top;
 }  /* compute_Bad */
@@ -1955,7 +1962,8 @@ static void compute_Bad(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Unknown(node_t *node) {
+static void compute_Unknown(node_t *node)
+{
 	/* While Unknown nodes should compute Top this is dangerous:
 	 * a Top input to a Cond would lead to BOTH control flows unreachable.
 	 * While this is correct in the given semantics, it would destroy the Firm
@@ -1964,7 +1972,7 @@ static void compute_Unknown(node_t *node) {
 	 * It would be safe to compute Top IF it can be assured, that only Cmp
 	 * nodes are inputs to Conds. We check that first.
 	 * This is the way Frontends typically build Firm, but some optimizations
-	 * (cond_eval for instance) might replace them by Phib's...
+	 * (jump threading for instance) might replace them by Phib's...
 	 */
 	node->type.tv = tarval_UNKNOWN;
 }  /* compute_Unknown */
@@ -1974,7 +1982,8 @@ static void compute_Unknown(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Jmp(node_t *node) {
+static void compute_Jmp(node_t *node)
+{
 	node_t *block = get_irn_node(get_nodes_block(node->node));
 
 	node->type = block->type;
@@ -1985,7 +1994,8 @@ static void compute_Jmp(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Return(node_t *node) {
+static void compute_Return(node_t *node)
+{
 	/* The Return node is NOT dead if it is in a reachable block.
 	 * This is already checked in compute(). so we can return
 	 * Reachable here. */
@@ -1997,7 +2007,8 @@ static void compute_Return(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_End(node_t *node) {
+static void compute_End(node_t *node)
+{
 	/* the End node is NOT dead of course */
 	node->type.tv = tarval_reachable;
 }  /* compute_End */
@@ -2007,7 +2018,8 @@ static void compute_End(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Call(node_t *node) {
+static void compute_Call(node_t *node)
+{
 	/*
 	 * A Call computes always bottom, even if it has Unknown
 	 * predecessors.
@@ -2020,7 +2032,8 @@ static void compute_Call(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_SymConst(node_t *node) {
+static void compute_SymConst(node_t *node)
+{
 	ir_node *irn = node->node;
 	node_t  *block = get_irn_node(get_nodes_block(irn));
 
@@ -2030,7 +2043,6 @@ static void compute_SymConst(node_t *node) {
 	}
 	switch (get_SymConst_kind(irn)) {
 	case symconst_addr_ent:
-	/* case symconst_addr_name: cannot handle this yet */
 		node->type.sym = get_SymConst_symbol(irn);
 		break;
 	default:
@@ -2043,7 +2055,8 @@ static void compute_SymConst(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Phi(node_t *node) {
+static void compute_Phi(node_t *node)
+{
 	int            i;
 	ir_node        *phi = node->node;
 	lattice_elem_t type;
@@ -2090,7 +2103,8 @@ static void compute_Phi(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Add(node_t *node) {
+static void compute_Add(node_t *node)
+{
 	ir_node        *sub = node->node;
 	node_t         *l   = get_irn_node(get_Add_left(sub));
 	node_t         *r   = get_irn_node(get_Add_right(sub));
@@ -2131,13 +2145,14 @@ static void compute_Add(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Sub(node_t *node) {
+static void compute_Sub(node_t *node)
+{
 	ir_node        *sub = node->node;
 	node_t         *l   = get_irn_node(get_Sub_left(sub));
 	node_t         *r   = get_irn_node(get_Sub_right(sub));
 	lattice_elem_t a    = l->type;
 	lattice_elem_t b    = r->type;
-	tarval         *tv;
+	ir_tarval      *tv;
 
 	if (a.tv == tarval_top || b.tv == tarval_top) {
 		node->type.tv = tarval_top;
@@ -2177,13 +2192,14 @@ static void compute_Sub(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Eor(node_t *node) {
+static void compute_Eor(node_t *node)
+{
 	ir_node        *eor = node->node;
 	node_t         *l   = get_irn_node(get_Eor_left(eor));
 	node_t         *r   = get_irn_node(get_Eor_right(eor));
 	lattice_elem_t a    = l->type;
 	lattice_elem_t b    = r->type;
-	tarval         *tv;
+	ir_tarval      *tv;
 
 	if (a.tv == tarval_top || b.tv == tarval_top) {
 		node->type.tv = tarval_top;
@@ -2218,64 +2234,43 @@ static void compute_Eor(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Cmp(node_t *node) {
-	ir_node        *cmp  = node->node;
-	node_t         *l    = get_irn_node(get_Cmp_left(cmp));
-	node_t         *r    = get_irn_node(get_Cmp_right(cmp));
-	lattice_elem_t a     = l->type;
-	lattice_elem_t b     = r->type;
-
-	if (a.tv == tarval_top || b.tv == tarval_top) {
-		node->type.tv = tarval_top;
-	} else if (r->part == l->part) {
-		/* both nodes congruent, we can probably do something */
-		node->type.tv = tarval_b_true;
-	} else if (is_con(a) && is_con(b)) {
-		/* both nodes are constants, we can probably do something */
-		node->type.tv = tarval_b_true;
-	} else {
-		node->type.tv = tarval_bottom;
-	}
-}  /* compute_Cmp */
-
-/**
- * (Re-)compute the type for a Proj(Cmp).
- *
- * @param node  the node
- * @param cond  the predecessor Cmp node
- */
-static void compute_Proj_Cmp(node_t *node, ir_node *cmp) {
-	ir_node        *proj = node->node;
-	node_t         *l    = get_irn_node(get_Cmp_left(cmp));
-	node_t         *r    = get_irn_node(get_Cmp_right(cmp));
-	lattice_elem_t a     = l->type;
-	lattice_elem_t b     = r->type;
-	pn_Cmp         pnc   = get_Proj_proj(proj);
-	tarval         *tv;
+static void compute_Cmp(node_t *node)
+{
+	ir_node        *cmp     = node->node;
+	node_t         *l       = get_irn_node(get_Cmp_left(cmp));
+	node_t         *r       = get_irn_node(get_Cmp_right(cmp));
+	lattice_elem_t a        = l->type;
+	lattice_elem_t b        = r->type;
+	ir_relation    relation = get_Cmp_relation(cmp);
+	ir_tarval      *tv;
 
 	if (a.tv == tarval_top || b.tv == tarval_top) {
 		node->type.tv = tarval_undefined;
 	} else if (is_con(a) && is_con(b)) {
 		default_compute(node);
-	} else if (r->part == l->part &&
-	           (!mode_is_float(get_irn_mode(l->node)) || pnc == pn_Cmp_Lt || pnc == pn_Cmp_Gt)) {
-		/*
-		 * BEWARE: a == a is NOT always True for floating Point values, as
-		 * NaN != NaN is defined, so we must check this here.
-		 */
-		tv = pnc & pn_Cmp_Eq ? tarval_b_true: tarval_b_false;
 
-		/* if the node was ONCE evaluated by all constants, but now
+	/*
+	 * BEWARE: a == a is NOT always True for floating Point values, as
+	 * NaN != NaN is defined, so we must check this here.
+	 * (while for some pnc we could still optimize we have to stay
+	 *  consistent with compute_Cmp, so don't do anything for floats)
+	 */
+	} else if (r->part == l->part && !mode_is_float(get_irn_mode(l->node))) {
+		tv = relation & ir_relation_equal ? tarval_b_true : tarval_b_false;
+
+		/* if the node was ONCE evaluated to a constant, but now
 		   this breaks AND we get from the argument partitions a different
-		   result, switch to bottom.
+		   result, ensure monotony by fall to bottom.
 		   This happens because initially all nodes are in the same partition ... */
-		if (node->type.tv != tv)
+		if (node->type.tv == tarval_bottom)
+			tv = tarval_bottom;
+		else if (node->type.tv != tv && is_constant_type(node->type))
 			tv = tarval_bottom;
 		node->type.tv = tv;
 	} else {
 		node->type.tv = tarval_bottom;
 	}
-}  /* compute_Proj_Cmp */
+}
 
 /**
  * (Re-)compute the type for a Proj(Cond).
@@ -2283,7 +2278,8 @@ static void compute_Proj_Cmp(node_t *node, ir_node *cmp) {
  * @param node  the node
  * @param cond  the predecessor Cond node
  */
-static void compute_Proj_Cond(node_t *node, ir_node *cond) {
+static void compute_Proj_Cond(node_t *node, ir_node *cond)
+{
 	ir_node *proj     = node->node;
 	long    pnc       = get_Proj_proj(proj);
 	ir_node *sel      = get_Cond_selector(cond);
@@ -2422,7 +2418,8 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) {
  *
  * @param node  the node
  */
-static void compute_Proj(node_t *node) {
+static void compute_Proj(node_t *node)
+{
 	ir_node *proj = node->node;
 	ir_mode *mode = get_irn_mode(proj);
 	node_t  *block = get_irn_node(get_nodes_block(skip_Proj(proj)));
@@ -2443,28 +2440,23 @@ static void compute_Proj(node_t *node) {
 		/* mode M is always bottom */
 		node->type.tv = tarval_bottom;
 		return;
+	} else if (mode == mode_X) {
+		/* handle mode_X nodes */
+		switch (get_irn_opcode(pred)) {
+		case iro_Start:
+			/* the Proj_X from the Start is always reachable.
+			   However this is already handled at the top. */
+			node->type.tv = tarval_reachable;
+			return;
+		case iro_Cond:
+			compute_Proj_Cond(node, pred);
+			return;
+		default:
+			break;
+		}
 	}
-	if (mode != mode_X) {
-		if (is_Cmp(pred))
-			compute_Proj_Cmp(node, pred);
-		else
-			default_compute(node);
-		return;
-	}
-	/* handle mode_X nodes */
 
-	switch (get_irn_opcode(pred)) {
-	case iro_Start:
-		/* the Proj_X from the Start is always reachable.
-		   However this is already handled at the top. */
-		node->type.tv = tarval_reachable;
-		break;
-	case iro_Cond:
-		compute_Proj_Cond(node, pred);
-		break;
-	default:
-		default_compute(node);
-	}
+	default_compute(node);
 }  /* compute_Proj */
 
 /**
@@ -2472,11 +2464,12 @@ static void compute_Proj(node_t *node) {
  *
  * @param node  the node
  */
-static void compute_Confirm(node_t *node) {
+static void compute_Confirm(node_t *node)
+{
 	ir_node *confirm = node->node;
 	node_t  *pred = get_irn_node(get_Confirm_value(confirm));
 
-	if (get_Confirm_cmp(confirm) == pn_Cmp_Eq) {
+	if (get_Confirm_relation(confirm) == ir_relation_equal) {
 		node_t *bound = get_irn_node(get_Confirm_bound(confirm));
 
 		if (is_con(bound->type)) {
@@ -2494,7 +2487,8 @@ static void compute_Confirm(node_t *node) {
  *
  * @param node  the node
  */
-static void compute(node_t *node) {
+static void compute(node_t *node)
+{
 	ir_node *irn = node->node;
 	compute_func func;
 
@@ -2509,7 +2503,7 @@ static void compute(node_t *node) {
 		return;
 #endif
 
-	if (is_no_Block(irn)) {
+	if (!is_Block(irn)) {
 		/* for pinned nodes, check its control input */
 		if (get_irn_pinned(skip_Proj(irn)) == op_pin_state_pinned) {
 			node_t *block = get_irn_node(get_nodes_block(irn));
@@ -2527,7 +2521,7 @@ static void compute(node_t *node) {
 }  /* compute */
 
 /*
- * Identity functions: Note that one might thing that identity() is just a
+ * Identity functions: Note that one might think that identity() is just a
  * synonym for equivalent_node(). While this is true, we cannot use it for the algorithm
  * here, because it expects that the identity node is one of the inputs, which is NOT
  * always true for equivalent_node() which can handle (and does sometimes) DAGs.
@@ -2537,7 +2531,8 @@ static void compute(node_t *node) {
 /**
  * Calculates the Identity for Phi nodes
  */
-static node_t *identity_Phi(node_t *node) {
+static node_t *identity_Phi(node_t *node)
+{
 	ir_node *phi    = node->node;
 	ir_node *block  = get_nodes_block(phi);
 	node_t  *n_part = NULL;
@@ -2566,12 +2561,13 @@ static node_t *identity_Phi(node_t *node) {
 /**
  * Calculates the Identity for commutative 0 neutral nodes.
  */
-static node_t *identity_comm_zero_binop(node_t *node) {
-	ir_node *op   = node->node;
-	node_t  *a    = get_irn_node(get_binop_left(op));
-	node_t  *b    = get_irn_node(get_binop_right(op));
-	ir_mode *mode = get_irn_mode(op);
-	tarval  *zero;
+static node_t *identity_comm_zero_binop(node_t *node)
+{
+	ir_node   *op   = node->node;
+	node_t    *a    = get_irn_node(get_binop_left(op));
+	node_t    *b    = get_irn_node(get_binop_right(op));
+	ir_mode   *mode = get_irn_mode(op);
+	ir_tarval *zero;
 
 	/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
 	if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
@@ -2590,11 +2586,12 @@ static node_t *identity_comm_zero_binop(node_t *node) {
 /**
  * Calculates the Identity for Shift nodes.
  */
-static node_t *identity_shift(node_t *node) {
-	ir_node *op   = node->node;
-	node_t  *b    = get_irn_node(get_binop_right(op));
-	ir_mode *mode = get_irn_mode(b->node);
-	tarval  *zero;
+static node_t *identity_shift(node_t *node)
+{
+	ir_node   *op   = node->node;
+	node_t    *b    = get_irn_node(get_binop_right(op));
+	ir_mode   *mode = get_irn_mode(b->node);
+	ir_tarval *zero;
 
 	/* node: no input should be tarval_top, else the binop would be also
 	 * Top and not being split. */
@@ -2607,12 +2604,13 @@ static node_t *identity_shift(node_t *node) {
 /**
  * Calculates the Identity for Mul nodes.
  */
-static node_t *identity_Mul(node_t *node) {
-	ir_node *op   = node->node;
-	node_t  *a    = get_irn_node(get_Mul_left(op));
-	node_t  *b    = get_irn_node(get_Mul_right(op));
-	ir_mode *mode = get_irn_mode(op);
-	tarval  *one;
+static node_t *identity_Mul(node_t *node)
+{
+	ir_node   *op   = node->node;
+	node_t    *a    = get_irn_node(get_Mul_left(op));
+	node_t    *b    = get_irn_node(get_Mul_right(op));
+	ir_mode   *mode = get_irn_mode(op);
+	ir_tarval *one;
 
 	/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
 	if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
@@ -2631,7 +2629,8 @@ static node_t *identity_Mul(node_t *node) {
 /**
  * Calculates the Identity for Sub nodes.
  */
-static node_t *identity_Sub(node_t *node) {
+static node_t *identity_Sub(node_t *node)
+{
 	ir_node *sub  = node->node;
 	node_t  *b    = get_irn_node(get_Sub_right(sub));
 	ir_mode *mode = get_irn_mode(sub);
@@ -2650,11 +2649,12 @@ static node_t *identity_Sub(node_t *node) {
 /**
  * Calculates the Identity for And nodes.
  */
-static node_t *identity_And(node_t *node) {
-	ir_node *and = node->node;
-	node_t  *a   = get_irn_node(get_And_left(and));
-	node_t  *b   = get_irn_node(get_And_right(and));
-	tarval  *neutral = get_mode_all_one(get_irn_mode(and));
+static node_t *identity_And(node_t *node)
+{
+	ir_node   *andnode = node->node;
+	node_t    *a       = get_irn_node(get_And_left(andnode));
+	node_t    *b       = get_irn_node(get_And_right(andnode));
+	ir_tarval *neutral = get_mode_all_one(get_irn_mode(andnode));
 
 	/* node: no input should be tarval_top, else the And would be also
 	 * Top and not being split. */
@@ -2668,7 +2668,8 @@ static node_t *identity_And(node_t *node) {
 /**
  * Calculates the Identity for Confirm nodes.
  */
-static node_t *identity_Confirm(node_t *node) {
+static node_t *identity_Confirm(node_t *node)
+{
 	ir_node *confirm = node->node;
 
 	/* a Confirm is always a Copy */
@@ -2678,7 +2679,8 @@ static node_t *identity_Confirm(node_t *node) {
 /**
  * Calculates the Identity for Mux nodes.
  */
-static node_t *identity_Mux(node_t *node) {
+static node_t *identity_Mux(node_t *node)
+{
 	ir_node *mux = node->node;
 	node_t  *t   = get_irn_node(get_Mux_true(mux));
 	node_t  *f   = get_irn_node(get_Mux_false(mux));
@@ -2703,7 +2705,8 @@ static node_t *identity_Mux(node_t *node) {
 /**
  * Calculates the Identity for nodes.
  */
-static node_t *identity(node_t *node) {
+static node_t *identity(node_t *node)
+{
 	ir_node *irn = node->node;
 
 	switch (get_irn_opcode(irn)) {
@@ -2737,7 +2740,8 @@ static node_t *identity(node_t *node) {
  * Node follower is a (new) follower of leader, segregate Leader
  * out edges.
  */
-static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader) {
+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);
 
@@ -2763,7 +2767,8 @@ static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader) {
  *
  * @param follower  the follower IR node
  */
-static void segregate_def_use_chain(const ir_node *follower) {
+static void segregate_def_use_chain(const ir_node *follower)
+{
 	int i;
 
 	for (i = get_irn_arity(follower) - 1; i >= 0; --i) {
@@ -2778,7 +2783,8 @@ static void segregate_def_use_chain(const ir_node *follower) {
  *
  * @param env  the environment
  */
-static void propagate(environment_t *env) {
+static void propagate(environment_t *env)
+{
 	partition_t    *X, *Y;
 	node_t         *x;
 	lattice_elem_t old_type;
@@ -2916,7 +2922,8 @@ static void propagate(environment_t *env) {
  *
  * @param irn  the node
  */
-static ir_node *get_leader(node_t *node) {
+static ir_node *get_leader(node_t *node)
+{
 	partition_t *part = node->part;
 
 	if (part->n_leader > 1 || node->is_follower) {
@@ -2934,7 +2941,8 @@ static ir_node *get_leader(node_t *node) {
 /**
  * Returns non-zero if a mode_T node has only one reachable output.
  */
-static int only_one_reachable_proj(ir_node *n) {
+static int only_one_reachable_proj(ir_node *n)
+{
 	int i, k = 0;
 
 	for (i = get_irn_n_outs(n) - 1; i >= 0; --i) {
@@ -2961,7 +2969,8 @@ static int only_one_reachable_proj(ir_node *n) {
  * @param pred   the control flow exit
  * @param block  the destination block
  */
-static int can_exchange(ir_node *pred, ir_node *block) {
+static int can_exchange(ir_node *pred, ir_node *block)
+{
 	if (is_Start(pred) || has_Block_entity(block))
 		return 0;
 	else if (is_Jmp(pred))
@@ -2978,8 +2987,9 @@ static int can_exchange(ir_node *pred, ir_node *block) {
  * Block Post-Walker, apply the analysis results on control flow by
  * shortening Phi's and Block inputs.
  */
-static void apply_cf(ir_node *block, void *ctx) {
-	environment_t *env = ctx;
+static void apply_cf(ir_node *block, void *ctx)
+{
+	environment_t *env = (environment_t*)ctx;
 	node_t        *node = get_irn_node(block);
 	int           i, j, k, n;
 	ir_node       **ins, **in_X;
@@ -2994,18 +3004,21 @@ static void apply_cf(ir_node *block, void *ctx) {
 			ir_node *pred = get_Block_cfgpred(block, i);
 
 			if (! is_Bad(pred)) {
-				node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-				if (pred_bl->flagged == 0) {
-					pred_bl->flagged = 3;
-
-					if (pred_bl->type.tv == tarval_reachable) {
-						/*
-						 * We will remove an edge from block to its pred.
-						 * This might leave the pred block as an endless loop
-						 */
-						if (! is_backedge(block, i))
-							keep_alive(pred_bl->node);
+				ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+				if (!is_Bad(pred_block)) {
+					node_t *pred_bl = get_irn_node(pred_block);
+
+					if (pred_bl->flagged == 0) {
+						pred_bl->flagged = 3;
+
+						if (pred_bl->type.tv == tarval_reachable) {
+							/*
+							 * We will remove an edge from block to its pred.
+							 * This might leave the pred block as an endless loop
+							 */
+							if (! is_backedge(block, i))
+								keep_alive(pred_bl->node);
+						}
 					}
 				}
 			}
@@ -3015,7 +3028,9 @@ static void apply_cf(ir_node *block, void *ctx) {
 		   finds out the opposite :-) */
 		if (block != get_irg_end_block(current_ir_graph)) {
 			/* mark dead blocks */
-			set_Block_dead(block);
+			//set_Block_dead(block);
+			//ir_graph *irg = get_irn_irg(block);
+			//exchange(block, get_irg_bad(irg));
 			DB((dbg, LEVEL_1, "Removing dead %+F\n", block));
 		} else {
 			/* the endblock is unreachable */
@@ -3050,18 +3065,21 @@ static void apply_cf(ir_node *block, void *ctx) {
 		} else {
 			DB((dbg, LEVEL_1, "Removing dead input %d from %+F (%+F)\n", i, block, pred));
 			if (! is_Bad(pred)) {
-				node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-				if (pred_bl->flagged == 0) {
-					pred_bl->flagged = 3;
-
-					if (pred_bl->type.tv == tarval_reachable) {
-						/*
-						 * We will remove an edge from block to its pred.
-						 * This might leave the pred block as an endless loop
-						 */
-						if (! is_backedge(block, i))
-							keep_alive(pred_bl->node);
+				ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+				if (!is_Bad(pred_block)) {
+					node_t *pred_bl = get_irn_node(pred_block);
+
+					if (!is_Bad(pred_bl->node) && pred_bl->flagged == 0) {
+						pred_bl->flagged = 3;
+
+						if (pred_bl->type.tv == tarval_reachable) {
+							/*
+							 * We will remove an edge from block to its pred.
+							 * This might leave the pred block as an endless loop
+							 */
+							if (! is_backedge(block, i))
+								keep_alive(pred_bl->node);
+						}
 					}
 				}
 			}
@@ -3078,8 +3096,8 @@ static void apply_cf(ir_node *block, void *ctx) {
 		next = get_Phi_next(phi);
 		if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) {
 			/* this Phi is replaced by a constant */
-			tarval  *tv = node->type.tv;
-			ir_node *c  = new_Const(tv);
+			ir_tarval *tv = node->type.tv;
+			ir_node   *c  = new_r_Const(current_ir_graph, tv);
 
 			set_irn_node(c, node);
 			node->node = c;
@@ -3138,7 +3156,8 @@ static void apply_cf(ir_node *block, void *ctx) {
  * AddP(x, NULL) is a follower of x, but with different mode.
  * Fix it here.
  */
-static void exchange_leader(ir_node *irn, ir_node *leader) {
+static void exchange_leader(ir_node *irn, ir_node *leader)
+{
 	ir_mode *mode = get_irn_mode(irn);
 	if (mode != get_irn_mode(leader)) {
 		/* The conv is a no-op, so we are free to place it
@@ -3147,8 +3166,20 @@ static void exchange_leader(ir_node *irn, ir_node *leader) {
 		 * the number of Conv due to CSE. */
 		ir_node  *block = get_nodes_block(leader);
 		dbg_info *dbg   = get_irn_dbg_info(irn);
-
-		leader = new_rd_Conv(dbg, block, leader, mode);
+		ir_node  *nlead = new_rd_Conv(dbg, block, leader, mode);
+
+		if (nlead != leader) {
+			/* Note: this newly create irn has no node info because
+			 * it is created after the analysis. However, this node
+			 * replaces the node irn and should not be visited again,
+			 * so set its visited count to the count of irn.
+			 * Otherwise we might visited this node more than once if
+			 * irn had more than one user.
+			 */
+			set_irn_node(nlead, NULL);
+			set_irn_visited(nlead, get_irn_visited(irn));
+			leader = nlead;
+		}
 	}
 	exchange(irn, leader);
 }  /* exchange_leader */
@@ -3158,7 +3189,8 @@ static void exchange_leader(ir_node *irn, ir_node *leader) {
  * the Def-Use edges for this purpose, as they still
  * reflect the situation.
  */
-static int all_users_are_dead(const ir_node *irn) {
+static int all_users_are_dead(const ir_node *irn)
+{
 	int i, n = get_irn_n_outs(irn);
 
 	for (i = 1; i <= n; ++i) {
@@ -3184,8 +3216,9 @@ static int all_users_are_dead(const ir_node *irn) {
  * Walker: Find reachable mode_M nodes that have only
  * unreachable users. These nodes must be kept later.
  */
-static void find_kept_memory(ir_node *irn, void *ctx) {
-	environment_t *env = ctx;
+static void find_kept_memory(ir_node *irn, void *ctx)
+{
+	environment_t *env = (environment_t*)ctx;
 	node_t        *node, *block;
 
 	if (get_irn_mode(irn) != mode_M)
@@ -3209,8 +3242,9 @@ static void find_kept_memory(ir_node *irn, void *ctx) {
 /**
  * Post-Walker, apply the analysis results;
  */
-static void apply_result(ir_node *irn, void *ctx) {
-	environment_t *env = ctx;
+static void apply_result(ir_node *irn, void *ctx)
+{
+	environment_t *env = (environment_t*)ctx;
 	node_t        *node = get_irn_node(irn);
 
 	if (is_Block(irn) || is_End(irn) || is_Bad(irn)) {
@@ -3279,8 +3313,8 @@ static void apply_result(ir_node *irn, void *ctx) {
 						exchange(irn, jmp);
 						env->modified = 1;
 					} else {
-						node_t *sel = get_irn_node(get_Cond_selector(cond));
-						tarval *tv  = sel->type.tv;
+						node_t    *sel = get_irn_node(get_Cond_selector(cond));
+						ir_tarval *tv  = sel->type.tv;
 
 						if (is_tarval(tv) && tarval_is_constant(tv)) {
 							/* The selector is a constant, but more
@@ -3294,7 +3328,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 		} else {
 			/* normal data node */
 			if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) {
-				tarval *tv = node->type.tv;
+				ir_tarval *tv = node->type.tv;
 
 				/*
 				 * Beware: never replace mode_T nodes by constants. Currently we must mark
@@ -3302,7 +3336,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 				 */
 				if (! is_Const(irn) && get_irn_mode(irn) != mode_T) {
 					/* can be replaced by a constant */
-					ir_node *c = new_Const(tv);
+					ir_node *c = new_r_Const(current_ir_graph, tv);
 					set_irn_node(c, node);
 					node->node = c;
 					DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, c));
@@ -3364,22 +3398,32 @@ static void apply_result(ir_node *irn, void *ctx) {
 /**
  * Fix the keep-alives by deleting unreachable ones.
  */
-static void apply_end(ir_node *end, environment_t *env) {
+static void apply_end(ir_node *end, environment_t *env)
+{
 	int i, j,  n = get_End_n_keepalives(end);
-	ir_node **in;
+	ir_node **in = NULL;
 
 	if (n > 0)
 		NEW_ARR_A(ir_node *, in, n);
 
 	/* fix the keep alive */
 	for (i = j = 0; i < n; i++) {
-		ir_node *ka   = get_End_keepalive(end, i);
-		node_t  *node = get_irn_node(ka);
+		ir_node *ka = get_End_keepalive(end, i);
+		ir_node *block;
+		node_t  *node;
 
-		if (! is_Block(ka))
-			node = get_irn_node(get_nodes_block(ka));
+		if (is_Bad(ka))
+			continue;
+		if (!is_Block(ka)) {
+			block = get_nodes_block(ka);
+			if (is_Bad(block))
+				continue;
+		} else {
+			block = ka;
+		}
 
-		if (node->type.tv != tarval_unreachable && !is_Bad(ka))
+		node = get_irn_node(block);
+		if (node->type.tv != tarval_unreachable)
 			in[j++] = ka;
 	}
 	if (j != n) {
@@ -3393,11 +3437,12 @@ static void apply_end(ir_node *end, environment_t *env) {
 /**
  * sets the generic functions to compute.
  */
-static void set_compute_functions(void) {
-	int i;
+static void set_compute_functions(void)
+{
+	size_t i, n;
 
 	/* set the default compute function */
-	for (i = get_irp_n_opcodes() - 1; i >= 0; --i) {
+	for (i = 0, n = get_irp_n_opcodes(); i < n; ++i) {
 		ir_op *op = get_irp_opcode(i);
 		op->ops.generic = (op_func)default_compute;
 	}
@@ -3423,9 +3468,11 @@ static void set_compute_functions(void) {
 /**
  * Add memory keeps.
  */
-static void add_memory_keeps(ir_node **kept_memory, int len) {
+static void add_memory_keeps(ir_node **kept_memory, size_t len)
+{
 	ir_node      *end = get_irg_end(current_ir_graph);
 	int          i;
+	size_t       idx;
 	ir_nodeset_t set;
 
 	ir_nodeset_init(&set);
@@ -3434,8 +3481,8 @@ static void add_memory_keeps(ir_node **kept_memory, int len) {
 	for (i = get_End_n_keepalives(end) - 1; i >= 0; --i)
 		ir_nodeset_insert(&set, get_End_keepalive(end, i));
 
-	for (i = len - 1; i >= 0; --i) {
-		ir_node *ka = kept_memory[i];
+	for (idx = 0; idx < len; ++idx) {
+		ir_node *ka = kept_memory[idx];
 
 		if (! ir_nodeset_contains(&set, ka)) {
 			add_End_keepalive(end, ka);
@@ -3444,12 +3491,13 @@ static void add_memory_keeps(ir_node **kept_memory, int len) {
 	ir_nodeset_destroy(&set);
 }  /* add_memory_keeps */
 
-void combo(ir_graph *irg) {
+void combo(ir_graph *irg)
+{
 	environment_t env;
 	ir_node       *initial_bl;
 	node_t        *start;
 	ir_graph      *rem = current_ir_graph;
-	int           len;
+	size_t        len;
 
 	current_ir_graph = irg;
 
@@ -3467,7 +3515,6 @@ void combo(ir_graph *irg) {
 	env.dbg_list       = NULL;
 #endif
 	env.opcode2id_map  = new_set(cmp_opcode, iro_Last * 4);
-	env.type2id_map    = pmap_create();
 	env.kept_memory    = NEW_ARR_F(ir_node *, 0);
 	env.end_idx        = get_opt_global_cse() ? 0 : -1;
 	env.lambda_input   = 0;
@@ -3559,7 +3606,6 @@ void combo(ir_graph *irg) {
 	DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL));
 
 	DEL_ARR_F(env.kept_memory);
-	pmap_destroy(env.type2id_map);
 	del_set(env.opcode2id_map);
 	obstack_free(&env.obst, NULL);
 
@@ -3567,3 +3613,9 @@ void combo(ir_graph *irg) {
 	set_value_of_func(NULL);
 	current_ir_graph = rem;
 }  /* 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 */