projects / libfirm / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
removed INLIEN before global functions
[libfirm] / ir / ir / ircons.c
diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 1d881c3..7966d17 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -12,21 +12,29 @@
  */
 
 #ifdef HAVE_CONFIG_H
  */
 
 #ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
+#endif
+
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
 #endif
 
 # include "irgraph_t.h"
 # include "irnode_t.h"
 # include "irmode_t.h"
 #endif
 
 # include "irgraph_t.h"
 # include "irnode_t.h"
 # include "irmode_t.h"
-# include "ircons.h"
+# include "ircons_t.h"
 # include "firm_common_t.h"
 # include "irvrfy.h"
 # include "firm_common_t.h"
 # include "irvrfy.h"
-# include "irop.h"
+# include "irop_t.h"
 # include "iropt_t.h"
 # include "irgmod.h"
 # include "array.h"
 # include "iropt_t.h"
 # include "irgmod.h"
 # include "array.h"
-/* memset belongs to string.h */
-# include "string.h"
 # include "irbackedge_t.h"
 # include "irflag_t.h"
 
 # include "irbackedge_t.h"
 # include "irflag_t.h"
 
@@ -40,13 +48,21 @@ struct Phi_in_stack {
 typedef struct Phi_in_stack Phi_in_stack;
 #endif
 
 typedef struct Phi_in_stack Phi_in_stack;
 #endif
 
+/* when we need verifying */
+#ifdef NDEBUG
+# define IRN_VRFY_IRG(res, irg)
+#else
+# define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)
+#endif
+
 /*
  * language dependant initialization variable
  */
 static default_initialize_local_variable_func_t *default_initialize_local_variable = NULL;
 
 /*
  * language dependant initialization variable
  */
 static default_initialize_local_variable_func_t *default_initialize_local_variable = NULL;
 
-/*** ******************************************** */
-/** privat interfaces, for professional use only */
+/* -------------------------------------------- */
+/* privat interfaces, for professional use only */
+/* -------------------------------------------- */
 
 /* Constructs a Block with a fixed number of predecessors.
    Does not set current_block.  Can not be used with automatic
 
 /* Constructs a Block with a fixed number of predecessors.
    Does not set current_block.  Can not be used with automatic
@@ -62,12 +78,13 @@ new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
 
   /* res->attr.block.exc = exc_normal; */
   /* res->attr.block.handler_entry = 0; */
 
   /* res->attr.block.exc = exc_normal; */
   /* res->attr.block.handler_entry = 0; */
-  res->attr.block.irg = irg;
-  res->attr.block.backedge = new_backedge_arr(irg->obst, arity);
-  res->attr.block.in_cg = NULL;
+  res->attr.block.dead        = 0;
+  res->attr.block.irg         = irg;
+  res->attr.block.backedge    = new_backedge_arr(irg->obst, arity);
+  res->attr.block.in_cg       = NULL;
   res->attr.block.cg_backedge = NULL;
 
   res->attr.block.cg_backedge = NULL;
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -76,10 +93,10 @@ new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
+  res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = irg; */
 
   /* res->attr.start.irg = irg; */
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -88,9 +105,9 @@ new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_End, mode_X, -1, NULL);
+  res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
 
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -108,7 +125,7 @@ new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in
   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 = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
 
   res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
 
 
   res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
 
@@ -119,7 +136,7 @@ new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in
     }
 
   if (!has_unknown) res = optimize_node (res);
     }
 
   if (!has_unknown) res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
 
   /* Memory Phis in endless loops must be kept alive.
      As we can't distinguish these easily we keep all of them alive. */
 
   /* Memory Phis in endless loops must be kept alive.
      As we can't distinguish these easily we keep all of them alive. */
@@ -132,16 +149,13 @@ INLINE ir_node *
 new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
 {
   ir_node *res;
 new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
 {
   ir_node *res;
-  res = new_ir_node (db, irg, block, op_Const, mode, 0, NULL);
+
+  res = new_ir_node (db, irg, irg->start_block, op_Const, mode, 0, NULL);
   res->attr.con.tv = con;
   set_Const_type(res, tp);  /* Call method because of complex assertion. */
   res = optimize_node (res);
   assert(get_Const_type(res) == tp);
   res->attr.con.tv = con;
   set_Const_type(res, tp);  /* Call method because of complex assertion. */
   res = optimize_node (res);
   assert(get_Const_type(res) == tp);
-  irn_vrfy_irg (res, irg);
-
-#if 0
-  res = local_optimize_newby (res);
-# endif
+  IRN_VRFY_IRG(res, irg);
 
   return res;
 }
 
   return res;
 }
@@ -149,21 +163,19 @@ new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, t
 INLINE ir_node *
 new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
 {
 INLINE ir_node *
 new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
 {
-  type *tp = unknown_type;
-  if (tarval_is_entity(con))
-    tp = find_pointer_type_to_type(get_entity_type(get_tarval_entity(con)));
+  type *tp = firm_unknown_type;
+  /* removing this somehow causes errors in jack. */
   return new_rd_Const_type (db, irg, block, mode, con, tp);
 }
 
 INLINE ir_node *
 new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 {
   return new_rd_Const_type (db, irg, block, mode, con, tp);
 }
 
 INLINE ir_node *
 new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0]=val;
-  res = new_ir_node (db, irg, block, op_Id, mode, 1, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -171,19 +183,18 @@ INLINE ir_node *
 new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
         long proj)
 {
 new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
         long proj)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0]=arg;
-  res = new_ir_node (db, irg, block, op_Proj, mode, 1, in);
+
+  res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
   res->attr.proj = proj;
 
   assert(res);
   assert(get_Proj_pred(res));
   res->attr.proj = proj;
 
   assert(res);
   assert(get_Proj_pred(res));
-  assert(get_nodes_Block(get_Proj_pred(res)));
+  assert(get_nodes_block(get_Proj_pred(res)));
 
 
-  res = optimize_node (res);
+  res = optimize_node(res);
 
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 
 }
   return res;
 
 }
@@ -203,12 +214,11 @@ new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
 INLINE ir_node *
 new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 {
 INLINE ir_node *
 new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0]=op;
-  res = new_ir_node (db, irg, block, op_Conv, mode, 1, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -216,10 +226,13 @@ INLINE ir_node *
 new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
 {
   ir_node *res;
 new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
 {
   ir_node *res;
-  res = new_ir_node (db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
+
+  assert(is_atomic_type(to_tp));
+
+  res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
   res->attr.cast.totype = to_tp;
   res->attr.cast.totype = to_tp;
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -228,9 +241,9 @@ new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **
 {
   ir_node *res;
 
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_Tuple, mode_T, arity, in);
+  res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
   res = optimize_node (res);
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -240,11 +253,12 @@ new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   in[0] = op1;
   in[1] = op2;
-  res = new_ir_node (db, irg, block, op_Add, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Add, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -254,24 +268,24 @@ new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   res = new_ir_node (db, irg, block, op_Sub, mode, 2, in);
   res = optimize_node (res);
   in[0] = op1;
   in[1] = op2;
   res = new_ir_node (db, irg, block, op_Sub, mode, 2, in);
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
 INLINE ir_node *
 new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
   return res;
 }
 
 INLINE ir_node *
 new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
-         ir_node *op,  ir_mode *mode)
+         ir_node *op, ir_mode *mode)
 {
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0]=op;
-  res = new_ir_node (db, irg, block, op_Minus, mode, 1, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Minus, mode, 1, &op);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -281,11 +295,12 @@ new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   in[0] = op1;
   in[1] = op2;
-  res = new_ir_node (db, irg, block, op_Mul, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Mul, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -293,14 +308,15 @@ INLINE ir_node *
 new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
             ir_node *memop, ir_node *op1, ir_node *op2)
 {
 new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
             ir_node *memop, ir_node *op1, ir_node *op2)
 {
-  ir_node *in[3] ;
+  ir_node *in[3];
   ir_node *res;
   ir_node *res;
+
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
-  res = new_ir_node (db, irg, block, op_Quot, mode_T, 3, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Quot, mode_T, 3, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -310,12 +326,13 @@ new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
 {
   ir_node *in[3];
   ir_node *res;
+
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
-  res = new_ir_node (db, irg, block, op_DivMod, mode_T, 3, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_DivMod, mode_T, 3, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -325,12 +342,13 @@ new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
 {
   ir_node *in[3];
   ir_node *res;
+
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
-  res = new_ir_node (db, irg, block, op_Div, mode_T, 3, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Div, mode_T, 3, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -340,12 +358,13 @@ new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
 {
   ir_node *in[3];
   ir_node *res;
+
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
   in[0] = memop;
   in[1] = op1;
   in[2] = op2;
-  res = new_ir_node (db, irg, block, op_Mod, mode_T, 3, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Mod, mode_T, 3, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -355,11 +374,12 @@ new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   in[0] = op1;
   in[1] = op2;
-  res = new_ir_node (db, irg, block, op_And, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_And, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -369,11 +389,12 @@ new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   in[0] = op1;
   in[1] = op2;
-  res = new_ir_node (db, irg, block, op_Or, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Or, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -383,11 +404,12 @@ new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op1;
   in[1] = op2;
   res = new_ir_node (db, irg, block, op_Eor, mode, 2, in);
   res = optimize_node (res);
   in[0] = op1;
   in[1] = op2;
   res = new_ir_node (db, irg, block, op_Eor, mode, 2, in);
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -395,12 +417,11 @@ INLINE ir_node *
 new_rd_Not    (dbg_info* db, ir_graph *irg, ir_node *block,
           ir_node *op, ir_mode *mode)
 {
 new_rd_Not    (dbg_info* db, ir_graph *irg, ir_node *block,
           ir_node *op, ir_mode *mode)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0] = op;
-  res = new_ir_node (db, irg, block, op_Not, mode, 1, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Not, mode, 1, &op);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -410,11 +431,12 @@ new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op;
   in[1] = k;
   in[0] = op;
   in[1] = k;
-  res = new_ir_node (db, irg, block, op_Shl, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Shl, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -424,11 +446,12 @@ new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op;
   in[1] = k;
   in[0] = op;
   in[1] = k;
-  res = new_ir_node (db, irg, block, op_Shr, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Shr, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -438,11 +461,12 @@ new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op;
   in[1] = k;
   in[0] = op;
   in[1] = k;
-  res = new_ir_node (db, irg, block, op_Shrs, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Shrs, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -452,11 +476,12 @@ new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = op;
   in[1] = k;
   in[0] = op;
   in[1] = k;
-  res = new_ir_node (db, irg, block, op_Rot, mode, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Rot, mode, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -464,12 +489,11 @@ INLINE ir_node *
 new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
        ir_node *op, ir_mode *mode)
 {
 new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
        ir_node *op, ir_mode *mode)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0] = op;
-  res = new_ir_node (db, irg, block, op_Abs, mode, 1, in);
+
+  res = new_ir_node(db, irg, block, op_Abs, mode, 1, &op);
   res = optimize_node (res);
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -481,9 +505,10 @@ new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
   ir_node *res;
   in[0] = op1;
   in[1] = op2;
   ir_node *res;
   in[0] = op1;
   in[1] = op2;
-  res = new_ir_node (db, irg, block, op_Cmp, mode_T, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -491,23 +516,23 @@ INLINE ir_node *
 new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
+
   res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
   res = optimize_node (res);
   res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG (res, irg);
   return res;
 }
 
 INLINE ir_node *
 new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
 {
   return res;
 }
 
 INLINE ir_node *
 new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0] = c;
-  res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, in);
-  res->attr.c.kind = dense;
+
+  res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, &c);
+  res->attr.c.kind         = dense;
   res->attr.c.default_proj = 0;
   res = optimize_node (res);
   res->attr.c.default_proj = 0;
   res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -520,18 +545,19 @@ new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
   int r_arity;
 
   r_arity = arity+2;
   int r_arity;
 
   r_arity = arity+2;
-  NEW_ARR_A (ir_node *, r_in, r_arity);
+  NEW_ARR_A(ir_node *, r_in, r_arity);
   r_in[0] = store;
   r_in[1] = callee;
   r_in[0] = store;
   r_in[1] = callee;
-  memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
+  memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 
 
-  res = new_ir_node (db, irg, block, op_Call, mode_T, r_arity, r_in);
+  res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
 
 
-  assert(is_method_type(tp));
+  assert((get_unknown_type() == tp) || is_method_type(tp));
   set_Call_type(res, tp);
   set_Call_type(res, tp);
-  res->attr.call.callee_arr = NULL;
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res->attr.call.exc.pin_state = op_pin_state_pinned;
+  res->attr.call.callee_arr    = NULL;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -546,10 +572,10 @@ new_rd_Return (dbg_info* db, ir_graph *irg, ir_node *block,
   r_arity = arity+1;
   NEW_ARR_A (ir_node *, r_in, r_arity);
   r_in[0] = store;
   r_arity = arity+1;
   NEW_ARR_A (ir_node *, r_in, r_arity);
   r_in[0] = store;
-  memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
-  res = new_ir_node (db, irg, block, op_Return, mode_X, r_arity, r_in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  memcpy(&r_in[1], in, sizeof(ir_node *) * arity);
+  res = new_ir_node(db, irg, block, op_Return, mode_X, r_arity, r_in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -558,26 +584,30 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = store;
   in[1] = obj;
   in[0] = store;
   in[1] = obj;
-  res = new_ir_node (db, irg, block, op_Raise, mode_T, 2, in);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
 INLINE ir_node *
 new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
   return res;
 }
 
 INLINE ir_node *
 new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
-        ir_node *store, ir_node *adr)
+        ir_node *store, ir_node *adr, ir_mode *mode)
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = store;
   in[1] = adr;
   in[0] = store;
   in[1] = adr;
-  res = new_ir_node (db, irg, block, op_Load, mode_T, 2, in);
-
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Load, mode_T, 2, in);
+  res->attr.load.exc.pin_state = op_pin_state_pinned;
+  res->attr.load.load_mode     = mode;
+  res->attr.load.volatility    = volatility_non_volatile;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -587,14 +617,15 @@ new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
 {
   ir_node *in[3];
   ir_node *res;
+
   in[0] = store;
   in[1] = adr;
   in[2] = val;
   in[0] = store;
   in[1] = adr;
   in[2] = val;
-  res = new_ir_node (db, irg, block, op_Store, mode_T, 3, in);
-
-  res = optimize_node (res);
-
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Store, mode_T, 3, in);
+  res->attr.store.exc.pin_state = op_pin_state_pinned;
+  res->attr.store.volatility    = volatility_non_volatile;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -604,15 +635,15 @@ new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
 {
   ir_node *in[2];
   ir_node *res;
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = store;
   in[1] = size;
   in[0] = store;
   in[1] = size;
-  res = new_ir_node (db, irg, block, op_Alloc, mode_T, 2, in);
-
-  res->attr.a.where = where;
-  res->attr.a.type = alloc_type;
-
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in);
+  res->attr.a.exc.pin_state = op_pin_state_pinned;
+  res->attr.a.where         = where;
+  res->attr.a.type          = alloc_type;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -622,15 +653,14 @@ new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
 {
   ir_node *in[3];
   ir_node *res;
 {
   ir_node *in[3];
   ir_node *res;
+
   in[0] = store;
   in[1] = ptr;
   in[2] = size;
   res = new_ir_node (db, irg, block, op_Free, mode_T, 3, in);
   in[0] = store;
   in[1] = ptr;
   in[2] = size;
   res = new_ir_node (db, irg, block, op_Free, mode_T, 3, in);
-
   res->attr.f = free_type;
   res->attr.f = free_type;
-
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -645,16 +675,14 @@ new_rd_Sel (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node
   assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
 
   r_arity = arity + 2;
   assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
 
   r_arity = arity + 2;
-  NEW_ARR_A (ir_node *, r_in, r_arity);  /* uses alloca */
+  NEW_ARR_A(ir_node *, r_in, r_arity);  /* uses alloca */
   r_in[0] = store;
   r_in[1] = objptr;
   r_in[0] = store;
   r_in[1] = objptr;
-  memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
-  res = new_ir_node (db, irg, block, op_Sel, mode_P_mach, r_arity, r_in);
-
+  memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
+  res = new_ir_node(db, irg, block, op_Sel, mode_P_mach, r_arity, r_in);
   res->attr.s.ent = ent;
   res->attr.s.ent = ent;
-
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -667,54 +695,76 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
   int r_arity;
 
   r_arity = 2;
   int r_arity;
 
   r_arity = 2;
-  NEW_ARR_A (ir_node *, r_in, r_arity);
-  r_in [0] = store;
-  r_in [1] = objptr;
-
-  res = new_ir_node (db, irg, block, op_Sel, mode_T, r_arity, r_in);
+  NEW_ARR_A(ir_node *, r_in, r_arity);
+  r_in[0] = store;
+  r_in[1] = objptr;
 
 
+  res = new_ir_node(db, irg, block, op_Sel, mode_T, r_arity, r_in);
   res->attr.io.ent = ent;
 
   res->attr.io.ent = ent;
 
-  /* res = optimize (res);
-  * irn_vrfy_irg (res, irg); */
-  return (res);
+  /* res = optimize(res); */
+  IRN_VRFY_IRG(res, irg);
+  return res;
 }
 
 INLINE ir_node *
 }
 
 INLINE ir_node *
-new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, type_or_id_p value,
-                symconst_kind symkind)
-{
+new_rd_SymConst_type (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
+                     symconst_kind symkind, type *tp) {
   ir_node *res;
   ir_mode *mode;
   ir_node *res;
   ir_mode *mode;
-  if (symkind == linkage_ptr_info)
+
+  if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
     mode = mode_P_mach;
   else
     mode = mode_Iu;
     mode = mode_P_mach;
   else
     mode = mode_Iu;
-  res = new_ir_node (db, irg, block, op_SymConst, mode, 0, NULL);
+
+  res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
 
   res->attr.i.num = symkind;
 
   res->attr.i.num = symkind;
-  if (symkind == linkage_ptr_info) {
-    res->attr.i.tori.ptrinfo = (ident *)value;
-  } else {
-    assert (   (   (symkind == type_tag)
-            || (symkind == size))
-            && (is_type(value)));
-    res->attr.i.tori.typ = (type *)value;
-  }
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res->attr.i.sym = value;
+  res->attr.i.tp  = tp;
+
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
+INLINE 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;
+}
+
+ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, type *tp) {
+  symconst_symbol sym = {(type *)symbol};
+  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_ent, tp);
+}
+
+ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, type *tp) {
+  symconst_symbol sym = {(type *)symbol};
+  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_name, tp);
+}
+
+ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+  symconst_symbol sym = {symbol};
+  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_type_tag, tp);
+}
+
+ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+  symconst_symbol sym = {symbol};
+  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp);
+}
+
 INLINE ir_node *
 new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
 {
   ir_node *res;
 
 INLINE ir_node *
 new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_Sync, mode_M, arity, in);
-
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = new_ir_node(db, irg, block, op_Sync, mode_M, arity, in);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -728,22 +778,20 @@ INLINE ir_node *
 new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
 {
   ir_node *in[2], *res;
 new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
 {
   ir_node *in[2], *res;
+
   in[0] = val;
   in[1] = bound;
   in[0] = val;
   in[1] = bound;
-
   res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
   res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
-
   res->attr.confirm_cmp = cmp;
   res->attr.confirm_cmp = cmp;
-
   res = optimize_node (res);
   res = optimize_node (res);
-  irn_vrfy_irg(res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
 INLINE ir_node *
 new_rd_Unknown (ir_graph *irg, ir_mode *m)
 {
   return res;
 }
 
 INLINE ir_node *
 new_rd_Unknown (ir_graph *irg, ir_mode *m)
 {
-  return new_ir_node (NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
+  return new_ir_node(NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
 }
 
 INLINE ir_node *
 }
 
 INLINE ir_node *
@@ -751,12 +799,13 @@ new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
 {
   ir_node *in[1];
   ir_node *res;
 {
   ir_node *in[1];
   ir_node *res;
+
   in[0] = get_Call_ptr(call);
   in[0] = get_Call_ptr(call);
-  res = new_ir_node (db, irg, block, op_CallBegin, mode_T, 1, in);
+  res = new_ir_node(db, irg, block, op_CallBegin, mode_T, 1, in);
   /* res->attr.callbegin.irg = irg; */
   res->attr.callbegin.call = call;
   /* res->attr.callbegin.irg = irg; */
   res->attr.callbegin.call = call;
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -765,10 +814,9 @@ new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL);
+  res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
   irg->end_reg = res;
   irg->end_reg = res;
-
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -777,10 +825,9 @@ new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 
 {
   ir_node *res;
 
-  res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL);
+  res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
   irg->end_except = res;
   irg->end_except = res;
-
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG (res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -788,9 +835,10 @@ INLINE ir_node *
 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   ir_node *res;
-  res = new_ir_node (db, irg, block, op_Break, mode_X, 0, NULL);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(db, irg, block, op_Break, mode_X, 0, NULL);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -798,45 +846,43 @@ INLINE ir_node *
 new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
            long proj)
 {
 new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
            long proj)
 {
-  ir_node *in[1];
   ir_node *res;
   ir_node *res;
-  in[0] = arg;
-  res = new_ir_node (db, irg, block, op_Filter, mode, 1, in);
+
+  res = new_ir_node(db, irg, block, op_Filter, mode, 1, &arg);
   res->attr.filter.proj = proj;
   res->attr.filter.in_cg = NULL;
   res->attr.filter.backedge = NULL;
 
   assert(res);
   assert(get_Proj_pred(res));
   res->attr.filter.proj = proj;
   res->attr.filter.in_cg = NULL;
   res->attr.filter.backedge = NULL;
 
   assert(res);
   assert(get_Proj_pred(res));
-  assert(get_nodes_Block(get_Proj_pred(res)));
+  assert(get_nodes_block(get_Proj_pred(res)));
 
 
-  res = optimize_node (res);
-
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
   return res;
+}
 
 
+INLINE ir_node *
+new_rd_NoMem (ir_graph *irg) {
+  return irg->no_mem;
 }
 
 }
 
-ir_node *
-new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block,
-        ir_node *callee, int arity, ir_node **in, type *tp)
+INLINE ir_node *
+new_rd_Mux  (dbg_info *db, ir_graph *irg, ir_node *block,
+    ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)
 {
 {
-  ir_node **r_in;
+  ir_node *in[3];
   ir_node *res;
   ir_node *res;
-  int r_arity;
 
 
-  r_arity = arity+1;
-  NEW_ARR_A (ir_node *, r_in, r_arity);
-  r_in[0] = callee;
-  memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
+  in[0] = sel;
+  in[1] = ir_false;
+  in[2] = ir_true;
 
 
-  res = new_ir_node (db, irg, block, op_FuncCall, mode_T, r_arity, r_in);
+  res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
+  assert(res);
 
 
-  assert(is_method_type(tp));
-  set_FuncCall_type(res, tp);
-  res->attr.call.callee_arr = NULL;
-  res = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -869,7 +915,7 @@ INLINE ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
   return new_rd_Const(NULL, irg, block, mode, con);
 }
 INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
   return new_rd_Const(NULL, irg, block, mode, con);
 }
 INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
-                       type_or_id_p value, symconst_kind symkind) {
+                       symconst_symbol value, symconst_kind symkind) {
   return new_rd_SymConst(NULL, irg, block, value, symkind);
 }
 INLINE ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
   return new_rd_SymConst(NULL, irg, block, value, symkind);
 }
 INLINE ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
@@ -970,8 +1016,8 @@ INLINE ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
   return new_rd_Phi(NULL, irg, block, arity, in, mode);
 }
 INLINE ir_node *new_r_Load   (ir_graph *irg, ir_node *block,
   return new_rd_Phi(NULL, irg, block, arity, in, mode);
 }
 INLINE ir_node *new_r_Load   (ir_graph *irg, ir_node *block,
-               ir_node *store, ir_node *adr) {
-  return new_rd_Load(NULL, irg, block, store, adr);
+               ir_node *store, ir_node *adr, ir_mode *mode) {
+  return new_rd_Load(NULL, irg, block, store, adr, mode);
 }
 INLINE ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
                ir_node *store, ir_node *adr, ir_node *val) {
 }
 INLINE ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
                ir_node *store, ir_node *adr, ir_node *val) {
@@ -1029,10 +1075,12 @@ INLINE ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
                ir_mode *mode, long proj) {
   return new_rd_Filter(NULL, irg, block, arg, mode, proj);
 }
                ir_mode *mode, long proj) {
   return new_rd_Filter(NULL, irg, block, arg, mode, proj);
 }
-INLINE ir_node *new_r_FuncCall (ir_graph *irg, ir_node *block,
-                  ir_node *callee, int arity, ir_node **in,
-                  type *tp) {
-  return new_rd_FuncCall(NULL, irg, block, callee, arity, in, tp);
+INLINE ir_node *new_r_NoMem  (ir_graph *irg) {
+  return new_rd_NoMem(irg);
+}
+INLINE ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
+    ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
+  return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
 }
 
 
 }
 
 
@@ -1057,8 +1105,8 @@ new_d_Start (dbg_info* db)
              op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = current_ir_graph; */
 
              op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = current_ir_graph; */
 
-  res = optimize_node (res);
-  irn_vrfy_irg (res, current_ir_graph);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, current_ir_graph);
   return res;
 }
 
   return res;
 }
 
@@ -1066,10 +1114,10 @@ ir_node *
 new_d_End (dbg_info* db)
 {
   ir_node *res;
 new_d_End (dbg_info* db)
 {
   ir_node *res;
-  res = new_ir_node (db, current_ir_graph,  current_ir_graph->current_block,
+  res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
              op_End, mode_X, -1, NULL);
              op_End, mode_X, -1, NULL);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, current_ir_graph);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
 }
 
   return res;
 }
@@ -1084,19 +1132,25 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
   int i;
   bool has_unknown = false;
 
   int i;
   bool has_unknown = false;
 
-  res = new_rd_Block (db, current_ir_graph, arity, in);
+  res = new_rd_Block(db, current_ir_graph, arity, in);
 
   /* Create and initialize array for Phi-node construction. */
 
   /* Create and initialize array for Phi-node construction. */
-  res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
-                                         current_ir_graph->n_loc);
-  memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
+  if (get_irg_phase_state(current_ir_graph) == phase_building) {
+    res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
+                                         current_ir_graph->n_loc);
+    memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
+  }
 
 
-  for (i = arity-1; i >= 0; i--) if (get_irn_op(in[i]) == op_Unknown) has_unknown = true;
+  for (i = arity-1; i >= 0; i--)
+    if (get_irn_op(in[i]) == op_Unknown) {
+      has_unknown = true;
+      break;
+    }
 
 
-  if (!has_unknown) res = optimize_node (res);
+  if (!has_unknown) res = optimize_node(res);
   current_ir_graph->current_block = res;
 
   current_ir_graph->current_block = res;
 
-  irn_vrfy_irg (res, current_ir_graph);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
 }
 
   return res;
 }
@@ -1111,7 +1165,7 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
 
   Call Graph:   ( A ---> B == A "calls" B)
 
 
   Call Graph:   ( A ---> B == A "calls" B)
 
-       get_value         mature_block
+       get_value         mature_immBlock
           |                   |
           |                   |
           |                   |
           |                   |
           |                   |
           |                   |
@@ -1132,8 +1186,9 @@ static INLINE ir_node *
 new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
 {
   ir_node *res;
 new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
 {
   ir_node *res;
-  res = new_ir_node (NULL, irg, block, op_Phi, mode, 0, NULL);
-  irn_vrfy_irg (res, irg);
+
+  res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   return res;
 }
 
@@ -1156,7 +1211,7 @@ new_Phi_in_stack(void) {
 
   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
 
 
   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
 
-  res->stack = NEW_ARR_F (ir_node *, 1);
+  res->stack = NEW_ARR_F (ir_node *, 0);
   res->pos = 0;
 
   return res;
   res->pos = 0;
 
   return res;
@@ -1282,7 +1337,7 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int i
     res = known;
   } else {
     res = optimize_node (res);
     res = known;
   } else {
     res = optimize_node (res);
-    irn_vrfy_irg (res, irg);
+    IRN_VRFY_IRG(res, irg);
   }
 
   /* return the pointer to the Phi node.  This node might be deallocated! */
   }
 
   /* return the pointer to the Phi node.  This node might be deallocated! */
@@ -1332,7 +1387,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
      The call order
        get_value    (makes Phi0, put's it into graph_arr)
        set_value    (overwrites Phi0 in graph_arr)
      The call order
        get_value    (makes Phi0, put's it into graph_arr)
        set_value    (overwrites Phi0 in graph_arr)
-       mature_block (upgrades Phi0, puts it again into graph_arr, overwriting
+       mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
                      the proper value.)
      fails. */
   if (!block->attr.block.graph_arr[pos]) {
                      the proper value.)
      fails. */
   if (!block->attr.block.graph_arr[pos]) {
@@ -1423,7 +1478,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
     /* 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
     /* 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_block
+       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
        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
@@ -1515,7 +1570,7 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
     }
   } else {
     res = optimize_node (res);  /* This is necessary to add the node to the hash table for cse. */
     }
   } else {
     res = optimize_node (res);  /* This is necessary to add the node to the hash table for cse. */
-    irn_vrfy_irg (res, irg);
+    IRN_VRFY_IRG(res, irg);
     /* Memory Phis in endless loops must be kept alive.
        As we can't distinguish these easily we keep all of them alive. */
     if ((res->op == op_Phi) && (mode == mode_M))
     /* Memory Phis in endless loops must be kept alive.
        As we can't distinguish these easily we keep all of them alive. */
     if ((res->op == op_Phi) && (mode == mode_M))
@@ -1569,14 +1624,22 @@ static INLINE ir_node ** new_frag_arr (ir_node *n)
   return arr;
 }
 
   return arr;
 }
 
+/**
+ * returns the frag_arr from a node
+ */
 static INLINE ir_node **
 get_frag_arr (ir_node *n) {
 static INLINE ir_node **
 get_frag_arr (ir_node *n) {
-  if (get_irn_op(n) == op_Call) {
-    return n->attr.call.frag_arr;
-  } else if (get_irn_op(n) == op_Alloc) {
-    return n->attr.a.frag_arr;
-  } else {
-    return n->attr.frag_arr;
+  switch (get_irn_opcode(n)) {
+  case iro_Call:
+    return n->attr.call.exc.frag_arr;
+  case iro_Alloc:
+    return n->attr.a.exc.frag_arr;
+  case iro_Load:
+    return n->attr.load.exc.frag_arr;
+  case iro_Store:
+    return n->attr.store.exc.frag_arr;
+  default:
+    return n->attr.except.frag_arr;
   }
 }
 
   }
 }
 
@@ -1675,7 +1738,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
          before recuring.
       */
       if (default_initialize_local_variable)
          before recuring.
       */
       if (default_initialize_local_variable)
-        block->attr.block.graph_arr[pos] = default_initialize_local_variable(mode, pos);
+        block->attr.block.graph_arr[pos] = default_initialize_local_variable(mode, pos - 1);
       else
         block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
       /* We don't need to care about exception ops in the start block.
       else
         block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
       /* We don't need to care about exception ops in the start block.
@@ -1727,7 +1790,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
      optimization possibilities.
      The Phi0 node either is allocated in this function, or it comes from
      a former call to get_r_value_internal. In this case we may not yet
      optimization possibilities.
      The Phi0 node either is allocated in this function, or it comes from
      a former call to get_r_value_internal. In this case we may not yet
-     exchange phi0, as this is done in mature_block. */
+     exchange phi0, as this is done in mature_immBlock. */
   if (!phi0) {
     phi0_all = block->attr.block.graph_arr[pos];
     if (!((get_irn_op(phi0_all) == op_Phi) &&
   if (!phi0) {
     phi0_all = block->attr.block.graph_arr[pos];
     if (!((get_irn_op(phi0_all) == op_Phi) &&
@@ -1824,7 +1887,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
     /* 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.  The Phi0 is then added to the list of Phi0 nodes in this block
     /* 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.  The Phi0 is then added to the list of Phi0 nodes in this block
-       to be matured by mature_block later.
+       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. */
        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. */
@@ -1856,7 +1919,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
 /** Finalize a Block node, when all control flows are known.  */
 /** Acceptable parameters are only Block nodes.               */
 void
 /** Finalize a Block node, when all control flows are known.  */
 /** Acceptable parameters are only Block nodes.               */
 void
-mature_block (ir_node *block)
+mature_immBlock (ir_node *block)
 {
 
   int ins;
 {
 
   int ins;
@@ -1893,28 +1956,28 @@ mature_block (ir_node *block)
        nodes refer to the unoptimized node.
        We can call _2, as global cse has no effect on blocks. */
     block = optimize_in_place_2(block);
        nodes refer to the unoptimized node.
        We can call _2, as global cse has no effect on blocks. */
     block = optimize_in_place_2(block);
-    irn_vrfy_irg(block, current_ir_graph);
+    IRN_VRFY_IRG(block, current_ir_graph);
   }
 }
 
 ir_node *
 new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
 {
   }
 }
 
 ir_node *
 new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
 {
-  return new_rd_Phi (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Phi(db, current_ir_graph, current_ir_graph->current_block,
             arity, in, mode);
 }
 
 ir_node *
 new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
 {
             arity, in, mode);
 }
 
 ir_node *
 new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
 {
-  return new_rd_Const (db, current_ir_graph, current_ir_graph->start_block,
+  return new_rd_Const(db, current_ir_graph, current_ir_graph->start_block,
               mode, con);
 }
 
 ir_node *
 new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
 {
               mode, con);
 }
 
 ir_node *
 new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
 {
-  return new_rd_Const_type (db, current_ir_graph, current_ir_graph->start_block,
+  return new_rd_Const_type(db, current_ir_graph, current_ir_graph->start_block,
                 mode, con, tp);
 }
 
                 mode, con, tp);
 }
 
@@ -1922,14 +1985,14 @@ new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
 ir_node *
 new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
 {
 ir_node *
 new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
 {
-  return new_rd_Id (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Id(db, current_ir_graph, current_ir_graph->current_block,
            val, mode);
 }
 
 ir_node *
 new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj)
 {
            val, mode);
 }
 
 ir_node *
 new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj)
 {
-  return new_rd_Proj (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Proj(db, current_ir_graph, current_ir_graph->current_block,
              arg, mode, proj);
 }
 
              arg, mode, proj);
 }
 
@@ -1947,49 +2010,49 @@ new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
 ir_node *
 new_d_Conv (dbg_info* db, ir_node *op, ir_mode *mode)
 {
 ir_node *
 new_d_Conv (dbg_info* db, ir_node *op, ir_mode *mode)
 {
-  return new_rd_Conv (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Conv(db, current_ir_graph, current_ir_graph->current_block,
              op, mode);
 }
 
 ir_node *
 new_d_Cast (dbg_info* db, ir_node *op, type *to_tp)
 {
              op, mode);
 }
 
 ir_node *
 new_d_Cast (dbg_info* db, ir_node *op, type *to_tp)
 {
-  return new_rd_Cast (db, current_ir_graph, current_ir_graph->current_block, op, to_tp);
+  return new_rd_Cast(db, current_ir_graph, current_ir_graph->current_block, op, to_tp);
 }
 
 ir_node *
 new_d_Tuple (dbg_info* db, int arity, ir_node **in)
 {
 }
 
 ir_node *
 new_d_Tuple (dbg_info* db, int arity, ir_node **in)
 {
-  return new_rd_Tuple (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Tuple(db, current_ir_graph, current_ir_graph->current_block,
               arity, in);
 }
 
 ir_node *
 new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
               arity, in);
 }
 
 ir_node *
 new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
-  return new_rd_Add (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Add(db, current_ir_graph, current_ir_graph->current_block,
             op1, op2, mode);
 }
 
 ir_node *
 new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
             op1, op2, mode);
 }
 
 ir_node *
 new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
-  return new_rd_Sub (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Sub(db, current_ir_graph, current_ir_graph->current_block,
             op1, op2, mode);
 }
 
 
 ir_node *
             op1, op2, mode);
 }
 
 
 ir_node *
-new_d_Minus  (dbg_info* db, ir_node *op,  ir_mode *mode)
+new_d_Minus (dbg_info* db, ir_node *op,  ir_mode *mode)
 {
 {
-  return new_rd_Minus (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Minus(db, current_ir_graph, current_ir_graph->current_block,
               op, mode);
 }
 
 ir_node *
 new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
               op, mode);
 }
 
 ir_node *
 new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
 {
-  return new_rd_Mul (db, current_ir_graph, current_ir_graph->current_block,
+  return new_rd_Mul(db, current_ir_graph, current_ir_graph->current_block,
             op1, op2, mode);
 }
 
             op1, op2, mode);
 }
 
@@ -2013,8 +2076,9 @@ new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   ir_node *res;
   res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
              memop, op1, op2);
   ir_node *res;
   res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
              memop, op1, op2);
+  res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Quot, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2026,8 +2090,9 @@ new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   ir_node *res;
   res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
                memop, op1, op2);
   ir_node *res;
   res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
                memop, op1, op2);
+  res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_DivMod, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2039,8 +2104,9 @@ new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   ir_node *res;
   res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
   ir_node *res;
   res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
+  res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Div, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2052,8 +2118,9 @@ new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   ir_node *res;
   res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
   ir_node *res;
   res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
+  res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Mod, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2149,7 +2216,7 @@ new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **
   res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
              store, callee, arity, in, tp);
 #if PRECISE_EXC_CONTEXT
   res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
              store, callee, arity, in, tp);
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Call, &res->attr.call.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2170,13 +2237,13 @@ new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj)
 }
 
 ir_node *
 }
 
 ir_node *
-new_d_Load (dbg_info* db, ir_node *store, ir_node *addr)
+new_d_Load (dbg_info* db, ir_node *store, ir_node *addr, ir_mode *mode)
 {
   ir_node *res;
   res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block,
 {
   ir_node *res;
   res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block,
-             store, addr);
+             store, addr, mode);
 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Load, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2189,7 +2256,7 @@ new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val)
   res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block,
               store, addr, val);
 #if PRECISE_EXC_CONTEXT
   res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block,
               store, addr, val);
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Store, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2203,7 +2270,7 @@ new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type,
   res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
               store, size, alloc_type, where);
 #if PRECISE_EXC_CONTEXT
   res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
               store, size, alloc_type, where);
 #if PRECISE_EXC_CONTEXT
-  allocate_frag_arr(res, op_Alloc, &res->attr.a.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #endif
 
   return res;
@@ -2240,7 +2307,14 @@ new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
 }
 
 ir_node *
 }
 
 ir_node *
-new_d_SymConst (dbg_info* db, type_or_id_p value, symconst_kind kind)
+new_d_SymConst_type (dbg_info* db, symconst_symbol value, symconst_kind kind, type *tp)
+{
+  return new_rd_SymConst_type (db, current_ir_graph, current_ir_graph->start_block,
+                         value, kind, tp);
+}
+
+ir_node *
+new_d_SymConst (dbg_info* db, symconst_symbol value, symconst_kind kind)
 {
   return new_rd_SymConst (db, current_ir_graph, current_ir_graph->start_block,
                          value, kind);
 {
   return new_rd_SymConst (db, current_ir_graph, current_ir_graph->start_block,
                          value, kind);
@@ -2255,9 +2329,9 @@ new_d_Sync (dbg_info* db, int arity, ir_node** in)
 
 
 ir_node *
 
 
 ir_node *
-new_d_Bad (void)
+(new_d_Bad)(void)
 {
 {
-  return current_ir_graph->bad;
+  return __new_d_Bad();
 }
 
 ir_node *
 }
 
 ir_node *
@@ -2311,14 +2385,16 @@ new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
 }
 
 ir_node *
 }
 
 ir_node *
-new_d_FuncCall (dbg_info* db, ir_node *callee, int arity, ir_node **in,
-      type *tp)
+(new_d_NoMem)(void)
 {
 {
-  ir_node *res;
-  res = new_rd_FuncCall (db, current_ir_graph, current_ir_graph->current_block,
-             callee, arity, in, tp);
+  return __new_d_NoMem();
+}
 
 
-  return res;
+ir_node *
+new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
+    ir_node *ir_true, ir_mode *mode) {
+  return new_rd_Mux (db, current_ir_graph, current_ir_graph->current_block,
+      sel, ir_false, ir_true, mode);
 }
 
 /* ********************************************************************* */
 }
 
 /* ********************************************************************* */
@@ -2335,12 +2411,13 @@ ir_node *new_d_immBlock (dbg_info* db) {
   /* creates a new dynamic in-array as length of in is -1 */
   res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
   current_ir_graph->current_block = res;
   /* creates a new dynamic in-array as length of in is -1 */
   res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
   current_ir_graph->current_block = res;
-  res->attr.block.matured = 0;
+  res->attr.block.matured     = 0;
+  res->attr.block.dead        = 0;
   /* res->attr.block.exc = exc_normal; */
   /* res->attr.block.handler_entry = 0; */
   /* res->attr.block.exc = exc_normal; */
   /* res->attr.block.handler_entry = 0; */
-  res->attr.block.irg = current_ir_graph;
-  res->attr.block.backedge = NULL;
-  res->attr.block.in_cg = NULL;
+  res->attr.block.irg         = current_ir_graph;
+  res->attr.block.backedge    = NULL;
+  res->attr.block.in_cg       = NULL;
   res->attr.block.cg_backedge = NULL;
   set_Block_block_visited(res, 0);
 
   res->attr.block.cg_backedge = NULL;
   set_Block_block_visited(res, 0);
 
@@ -2350,32 +2427,32 @@ ir_node *new_d_immBlock (dbg_info* db) {
   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
 
   /* Immature block may not be optimized! */
   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
 
   /* Immature block may not be optimized! */
-  irn_vrfy_irg (res, current_ir_graph);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
 }
 
 INLINE ir_node *
 
   return res;
 }
 
 INLINE ir_node *
-new_immBlock () {
+new_immBlock (void) {
   return new_d_immBlock(NULL);
 }
 
 /* add an adge to a jmp/control flow node */
 void
   return new_d_immBlock(NULL);
 }
 
 /* add an adge to a jmp/control flow node */
 void
-add_in_edge (ir_node *block, ir_node *jmp)
+add_immBlock_pred (ir_node *block, ir_node *jmp)
 {
   if (block->attr.block.matured) {
     assert(0 && "Error: Block already matured!\n");
   }
   else {
 {
   if (block->attr.block.matured) {
     assert(0 && "Error: Block already matured!\n");
   }
   else {
-    assert (jmp != NULL);
-    ARR_APP1 (ir_node *, block->in, jmp);
+    assert(jmp != NULL);
+    ARR_APP1(ir_node *, block->in, jmp);
   }
 }
 
 /* changing the current block */
 void
   }
 }
 
 /* changing the current block */
 void
-switch_block (ir_node *target)
+set_cur_block (ir_node *target)
 {
   current_ir_graph->current_block = target;
 }
 {
   current_ir_graph->current_block = target;
 }
@@ -2435,7 +2512,7 @@ keep_alive (ir_node *ka)
 
 /** Useful access routines **/
 /* Returns the current block of the current graph.  To set the current
 
 /** Useful access routines **/
 /* Returns the current block of the current graph.  To set the current
-   block use switch_block(). */
+   block use set_cur_block. */
 ir_node *get_cur_block() {
   return get_irg_current_block(current_ir_graph);
 }
 ir_node *get_cur_block() {
   return get_irg_current_block(current_ir_graph);
 }
@@ -2487,7 +2564,12 @@ ir_node *new_Raise  (ir_node *store, ir_node *obj) {
 ir_node *new_Const  (ir_mode *mode, tarval *con) {
   return new_d_Const(NULL, mode, con);
 }
 ir_node *new_Const  (ir_mode *mode, tarval *con) {
   return new_d_Const(NULL, mode, con);
 }
-ir_node *new_SymConst (type_or_id_p value, symconst_kind kind) {
+
+ir_node *new_Const_type(tarval *con, type *tp) {
+  return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
+}
+
+ir_node *new_SymConst (symconst_symbol value, symconst_kind kind) {
   return new_d_SymConst(NULL, value, kind);
 }
 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, entity *ent) {
   return new_d_SymConst(NULL, value, kind);
 }
 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, entity *ent) {
@@ -2568,8 +2650,8 @@ ir_node *new_Cast   (ir_node *op, type *to_tp) {
 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
   return new_d_Phi(NULL, arity, in, mode);
 }
 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
   return new_d_Phi(NULL, arity, in, mode);
 }
-ir_node *new_Load   (ir_node *store, ir_node *addr) {
-  return new_d_Load(NULL, store, addr);
+ir_node *new_Load   (ir_node *store, ir_node *addr, ir_mode *mode) {
+  return new_d_Load(NULL, store, addr, mode);
 }
 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
   return new_d_Store(NULL, store, addr, val);
 }
 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
   return new_d_Store(NULL, store, addr, val);
@@ -2621,6 +2703,9 @@ ir_node *new_Break  (void) {
 ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
   return new_d_Filter(NULL, arg, mode, proj);
 }
 ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
   return new_d_Filter(NULL, arg, mode, proj);
 }
-ir_node *new_FuncCall (ir_node *callee, int arity, ir_node **in, type *tp) {
-  return new_d_FuncCall(NULL, callee, arity, in, tp);
+ir_node *new_NoMem  (void) {
+  return new_d_NoMem();
+}
+ir_node *new_Mux (ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
+  return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
 }
 }
libfirm