Added index -> node map to irgs

[libfirm] / ir / ir / ircons.c

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 38c6dd9..22f6743 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -55,24 +55,127 @@ typedef struct Phi_in_stack Phi_in_stack;
 # define IRN_VRFY_IRG(res, irg)
 #else
 # define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)
 # define IRN_VRFY_IRG(res, irg)
 #else
 # define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)

-#endif
+#endif /* NDEBUG */

 
 

-/*
- * language dependant initialization variable
+/**
+ * Language dependent variable initialization callback.

  */
 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
 
  */
 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
 

-/* -------------------------------------------- */
-/* privat interfaces, for professional use only */
-/* -------------------------------------------- */
+/* creates a bd constructor for a binop */
+#define NEW_BD_BINOP(instr)                                     \
+static ir_node *                                                \
+new_bd_##instr (dbg_info *db, ir_node *block,                   \
+       ir_node *op1, ir_node *op2, ir_mode *mode)               \
+{                                                               \
+  ir_node  *in[2];                                              \
+  ir_node  *res;                                                \
+  ir_graph *irg = current_ir_graph;                             \
+  in[0] = op1;                                                  \
+  in[1] = op2;                                                  \
+  res = new_ir_node(db, irg, block, op_##instr, mode, 2, in);   \
+  res = optimize_node(res);                                     \
+  IRN_VRFY_IRG(res, irg);                                       \
+  return res;                                                   \
+}
+
+/* creates a bd constructor for an unop */
+#define NEW_BD_UNOP(instr)                                      \
+static ir_node *                                                \
+new_bd_##instr (dbg_info *db, ir_node *block,                   \
+              ir_node *op, ir_mode *mode)                       \
+{                                                               \
+  ir_node  *res;                                                \
+  ir_graph *irg = current_ir_graph;                             \
+  res = new_ir_node(db, irg, block, op_##instr, mode, 1, &op);  \
+  res = optimize_node(res);                                     \
+  IRN_VRFY_IRG(res, irg);                                       \
+  return res;                                                   \
+}
+
+/* creates a bd constructor for an divop */
+#define NEW_BD_DIVOP(instr)                                     \
+static ir_node *                                                \
+new_bd_##instr (dbg_info *db, ir_node *block,                   \
+            ir_node *memop, ir_node *op1, ir_node *op2)         \
+{                                                               \
+  ir_node  *in[3];                                              \
+  ir_node  *res;                                                \
+  ir_graph *irg = current_ir_graph;                             \
+  in[0] = memop;                                                \
+  in[1] = op1;                                                  \
+  in[2] = op2;                                                  \
+  res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
+  res = optimize_node(res);                                     \
+  IRN_VRFY_IRG(res, irg);                                       \
+  return res;                                                   \
+}
+
+/* creates a rd constructor for a binop */
+#define NEW_RD_BINOP(instr)                                     \
+ir_node *                                                       \
+new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
+       ir_node *op1, ir_node *op2, ir_mode *mode)               \
+{                                                               \
+  ir_node  *res;                                                \
+  ir_graph *rem = current_ir_graph;                             \
+  current_ir_graph = irg;                                       \
+  res = new_bd_##instr(db, block, op1, op2, mode);              \
+  current_ir_graph = rem;                                       \
+  return res;                                                   \
+}
+
+/* creates a rd constructor for an unop */
+#define NEW_RD_UNOP(instr)                                      \
+ir_node *                                                       \
+new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
+              ir_node *op, ir_mode *mode)                       \
+{                                                               \
+  ir_node  *res;                                                \
+  ir_graph *rem = current_ir_graph;                             \
+  current_ir_graph = irg;                                       \
+  res = new_bd_##instr(db, block, op, mode);                    \
+  current_ir_graph = rem;                                       \
+  return res;                                                   \
+}
+
+/* creates a rd constructor for an divop */
+#define NEW_RD_DIVOP(instr)                                     \
+ir_node *                                                       \
+new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
+            ir_node *memop, ir_node *op1, ir_node *op2)         \
+{                                                               \
+  ir_node  *res;                                                \
+  ir_graph *rem = current_ir_graph;                             \
+  current_ir_graph = irg;                                       \
+  res = new_bd_##instr(db, block, memop, op1, op2);             \
+  current_ir_graph = rem;                                       \
+  return res;                                                   \
+}
+
+/* creates a d constructor for an binop */
+#define NEW_D_BINOP(instr)                                                    \
+ir_node *                                                                     \
+new_d_##instr (dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {     \
+  return new_bd_##instr(db, current_ir_graph->current_block, op1, op2, mode); \
+}
+
+/* creates a d constructor for an unop */
+#define NEW_D_UNOP(instr)                                                     \
+ir_node *                                                                     \
+new_d_##instr (dbg_info *db, ir_node *op, ir_mode *mode) {                    \
+  return new_bd_##instr(db, current_ir_graph->current_block, op, mode);         \
+}
+

 
 /* Constructs a Block with a fixed number of predecessors.
    Does not set current_block.  Can not be used with automatic
    Phi node construction. */
 
 /* Constructs a Block with a fixed number of predecessors.
    Does not set current_block.  Can not be used with automatic
    Phi node construction. */

-ir_node *
-new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
+static ir_node *
+new_bd_Block (dbg_info *db,  int arity, ir_node **in)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node (db, irg, NULL, op_Block, mode_BB, arity, in);
   set_Block_matured(res, 1);
 
   res = new_ir_node (db, irg, NULL, op_Block, mode_BB, arity, in);
   set_Block_matured(res, 1);


@@ -85,15 +188,17 @@ new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
   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.backedge    = new_backedge_arr(irg->obst, arity);
   res->attr.block.in_cg       = NULL;
   res->attr.block.cg_backedge = NULL;

+  res->attr.block.extblk      = NULL;

 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
+static ir_node *
+new_bd_Start (dbg_info *db, ir_node *block)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = irg; */
 
   res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = irg; */


@@ -102,10 +207,11 @@ new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
+static ir_node *
+new_bd_End (dbg_info *db, ir_node *block)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   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);
 


@@ -115,12 +221,13 @@ new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
 
 /* Creates a Phi node with all predecessors.  Calling this constructor
    is only allowed if the corresponding block is mature.  */
 
 /* Creates a Phi node with all predecessors.  Calling this constructor
    is only allowed if the corresponding block is mature.  */

-ir_node *
-new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
+static ir_node *
+new_bd_Phi (dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

   int i;
   int i;

-  bool has_unknown = false;
+  int has_unknown = 0;

 
   /* Don't assert that block matured: the use of this constructor is strongly
      restricted ... */
 
   /* Don't assert that block matured: the use of this constructor is strongly
      restricted ... */


@@ -133,7 +240,7 @@ new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in
 
   for (i = arity-1; i >= 0; i--)
     if (get_irn_op(in[i]) == op_Unknown) {
 
   for (i = arity-1; i >= 0; i--)
     if (get_irn_op(in[i]) == op_Unknown) {

-      has_unknown = true;
+      has_unknown = 1;

       break;
     }
 
       break;
     }
 


@@ -143,16 +250,17 @@ new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in
   /* 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))

-    add_End_keepalive(irg->end, res);
+    add_End_keepalive(get_irg_end(irg), res);

   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
+static ir_node *
+new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  res = new_ir_node (db, irg, irg->start_block, op_Const, mode, 0, NULL);
+  res = new_ir_node (db, irg, get_irg_start_block(irg), 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);
   res->attr.con.tv = con;
   set_Const_type(res, tp);  /* Call method because of complex assertion. */
   res = optimize_node (res);


@@ -162,22 +270,27 @@ new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, t
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+static ir_node *
+new_bd_Const (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con)

 {
 {

+  ir_graph *irg = current_ir_graph;
+

   return new_rd_Const_type (db, irg, block, mode, con, firm_unknown_type);
 }
 
   return new_rd_Const_type (db, irg, block, mode, con, firm_unknown_type);
 }
 

-ir_node *
-new_rd_Const_long (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, long value)
+static ir_node *
+new_bd_Const_long (dbg_info *db, ir_node *block, ir_mode *mode, long value)

 {
 {

-    return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
+  ir_graph *irg = current_ir_graph;
+
+  return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));

 }
 
 }
 

-ir_node *
-new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
+static ir_node *
+new_bd_Id (dbg_info *db, ir_node *block, ir_node *val, ir_mode *mode)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
   res = optimize_node(res);
 
   res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
   res = optimize_node(res);


@@ -185,11 +298,12 @@ new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *m
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
+static ir_node *
+new_bd_Proj (dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,

         long proj)
 {
         long proj)
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
   res->attr.proj = proj;
 
   res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
   res->attr.proj = proj;


@@ -205,11 +319,13 @@ new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode
 
 }
 
 
 }
 

-ir_node *
-new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
+static ir_node *
+new_bd_defaultProj (dbg_info *db, ir_node *block, ir_node *arg,

            long max_proj)
 {
            long max_proj)
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+

   assert(arg->op == op_Cond);
   arg->attr.c.kind = fragmentary;
   arg->attr.c.default_proj = max_proj;
   assert(arg->op == op_Cond);
   arg->attr.c.kind = fragmentary;
   arg->attr.c.default_proj = max_proj;


@@ -217,10 +333,11 @@ new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
+static ir_node *
+new_bd_Conv (dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
   res = optimize_node(res);
 
   res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
   res = optimize_node(res);


@@ -228,10 +345,11 @@ new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
+static ir_node *
+new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   assert(is_atomic_type(to_tp));
 
 
   assert(is_atomic_type(to_tp));
 


@@ -242,10 +360,11 @@ new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
+static ir_node *
+new_bd_Tuple (dbg_info *db, ir_node *block, int arity, ir_node **in)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
   res = optimize_node (res);
 
   res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
   res = optimize_node (res);


@@ -253,343 +372,463 @@ new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  ir_node *in[2];
-  ir_node *res;
+NEW_BD_BINOP(Add)
+NEW_BD_BINOP(Sub)
+NEW_BD_UNOP(Minus)
+NEW_BD_BINOP(Mul)
+NEW_BD_DIVOP(Quot)
+NEW_BD_DIVOP(DivMod)
+NEW_BD_DIVOP(Div)
+NEW_BD_DIVOP(Mod)
+NEW_BD_BINOP(And)
+NEW_BD_BINOP(Or)
+NEW_BD_BINOP(Eor)
+NEW_BD_UNOP(Not)
+NEW_BD_BINOP(Shl)
+NEW_BD_BINOP(Shr)
+NEW_BD_BINOP(Shrs)
+NEW_BD_BINOP(Rot)
+NEW_BD_UNOP(Abs)
+NEW_BD_BINOP(Carry)
+NEW_BD_BINOP(Borrow)

 
 

+static ir_node *
+new_bd_Cmp (dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2)
+{
+  ir_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

   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 = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op1, ir_node *op2, ir_mode *mode)
+static ir_node *
+new_bd_Jmp (dbg_info *db, ir_node *block)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op1;
-  in[1] = op2;
-  res = new_ir_node (db, irg, block, op_Sub, mode, 2, in);
+  res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
+  res = optimize_node (res);
+  IRN_VRFY_IRG (res, irg);
+  return res;
+}
+
+static ir_node *
+new_bd_IJmp (dbg_info *db, ir_node *block, ir_node *tgt)
+{
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+
+  res = new_ir_node (db, irg, block, op_IJmp, mode_X, 1, &tgt);
+  res = optimize_node (res);
+  IRN_VRFY_IRG (res, irg);
+
+  if (get_irn_op(res) == op_IJmp) /* still an IJmp */
+    keep_alive(res);
+  return res;
+}
+
+static ir_node *
+new_bd_Cond (dbg_info *db, ir_node *block, ir_node *c)
+{
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+
+  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->attr.c.pred         = COND_JMP_PRED_NONE;

   res = optimize_node (res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node (res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
-              ir_node *op, ir_mode *mode)
+static ir_node *
+new_bd_Call (dbg_info *db, ir_node *block, ir_node *store,
+        ir_node *callee, int arity, ir_node **in, ir_type *tp)

 {
 {

-  ir_node *res;
+  ir_node  **r_in;
+  ir_node  *res;
+  int      r_arity;
+  ir_graph *irg = current_ir_graph;
+
+  r_arity = arity+2;
+  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);

 
 

-  res = new_ir_node(db, irg, block, op_Minus, mode, 1, &op);
+  res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
+
+  assert((get_unknown_type() == tp) || is_Method_type(tp));
+  set_Call_type(res, tp);
+  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;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op1, ir_node *op2, ir_mode *mode)
+static ir_node *
+new_bd_Return (dbg_info *db, ir_node *block,
+              ir_node *store, int arity, ir_node **in)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  **r_in;
+  ir_node  *res;
+  int      r_arity;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op1;
-  in[1] = op2;
-  res = new_ir_node(db, irg, block, op_Mul, mode, 2, in);
+  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);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
-            ir_node *memop, ir_node *op1, ir_node *op2)
+static ir_node *
+new_bd_Load (dbg_info *db, ir_node *block,
+        ir_node *store, ir_node *adr, ir_mode *mode)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = memop;
-  in[1] = op1;
-  in[2] = op2;
-  res = new_ir_node(db, irg, block, op_Quot, mode_T, 3, in);
+  in[0] = store;
+  in[1] = adr;
+  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;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *memop, ir_node *op1, ir_node *op2)
+static ir_node *
+new_bd_Store (dbg_info *db, ir_node *block,
+         ir_node *store, ir_node *adr, ir_node *val)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  *in[3];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = memop;
-  in[1] = op1;
-  in[2] = op2;
-  res = new_ir_node(db, irg, block, op_DivMod, mode_T, 3, in);
+  in[0] = store;
+  in[1] = adr;
+  in[2] = val;
+  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;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
-           ir_node *memop, ir_node *op1, ir_node *op2)
+static ir_node *
+new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store,
+        ir_node *size, ir_type *alloc_type, where_alloc where)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = memop;
-  in[1] = op1;
-  in[2] = op2;
-  res = new_ir_node(db, irg, block, op_Div, mode_T, 3, in);
+  in[0] = store;
+  in[1] = size;
+  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;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
-           ir_node *memop, ir_node *op1, ir_node *op2)
+static ir_node *
+new_bd_Free (dbg_info *db, ir_node *block, ir_node *store,
+        ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  *in[3];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = memop;
-  in[1] = op1;
-  in[2] = op2;
-  res = new_ir_node(db, irg, block, op_Mod, mode_T, 3, in);
+  in[0] = store;
+  in[1] = ptr;
+  in[2] = size;
+  res = new_ir_node (db, irg, block, op_Free, mode_M, 3, in);
+  res->attr.f.where = where;
+  res->attr.f.type  = free_type;

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
-           ir_node *op1, ir_node *op2, ir_mode *mode)
+static ir_node *
+new_bd_Sel (dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
+           int arity, ir_node **in, entity *ent)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  **r_in;
+  ir_node  *res;
+  int      r_arity;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op1;
-  in[1] = op2;
-  res = new_ir_node(db, irg, block, op_And, mode, 2, in);
+  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 */
+  r_in[0] = store;
+  r_in[1] = objptr;
+  memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
+  /*
+   * FIXM: Sel's can select functions which should be of mode mode_P_code.
+   */
+  res = new_ir_node(db, irg, block, op_Sel, mode_P_data, r_arity, r_in);
+  res->attr.s.ent = ent;

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  ir_node *in[2];
-  ir_node *res;
+static ir_node *
+new_bd_SymConst_type (dbg_info *db, ir_node *block, symconst_symbol value,
+              symconst_kind symkind, ir_type *tp) {
+  ir_node  *res;
+  ir_mode  *mode;
+  ir_graph *irg = current_ir_graph;
+
+  if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
+    mode = mode_P_data;   /* FIXME: can be mode_P_code */
+  else
+    mode = mode_Iu;
+
+  res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
+
+  res->attr.i.num = symkind;
+  res->attr.i.sym = value;
+  res->attr.i.tp  = tp;

 
 

-  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);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op1, ir_node *op2, ir_mode *mode)
+static ir_node *
+new_bd_SymConst (dbg_info *db, ir_node *block, symconst_symbol value,
+         symconst_kind symkind)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  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);
+  ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);

   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Not    (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op, ir_mode *mode)
+static ir_node *
+new_bd_Sync (dbg_info *db, ir_node *block, int arity, ir_node **in)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  res = new_ir_node(db, irg, block, op_Not, mode, 1, &op);
+  res = new_ir_node(db, irg, block, op_Sync, mode_M, arity, in);

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op, ir_node *k, ir_mode *mode)
+static ir_node *
+new_bd_Confirm (dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *in[2], *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op;
-  in[1] = k;
-  res = new_ir_node(db, irg, block, op_Shl, mode, 2, in);
-  res = optimize_node(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);
   return res;
 }
 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op, ir_node *k, ir_mode *mode)
+/* this function is often called with current_ir_graph unset */
+static ir_node *
+new_bd_Unknown (ir_mode *m)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op;
-  in[1] = k;
-  res = new_ir_node(db, irg, block, op_Shr, mode, 2, in);
+  res = new_ir_node(NULL, irg, get_irg_start_block(irg), op_Unknown, m, 0, NULL);

   res = optimize_node(res);
   res = optimize_node(res);

-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op, ir_node *k, ir_mode *mode)
+static ir_node *
+new_bd_CallBegin (dbg_info *db, ir_node *block, ir_node *call)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *in[1];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op;
-  in[1] = k;
-  res = new_ir_node(db, irg, block, op_Shrs, mode, 2, in);
+  in[0] = get_Call_ptr(call);
+  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);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op, ir_node *k, ir_mode *mode)
+static ir_node *
+new_bd_EndReg (dbg_info *db, ir_node *block)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op;
-  in[1] = k;
-  res = new_ir_node(db, irg, block, op_Rot, mode, 2, in);
-  res = optimize_node(res);
+  res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
+  set_irg_end_reg(irg, res);

   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op, ir_mode *mode)
+static ir_node *
+new_bd_EndExcept (dbg_info *db, ir_node *block)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  res = new_ir_node(db, irg, block, op_Abs, mode, 1, &op);
-  res = optimize_node (res);
+  res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
+  set_irg_end_except(irg, res);
+  IRN_VRFY_IRG (res, irg);
+  return res;
+}
+
+static ir_node *
+new_bd_Break (dbg_info *db, ir_node *block)
+{
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+
+  res = new_ir_node(db, irg, block, op_Break, mode_X, 0, NULL);
+  res = optimize_node(res);

   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op1, ir_node *op2)
+static ir_node *
+new_bd_Filter (dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
+           long proj)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
-  in[0] = op1;
-  in[1] = op2;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+
+  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)));

 
 

-  res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
+static ir_node *
+new_bd_Mux  (dbg_info *db, ir_node *block,
+    ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)

 {
 {

-  ir_node *res;
+  ir_node  *in[3];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
-  res = optimize_node (res);
-  IRN_VRFY_IRG (res, irg);
+  in[0] = sel;
+  in[1] = ir_false;
+  in[2] = ir_true;
+
+  res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
+  assert(res);
+
+  res = optimize_node(res);
+  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
+static ir_node *
+new_bd_Psi (dbg_info *db, ir_node *block,
+    int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)

 {
 {

-  ir_node *res;
+  ir_node  **in;
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+  int i;

 
 

-  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);
+  NEW_ARR_A(ir_node *, in, 2 * arity + 1);
+
+  for (i = 0; i < arity; ++i) {
+    in[2 * i]     = cond[i];
+    in[2 * i + 1] = vals[i];
+  }
+  in[2 * i] = vals[i];
+
+  res = new_ir_node(db, irg, block, op_Psi, mode, 2 * arity + 1, in);
+  assert(res);
+
+  res = optimize_node(res);

   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *callee, int arity, ir_node **in, type *tp)
+static ir_node *
+new_bd_CopyB  (dbg_info *db, ir_node *block,
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)

 {
 {

-  ir_node **r_in;
-  ir_node *res;
-  int r_arity;
+  ir_node  *in[3];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  r_arity = arity+2;
-  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);
+  in[0] = store;
+  in[1] = dst;
+  in[2] = src;

 
 

-  res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
+  res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in);

 
 

-  assert((get_unknown_type() == tp) || is_Method_type(tp));
-  set_Call_type(res, tp);
-  res->attr.call.exc.pin_state = op_pin_state_pinned;
-  res->attr.call.callee_arr    = NULL;
+  res->attr.copyb.exc.pin_state = op_pin_state_pinned;
+  res->attr.copyb.data_type     = data_type;

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Return (dbg_info* db, ir_graph *irg, ir_node *block,
-              ir_node *store, int arity, ir_node **in)
+static ir_node *
+new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store,
+           ir_node *objptr, ir_type *type)

 {
 {

-  ir_node **r_in;
-  ir_node *res;
-  int r_arity;
+  ir_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  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);
+  in[0] = store;
+  in[1] = objptr;
+  res = new_ir_node(db, irg, block, op_Sel, mode_T, 2, in);
+  res->attr.io.type = type;

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

-ir_node *
-new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
+static ir_node *
+new_bd_Raise (dbg_info *db, ir_node *block, ir_node *store, ir_node *obj)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   in[0] = store;
   in[1] = obj;
 
   in[0] = store;
   in[1] = obj;


@@ -599,220 +838,481 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
-        ir_node *store, ir_node *adr, ir_mode *mode)
+static ir_node *
+new_bd_Bound (dbg_info *db, ir_node *block,
+    ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_node  *in[4];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
   in[0] = store;
 
   in[0] = store;

-  in[1] = adr;
-  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;
+  in[1] = idx;
+  in[2] = lower;
+  in[3] = upper;
+  res = new_ir_node(db, irg, block, op_Bound, mode_T, 4, in);
+  res->attr.bound.exc.pin_state = op_pin_state_pinned;

   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
 }
 

+/* --------------------------------------------- */
+/* private 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
+   Phi node construction. */

 ir_node *
 ir_node *

-new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block,
-         ir_node *store, ir_node *adr, ir_node *val)
+new_rd_Block (dbg_info *db, ir_graph *irg,  int arity, ir_node **in)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_graph *rem    = current_ir_graph;
+  ir_node  *res;
+
+  current_ir_graph = irg;
+  res = new_bd_Block (db, arity, in);
+  current_ir_graph = rem;

 
 

-  in[0] = store;
-  in[1] = adr;
-  in[2] = val;
-  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;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *size, type *alloc_type, where_alloc where)
+new_rd_Start (dbg_info *db, ir_graph *irg, ir_node *block)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  ir_graph *rem = current_ir_graph;
+  ir_node  *res;
+
+  current_ir_graph = irg;
+  res = new_bd_Start (db, block);
+  current_ir_graph = rem;

 
 

-  in[0] = store;
-  in[1] = size;
-  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;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *ptr, ir_node *size, type *free_type, where_alloc where)
+new_rd_End (dbg_info *db, ir_graph *irg, ir_node *block)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = rem;
+  res = new_bd_End (db, block);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+/* Creates a Phi node with all predecessors.  Calling this constructor
+   is only allowed if the corresponding block is mature.  */
+ir_node *
+new_rd_Phi (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph  = irg;
+  res = new_bd_Phi (db, block,arity, in, mode);
+  current_ir_graph = rem;

 
 

-  in[0] = store;
-  in[1] = ptr;
-  in[2] = size;
-  res = new_ir_node (db, irg, block, op_Free, mode_M, 3, in);
-  res->attr.f.where = where;
-  res->attr.f.type  = free_type;
-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_Sel (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
-           int arity, ir_node **in, entity *ent)
+new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)

 {
 {

-  ir_node **r_in;
-  ir_node *res;
-  int r_arity;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

-  assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
+  current_ir_graph  = irg;
+  res = new_bd_Const_type (db, block, mode, con, tp);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Const (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Const_type (db, block, mode, con, firm_unknown_type);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Const_long (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, long value)
+{
+    return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
+}
+
+ir_node *
+new_rd_Id (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Id(db, block, val, mode);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Proj (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
+        long proj)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Proj(db, block, arg, mode, proj);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_defaultProj (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg,
+           long max_proj)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_defaultProj(db, block, arg, max_proj);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Conv (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Conv(db, block, op, mode);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Cast(db, block, op, to_tp);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Tuple (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Tuple(db, block, arity, in);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+NEW_RD_BINOP(Add)
+NEW_RD_BINOP(Sub)
+NEW_RD_UNOP(Minus)
+NEW_RD_BINOP(Mul)
+NEW_RD_DIVOP(Quot)
+NEW_RD_DIVOP(DivMod)
+NEW_RD_DIVOP(Div)
+NEW_RD_DIVOP(Mod)
+NEW_RD_BINOP(And)
+NEW_RD_BINOP(Or)
+NEW_RD_BINOP(Eor)
+NEW_RD_UNOP(Not)
+NEW_RD_BINOP(Shl)
+NEW_RD_BINOP(Shr)
+NEW_RD_BINOP(Shrs)
+NEW_RD_BINOP(Rot)
+NEW_RD_UNOP(Abs)
+NEW_RD_BINOP(Carry)
+NEW_RD_BINOP(Borrow)
+
+ir_node *
+new_rd_Cmp (dbg_info *db, ir_graph *irg, ir_node *block,
+       ir_node *op1, ir_node *op2)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Cmp(db, block, op1, op2);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Jmp (dbg_info *db, ir_graph *irg, ir_node *block)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Jmp(db, block);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_IJmp (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *tgt)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_IJmp(db, block, tgt);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Cond (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Cond(db, block, c);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Call (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+        ir_node *callee, int arity, ir_node **in, ir_type *tp)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Call(db, block, store, callee, arity, in, tp);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Return (dbg_info *db, ir_graph *irg, ir_node *block,
+              ir_node *store, int arity, ir_node **in)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Return(db, block, store, arity, in);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Load (dbg_info *db, ir_graph *irg, ir_node *block,
+        ir_node *store, ir_node *adr, ir_mode *mode)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Load(db, block, store, adr, mode);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Store (dbg_info *db, ir_graph *irg, ir_node *block,
+         ir_node *store, ir_node *adr, ir_node *val)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Store(db, block, store, adr, val);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+        ir_node *size, ir_type *alloc_type, where_alloc where)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Alloc (db, block, store, size, alloc_type, where);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Free (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+        ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Free(db, block, store, ptr, size, free_type, where);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_simpleSel (dbg_info *db, ir_graph *irg, ir_node *block,
+                  ir_node *store, ir_node *objptr, entity *ent)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
+  current_ir_graph = rem;

 
 

-  r_arity = arity + 2;
-  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);
-  res->attr.s.ent = ent;
-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-           ir_node *objptr, type *ent)
+new_rd_Sel (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
+           int arity, ir_node **in, entity *ent)

 {
 {

-  ir_node **r_in;
-  ir_node *res;
-  int r_arity;
-
-  r_arity = 2;
-  NEW_ARR_A(ir_node *, r_in, r_arity);
-  r_in[0] = store;
-  r_in[1] = objptr;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

-  res = new_ir_node(db, irg, block, op_Sel, mode_T, r_arity, r_in);
-  res->attr.io.ent = ent;
+  current_ir_graph = irg;
+  res = new_bd_Sel(db, block, store, objptr, arity, in, ent);
+  current_ir_graph = rem;

 
 

-  /* res = optimize(res); */
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-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 == 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);
+new_rd_SymConst_type (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
+              symconst_kind symkind, ir_type *tp)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

-  res->attr.i.num = symkind;
-  res->attr.i.sym = value;
-  res->attr.i.tp  = tp;
+  current_ir_graph = irg;
+  res = new_bd_SymConst_type(db, block, value, symkind, tp);
+  current_ir_graph = rem;

 
 

-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
+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;
 }
 
          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_ent (dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp)
+{
+  symconst_symbol sym = {(ir_type *)symbol};
+  return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), 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_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
+  symconst_symbol sym = {(ir_type *)symbol};
+  return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);

 }
 
 }
 

-ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {

   symconst_symbol sym = {symbol};
   symconst_symbol sym = {symbol};

-  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_type_tag, tp);
+  return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);

 }
 
 }
 

-ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {

   symconst_symbol sym = {symbol};
   symconst_symbol sym = {symbol};

-  return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp);
+  return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_size, tp);

 }
 
 ir_node *
 }
 
 ir_node *

-new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
+new_rd_Sync (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in)

 {
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Sync(db, block, arity, in);
+  current_ir_graph = rem;

 
 

-  res = new_ir_node(db, irg, block, op_Sync, mode_M, arity, in);
-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
   return res;
 }
 
 ir_node *

-new_rd_Bad (ir_graph *irg)
-{
-  return irg->bad;
+new_rd_Bad (ir_graph *irg) {
+  return get_irg_bad(irg);

 }
 
 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 *
 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;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Confirm(db, block, val, bound, cmp);
+  current_ir_graph = rem;

 
 

-  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);

   return res;
 }
 
   return res;
 }
 

+/* this function is often called with current_ir_graph unset */

 ir_node *
 new_rd_Unknown (ir_graph *irg, ir_mode *m)
 {
 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);
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Unknown(m);
+  current_ir_graph = rem;
+
+  return res;

 }
 
 ir_node *
 new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
 {
 }
 
 ir_node *
 new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
 {

-  ir_node *in[1];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_CallBegin(db, block, call);
+  current_ir_graph = rem;

 
 

-  in[0] = get_Call_ptr(call);
-  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);

   return res;
 }
 
   return res;
 }
 


@@ -822,7 +1322,7 @@ 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);
   ir_node *res;
 
   res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);

-  irg->end_reg = res;
+  set_irg_end_reg(irg, res);

   IRN_VRFY_IRG(res, irg);
   return res;
 }
   IRN_VRFY_IRG(res, irg);
   return res;
 }


@@ -833,7 +1333,7 @@ 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);
   ir_node *res;
 
   res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);

-  irg->end_except = res;
+  set_irg_end_except(irg, res);

   IRN_VRFY_IRG (res, irg);
   return res;
 }
   IRN_VRFY_IRG (res, irg);
   return res;
 }


@@ -841,11 +1341,13 @@ new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
 ir_node *
 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
 {
 ir_node *
 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
 {

-  ir_node *res;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Break(db, block);
+  current_ir_graph = rem;

 
 

-  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;
 }
 


@@ -853,46 +1355,101 @@ 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 *res;
-
-  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;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

-  assert(res);
-  assert(get_Proj_pred(res));
-  assert(get_nodes_block(get_Proj_pred(res)));
+  current_ir_graph = irg;
+  res = new_bd_Filter(db, block, arg, mode, proj);
+  current_ir_graph = rem;

 
 

-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
 ir_node *
 new_rd_NoMem (ir_graph *irg) {
   return res;
 }
 
 ir_node *
 new_rd_NoMem (ir_graph *irg) {

-  return irg->no_mem;
+  return get_irg_no_mem(irg);

 }
 
 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 *
 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 *in[3];
-  ir_node *res;
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

-  in[0] = sel;
-  in[1] = ir_false;
-  in[2] = ir_true;
+  current_ir_graph = irg;
+  res = new_bd_Mux(db, block, sel, ir_false, ir_true, mode);
+  current_ir_graph = rem;

 
 

-  res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
-  assert(res);
+  return res;
+}
+
+ir_node *
+new_rd_Psi (dbg_info *db, ir_graph *irg, ir_node *block,
+    int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Psi(db, block, arity, cond, vals, mode);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_CopyB(db, block, store, dst, src, data_type);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+           ir_node *objptr, ir_type *type)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_InstOf(db, block, store, objptr, type);
+  current_ir_graph = rem;
+
+  return res;
+}
+
+ir_node *
+new_rd_Raise (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Raise(db, block, store, obj);
+  current_ir_graph = rem;

 
 

-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);

   return res;
 }
 
   return res;
 }
 

+ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block,
+    ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Bound(db, block, store, idx, lower, upper);
+  current_ir_graph = rem;
+
+  return res;
+}

 
 ir_node *new_r_Block  (ir_graph *irg,  int arity, ir_node **in) {
   return new_rd_Block(NULL, irg, arity, in);
 
 ir_node *new_r_Block  (ir_graph *irg,  int arity, ir_node **in) {
   return new_rd_Block(NULL, irg, arity, in);


@@ -906,6 +1463,9 @@ ir_node *new_r_End    (ir_graph *irg, ir_node *block) {
 ir_node *new_r_Jmp    (ir_graph *irg, ir_node *block) {
   return new_rd_Jmp(NULL, irg, block);
 }
 ir_node *new_r_Jmp    (ir_graph *irg, ir_node *block) {
   return new_rd_Jmp(NULL, irg, block);
 }

+ir_node *new_r_IJmp   (ir_graph *irg, ir_node *block, ir_node *tgt) {
+  return new_rd_IJmp(NULL, irg, block, tgt);
+}

 ir_node *new_r_Cond   (ir_graph *irg, ir_node *block, ir_node *c) {
   return new_rd_Cond(NULL, irg, block, c);
 }
 ir_node *new_r_Cond   (ir_graph *irg, ir_node *block, ir_node *c) {
   return new_rd_Cond(NULL, irg, block, c);
 }


@@ -913,37 +1473,34 @@ ir_node *new_r_Return (ir_graph *irg, ir_node *block,
                ir_node *store, int arity, ir_node **in) {
   return new_rd_Return(NULL, irg, block, store, arity, in);
 }
                ir_node *store, int arity, ir_node **in) {
   return new_rd_Return(NULL, irg, block, store, arity, in);
 }

-ir_node *new_r_Raise  (ir_graph *irg, ir_node *block,
-               ir_node *store, ir_node *obj) {
-  return new_rd_Raise(NULL, irg, block, store, obj);
-}

 ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
                ir_mode *mode, tarval *con) {
   return new_rd_Const(NULL, irg, block, mode, con);
 }
 ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
                ir_mode *mode, tarval *con) {
   return new_rd_Const(NULL, irg, block, mode, con);
 }

-

 ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
                ir_mode *mode, long value) {
   return new_rd_Const_long(NULL, irg, block, mode, value);
 }
 ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
                ir_mode *mode, long value) {
   return new_rd_Const_long(NULL, irg, block, mode, value);
 }

-
-
+ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
+               ir_mode *mode, tarval *con, ir_type *tp) {
+  return new_rd_Const_type(NULL, irg, block, mode, con, tp);
+}

 ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
                        symconst_symbol value, symconst_kind symkind) {
   return new_rd_SymConst(NULL, irg, block, value, symkind);
 }
 ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
                        symconst_symbol value, symconst_kind symkind) {
   return new_rd_SymConst(NULL, irg, block, value, symkind);
 }

+ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
+                         ir_node *objptr, entity *ent) {
+  return new_rd_Sel(NULL, irg, block, store, objptr, 0, NULL, ent);
+}

 ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
                   ir_node *objptr, int n_index, ir_node **index,
                   entity *ent) {
   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
 }
 ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
                   ir_node *objptr, int n_index, ir_node **index,
                   entity *ent) {
   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
 }

-ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
-                  type *ent) {
-  return (new_rd_InstOf (NULL, irg, block, store, objptr, ent));
-}

 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
                   ir_node *callee, int arity, ir_node **in,
 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
                   ir_node *callee, int arity, ir_node **in,

-                  type *tp) {
+                  ir_type *tp) {

   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
 }
 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
 }
 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,


@@ -998,10 +1555,6 @@ ir_node *new_r_Not    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_mode *mode) {
   return new_rd_Not(NULL, irg, block, op, mode);
 }
                ir_node *op, ir_mode *mode) {
   return new_rd_Not(NULL, irg, block, op, mode);
 }

-ir_node *new_r_Cmp    (ir_graph *irg, ir_node *block,
-               ir_node *op1, ir_node *op2) {
-  return new_rd_Cmp(NULL, irg, block, op1, op2);
-}

 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_node *k, ir_mode *mode) {
   return new_rd_Shl(NULL, irg, block, op, k, mode);
 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_node *k, ir_mode *mode) {
   return new_rd_Shl(NULL, irg, block, op, k, mode);


@@ -1018,11 +1571,23 @@ ir_node *new_r_Rot    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_node *k, ir_mode *mode) {
   return new_rd_Rot(NULL, irg, block, op, k, mode);
 }
                ir_node *op, ir_node *k, ir_mode *mode) {
   return new_rd_Rot(NULL, irg, block, op, k, mode);
 }

+ir_node *new_r_Carry  (ir_graph *irg, ir_node *block,
+               ir_node *op, ir_node *k, ir_mode *mode) {
+  return new_rd_Carry(NULL, irg, block, op, k, mode);
+}
+ir_node *new_r_Borrow (ir_graph *irg, ir_node *block,
+               ir_node *op, ir_node *k, ir_mode *mode) {
+  return new_rd_Borrow(NULL, irg, block, op, k, mode);
+}
+ir_node *new_r_Cmp    (ir_graph *irg, ir_node *block,
+               ir_node *op1, ir_node *op2) {
+  return new_rd_Cmp(NULL, irg, block, op1, op2);
+}

 ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
                ir_node *op, ir_mode *mode) {
   return new_rd_Conv(NULL, irg, block, op, mode);
 }
 ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
                ir_node *op, ir_mode *mode) {
   return new_rd_Conv(NULL, irg, block, op, mode);
 }

-ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
+ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {

   return new_rd_Cast(NULL, irg, block, op, to_tp);
 }
 ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
   return new_rd_Cast(NULL, irg, block, op, to_tp);
 }
 ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,


@@ -1038,11 +1603,11 @@ ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
   return new_rd_Store(NULL, irg, block, store, adr, val);
 }
 ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,
   return new_rd_Store(NULL, irg, block, store, adr, val);
 }
 ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,

-               ir_node *size, type *alloc_type, where_alloc where) {
+               ir_node *size, ir_type *alloc_type, where_alloc where) {

   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
 }
 ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,
   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
 }
 ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,

-               ir_node *ptr, ir_node *size, type *free_type, where_alloc where) {
+               ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {

   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
 }
 ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
 }
 ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {


@@ -1096,7 +1661,26 @@ 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);
 }
     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);
 }

-
+ir_node *new_r_Psi (ir_graph *irg, ir_node *block,
+    int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
+  return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
+}
+ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
+  return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
+}
+ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
+                  ir_type *type) {
+  return (new_rd_InstOf (NULL, irg, block, store, objptr, type));
+}
+ir_node *new_r_Raise  (ir_graph *irg, ir_node *block,
+               ir_node *store, ir_node *obj) {
+  return new_rd_Raise(NULL, irg, block, store, obj);
+}
+ir_node *new_r_Bound(ir_graph *irg, ir_node *block,
+    ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
+  return new_rd_Bound(NULL, irg, block, store, idx, lower, upper);
+}

 
 /** ********************/
 /** public interfaces  */
 
 /** ********************/
 /** public interfaces  */


@@ -1111,7 +1695,7 @@ ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
  *
  */
 ir_node *
  *
  */
 ir_node *

-new_d_Start (dbg_info* db)
+new_d_Start (dbg_info *db)

 {
   ir_node *res;
 
 {
   ir_node *res;
 


@@ -1125,7 +1709,7 @@ new_d_Start (dbg_info* db)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_End (dbg_info* db)
+new_d_End (dbg_info *db)

 {
   ir_node *res;
   res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
 {
   ir_node *res;
   res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,


@@ -1140,13 +1724,13 @@ new_d_End (dbg_info* db)
    Does set current_block.  Can be used with automatic Phi
    node construction. */
 ir_node *
    Does set current_block.  Can be used with automatic Phi
    node construction. */
 ir_node *

-new_d_Block (dbg_info* db, int arity, ir_node **in)
+new_d_Block (dbg_info *db, int arity, ir_node **in)

 {
   ir_node *res;
   int i;
 {
   ir_node *res;
   int i;

-  bool has_unknown = false;
+  int has_unknown = 0;

 
 

-  res = new_rd_Block(db, current_ir_graph, arity, in);
+  res = new_bd_Block(db, arity, in);

 
   /* Create and initialize array for Phi-node construction. */
   if (get_irg_phase_state(current_ir_graph) == phase_building) {
 
   /* Create and initialize array for Phi-node construction. */
   if (get_irg_phase_state(current_ir_graph) == phase_building) {


@@ -1157,7 +1741,7 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
 
   for (i = arity-1; i >= 0; i--)
     if (get_irn_op(in[i]) == op_Unknown) {
 
   for (i = arity-1; i >= 0; i--)
     if (get_irn_op(in[i]) == op_Unknown) {

-      has_unknown = true;
+      has_unknown = 1;

       break;
     }
 
       break;
     }
 


@@ -1174,8 +1758,8 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
 /*
   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 /*
   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);

-  ir_node *new_rd_Phi0           (ir_graph *irg, ir_node *block, ir_mode *mode)
-  ir_node *new_rd_Phi_in         (ir_graph *irg, ir_node *block, ir_mode *mode,  ir_node **in, int ins)
+  ir_node *new_rd_Phi0          (ir_graph *irg, ir_node *block, ir_mode *mode)
+  ir_node *new_rd_Phi_in        (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)

 
   Call Graph:   ( A ---> B == A "calls" B)
 
 
   Call Graph:   ( A ---> B == A "calls" B)
 


@@ -1553,7 +2137,7 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
   {
     assert(in[i]);
 
   {
     assert(in[i]);
 

-    in[i] = skip_Id(in[i]);  /* increasses the number of freed Phis. */
+    in[i] = skip_Id(in[i]);  /* increases the number of freed Phis. */

 
     /* Optimize self referencing Phis:  We can't detect them yet properly, as
        they still refer to the Phi0 they will replace.  So replace right now. */
 
     /* Optimize self referencing Phis:  We can't detect them yet properly, as
        they still refer to the Phi0 they will replace.  So replace right now. */


@@ -1592,7 +2176,7 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
     /* 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))

-      add_End_keepalive(irg->end, res);
+      add_End_keepalive(get_irg_end(irg), res);

   }
 
   return res;
   }
 
   return res;


@@ -1627,6 +2211,10 @@ static INLINE ir_node ** new_frag_arr (ir_node *n)
   /* 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, pn_Call_M_except);
   /* 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, pn_Call_M_except);

+  else if (get_irn_op(n) == op_CopyB)
+    arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
+  else if (get_irn_op(n) == op_Bound)
+    arr[0] = new_Proj(n, mode_M, pn_Bound_M_except);

   else {
     assert((pn_Quot_M == pn_DivMod_M) &&
        (pn_Quot_M == pn_Div_M)    &&
   else {
     assert((pn_Quot_M == pn_DivMod_M) &&
        (pn_Quot_M == pn_Div_M)    &&


@@ -1724,7 +2312,7 @@ get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode
   }
   return res;
 }
   }
   return res;
 }

-#endif
+#endif /* PRECISE_EXC_CONTEXT */

 
 /**
     computes the predecessors for the real phi node, and then
 
 /**
     computes the predecessors for the real phi node, and then


@@ -1745,32 +2333,37 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
     if (block == get_irg_start_block(current_ir_graph)) {
       /* Collapsing to Bad tarvals is no good idea.
          So we call a user-supplied routine here that deals with this case as
     if (block == get_irg_start_block(current_ir_graph)) {
       /* Collapsing to Bad tarvals is no good idea.
          So we call a user-supplied routine here that deals with this case as

-         appropriate for the given language. Sorryly the only help we can give
+         appropriate for the given language. Sorrily the only help we can give

          here is the position.
 
          Even if all variables are defined before use, it can happen that
          here is the position.
 
          Even if all variables are defined before use, it can happen that

-         we get to the start block, if a cond has been replaced by a tuple
+         we get to the start block, if a Cond has been replaced by a tuple

          (bad, jmp).  In this case we call the function needlessly, eventually
          (bad, jmp).  In this case we call the function needlessly, eventually

-         generating an non existant error.
+         generating an non existent error.

          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted

-         before recuring.
+         before recurring.

       */
       */

-      if (default_initialize_local_variable)
+      if (default_initialize_local_variable) {
+        ir_node *rem = get_cur_block();
+
+        set_cur_block(block);

         block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);
         block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);

+        set_cur_block(rem);
+      }

       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.

-     There are none by definition. */
+         There are none by definition. */

       return block->attr.block.graph_arr[pos];
     } else {
       phi0 = new_rd_Phi0(current_ir_graph, block, mode);
       block->attr.block.graph_arr[pos] = phi0;
 #if PRECISE_EXC_CONTEXT
       if (get_opt_precise_exc_context()) {
       return block->attr.block.graph_arr[pos];
     } else {
       phi0 = new_rd_Phi0(current_ir_graph, block, mode);
       block->attr.block.graph_arr[pos] = phi0;
 #if PRECISE_EXC_CONTEXT
       if (get_opt_precise_exc_context()) {

-    /* Set graph_arr for fragile ops.  Also here we should break recursion.
-       We could choose a cyclic path through an cfop.  But the recursion would
-       break at some point. */
-    set_frag_value(block->attr.block.graph_arr, pos, phi0);
+        /* Set graph_arr for fragile ops.  Also here we should break recursion.
+           We could choose a cyclic path through an cfop.  But the recursion would
+           break at some point. */
+        set_frag_value(block->attr.block.graph_arr, pos, phi0);

       }
 #endif
     }
       }
 #endif
     }


@@ -1784,7 +2377,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
     assert (prevCfOp);
     if (is_Bad(prevCfOp)) {
       /* In case a Cond has been optimized we would get right to the start block
     assert (prevCfOp);
     if (is_Bad(prevCfOp)) {
       /* In case a Cond has been optimized we would get right to the start block

-     with an invalid definition. */
+         with an invalid definition. */

       nin[i-1] = new_Bad();
       continue;
     }
       nin[i-1] = new_Bad();
       continue;
     }


@@ -1793,9 +2386,9 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
     if (!is_Bad(prevBlock)) {
 #if PRECISE_EXC_CONTEXT
       if (get_opt_precise_exc_context() &&
     if (!is_Bad(prevBlock)) {
 #if PRECISE_EXC_CONTEXT
       if (get_opt_precise_exc_context() &&

-      is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
-    assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
-    nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
+          is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
+        assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
+        nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);

       } else
 #endif
       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
       } else
 #endif
       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);


@@ -1851,7 +2444,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
         create a proper Phi node, therefore a Phi0, i.e., a Phi without
         predecessors is returned.  This node is added to the linked list (field
         "link") of the containing block to be completed when this block is
         create a proper Phi node, therefore a Phi0, i.e., a Phi without
         predecessors is returned.  This node is added to the linked list (field
         "link") of the containing block to be completed when this block is

-        matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
+        matured. (Completion will add a new Phi and turn the Phi0 into an Id

         node.)
 
      2. The value is already known in this block, graph_arr[pos] is set and we
         node.)
 
      2. The value is already known in this block, graph_arr[pos] is set and we


@@ -1934,12 +2527,13 @@ 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.               */
+/*
+ * Finalize a Block node, when all control flows are known.
+ * Acceptable parameters are only Block nodes.
+ */

 void
 mature_immBlock (ir_node *block)
 {
 void
 mature_immBlock (ir_node *block)
 {

-

   int ins;
   ir_node *n, **nin;
   ir_node *next;
   int ins;
   ir_node *n, **nin;
   ir_node *next;


@@ -1979,49 +2573,44 @@ mature_immBlock (ir_node *block)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
+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,
-            arity, in, mode);
+  return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
+new_d_Const (dbg_info *db, ir_mode *mode, tarval *con)

 {
 {

-  return new_rd_Const(db, current_ir_graph, current_ir_graph->start_block,
-              mode, con);
+  return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Const_long(dbg_info* db, ir_mode *mode, long value)
+new_d_Const_long(dbg_info *db, ir_mode *mode, long value)

 {
 {

-  return new_rd_Const_long(db, current_ir_graph, current_ir_graph->start_block, mode, value);
+  return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value);

 }
 
 }
 

-    ir_node *
-new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
+ir_node *
+new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp)

 {
 {

-  return new_rd_Const_type(db, current_ir_graph, current_ir_graph->start_block,
-                mode, con, tp);
+  return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp);

 }
 
 
 ir_node *
 }
 
 
 ir_node *

-new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
+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,
-           val, mode);
+  return new_bd_Id(db, current_ir_graph->current_block, val, mode);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj)
+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,
-             arg, mode, proj);
+  return new_bd_Proj(db, current_ir_graph->current_block, arg, mode, proj);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
+new_d_defaultProj (dbg_info *db, ir_node *arg, long max_proj)

 {
   ir_node *res;
   assert(arg->op == op_Cond);
 {
   ir_node *res;
   assert(arg->op == op_Cond);


@@ -2032,53 +2621,27 @@ new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
 }
 
 ir_node *
 }
 
 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,
-             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);
-}
-
-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,
-              arity, in);
-}
-
-ir_node *
-new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode)

 {
 {

-  return new_rd_Add(db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
+  return new_bd_Conv(db, current_ir_graph->current_block, op, mode);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Cast (dbg_info *db, ir_node *op, ir_type *to_tp)

 {
 {

-  return new_rd_Sub(db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
+  return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);

 }
 
 }
 

-

 ir_node *
 ir_node *

-new_d_Minus (dbg_info* db, ir_node *op,  ir_mode *mode)
+new_d_Tuple (dbg_info *db, int arity, ir_node **in)

 {
 {

-  return new_rd_Minus(db, current_ir_graph, current_ir_graph->current_block,
-              op, mode);
+  return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);

 }
 
 }
 

-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,
-            op1, op2, mode);
-}
+NEW_D_BINOP(Add)
+NEW_D_BINOP(Sub)
+NEW_D_UNOP(Minus)
+NEW_D_BINOP(Mul)

 
 /**
  * allocate the frag array
 
 /**
  * allocate the frag array


@@ -2086,20 +2649,18 @@ 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 ((current_ir_graph->phase_state == phase_building) &&
 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
   if (get_opt_precise_exc_context()) {
     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. */ {
+        (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);
     }
   }
 }
 
       *frag_store = new_frag_arr(res);
     }
   }
 }
 

-

 ir_node *
 ir_node *

-new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Quot (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
-             memop, op1, op2);
+  res = new_bd_Quot (db, current_ir_graph->current_block, memop, op1, op2);

   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */
   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */


@@ -2109,11 +2670,10 @@ new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_DivMod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
-               memop, op1, op2);
+  res = new_bd_DivMod (db, current_ir_graph->current_block, memop, op1, op2);

   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */
   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */


@@ -2123,11 +2683,10 @@ new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Div (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
-            memop, op1, op2);
+  res = new_bd_Div (db, current_ir_graph->current_block, memop, op1, op2);

   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */
   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */


@@ -2137,11 +2696,10 @@ new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Mod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
-            memop, op1, op2);
+  res = new_bd_Mod (db, current_ir_graph->current_block, memop, op1, op2);

   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
   res->attr.except.pin_state = op_pin_state_pinned;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */


@@ -2150,94 +2708,48 @@ new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
   return res;
 }
 
   return res;
 }
 

-ir_node *
-new_d_And (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  return new_rd_And (db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
-}
-
-ir_node *
-new_d_Or (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  return new_rd_Or (db, current_ir_graph, current_ir_graph->current_block,
-           op1, op2, mode);
-}
-
-ir_node *
-new_d_Eor (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  return new_rd_Eor (db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
-}
-
-ir_node *
-new_d_Not (dbg_info* db, ir_node *op, ir_mode *mode)
-{
-  return new_rd_Not (db, current_ir_graph, current_ir_graph->current_block,
-            op, mode);
-}
-
-ir_node *
-new_d_Shl (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
-{
-  return new_rd_Shl (db, current_ir_graph, current_ir_graph->current_block,
-            op, k, mode);
-}
-
-ir_node *
-new_d_Shr (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
-{
-  return new_rd_Shr (db, current_ir_graph, current_ir_graph->current_block,
-            op, k, mode);
-}
-
-ir_node *
-new_d_Shrs (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
-{
-  return new_rd_Shrs (db, current_ir_graph, current_ir_graph->current_block,
-             op, k, mode);
-}
-
-ir_node *
-new_d_Rot (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
-{
-  return new_rd_Rot (db, current_ir_graph, current_ir_graph->current_block,
-             op, k, mode);
-}
+NEW_D_BINOP(And)
+NEW_D_BINOP(Or)
+NEW_D_BINOP(Eor)
+NEW_D_UNOP(Not)
+NEW_D_BINOP(Shl)
+NEW_D_BINOP(Shr)
+NEW_D_BINOP(Shrs)
+NEW_D_BINOP(Rot)
+NEW_D_UNOP(Abs)
+NEW_D_BINOP(Carry)
+NEW_D_BINOP(Borrow)

 
 ir_node *
 
 ir_node *

-new_d_Abs (dbg_info* db, ir_node *op, ir_mode *mode)
+new_d_Cmp (dbg_info *db, ir_node *op1, ir_node *op2)

 {
 {

-  return new_rd_Abs (db, current_ir_graph, current_ir_graph->current_block,
-            op, mode);
+  return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Cmp (dbg_info* db, ir_node *op1, ir_node *op2)
+new_d_Jmp (dbg_info *db)

 {
 {

-  return new_rd_Cmp (db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2);
+  return new_bd_Jmp (db, current_ir_graph->current_block);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Jmp (dbg_info* db)
+new_d_IJmp (dbg_info *db, ir_node *tgt)

 {
 {

-  return new_rd_Jmp (db, current_ir_graph, current_ir_graph->current_block);
+  return new_bd_IJmp (db, current_ir_graph->current_block, tgt);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Cond (dbg_info* db, ir_node *c)
+new_d_Cond (dbg_info *db, ir_node *c)

 {
 {

-  return new_rd_Cond (db, current_ir_graph, current_ir_graph->current_block, c);
+  return new_bd_Cond (db, current_ir_graph->current_block, c);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
-      type *tp)
+new_d_Call (dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
+      ir_type *tp)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
+  res = new_bd_Call (db, current_ir_graph->current_block,

              store, callee, arity, in, tp);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */
              store, callee, arity, in, tp);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */


@@ -2247,24 +2759,17 @@ new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Return (dbg_info* db, ir_node* store, int arity, ir_node **in)
+new_d_Return (dbg_info *db, ir_node* store, int arity, ir_node **in)

 {
 {

-  return new_rd_Return (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Return (db, current_ir_graph->current_block,

                store, arity, in);
 }
 
 ir_node *
                store, arity, in);
 }
 
 ir_node *

-new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj)
-{
-  return new_rd_Raise (db, current_ir_graph, current_ir_graph->current_block,
-              store, obj);
-}
-
-ir_node *
-new_d_Load (dbg_info* db, ir_node *store, ir_node *addr, ir_mode *mode)
+new_d_Load (dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block,
+  res = new_bd_Load (db, current_ir_graph->current_block,

              store, addr, mode);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
              store, addr, mode);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */


@@ -2274,10 +2779,10 @@ new_d_Load (dbg_info* db, ir_node *store, ir_node *addr, ir_mode *mode)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val)
+new_d_Store (dbg_info *db, ir_node *store, ir_node *addr, ir_node *val)

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block,
+  res = new_bd_Store (db, current_ir_graph->current_block,

               store, addr, val);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
               store, addr, val);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */


@@ -2287,11 +2792,11 @@ new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val)
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type,
+new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,

            where_alloc where)
 {
   ir_node *res;
            where_alloc where)
 {
   ir_node *res;

-  res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
+  res = new_bd_Alloc (db, current_ir_graph->current_block,

               store, size, alloc_type, where);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */
               store, size, alloc_type, where);
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */


@@ -2301,82 +2806,73 @@ new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type,
 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Free (dbg_info* db, ir_node *store, ir_node *ptr,
-    ir_node *size, type *free_type, where_alloc where)
+new_d_Free (dbg_info *db, ir_node *store, ir_node *ptr,
+    ir_node *size, ir_type *free_type, where_alloc where)

 {
 {

-  return new_rd_Free (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Free (db, current_ir_graph->current_block,

              store, ptr, size, free_type, where);
 }
 
 ir_node *
              store, ptr, size, free_type, where);
 }
 
 ir_node *

-new_d_simpleSel (dbg_info* db, ir_node *store, ir_node *objptr, entity *ent)
+new_d_simpleSel (dbg_info *db, ir_node *store, ir_node *objptr, entity *ent)

 /* GL: objptr was called frame before.  Frame was a bad choice for the name
    as the operand could as well be a pointer to a dynamic object. */
 {
 /* GL: objptr was called frame before.  Frame was a bad choice for the name
    as the operand could as well be a pointer to a dynamic object. */
 {

-  return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Sel (db, current_ir_graph->current_block,

             store, objptr, 0, NULL, ent);
 }
 
 ir_node *
             store, objptr, 0, NULL, ent);
 }
 
 ir_node *

-new_d_Sel (dbg_info* db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
+new_d_Sel (dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)

 {
 {

-  return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Sel (db, current_ir_graph->current_block,

             store, objptr, n_index, index, sel);
 }
 
 ir_node *
             store, objptr, n_index, index, sel);
 }
 
 ir_node *

-new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
-{
-  return (new_rd_InstOf (db, current_ir_graph, current_ir_graph->current_block,
-                         store, objptr, ent));
-}
-
-ir_node *
-new_d_SymConst_type (dbg_info* db, symconst_symbol value, symconst_kind kind, type *tp)
+new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp)

 {
 {

-  return new_rd_SymConst_type (db, current_ir_graph, current_ir_graph->start_block,
+  return new_bd_SymConst_type (db, get_irg_start_block(current_ir_graph),

                          value, kind, tp);
 }
 
 ir_node *
                          value, kind, tp);
 }
 
 ir_node *

-new_d_SymConst (dbg_info* db, symconst_symbol value, symconst_kind kind)
+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,
+  return new_bd_SymConst (db, get_irg_start_block(current_ir_graph),

                          value, kind);
 }
 
 ir_node *
                          value, kind);
 }
 
 ir_node *

-new_d_Sync (dbg_info* db, int arity, ir_node** in)
+new_d_Sync (dbg_info *db, int arity, ir_node** in)

 {
 {

-  return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block,
-              arity, in);
+  return new_bd_Sync (db, current_ir_graph->current_block, arity, in);

 }
 
 
 ir_node *
 }
 
 
 ir_node *

-(new_d_Bad)(void)
-{
+(new_d_Bad)(void) {

   return _new_d_Bad();
 }
 
 ir_node *
 new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
 {
   return _new_d_Bad();
 }
 
 ir_node *
 new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
 {

-  return new_rd_Confirm (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Confirm (db, current_ir_graph->current_block,

              val, bound, cmp);
 }
 
 ir_node *
 new_d_Unknown (ir_mode *m)
 {
              val, bound, cmp);
 }
 
 ir_node *
 new_d_Unknown (ir_mode *m)
 {

-  return new_rd_Unknown(current_ir_graph, m);
+  return new_bd_Unknown(m);

 }
 
 ir_node *
 new_d_CallBegin (dbg_info *db, ir_node *call)
 {
   ir_node *res;
 }
 
 ir_node *
 new_d_CallBegin (dbg_info *db, ir_node *call)
 {
   ir_node *res;

-  res = new_rd_CallBegin (db, current_ir_graph, current_ir_graph->current_block, call);
+  res = new_bd_CallBegin (db, current_ir_graph->current_block, call);

   return res;
 }
 
   return res;
 }
 


@@ -2384,7 +2880,7 @@ ir_node *
 new_d_EndReg (dbg_info *db)
 {
   ir_node *res;
 new_d_EndReg (dbg_info *db)
 {
   ir_node *res;

-  res = new_rd_EndReg(db, current_ir_graph, current_ir_graph->current_block);
+  res = new_bd_EndReg(db, current_ir_graph->current_block);

   return res;
 }
 
   return res;
 }
 


@@ -2392,20 +2888,20 @@ ir_node *
 new_d_EndExcept (dbg_info *db)
 {
   ir_node *res;
 new_d_EndExcept (dbg_info *db)
 {
   ir_node *res;

-  res = new_rd_EndExcept(db, current_ir_graph, current_ir_graph->current_block);
+  res = new_bd_EndExcept(db, current_ir_graph->current_block);

   return res;
 }
 
 ir_node *
 new_d_Break (dbg_info *db)
 {
   return res;
 }
 
 ir_node *
 new_d_Break (dbg_info *db)
 {

-  return new_rd_Break (db, current_ir_graph, current_ir_graph->current_block);
+  return new_bd_Break (db, current_ir_graph->current_block);

 }
 
 ir_node *
 new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
 {
 }
 
 ir_node *
 new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
 {

-  return new_rd_Filter (db, current_ir_graph, current_ir_graph->current_block,
+  return new_bd_Filter (db, current_ir_graph->current_block,

             arg, mode, proj);
 }
 
             arg, mode, proj);
 }
 


@@ -2418,18 +2914,60 @@ ir_node *
 ir_node *
 new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
     ir_node *ir_true, ir_mode *mode) {
 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,
+  return new_bd_Mux (db, current_ir_graph->current_block,

       sel, ir_false, ir_true, mode);
 }
 
       sel, ir_false, ir_true, mode);
 }
 

+ir_node *
+new_d_Psi (dbg_info *db,int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
+  return new_bd_Psi (db, current_ir_graph->current_block,
+      arity, conds, vals, mode);
+}
+
+ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
+    ir_node *dst, ir_node *src, ir_type *data_type) {
+  ir_node *res;
+  res = new_bd_CopyB(db, current_ir_graph->current_block,
+    store, dst, src, data_type);
+#if PRECISE_EXC_CONTEXT
+  allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
+#endif
+  return res;
+}
+
+ir_node *
+new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type)
+{
+  return new_bd_InstOf (db, current_ir_graph->current_block,
+                        store, objptr, type);
+}
+
+ir_node *
+new_d_Raise (dbg_info *db, ir_node *store, ir_node *obj)
+{
+  return new_bd_Raise (db, current_ir_graph->current_block,
+              store, obj);
+}
+
+ir_node *new_d_Bound(dbg_info *db,ir_node *store,
+    ir_node *idx, ir_node *lower, ir_node *upper) {
+  ir_node *res;
+  res = new_bd_Bound(db, current_ir_graph->current_block,
+    store, idx, lower, upper);
+#if PRECISE_EXC_CONTEXT
+  allocate_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
+#endif
+  return res;
+}
+

 /* ********************************************************************* */
 /* Comfortable interface with automatic Phi node construction.           */
 /* (Uses also constructors of ?? interface, except new_Block.            */
 /* ********************************************************************* */
 
 /* ********************************************************************* */
 /* Comfortable interface with automatic Phi node construction.           */
 /* (Uses also constructors of ?? interface, except new_Block.            */
 /* ********************************************************************* */
 

-/* * Block construction **/
+/*  Block construction */

 /* immature Block without predecessors */
 /* immature Block without predecessors */

-ir_node *new_d_immBlock (dbg_info* db) {
+ir_node *new_d_immBlock (dbg_info *db) {

   ir_node *res;
 
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   ir_node *res;
 
   assert(get_irg_phase_state (current_ir_graph) == phase_building);


@@ -2462,7 +3000,7 @@ new_immBlock (void) {
   return new_d_immBlock(NULL);
 }
 
   return new_d_immBlock(NULL);
 }
 

-/* add an adge to a jmp/control flow node */
+/* add an edge to a jmp/control flow node */

 void
 add_immBlock_pred (ir_node *block, ir_node *jmp)
 {
 void
 add_immBlock_pred (ir_node *block, ir_node *jmp)
 {


@@ -2477,8 +3015,7 @@ add_immBlock_pred (ir_node *block, ir_node *jmp)
 
 /* changing the current block */
 void
 
 /* changing the current block */
 void

-set_cur_block (ir_node *target)
-{
+set_cur_block (ir_node *target) {

   current_ir_graph->current_block = target;
 }
 
   current_ir_graph->current_block = target;
 }
 


@@ -2487,7 +3024,7 @@ set_cur_block (ir_node *target)
 
 /* get a value from the parameter array from the current block by its index */
 ir_node *
 
 /* get a value from the parameter array from the current block by its index */
 ir_node *

-get_d_value (dbg_info* db, int pos, ir_mode *mode)
+get_d_value (dbg_info *db, int pos, ir_mode *mode)

 {
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   inc_irg_visited(current_ir_graph);
 {
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   inc_irg_visited(current_ir_graph);


@@ -2510,6 +3047,18 @@ set_value (int pos, ir_node *value)
   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
 }
 
   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
 }
 

+int
+find_value(ir_node *value)
+{
+  int i;
+  ir_node *bl = current_ir_graph->current_block;
+
+  for (i = 1; i < ARR_LEN(bl->attr.block.graph_arr); ++i)
+    if (bl->attr.block.graph_arr[i] == value)
+      return i - 1;
+  return -1;
+}
+

 /* get the current store */
 ir_node *
 get_store (void)
 /* get the current store */
 ir_node *
 get_store (void)


@@ -2530,20 +3079,19 @@ set_store (ir_node *store)
 }
 
 void
 }
 
 void

-keep_alive (ir_node *ka)
-{
-  add_End_keepalive(current_ir_graph->end, ka);
+keep_alive (ir_node *ka) {
+  add_End_keepalive(get_irg_end(current_ir_graph), ka);

 }
 
 }
 

-/** Useful access routines **/
+/* --- Useful access routines --- */

 /* Returns the current block of the current graph.  To set the current
    block use set_cur_block. */
 /* Returns the current block of the current graph.  To set the current
    block use set_cur_block. */

-ir_node *get_cur_block() {
+ir_node *get_cur_block(void) {

   return get_irg_current_block(current_ir_graph);
 }
 
 /* Returns the frame type of the current graph */
   return get_irg_current_block(current_ir_graph);
 }
 
 /* Returns the frame type of the current graph */

-type *get_cur_frame_type() {
+ir_type *get_cur_frame_type(void) {

   return get_irg_frame_type(current_ir_graph);
 }
 
   return get_irg_frame_type(current_ir_graph);
 }
 


@@ -2558,24 +3106,16 @@ init_cons(uninitialized_local_variable_func_t *func)
   default_initialize_local_variable = func;
 }
 
   default_initialize_local_variable = func;
 }
 

-/* call for each graph */
-void
-irg_finalize_cons (ir_graph *irg) {
-  irg->phase_state = phase_high;
-}
-

 void
 irp_finalize_cons (void) {
 void
 irp_finalize_cons (void) {

-  int i, n_irgs = get_irp_n_irgs();
-  for (i = 0; i < n_irgs; i++) {
+  int i;
+  for (i = get_irp_n_irgs() - 1; i >= 0; --i) {

     irg_finalize_cons(get_irp_irg(i));
   }
     irg_finalize_cons(get_irp_irg(i));
   }

-  irp->phase_state = phase_high;\
+  irp->phase_state = phase_high;

 }
 
 
 }
 
 

-
-

 ir_node *new_Block(int arity, ir_node **in) {
   return new_d_Block(NULL, arity, in);
 }
 ir_node *new_Block(int arity, ir_node **in) {
   return new_d_Block(NULL, arity, in);
 }


@@ -2588,15 +3128,15 @@ ir_node *new_End    (void) {
 ir_node *new_Jmp    (void) {
   return new_d_Jmp(NULL);
 }
 ir_node *new_Jmp    (void) {
   return new_d_Jmp(NULL);
 }

+ir_node *new_IJmp   (ir_node *tgt) {
+  return new_d_IJmp(NULL, tgt);
+}

 ir_node *new_Cond   (ir_node *c) {
   return new_d_Cond(NULL, c);
 }
 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
   return new_d_Return(NULL, store, arity, in);
 }
 ir_node *new_Cond   (ir_node *c) {
   return new_d_Cond(NULL, c);
 }
 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
   return new_d_Return(NULL, store, arity, in);
 }

-ir_node *new_Raise  (ir_node *store, ir_node *obj) {
-  return new_d_Raise(NULL, store, 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);
 }


@@ -2606,7 +3146,7 @@ ir_node *new_Const_long(ir_mode *mode, long value)
     return new_d_Const_long(NULL, mode, value);
 }
 
     return new_d_Const_long(NULL, mode, value);
 }
 

-ir_node *new_Const_type(tarval *con, type *tp) {
+ir_node *new_Const_type(tarval *con, ir_type *tp) {

   return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
 }
 
   return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
 }
 


@@ -2620,11 +3160,8 @@ ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
                      entity *ent) {
   return new_d_Sel(NULL, store, objptr, arity, in, ent);
 }
                      entity *ent) {
   return new_d_Sel(NULL, store, objptr, arity, in, ent);
 }

-ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
-  return new_d_InstOf (NULL, store, objptr, ent);
-}

 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,

-             type *tp) {
+             ir_type *tp) {

   return new_d_Call(NULL, store, callee, arity, in, tp);
 }
 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
   return new_d_Call(NULL, store, callee, arity, in, tp);
 }
 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {


@@ -2675,17 +3212,22 @@ ir_node *new_Shr    (ir_node *op,  ir_node *k,   ir_mode *mode) {
 ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *mode) {
   return new_d_Shrs(NULL, op, k, mode);
 }
 ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *mode) {
   return new_d_Shrs(NULL, op, k, mode);
 }

-#define new_Rotate new_Rot

 ir_node *new_Rot    (ir_node *op,  ir_node *k,   ir_mode *mode) {
   return new_d_Rot(NULL, op, k, mode);
 }
 ir_node *new_Rot    (ir_node *op,  ir_node *k,   ir_mode *mode) {
   return new_d_Rot(NULL, op, k, mode);
 }

+ir_node *new_Carry  (ir_node *op1, ir_node *op2, ir_mode *mode) {
+  return new_d_Carry(NULL, op1, op2, mode);
+}
+ir_node *new_Borrow (ir_node *op1, ir_node *op2, ir_mode *mode) {
+  return new_d_Borrow(NULL, op1, op2, mode);
+}

 ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
   return new_d_Cmp(NULL, op1, op2);
 }
 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
   return new_d_Conv(NULL, op, mode);
 }
 ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
   return new_d_Cmp(NULL, op1, op2);
 }
 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
   return new_d_Conv(NULL, op, mode);
 }

-ir_node *new_Cast   (ir_node *op, type *to_tp) {
+ir_node *new_Cast   (ir_node *op, ir_type *to_tp) {

   return new_d_Cast(NULL, op, to_tp);
 }
 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
   return new_d_Cast(NULL, op, to_tp);
 }
 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {


@@ -2697,12 +3239,12 @@ ir_node *new_Load   (ir_node *store, ir_node *addr, ir_mode *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);
 }

-ir_node *new_Alloc  (ir_node *store, ir_node *size, type *alloc_type,
+ir_node *new_Alloc  (ir_node *store, ir_node *size, ir_type *alloc_type,

                      where_alloc where) {
   return new_d_Alloc(NULL, store, size, alloc_type, where);
 }
 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,
                      where_alloc where) {
   return new_d_Alloc(NULL, store, size, alloc_type, where);
 }
 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,

-             type *free_type, where_alloc where) {
+             ir_type *free_type, where_alloc where) {

   return new_d_Free(NULL, store, ptr, size, free_type, where);
 }
 ir_node *new_Sync   (int arity, ir_node **in) {
   return new_d_Free(NULL, store, ptr, size, free_type, where);
 }
 ir_node *new_Sync   (int arity, ir_node **in) {


@@ -2750,3 +3292,18 @@ ir_node *new_NoMem  (void) {
 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);
 }
 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);
 }

+ir_node *new_Psi (int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
+  return new_d_Psi(NULL, arity, conds, vals, mode);
+}
+ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
+  return new_d_CopyB(NULL, store, dst, src, data_type);
+}
+ir_node *new_InstOf (ir_node *store, ir_node *objptr, ir_type *ent) {
+  return new_d_InstOf (NULL, store, objptr, ent);
+}
+ir_node *new_Raise  (ir_node *store, ir_node *obj) {
+  return new_d_Raise(NULL, store, obj);
+}
+ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
+  return new_d_Bound(NULL, store, idx, lower, upper);
+}