X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Fircons.c;h=bcd8b7bdda94af3b58f0ebeef2b8dcff224c2847;hb=cb91bddc9cacdab7c28e4336847bd3dc248aa549;hp=3aac081dcd1d91d7ec97032849f9895e081c3042;hpb=19a8e44d561f4eb9d766a790a007641086d00581;p=libfirm

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 3aac081dc..bcd8b7bdd 100644
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -18,10 +18,10 @@
 # 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 "irop.h"
+# include "irop_t.h"
 # include "iropt_t.h"
 # include "irgmod.h"
 # include "array.h"
@@ -40,6 +40,13 @@ struct Phi_in_stack {
 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
  */
@@ -67,7 +74,7 @@ new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
   res->attr.block.in_cg = NULL;
   res->attr.block.cg_backedge = NULL;
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -76,10 +83,10 @@ new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   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; */
 
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -88,9 +95,9 @@ new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
 {
   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;
 }
 
@@ -108,7 +115,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 );
 
-  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);
 
@@ -119,7 +126,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);
-  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. */
@@ -132,16 +139,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;
-  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);
-  irn_vrfy_irg (res, irg);
-
-#if 0
-  res = local_optimize_newby (res);
-# endif
+  IRN_VRFY_IRG(res, irg);
 
   return res;
 }
@@ -150,20 +154,18 @@ 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)));
+  /* 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)
 {
-  ir_node *in[1];
   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;
 }
 
@@ -171,19 +173,18 @@ INLINE ir_node *
 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;
-  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));
-  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;
 
 }
@@ -203,12 +204,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)
 {
-  ir_node *in[1];
   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;
 }
 
@@ -216,10 +216,11 @@ INLINE ir_node *
 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);
+
+  res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
   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;
 }
 
@@ -228,9 +229,9 @@ new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **
 {
   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);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -240,11 +241,12 @@ new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -254,24 +256,24 @@ new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   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);
-  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,
-         ir_node *op,  ir_mode *mode)
+         ir_node *op, ir_mode *mode)
 {
-  ir_node *in[1];
   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;
 }
 
@@ -281,11 +283,12 @@ new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -293,14 +296,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)
 {
-  ir_node *in[3] ;
+  ir_node *in[3];
   ir_node *res;
+
   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;
 }
 
@@ -310,12 +314,13 @@ new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
+
   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;
 }
 
@@ -325,12 +330,13 @@ new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
+
   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;
 }
 
@@ -340,12 +346,13 @@ new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
+
   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;
 }
 
@@ -355,11 +362,12 @@ new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -369,11 +377,12 @@ new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -383,11 +392,12 @@ new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   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);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -395,12 +405,11 @@ INLINE ir_node *
 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;
-  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;
 }
 
@@ -410,11 +419,12 @@ new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -424,11 +434,12 @@ new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -438,11 +449,12 @@ new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -452,11 +464,12 @@ new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[2];
   ir_node *res;
+
   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;
 }
 
@@ -464,12 +477,11 @@ INLINE ir_node *
 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;
-  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);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -481,9 +493,10 @@ new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
   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;
 }
 
@@ -491,23 +504,23 @@ INLINE ir_node *
 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);
-  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)
 {
-  ir_node *in[1];
   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);
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -520,18 +533,18 @@ new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
   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;
-  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));
   set_Call_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;
 }
 
@@ -546,10 +559,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;
-  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;
 }
 
@@ -558,26 +571,29 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no
 {
   ir_node *in[2];
   ir_node *res;
+
   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,
-        ir_node *store, ir_node *adr)
+        ir_node *store, ir_node *adr, ir_mode *mode)
 {
   ir_node *in[2];
   ir_node *res;
+
   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.load_mode  = mode;
+  res->attr.load.volatility = volatility_non_volatile;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -587,14 +603,14 @@ new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block,
 {
   ir_node *in[3];
   ir_node *res;
+
   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.volatility = volatility_non_volatile;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -604,15 +620,14 @@ new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
 {
   ir_node *in[2];
   ir_node *res;
+
   in[0] = store;
   in[1] = size;
-  res = new_ir_node (db, irg, block, op_Alloc, mode_T, 2, in);
-
+  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->attr.a.type  = alloc_type;
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -622,15 +637,14 @@ new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
 {
   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);
-
   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;
 }
 
@@ -645,16 +659,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;
-  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;
-  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 = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -667,54 +679,76 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
   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 = optimize (res);
-  * irn_vrfy_irg (res, irg); */
-  return (res);
+  /* res = optimize(res); */
+  IRN_VRFY_IRG(res, irg);
+  return res;
 }
 
 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;
-  if (symkind == linkage_ptr_info)
+
+  if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
     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;
-  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;
 }
 
+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, 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;
 
-  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;
 }
 
@@ -728,22 +762,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;
+
   in[0] = val;
   in[1] = bound;
-
   res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
-
   res->attr.confirm_cmp = cmp;
-
   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 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 *
@@ -751,12 +783,13 @@ new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
 {
   ir_node *in[1];
   ir_node *res;
+
   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 = optimize_node (res);
-  irn_vrfy_irg (res, irg);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -765,10 +798,9 @@ new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   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;
-
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG(res, irg);
   return res;
 }
 
@@ -777,10 +809,9 @@ new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
 {
   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;
-
-  irn_vrfy_irg (res, irg);
+  IRN_VRFY_IRG (res, irg);
   return res;
 }
 
@@ -788,9 +819,10 @@ INLINE ir_node *
 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;
 }
 
@@ -798,21 +830,19 @@ INLINE ir_node *
 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;
-  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));
-  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;
 
 }
@@ -826,17 +856,17 @@ new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block,
   int r_arity;
 
   r_arity = arity+1;
-  NEW_ARR_A (ir_node *, r_in, r_arity);
+  NEW_ARR_A(ir_node *, r_in, r_arity);
   r_in[0] = callee;
-  memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
+  memcpy(&r_in[1], in, sizeof (ir_node *) * arity);
 
-  res = new_ir_node (db, irg, block, op_FuncCall, mode_T, r_arity, r_in);
+  res = new_ir_node(db, irg, block, op_FuncCall, mode_T, r_arity, r_in);
 
   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;
 }
 
@@ -869,7 +899,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,
-                       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,
@@ -970,8 +1000,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,
-               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) {
@@ -1057,8 +1087,8 @@ new_d_Start (dbg_info* db)
              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;
 }
 
@@ -1066,10 +1096,10 @@ ir_node *
 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);
-  res = optimize_node (res);
-  irn_vrfy_irg (res, current_ir_graph);
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
 }
@@ -1084,19 +1114,25 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
   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. */
-  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;
 
-  irn_vrfy_irg (res, current_ir_graph);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
 }
@@ -1111,7 +1147,7 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
 
   Call Graph:   ( A ---> B == A "calls" B)
 
-       get_value         mature_block
+       get_value         mature_immBlock
           |                   |
           |                   |
           |                   |
@@ -1132,8 +1168,9 @@ static INLINE ir_node *
 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;
 }
 
@@ -1156,7 +1193,7 @@ new_Phi_in_stack(void) {
 
   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;
@@ -1282,7 +1319,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);
-    irn_vrfy_irg (res, irg);
+    IRN_VRFY_IRG(res, irg);
   }
 
   /* return the pointer to the Phi node.  This node might be deallocated! */
@@ -1332,7 +1369,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)
-       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]) {
@@ -1423,7 +1460,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
-       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
@@ -1515,7 +1552,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. */
-    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))
@@ -1543,30 +1580,48 @@ static INLINE ir_node ** new_frag_arr (ir_node *n)
 {
   ir_node **arr;
   int opt;
+
   arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
   memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
      sizeof(ir_node *)*current_ir_graph->n_loc);
+
   /* turn off optimization before allocating Proj nodes, as res isn't
      finished yet. */
   opt = get_opt_optimize(); set_optimize(0);
   /* Here we rely on the fact that all frag ops have Memory as first result! */
   if (get_irn_op(n) == op_Call)
-    arr[0] = new_Proj(n, mode_M, 3);
-  else
-    arr[0] = new_Proj(n, mode_M, 0);
+    arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
+  else {
+    assert((pn_Quot_M == pn_DivMod_M) &&
+	   (pn_Quot_M == pn_Div_M)    &&
+	   (pn_Quot_M == pn_Mod_M)    &&
+	   (pn_Quot_M == pn_Load_M)   &&
+	   (pn_Quot_M == pn_Store_M)  &&
+	   (pn_Quot_M == pn_Alloc_M)    );
+    arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
+  }
   set_optimize(opt);
+
   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
   return arr;
 }
 
+/**
+ * returns the frag_arr from a node
+ */
 static INLINE ir_node **
 get_frag_arr (ir_node *n) {
-  if (get_irn_op(n) == op_Call) {
+  switch (get_irn_opcode(n)) {
+  case iro_Call:
     return n->attr.call.frag_arr;
-  } else if (get_irn_op(n) == op_Alloc) {
+  case iro_Alloc:
     return n->attr.a.frag_arr;
-  } else {
-    return n->attr.frag_arr;
+  case iro_Load:
+    return n->attr.load.frag_arr;
+  case iro_Store:
+    return n->attr.store.frag_arr;
+  default:
+    return n->attr.except.frag_arr;
   }
 }
 
@@ -1665,7 +1720,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
          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.
@@ -1717,7 +1772,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
-     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) &&
@@ -1814,7 +1869,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
-       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. */
@@ -1846,7 +1901,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
-mature_block (ir_node *block)
+mature_immBlock (ir_node *block)
 {
 
   int ins;
@@ -1883,28 +1938,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);
-    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)
 {
-  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)
 {
-  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)
 {
-  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);
 }
 
@@ -1912,14 +1967,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)
 {
-  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)
 {
-  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);
 }
 
@@ -1937,49 +1992,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)
 {
-  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)
 {
-  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)
 {
-  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)
 {
-  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)
 {
-  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 *
-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)
 {
-  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);
 }
 
@@ -1988,9 +2043,9 @@ new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
  */
 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
   if (get_opt_precise_exc_context()) {
-    if (! *frag_store &&
-	(current_ir_graph->phase_state == phase_building) &&
-	(get_irn_op(res) == op)) { /* Could be optimized away. */
+    if ((current_ir_graph->phase_state == phase_building) &&
+	(get_irn_op(res) == op) && /* Could be optimized away. */
+	!*frag_store)    /* Could be a cse where the arr is already set. */ {
       *frag_store = new_frag_arr(res);
     }
   }
@@ -2004,7 +2059,7 @@ new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
              memop, op1, op2);
 #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;
@@ -2017,7 +2072,7 @@ new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
                memop, op1, op2);
 #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;
@@ -2030,7 +2085,7 @@ new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
 #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;
@@ -2043,7 +2098,7 @@ new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
             memop, op1, op2);
 #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;
@@ -2160,13 +2215,13 @@ new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj)
 }
 
 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,
-             store, addr);
+             store, addr, mode);
 #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.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
@@ -2179,7 +2234,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
-  allocate_frag_arr(res, op_Store, &res->attr.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Store, &res->attr.store.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
@@ -2230,7 +2285,14 @@ new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
 }
 
 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);
@@ -2245,9 +2307,9 @@ new_d_Sync (dbg_info* db, int arity, ir_node** in)
 
 
 ir_node *
-new_d_Bad (void)
+(new_d_Bad)(void)
 {
-  return current_ir_graph->bad;
+  return __new_d_Bad();
 }
 
 ir_node *
@@ -2340,32 +2402,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! */
-  irn_vrfy_irg (res, current_ir_graph);
+  IRN_VRFY_IRG(res, current_ir_graph);
 
   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
-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 {
-    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
-switch_block (ir_node *target)
+set_cur_block (ir_node *target)
 {
   current_ir_graph->current_block = target;
 }
@@ -2425,7 +2487,7 @@ keep_alive (ir_node *ka)
 
 /** 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);
 }
@@ -2477,7 +2539,7 @@ 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_SymConst (type_or_id_p value, symconst_kind kind) {
+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) {
@@ -2558,8 +2620,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_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);