X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Fircons.c;h=7de8333aed97346b725ed755cfc78239a278112c;hb=8f355cb9b3d20c10f71d1b1e17cbf59a51ced83b;hp=7cbd797d1db61d96e9f73b3f32ee860962de2136;hpb=5140ee36f4ce52068a12c828de9e17c202b64462;p=libfirm

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 7cbd797d1..7de8333ae 100644
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -245,14 +245,14 @@ new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
 
 	/* Don't assert that block matured: the use of this constructor is strongly
 	   restricted ... */
-	if ( get_Block_matured(block) )
-		assert( get_irn_arity(block) == arity );
+	if (get_Block_matured(block))
+		assert(get_irn_arity(block) == arity);
 
 	res = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
 
 	res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
 
-	for (i = arity-1; i >= 0; i--)
+	for (i = arity - 1; i >= 0; --i)
 		if (get_irn_op(in[i]) == op_Unknown) {
 			has_unknown = 1;
 			break;
@@ -382,6 +382,7 @@ NEW_BD_BINOP(Add)
 NEW_BD_BINOP(Sub)
 NEW_BD_UNOP(Minus)
 NEW_BD_BINOP(Mul)
+NEW_BD_BINOP(Mulh)
 NEW_BD_DIVOP(Quot)
 NEW_BD_DIVOP(DivMod)
 NEW_BD_DIVOP(Div)
@@ -530,7 +531,7 @@ new_bd_Store(dbg_info *db, ir_node *block,
 
 static ir_node *
 new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
-        ir_node *size, ir_type *alloc_type, where_alloc where) {
+        ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
 	ir_node  *in[2];
 	ir_node  *res;
 	ir_graph *irg = current_ir_graph;
@@ -548,7 +549,7 @@ new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
 
 static ir_node *
 new_bd_Free(dbg_info *db, ir_node *block, ir_node *store,
-        ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+        ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
 	ir_node  *in[3];
 	ir_node  *res;
 	ir_graph *irg = current_ir_graph;
@@ -591,18 +592,10 @@ new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
 }  /* new_bd_Sel */
 
 static ir_node *
-new_bd_SymConst_type(dbg_info *db, ir_node *block, symconst_symbol value,
-                     symconst_kind symkind, ir_type *tp) {
-	ir_node  *res;
-	ir_mode  *mode;
+new_bd_SymConst_type(dbg_info *db, ir_node *block, ir_mode *mode,
+                     symconst_symbol value,symconst_kind symkind, ir_type *tp) {
 	ir_graph *irg = current_ir_graph;
-
-	if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
-		mode = mode_P_data;   /* FIXME: can be mode_P_code */
-	else
-		mode = mode_Iu;
-
-	res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
+	ir_node  *res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
 
 	res->attr.symc.num = symkind;
 	res->attr.symc.sym = value;
@@ -1024,6 +1017,7 @@ NEW_RD_BINOP(Add)
 NEW_RD_BINOP(Sub)
 NEW_RD_UNOP(Minus)
 NEW_RD_BINOP(Mul)
+NEW_RD_BINOP(Mulh)
 NEW_RD_DIVOP(Quot)
 NEW_RD_DIVOP(DivMod)
 NEW_RD_DIVOP(Div)
@@ -1143,7 +1137,7 @@ new_rd_Store(dbg_info *db, ir_graph *irg, ir_node *block,
 
 ir_node *
 new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-             ir_node *size, ir_type *alloc_type, where_alloc where) {
+             ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
 	ir_node  *res;
 	ir_graph *rem = current_ir_graph;
 
@@ -1156,7 +1150,7 @@ new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
 
 ir_node *
 new_rd_Free(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-            ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+            ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
 	ir_node  *res;
 	ir_graph *rem = current_ir_graph;
 
@@ -1194,59 +1188,58 @@ new_rd_Sel(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node
 }  /* new_rd_Sel */
 
 ir_node *
-new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
-                     symconst_kind symkind, ir_type *tp) {
+new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode,
+                     symconst_symbol value, symconst_kind symkind, ir_type *tp) {
 	ir_node  *res;
 	ir_graph *rem = current_ir_graph;
 
 	current_ir_graph = irg;
-	res = new_bd_SymConst_type(db, block, value, symkind, tp);
+	res = new_bd_SymConst_type(db, block, mode, value, symkind, tp);
 	current_ir_graph = rem;
 
 	return res;
 }  /* new_rd_SymConst_type */
 
 ir_node *
-new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
-                symconst_kind symkind) {
-	ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
-	return res;
+new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode,
+                symconst_symbol value, symconst_kind symkind) {
+	return new_rd_SymConst_type(db, irg, block, mode, value, symkind, firm_unknown_type);
 }  /* new_rd_SymConst */
 
- ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
+ ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.entity_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_addr_ent, tp);
 }  /* new_rd_SymConst_addr_ent */
 
-ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.entity_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_ofs_ent, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_ofs_ent, tp);
 }  /* new_rd_SymConst_ofs_ent */
 
-ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ir_mode *mode, ident *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.ident_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_addr_name, tp);
 }  /* new_rd_SymConst_addr_name */
 
-ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.type_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_tag, tp);
 }  /* new_rd_SymConst_type_tag */
 
-ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.type_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_size, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_size, tp);
 }  /* new_rd_SymConst_size */
 
-ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
 	symconst_symbol sym;
 	sym.type_p = symbol;
-	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp);
+	return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_align, tp);
 }  /* new_rd_SymConst_align */
 
 ir_node *
@@ -1491,9 +1484,9 @@ ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
                           ir_mode *mode, tarval *con, ir_type *tp) {
 	return new_rd_Const_type(NULL, irg, block, mode, con, tp);
 }
-ir_node *new_r_SymConst(ir_graph *irg, ir_node *block,
+ir_node *new_r_SymConst(ir_graph *irg, ir_node *block, ir_mode *mode,
                         symconst_symbol value, symconst_kind symkind) {
-	return new_rd_SymConst(NULL, irg, block, value, symkind);
+	return new_rd_SymConst(NULL, irg, block, mode, value, symkind);
 }
 ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
                          ir_node *objptr, ir_entity *ent) {
@@ -1525,6 +1518,10 @@ ir_node *new_r_Mul(ir_graph *irg, ir_node *block,
                    ir_node *op1, ir_node *op2, ir_mode *mode) {
 	return new_rd_Mul(NULL, irg, block, op1, op2, mode);
 }
+ir_node *new_r_Mulh(ir_graph *irg, ir_node *block,
+                   ir_node *op1, ir_node *op2, ir_mode *mode) {
+	return new_rd_Mulh(NULL, irg, block, op1, op2, mode);
+}
 ir_node *new_r_Quot(ir_graph *irg, ir_node *block,
                     ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
 	return new_rd_Quot(NULL, irg, block, memop, op1, op2, mode, state);
@@ -1609,11 +1606,11 @@ ir_node *new_r_Store(ir_graph *irg, ir_node *block,
 	return new_rd_Store(NULL, irg, block, store, adr, val);
 }
 ir_node *new_r_Alloc(ir_graph *irg, ir_node *block, ir_node *store,
-                     ir_node *size, ir_type *alloc_type, where_alloc where) {
+                     ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
 	return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
 }
 ir_node *new_r_Free(ir_graph *irg, ir_node *block, ir_node *store,
-                    ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+                    ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
 	return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
 }
 ir_node *new_r_Sync(ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
@@ -1800,333 +1797,6 @@ new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode) {
 	return res;
 }  /* new_rd_Phi0 */
 
-/* There are two implementations of the Phi node construction.  The first
-   is faster, but does not work for blocks with more than 2 predecessors.
-   The second works always but is slower and causes more unnecessary Phi
-   nodes.
-   Select the implementations by the following preprocessor flag set in
-   common/common.h: */
-#if USE_FAST_PHI_CONSTRUCTION
-
-/* This is a stack used for allocating and deallocating nodes in
-   new_rd_Phi_in.  The original implementation used the obstack
-   to model this stack, now it is explicit.  This reduces side effects.
-*/
-#if USE_EXPLICIT_PHI_IN_STACK
-Phi_in_stack *
-new_Phi_in_stack(void) {
-	Phi_in_stack *res;
-
-	res = (Phi_in_stack *) xmalloc(sizeof(Phi_in_stack));
-
-	res->stack = NEW_ARR_F(ir_node *, 0);
-	res->pos = 0;
-
-	return res;
-}  /* new_Phi_in_stack */
-
-void
-free_Phi_in_stack(Phi_in_stack *s) {
-	DEL_ARR_F(s->stack);
-	free(s);
-}  /* free_Phi_in_stack */
-
-static INLINE void
-free_to_Phi_in_stack(ir_node *phi) {
-	if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
-	    current_ir_graph->Phi_in_stack->pos)
-		ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
-	else
-		current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
-
-	(current_ir_graph->Phi_in_stack->pos)++;
-}  /* free_to_Phi_in_stack */
-
-static INLINE ir_node *
-alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
-                               int arity, ir_node **in) {
-	ir_node *res;
-	ir_node **stack = current_ir_graph->Phi_in_stack->stack;
-	int pos = current_ir_graph->Phi_in_stack->pos;
-
-
-	if (pos == 0) {
-		/* We need to allocate a new node */
-		res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
-		res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
-	} else {
-		/* reuse the old node and initialize it again. */
-		res = stack[pos-1];
-
-		assert(res->kind == k_ir_node);
-		assert(res->op == op_Phi);
-		res->mode = mode;
-		res->visited = 0;
-		res->link = NULL;
-		assert(arity >= 0);
-		/* ???!!! How to free the old in array??  Not at all: on obstack ?!! */
-		res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
-		res->in[0] = block;
-		memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
-
-		(current_ir_graph->Phi_in_stack->pos)--;
-	}
-	return res;
-}  /* alloc_or_pop_from_Phi_in_stack */
-#endif /* USE_EXPLICIT_PHI_IN_STACK */
-
-/**
- * Creates a Phi node with a given, fixed array **in of predecessors.
- * If the Phi node is unnecessary, as the same value reaches the block
- * through all control flow paths, it is eliminated and the value
- * returned directly.  This constructor is only intended for use in
- * the automatic Phi node generation triggered by get_value or mature.
- * The implementation is quite tricky and depends on the fact, that
- * the nodes are allocated on a stack:
- * The in array contains predecessors and NULLs.  The NULLs appear,
- * if get_r_value_internal, that computed the predecessors, reached
- * the same block on two paths.  In this case the same value reaches
- * this block on both paths, there is no definition in between.  We need
- * not allocate a Phi where these path's merge, but we have to communicate
- * this fact to the caller.  This happens by returning a pointer to the
- * node the caller _will_ allocate.  (Yes, we predict the address. We can
- * do so because the nodes are allocated on the obstack.)  The caller then
- * finds a pointer to itself and, when this routine is called again,
- * eliminates itself.
- */
-static INLINE ir_node *
-new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins) {
-	int i;
-	ir_node *res, *known;
-
-	/* Allocate a new node on the obstack.  This can return a node to
-	   which some of the pointers in the in-array already point.
-	   Attention: the constructor copies the in array, i.e., the later
-	   changes to the array in this routine do not affect the
-	   constructed node!  If the in array contains NULLs, there will be
-	   missing predecessors in the returned node.  Is this a possible
-	   internal state of the Phi node generation? */
-#if USE_EXPLICIT_PHI_IN_STACK
-	res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
-#else
-	res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
-	res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
-#endif
-
-	/* The in-array can contain NULLs.  These were returned by
-	   get_r_value_internal if it reached the same block/definition on a
-	   second path.  The NULLs are replaced by the node itself to
-	   simplify the test in the next loop. */
-	for (i = 0;  i < ins;  ++i) {
-		if (in[i] == NULL)
-			in[i] = res;
-	}
-
-	/* This loop checks whether the Phi has more than one predecessor.
-	   If so, it is a real Phi node and we break the loop.  Else the Phi
-	   node merges the same definition on several paths and therefore is
-	   not needed. */
-	for (i = 0;  i < ins;  ++i) {
-		if (in[i] == res || in[i] == known)
-			continue;
-
-		if (known == res)
-			known = in[i];
-		else
-			break;
-	}
-
-	/* i==ins: there is at most one predecessor, we don't need a phi node. */
-	if (i==ins) {
-#if USE_EXPLICIT_PHI_IN_STACK
-		free_to_Phi_in_stack(res);
-#else
-		edges_node_deleted(res, current_ir_graph);
-		obstack_free(current_ir_graph->obst, res);
-#endif
-		res = known;
-	} else {
-		res = optimize_node (res);
-		IRN_VRFY_IRG(res, irg);
-	}
-
-	/* return the pointer to the Phi node.  This node might be deallocated! */
-	return res;
-}  /* new_rd_Phi_in */
-
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
-
-/**
- * Allocates and returns this node.  The routine called to allocate the
- * node might optimize it away and return a real value, or even a pointer
- * to a deallocated Phi node on top of the obstack!
- * This function is called with an in-array of proper size.
- */
-static ir_node *
-phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
-	ir_node *prevBlock, *res;
-	int i;
-
-	/* This loop goes to all predecessor blocks of the block the Phi node is in
-	   and there finds the operands of the Phi node by calling
-	   get_r_value_internal. */
-	for (i = 1;  i <= ins;  ++i) {
-		assert (block->in[i]);
-		prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
-		assert (prevBlock);
-		nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
-	}
-
-	/* After collecting all predecessors into the array nin a new Phi node
-	   with these predecessors is created.  This constructor contains an
-	   optimization: If all predecessors of the Phi node are identical it
-	   returns the only operand instead of a new Phi node.  If the value
-	   passes two different control flow edges without being defined, and
-	   this is the second path treated, a pointer to the node that will be
-	   allocated for the first path (recursion) is returned.  We already
-	   know the address of this node, as it is the next node to be allocated
-	   and will be placed on top of the obstack. (The obstack is a _stack_!) */
-	res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
-
-	/* Now we now the value for "pos" and can enter it in the array with
-	   all known local variables.  Attention: this might be a pointer to
-	   a node, that later will be allocated!!! See new_rd_Phi_in().
-	   If this is called in mature, after some set_value() in the same block,
-	   the proper value must not be overwritten:
-	   The call order
-	     get_value    (makes Phi0, put's it into graph_arr)
-	     set_value    (overwrites Phi0 in graph_arr)
-	     mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
-	                   the proper value.)
-	   fails. */
-	if (!block->attr.block.graph_arr[pos]) {
-		block->attr.block.graph_arr[pos] = res;
-	} else {
-		/*  printf(" value already computed by %s\n",
-		get_id_str(block->attr.block.graph_arr[pos]->op->name));  */
-	}
-
-	return res;
-}
-
-/**
- * This function returns the last definition of a variable.  In case
- * this variable was last defined in a previous block, Phi nodes are
- * inserted.  If the part of the firm graph containing the definition
- * is not yet constructed, a dummy Phi node is returned.
- */
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode)
-{
-	ir_node *res;
-	/* There are 4 cases to treat.
-
-	   1. The block is not mature and we visit it the first time.  We can not
-	      create a proper Phi node, therefore a Phi0, i.e., a Phi without
-	      predecessors is returned.  This node is added to the linked list (field
-	      "link") of the containing block to be completed when this block is
-	      matured. (Completion will add a new Phi and turn the Phi0 into an Id
-	      node.)
-
-	   2. The value is already known in this block, graph_arr[pos] is set and we
-	      visit the block the first time.  We can return the value without
-	      creating any new nodes.
-
-	   3. The block is mature and we visit it the first time.  A Phi node needs
-	      to be created (phi_merge).  If the Phi is not needed, as all it's
-	      operands are the same value reaching the block through different
-	      paths, it's optimized away and the value itself is returned.
-
-	   4. The block is mature, and we visit it the second time.  Now two
-	      subcases are possible:
-	      * The value was computed completely the last time we were here. This
-	        is the case if there is no loop.  We can return the proper value.
-	      * The recursion that visited this node and set the flag did not
-	        return yet.  We are computing a value in a loop and need to
-	        break the recursion without knowing the result yet.
-	    @@@ strange case.  Straight forward we would create a Phi before
-	    starting the computation of it's predecessors.  In this case we will
-	    find a Phi here in any case.  The problem is that this implementation
-	    only creates a Phi after computing the predecessors, so that it is
-	    hard to compute self references of this Phi.  @@@
-	      There is no simple check for the second subcase.  Therefore we check
-	      for a second visit and treat all such cases as the second subcase.
-	      Anyways, the basic situation is the same:  we reached a block
-	      on two paths without finding a definition of the value:  No Phi
-	      nodes are needed on both paths.
-	      We return this information "Two paths, no Phi needed" by a very tricky
-	      implementation that relies on the fact that an obstack is a stack and
-	      will return a node with the same address on different allocations.
-	      Look also at phi_merge and new_rd_phi_in to understand this.
-	  @@@ Unfortunately this does not work, see testprogram
-	  three_cfpred_example.
-
-	*/
-
-	/* case 4 -- already visited. */
-	if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
-
-	/* visited the first time */
-	set_irn_visited(block, get_irg_visited(current_ir_graph));
-
-	/* Get the local valid value */
-	res = block->attr.block.graph_arr[pos];
-
-	/* case 2 -- If the value is actually computed, return it. */
-	if (res) return res;
-
-	if (block->attr.block.is_matured) { /* case 3 */
-
-		/* The Phi has the same amount of ins as the corresponding block. */
-		int ins = get_irn_arity(block);
-		ir_node **nin;
-		NEW_ARR_A(ir_node *, nin, ins);
-
-		/* Phi merge collects the predecessors and then creates a node. */
-		res = phi_merge(block, pos, mode, nin, ins);
-
-	} else {  /* case 1 */
-		/* The block is not mature, we don't know how many in's are needed.  A Phi
-		   with zero predecessors is created.  Such a Phi node is called Phi0
-		   node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
-		   to the list of Phi0 nodes in this block to be matured by mature_immBlock
-		   later.
-		   The Phi0 has to remember the pos of it's internal value.  If the real
-		   Phi is computed, pos is used to update the array with the local
-		   values. */
-
-		res = new_rd_Phi0(current_ir_graph, block, mode);
-		res->attr.phi0_pos = pos;
-		res->link = block->link;
-		block->link = res;
-	}
-
-	/* If we get here, the frontend missed a use-before-definition error */
-	if (!res) {
-		/* Error Message */
-		printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
-		assert(mode->code >= irm_F && mode->code <= irm_P);
-		res = new_rd_Const(NULL, current_ir_graph, block, mode, tarval_mode_null[mode->code]);
-	}
-
-	/* The local valid value is available now. */
-	block->attr.block.graph_arr[pos] = res;
-
-	return res;
-}  /* get_r_value_internal */
-
-#else /* if 0 */
-
-/**
-    it starts the recursion.  This causes an Id at the entry of
-    every block that has no definition of the value! **/
-
-#if USE_EXPLICIT_PHI_IN_STACK
-/* Just dummies */
-Phi_in_stack * new_Phi_in_stack() { return NULL; }
-void free_Phi_in_stack(Phi_in_stack *s) {}
-#endif
 
 static INLINE ir_node *
 new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode,
@@ -2323,6 +1993,34 @@ get_r_frag_value_internal(ir_node *block, ir_node *cfOp, int pos, ir_mode *mode)
 }  /* get_r_frag_value_internal */
 #endif /* PRECISE_EXC_CONTEXT */
 
+/**
+ * check whether a control flow cf_pred is a exception flow.
+ *
+ * @param cf_pred     the control flow node
+ * @param prev_cf_op  if cf_pred is a Proj, the predecessor node, else equal to cf_pred
+ */
+static int is_exception_flow(ir_node *cf_pred, ir_node *prev_cf_op) {
+	/*
+	 * Note: all projections from a raise are "exceptional control flow" we we handle it
+	 * like a normal Jmp, because there is no "regular" one.
+	 * That's why Raise is no "fragile_op"!
+	 */
+	if (is_fragile_op(prev_cf_op)) {
+		if (is_Proj(cf_pred)) {
+			if (get_Proj_proj(cf_pred) == pn_Generic_X_regular) {
+				/* the regular control flow, NO exception */
+				return 0;
+			}
+			assert(get_Proj_proj(cf_pred) == pn_Generic_X_except);
+			return 1;
+		}
+		/* Hmm, exception but not a Proj? */
+		assert(!"unexpected condition: fragile op without a proj");
+		return 1;
+	}
+	return 0;
+}  /* is_exception_flow */
+
 /**
  * Computes the predecessors for the real phi node, and then
  * allocates and returns this node.  The routine called to allocate the
@@ -2331,7 +2029,7 @@ get_r_frag_value_internal(ir_node *block, ir_node *cfOp, int pos, ir_mode *mode)
  */
 static ir_node *
 phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
-	ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
+	ir_node *prevBlock, *res, *phi0, *phi0_all;
 	int i;
 
 	/* If this block has no value at pos create a Phi0 and remember it
@@ -2381,26 +2079,26 @@ phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
 	/* This loop goes to all predecessor blocks of the block the Phi node
 	   is in and there finds the operands of the Phi node by calling
 	   get_r_value_internal.  */
-	for (i = 1;  i <= ins;  ++i) {
-		prevCfOp = skip_Proj(block->in[i]);
-		assert (prevCfOp);
+	for (i = 1; i <= ins; ++i) {
+		ir_node *cf_pred = block->in[i];
+		ir_node *prevCfOp = skip_Proj(cf_pred);
+		assert(prevCfOp);
 		if (is_Bad(prevCfOp)) {
 			/* In case a Cond has been optimized we would get right to the start block
 			with an invalid definition. */
 			nin[i-1] = new_Bad();
 			continue;
 		}
-		prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
-		assert (prevBlock);
+		prevBlock = prevCfOp->in[0]; /* go past control flow op to prev block */
+		assert(prevBlock);
 		if (!is_Bad(prevBlock)) {
 #if PRECISE_EXC_CONTEXT
-			if (get_opt_precise_exc_context() &&
-				is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
-					assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
-					nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
+			if (get_opt_precise_exc_context() && is_exception_flow(cf_pred, prevCfOp)) {
+				assert(get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode));
+				nin[i-1] = get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode);
 			} else
 #endif
-				nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
+				nin[i-1] = get_r_value_internal(prevBlock, pos, mode);
 		} else {
 			nin[i-1] = new_Bad();
 		}
@@ -2425,7 +2123,7 @@ phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
 	   with these predecessors is created.  This constructor contains an
 	   optimization: If all predecessors of the Phi node are identical it
 	   returns the only operand instead of a new Phi node.  */
-	res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins, phi0_all);
+	res = new_rd_Phi_in(current_ir_graph, block, mode, nin, ins, phi0_all);
 
 	/* In case we allocated a Phi0 node at the beginning of this procedure,
 	   we need to exchange this Phi0 with the real Phi. */
@@ -2440,10 +2138,14 @@ phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
 }  /* phi_merge */
 
 /**
- * This function returns the last definition of a variable.  In case
- * this variable was last defined in a previous block, Phi nodes are
+ * This function returns the last definition of a value.  In case
+ * this value was last defined in a previous block, Phi nodes are
  * inserted.  If the part of the firm graph containing the definition
  * is not yet constructed, a dummy Phi node is returned.
+ *
+ * @param block   the current block
+ * @param pos     the value number of the value searched
+ * @param mode    the mode of this value (needed for Phi construction)
  */
 static ir_node *
 get_r_value_internal(ir_node *block, int pos, ir_mode *mode) {
@@ -2533,8 +2235,6 @@ get_r_value_internal(ir_node *block, int pos, ir_mode *mode) {
 	return res;
 }  /* get_r_value_internal */
 
-#endif /* USE_FAST_PHI_CONSTRUCTION */
-
 /* ************************************************************************** */
 
 /*
@@ -2547,10 +2247,7 @@ mature_immBlock(ir_node *block) {
 	ir_node *n, **nin;
 	ir_node *next;
 
-	assert(get_irn_opcode(block) == iro_Block);
-	/* @@@ should be commented in
-	   assert (!get_Block_matured(block) && "Block already matured"); */
-
+	assert(is_Block(block));
 	if (!get_Block_matured(block)) {
 		ins = ARR_LEN(block->in)-1;
 		/* Fix block parameters */
@@ -2647,6 +2344,7 @@ NEW_D_BINOP(Add)
 NEW_D_BINOP(Sub)
 NEW_D_UNOP(Minus)
 NEW_D_BINOP(Mul)
+NEW_D_BINOP(Mulh)
 
 /**
  * Allocate the frag array.
@@ -2782,7 +2480,7 @@ new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val) {
 
 ir_node *
 new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
-            where_alloc where) {
+            ir_where_alloc where) {
 	ir_node *res;
 	res = new_bd_Alloc(db, current_ir_graph->current_block,
 	                   store, size, alloc_type, where);
@@ -2795,7 +2493,7 @@ new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
 
 ir_node *
 new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr,
-           ir_node *size, ir_type *free_type, where_alloc where) {
+           ir_node *size, ir_type *free_type, ir_where_alloc where) {
 	return new_bd_Free(db, current_ir_graph->current_block,
 	                   store, ptr, size, free_type, where);
 }
@@ -2816,14 +2514,14 @@ new_d_Sel(dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **
 }  /* new_d_Sel */
 
 ir_node *
-new_d_SymConst_type(dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp) {
-	return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
+new_d_SymConst_type(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *tp) {
+	return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
 	                            value, kind, tp);
 }  /* new_d_SymConst_type */
 
 ir_node *
-new_d_SymConst(dbg_info *db, symconst_symbol value, symconst_kind kind) {
-	return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
+new_d_SymConst(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind) {
+	return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
 	                            value, kind, firm_unknown_type);
 }  /* new_d_SymConst */
 
@@ -2995,6 +2693,7 @@ new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp) {
 	ir_node *blk = get_nodes_block(pred_jmp);
 
 	res->in[0] = blk->in[0];
+	assert(res->in[0] != NULL);
 	add_immBlock_pred(res, pred_jmp);
 
 	res->attr.block.is_mb_head = 0;
@@ -3015,7 +2714,7 @@ add_immBlock_pred(ir_node *block, ir_node *jmp) {
 
 	assert(!block->attr.block.is_matured && "Error: Block already matured!\n");
 	assert(block->attr.block.is_mb_head && "Error: Cannot add a predecessor to a PartBlock");
-	assert(jmp != NULL);
+	assert(is_ir_node(jmp));
 
 	ARR_APP1(ir_node *, block->in, jmp);
 	/* Call the hook */
@@ -3054,6 +2753,7 @@ set_value(int pos, ir_node *value) {
 	ir_graph *irg = current_ir_graph;
 	assert(get_irg_phase_state(irg) == phase_building);
 	assert(pos+1 < irg->n_loc);
+	assert(is_ir_node(value));
 	irg->current_block->attr.block.graph_arr[pos + 1] = value;
 }  /* set_value */
 
@@ -3189,11 +2889,11 @@ ir_node *new_Const_type(tarval *con, ir_type *tp) {
 	return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
 }
 
-ir_node *new_SymConst_type(symconst_symbol value, symconst_kind kind, ir_type *type) {
-	return new_d_SymConst_type(NULL, value, kind, type);
+ir_node *new_SymConst_type(ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *type) {
+	return new_d_SymConst_type(NULL, mode, value, kind, type);
 }
-ir_node *new_SymConst(symconst_symbol value, symconst_kind kind) {
-	return new_d_SymConst(NULL, value, kind);
+ir_node *new_SymConst(ir_mode *mode, symconst_symbol value, symconst_kind kind) {
+	return new_d_SymConst(NULL, mode, value, kind);
 }
 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent) {
 	return new_d_simpleSel(NULL, store, objptr, ent);
@@ -3218,6 +2918,9 @@ ir_node *new_Minus(ir_node *op,  ir_mode *mode) {
 ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode) {
 	return new_d_Mul(NULL, op1, op2, mode);
 }
+ir_node *new_Mulh(ir_node *op1, ir_node *op2, ir_mode *mode) {
+	return new_d_Mulh(NULL, op1, op2, mode);
+}
 ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
 	return new_d_Quot(NULL, memop, op1, op2, mode, state);
 }
@@ -3285,11 +2988,11 @@ ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val) {
 	return new_d_Store(NULL, store, addr, val);
 }
 ir_node *new_Alloc(ir_node *store, ir_node *size, ir_type *alloc_type,
-                   where_alloc where) {
+                   ir_where_alloc where) {
 	return new_d_Alloc(NULL, store, size, alloc_type, where);
 }
 ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size,
-                  ir_type *free_type, where_alloc where) {
+                  ir_type *free_type, ir_where_alloc where) {
 	return new_d_Free(NULL, store, ptr, size, free_type, where);
 }
 ir_node *new_Sync(int arity, ir_node *in[]) {