floating point operation nodes are created automatically pinned if the fp_exception...

[libfirm] / ir / ir / ircons.c

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index a11fcf7..a5cc37d 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -16,29 +16,30 @@
 #endif
 
 #ifdef HAVE_ALLOCA_H
 #endif
 
 #ifdef HAVE_ALLOCA_H

-#include <alloca.h>
+# include <alloca.h>

 #endif
 #ifdef HAVE_MALLOC_H
 #endif
 #ifdef HAVE_MALLOC_H

-#include <malloc.h>
+# include <malloc.h>

 #endif
 #ifdef HAVE_STRING_H
 #endif
 #ifdef HAVE_STRING_H

-#include <string.h>
+# include <string.h>

 #endif
 
 #endif
 

-# include "irprog_t.h"
-# include "irgraph_t.h"
-# include "irnode_t.h"
-# include "irmode_t.h"
-# include "ircons_t.h"
-# include "firm_common_t.h"
-# include "irvrfy.h"
-# include "irop_t.h"
-# include "iropt_t.h"
-# include "irgmod.h"
-# include "array.h"
-# include "irbackedge_t.h"
-# include "irflag_t.h"
-# include "iredges_t.h"
+#include "irprog_t.h"
+#include "irgraph_t.h"
+#include "irnode_t.h"
+#include "irmode_t.h"
+#include "ircons_t.h"
+#include "firm_common_t.h"
+#include "irvrfy.h"
+#include "irop_t.h"
+#include "iropt_t.h"
+#include "irgmod.h"
+#include "array.h"
+#include "irbackedge_t.h"
+#include "irflag_t.h"
+#include "iredges_t.h"
+#include "irflag_t.h"

 
 #if USE_EXPLICIT_PHI_IN_STACK
 /* A stack needed for the automatic Phi node construction in constructor
 
 #if USE_EXPLICIT_PHI_IN_STACK
 /* A stack needed for the automatic Phi node construction in constructor


@@ -55,24 +56,139 @@ 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 dependent variable initialization callback.
  */
 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
 
 
 /**
  * Language dependent variable initialization callback.
  */
 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
 

-/* --------------------------------------------- */
-/* private interfaces, for professional use only */
-/* --------------------------------------------- */
+/* creates a bd constructor for a binop */
+#define NEW_BD_BINOP(instr, float_support)                      \
+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);   \
+  if (float_support && mode_is_float(mode) &&                   \
+      (get_irg_fp_model(irg) & fp_exceptions))                  \
+    res->pinned = 1;                                            \
+  res = optimize_node(res);                                     \
+  IRN_VRFY_IRG(res, irg);                                       \
+  return res;                                                   \
+}
+
+/* creates a bd constructor for an unop */
+#define NEW_BD_UNOP(instr, float_support)                       \
+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);  \
+  if (float_support && mode_is_float(mode) &&                   \
+      (get_irg_fp_model(irg) & fp_exceptions))                  \
+    res->pinned = 1;                                            \
+  res = optimize_node(res);                                     \
+  IRN_VRFY_IRG(res, irg);                                       \
+  return res;                                                   \
+}
+
+/* creates a bd constructor for an divop */
+#define NEW_BD_DIVOP(instr, float_support)                      \
+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;                             \
+  ir_mode  *mode = get_irn_mode(op1);                           \
+  in[0] = memop;                                                \
+  in[1] = op1;                                                  \
+  in[2] = op2;                                                  \
+  res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
+  if (float_support && mode_is_float(mode) &&                   \
+      (get_irg_fp_model(irg) & fp_exceptions))                  \
+    res->pinned = 1;                                            \
+  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. */
-ir_node *
-new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
+
+/**
+ * Constructs a Block with a fixed number of predecessors.
+ * Does not set current_block.  Can not be used with automatic
+ * Phi node construction.
+ */
+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);


@@ -89,39 +205,44 @@ new_rd_Block (dbg_info* db, ir_graph *irg,  int arity, ir_node **in)
 
   IRN_VRFY_IRG(res, irg);
   return res;
 
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_Block */

 
 

-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; */
 
   IRN_VRFY_IRG(res, irg);
   return res;
 
   res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = irg; */
 
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_Start */

 
 

-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);
 
   IRN_VRFY_IRG(res, irg);
   return res;
 
   res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
 
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_End */

 
 

-/* 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)
+/**
+ * Creates a Phi node with all predecessors.  Calling this constructor
+ * is only allowed if the corresponding block is mature.
+ */
+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 ... */


@@ -134,7 +255,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;
     }
 


@@ -144,16 +265,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;

-}
+}  /* new_bd_Phi */

 
 

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


@@ -161,36 +283,42 @@ new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, t
   IRN_VRFY_IRG(res, irg);
 
   return res;
   IRN_VRFY_IRG(res, irg);
 
   return res;

-}
+}  /* new_bd_Const_type */

 
 

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

-}
+}  /* new_bd_Const */

 
 

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

 
 

-ir_node *
-new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
+  return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
+}  /* new_bd_Const_long */
+
+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);
   IRN_VRFY_IRG(res, irg);
   return res;
 
   res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_Id */

 
 

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


@@ -204,35 +332,42 @@ new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode
   IRN_VRFY_IRG(res, irg);
   return res;
 
   IRN_VRFY_IRG(res, irg);
   return res;
 

-}
+}  /* new_bd_Proj */

 
 

-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);
   assert(arg->op == op_Cond);

-  arg->attr.c.kind = fragmentary;
-  arg->attr.c.default_proj = max_proj;
+  arg->attr.cond.kind = fragmentary;
+  arg->attr.cond.default_proj = max_proj;

   res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
   return res;
   res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
   return res;

-}
+}  /* new_bd_defaultProj */

 
 

-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, int strict_flag)

 {
 {

-  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 = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);

+  res->attr.conv.strict = strict_flag;
+  if (mode_is_float(mode) && get_irg_fp_model(irg) & fp_exceptions)
+    res->pinned = 1;

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

-}
+}  /* new_bd_Conv */

 
 

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


@@ -241,684 +376,1130 @@ new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;
   res = optimize_node(res);
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_Cast */

 
 

-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);
   IRN_VRFY_IRG(res, irg);
   return res;
 
   res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
   res = optimize_node (res);
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_Tuple */
+
+#define supports_float 1
+#define only_integer   0
+
+NEW_BD_BINOP(Add, supports_float)
+NEW_BD_BINOP(Sub, supports_float)
+NEW_BD_UNOP(Minus, supports_float)
+NEW_BD_BINOP(Mul, supports_float)
+NEW_BD_DIVOP(Quot, supports_float)
+NEW_BD_DIVOP(DivMod, only_integer)
+NEW_BD_DIVOP(Div, only_integer)
+NEW_BD_DIVOP(Mod, only_integer)
+NEW_BD_BINOP(And, only_integer)
+NEW_BD_BINOP(Or, only_integer)
+NEW_BD_BINOP(Eor, only_integer)
+NEW_BD_UNOP(Not, only_integer)
+NEW_BD_BINOP(Shl, only_integer)
+NEW_BD_BINOP(Shr, only_integer)
+NEW_BD_BINOP(Shrs, only_integer)
+NEW_BD_BINOP(Rot, only_integer)
+NEW_BD_UNOP(Abs, supports_float)
+NEW_BD_BINOP(Carry, only_integer)
+NEW_BD_BINOP(Borrow, only_integer)

 
 

-ir_node *
-new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op1, ir_node *op2, ir_mode *mode)
+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_node  *in[2];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;
+  ir_mode  *mode = get_irn_mode(op1);

   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);
+  if (mode_is_float(mode) && get_irg_fp_model(irg) & fp_exceptions)
+    res->pinned = 1;

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

-}
+}  /* new_bd_Cmp */

 
 

-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);
   res = optimize_node (res);

-  IRN_VRFY_IRG(res, irg);
+  IRN_VRFY_IRG (res, irg);

   return res;
   return res;

-}
+}  /* new_bd_Jmp */

 
 

-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_IJmp(dbg_info *db, ir_node *block, ir_node *tgt)

 {
 {

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

 
 

-  res = new_ir_node(db, irg, block, op_Minus, mode, 1, &op);
-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);
+  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;
   return res;

-}
+}  /* new_bd_IJmp */

 
 

-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_Cond(dbg_info *db, ir_node *block, ir_node *c)

 {
 {

-  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_Mul, mode, 2, in);
-  res = optimize_node(res);
+  res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, &c);
+  res->attr.cond.kind         = dense;
+  res->attr.cond.default_proj = 0;
+  res->attr.cond.pred         = COND_JMP_PRED_NONE;
+  res = optimize_node (res);

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

-}
+}  /* new_bd_Cond */

 
 

-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_Call(dbg_info *db, ir_node *block, ir_node *store,
+        ir_node *callee, int arity, ir_node **in, ir_type *tp)

 {
 {

-  ir_node *in[3];
-  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_Call, mode_T, r_arity, r_in);

 
 

-  in[0] = memop;
-  in[1] = op1;
-  in[2] = op2;
-  res = new_ir_node(db, irg, block, op_Quot, mode_T, 3, in);
+  assert((get_unknown_type() == tp) || is_Method_type(tp));
+  set_Call_type(res, tp);
+  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;

-}
+}  /* new_bd_Call */

 
 

-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_Return (dbg_info *db, ir_node *block,
+              ir_node *store, int arity, ir_node **in)

 {
 {

-  ir_node *in[3];
-  ir_node *res;
+  ir_node  **r_in;
+  ir_node  *res;
+  int      r_arity;
+  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);
+  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_Div (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_Div, 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.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;

-}
+}  /* new_bd_Load */

 
 

-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_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_Mod, 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.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;

-}
+}  /* new_bd_Store */

 
 

-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_Alloc(dbg_info *db, ir_node *block, ir_node *store,
+        ir_node *size, ir_type *alloc_type, where_alloc where)

 {
 {

-  ir_node *in[2];
-  ir_node *res;
+  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_And, mode, 2, in);
+  in[0] = store;
+  in[1] = size;
+  res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in);
+  res->attr.alloc.where = where;
+  res->attr.alloc.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;

-}
+}  /* new_bd_Alloc */

 
 

-ir_node *
-new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op1, ir_node *op2, ir_mode *mode)
+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[2];
-  ir_node *res;
+  ir_node  *in[3];
+  ir_node  *res;
+  ir_graph *irg = current_ir_graph;

 
 

-  in[0] = op1;
-  in[1] = op2;
-  res = new_ir_node(db, irg, block, op_Or, mode, 2, 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.free.where = where;
+  res->attr.free.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;

-}
+}  /* new_bd_Free */

 
 

-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_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_Eor, mode, 2, in);
-  res = optimize_node (res);
+  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.sel.ent = ent;
+  res = optimize_node(res);

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

-}
+}  /* new_bd_Sel */

 
 

-ir_node *
-new_rd_Not    (dbg_info* db, ir_graph *irg, ir_node *block,
-          ir_node *op, ir_mode *mode)
-{
-  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.symc.num = symkind;
+  res->attr.symc.sym = value;
+  res->attr.symc.tp  = tp;

 
 

-  res = new_ir_node(db, irg, block, op_Not, mode, 1, &op);

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

-}
+}  /* new_bd_SymConst_type */

 
 

-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_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] = op;
-  in[1] = k;
-  res = new_ir_node(db, irg, block, op_Shl, mode, 2, in);
-  res = optimize_node(res);
-  IRN_VRFY_IRG(res, irg);
+  ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);

   return res;
   return res;

-}
+}  /* new_bd_SymConst */

 
 

-ir_node *
-new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
-       ir_node *op, ir_node *k, ir_mode *mode)
+static ir_node *
+new_bd_Sync(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_Shr, mode, 2, in);
-  res = optimize_node(res);
+  res = new_ir_node(db, irg, block, op_Sync, mode_M, -1, NULL);
+  /* no need to call optimize node here, Sync are always created with no predecessors */

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

-}
+}  /* new_bd_Sync */

 
 

-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_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_Shrs, 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_Rot (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_Rot, 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;

-}
+}  /* new_bd_Unknown */

 
 

-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_CallBegin(dbg_info *db, ir_node *block, ir_node *call)

 {
 {

-  ir_node *res;
+  ir_node  *in[1];
+  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);
+  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;
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_bd_CallBegin */

 
 

-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_EndReg(dbg_info *db, ir_node *block)

 {
 {

-  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_Cmp, mode_T, 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;

-}
+}  /* new_bd_EndReg */

 
 

-ir_node *
-new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
+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_Jmp, mode_X, 0, NULL);
-  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;
   IRN_VRFY_IRG (res, irg);
   return res;

-}
+}  /* new_bd_EndExcept */

 
 

-ir_node *
-new_rd_IJmp (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *tgt)
+static ir_node *
+new_bd_Break(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_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);
+  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;

-}
+}  /* new_bd_Break */

 
 

-ir_node *
-new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
+static ir_node *
+new_bd_Filter(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
+           long proj)

 {
 {

-  ir_node *res;
+  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 = optimize_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;
+
+  assert(res);
+  assert(get_Proj_pred(res));
+  assert(get_nodes_block(get_Proj_pred(res)));
+
+  res = optimize_node(res);

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

-}
+}  /* new_bd_Filter */

 
 

-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_Mux(dbg_info *db, ir_node *block,
+    ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)

 {
 {

-  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] = sel;
+  in[1] = ir_false;
+  in[2] = ir_true;

 
 

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

 
 

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

-}
+}  /* new_bd_Mux */

 
 

-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_Psi(dbg_info *db, ir_node *block,
+    int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)

 {
 {

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

 
 

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

-}
+}  /* new_bd_Psi */

 
 

-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_CopyB(dbg_info *db, ir_node *block,
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)

 {
 {

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

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

-  in[1] = obj;
-  res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);
+  in[1] = dst;
+  in[2] = src;
+
+  res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in);
+  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;

-}
+}  /* new_bd_CopyB */

 
 

-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_InstOf(dbg_info *db, ir_node *block, ir_node *store,
+           ir_node *objptr, ir_type *type)

 {
 {

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

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

-}
+}  /* new_bd_InstOf */

 
 

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

 {
 {

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

 
   in[0] = store;
 
   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;
+  in[1] = obj;
+  res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);

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

-}
+}  /* new_bd_Raise */

 
 

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

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

-}
+}  /* new_bd_Bound */

 
 

-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)
+static ir_node *
+new_bd_Pin(dbg_info *db, ir_node *block, ir_node *node)

 {
 {

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

 
 

-  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 = new_ir_node(db, irg, block, op_Pin, get_irn_mode(node), 1, &node);

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

-}
+}  /* new_bd_Pin */
+
+/* --------------------------------------------- */
+/* 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_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_Block(dbg_info *db, ir_graph *irg,  int arity, ir_node **in)

 {
 {

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

 
 

-  assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
+  current_ir_graph = irg;
+  res = new_bd_Block(db, arity, in);
+  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);
-  /*
-   * 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;
   return res;

-}
+}  /* new_rd_Block */

 
 ir_node *
 
 ir_node *

-new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-           ir_node *objptr, type *ent)
+new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block)

 {
 {

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

 
 

-  r_arity = 2;
-  NEW_ARR_A(ir_node *, r_in, r_arity);
-  r_in[0] = store;
-  r_in[1] = objptr;
+  current_ir_graph = irg;
+  res = new_bd_Start(db, block);
+  current_ir_graph = rem;

 
 

-  res = new_ir_node(db, irg, block, op_Sel, mode_T, r_arity, r_in);
-  res->attr.io.ent = ent;
+  return res;
+}  /* new_rd_Start */
+
+ir_node *
+new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = rem;
+  res = new_bd_End(db, block);
+  current_ir_graph = rem;

 
 

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

   return res;
   return res;

-}
+}  /* new_rd_End */

 
 

+/* Creates a Phi node with all predecessors.  Calling this constructor
+   is only allowed if the corresponding block is mature.  */

 ir_node *
 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;
+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;

 
 

-  if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
-    mode = mode_P_data;   /* FIXME: can be mode_P_code */
-  else
-    mode = mode_Iu;
+  current_ir_graph = irg;
+  res = new_bd_Phi(db, block,arity, in, mode);
+  current_ir_graph = rem;

 
 

-  res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
+  return res;
+}  /* new_rd_Phi */

 
 

-  res->attr.i.num = symkind;
-  res->attr.i.sym = value;
-  res->attr.i.tp  = tp;
+ir_node *
+new_rd_Const_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Const_type(db, block, mode, con, tp);
+  current_ir_graph = rem;

 
 

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

   return res;
   return res;

-}
+}  /* new_rd_Const_type */
+
+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;
+}  /* new_rd_Const */
+
+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));
+}  /* new_rd_Const_long */
+
+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;
+}  /* new_rd_Id */
+
+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;
+}  /* new_rd_Proj */
+
+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;
+}  /* new_rd_defaultProj */
+
+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, 0);
+  current_ir_graph = rem;
+
+  return res;
+}  /* new_rd_Conv */
+
+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;
+}  /* new_rd_Cast */
+
+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_Tuple */
+
+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;
+}  /* new_rd_Cmp */
+
+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;
+}  /* new_rd_Jmp */
+
+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;
+}  /* new_rd_IJmp */
+
+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;
+}  /* new_rd_Cond */

 
 ir_node *
 
 ir_node *

-new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
+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;
+}  /* new_rd_Call */
+
+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;
+}  /* new_rd_Return */
+
+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;
+}  /* new_rd_Load */
+
+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;
+}  /* new_rd_Store */
+
+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;
+}  /* new_rd_Alloc */
+
+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;
+}  /* new_rd_Free */
+
+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;
+
+  return res;
+}  /* new_rd_simpleSel */
+
+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)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_Sel(db, block, store, objptr, arity, in, ent);
+  current_ir_graph = rem;
+
+  return res;
+}  /* new_rd_Sel */
+
+ir_node *
+new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
+              symconst_kind symkind, ir_type *tp)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+  res = new_bd_SymConst_type(db, block, value, symkind, tp);
+  current_ir_graph = rem;
+
+  return res;
+}  /* new_rd_SymConst_type */
+
+ir_node *
+new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,

          symconst_kind symkind)
 {
   ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
   return res;
          symconst_kind symkind)
 {
   ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
   return res;

-}
+}  /* new_rd_SymConst */

 
 

-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);
+}  /* new_rd_SymConst_addr_ent */

 
 

-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);
+}  /* new_rd_SymConst_addr_name */

 
 

-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);
+}  /* new_rd_SymConst_type_tag */

 
 

-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_type_size, tp);
+}  /* new_rd_SymConst_size */
+
+ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+  symconst_symbol sym = {symbol};
+  return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp);
+}  /* new_rd_SymConst_align */

 
 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;
+  int      i;
+
+  current_ir_graph = irg;
+  res = new_bd_Sync(db, block);
+  current_ir_graph = rem;
+
+  for (i = 0; i < arity; ++i)
+    add_Sync_pred(res, in[i]);

 
 

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

   return res;
   return res;

-}
+}  /* new_rd_Sync */

 
 ir_node *
 
 ir_node *

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

 
 ir_node *
 
 ir_node *

-new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
+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;

-}
+}  /* new_rd_Confirm */

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

-new_rd_Unknown (ir_graph *irg, ir_mode *m)
+new_rd_Unknown(ir_graph *irg, ir_mode *m)

 {
 {

+  ir_node  *res;

   ir_graph *rem = current_ir_graph;
   ir_graph *rem = current_ir_graph;

-  ir_node *res;

 
   current_ir_graph = irg;
 
   current_ir_graph = irg;

-  res = new_ir_node(NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
-  res = optimize_node(res);
+  res = new_bd_Unknown(m);

   current_ir_graph = rem;
   current_ir_graph = rem;

+

   return res;
   return res;

-}
+}  /* new_rd_Unknown */

 
 ir_node *
 
 ir_node *

-new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
+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;

-}
+}  /* new_rd_CallBegin */

 
 ir_node *
 
 ir_node *

-new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
+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;

-}
+}  /* new_rd_EndReg */

 
 ir_node *
 
 ir_node *

-new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
+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;

-}
+}  /* new_rd_EndExcept */

 
 ir_node *
 
 ir_node *

-new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
+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;

-}
+}  /* new_rd_Break */

 
 ir_node *
 
 ir_node *

-new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
+new_rd_Filter(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,

            long proj)
 {
            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;
   return res;

-}
+}  /* new_rd_Filter */

 
 ir_node *
 
 ir_node *

-new_rd_NoMem (ir_graph *irg) {
-  return irg->no_mem;
-}
+new_rd_NoMem(ir_graph *irg) {
+  return get_irg_no_mem(irg);
+}  /* new_rd_NoMem */

 
 ir_node *
 
 ir_node *

-new_rd_Mux  (dbg_info *db, ir_graph *irg, ir_node *block,
+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 *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;
+}  /* new_rd_Mux */
+
+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;

 
 

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

   return res;
   return res;

-}
+}  /* new_rd_Psi */
+
+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;
+}  /* new_rd_CopyB */
+
+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;
+}  /* new_rd_InstOf */
+
+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;
+
+  return res;
+}  /* new_rd_Raise */
+
+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;
+}  /* new_rd_Bound */
+
+ir_node *new_rd_Pin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *node)
+{
+  ir_node  *res;
+  ir_graph *rem = current_ir_graph;

 
 

+  current_ir_graph = irg;
+  res = new_bd_Pin(db, block, node);
+  current_ir_graph = rem;
+
+  return res;
+}  /* new_rd_Pin */

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


@@ -942,41 +1523,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_node *new_r_Const_type(ir_graph *irg, ir_node *block,

-               ir_mode *mode, tarval *con, type *tp) {
+               ir_mode *mode, tarval *con, ir_type *tp) {

   return new_rd_Const_type(NULL, irg, block, mode, con, 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,


@@ -1029,11 +1603,7 @@ ir_node *new_r_Eor    (ir_graph *irg, ir_node *block,
 }
 ir_node *new_r_Not    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_mode *mode) {
 }
 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 *new_r_Cmp    (ir_graph *irg, ir_node *block,
-               ir_node *op1, ir_node *op2) {
-  return new_rd_Cmp(NULL, irg, block, op1, op2);
+  return new_rd_Not(NULL, irg, block, op, mode);

 }
 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_node *k, ir_mode *mode) {
 }
 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
                ir_node *op, ir_node *k, ir_mode *mode) {


@@ -1051,11 +1621,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,


@@ -1071,14 +1653,14 @@ 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);
 }
   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) {
+ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {

   return new_rd_Sync(NULL, irg, block, arity, in);
 }
 ir_node *new_r_Proj   (ir_graph *irg, ir_node *block, ir_node *arg,
   return new_rd_Sync(NULL, irg, block, arity, in);
 }
 ir_node *new_r_Proj   (ir_graph *irg, ir_node *block, ir_node *arg,


@@ -1129,7 +1711,29 @@ 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);
+}
+ir_node *new_r_Pin(ir_graph *irg, ir_node *block, ir_node *node) {
+  return new_rd_Pin(NULL, irg, block, node);
+}

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


@@ -1144,21 +1748,21 @@ 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;
 

-  res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
+  res = new_ir_node(db, current_ir_graph, current_ir_graph->current_block,

              op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = current_ir_graph; */
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, current_ir_graph);
   return res;
              op_Start, mode_T, 0, NULL);
   /* res->attr.start.irg = current_ir_graph; */
 
   res = optimize_node(res);
   IRN_VRFY_IRG(res, current_ir_graph);
   return res;

-}
+}  /* new_d_Start */

 
 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,


@@ -1167,19 +1771,19 @@ new_d_End (dbg_info* db)
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;

-}
+}  /* new_d_End */

 
 /* Constructs a Block with a fixed number of predecessors.
    Does set current_block.  Can be used with automatic Phi
    node construction. */
 ir_node *
 
 /* Constructs a Block with a fixed number of predecessors.
    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) {


@@ -1190,7 +1794,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;
     }
 


@@ -1200,7 +1804,7 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;

-}
+}  /* new_d_Block */

 
 /* ***********************************************************************/
 /* Methods necessary for automatic Phi node creation                     */
 
 /* ***********************************************************************/
 /* Methods necessary for automatic Phi node creation                     */


@@ -1228,16 +1832,16 @@ new_d_Block (dbg_info* db, int arity, ir_node **in)
 
 * *************************************************************************** */
 
 
 * *************************************************************************** */
 

-/** Creates a Phi node with 0 predecessors */
+/** Creates a Phi node with 0 predecessors. */

 static INLINE ir_node *
 static INLINE ir_node *

-new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
+new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode)

 {
   ir_node *res;
 
   res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
   IRN_VRFY_IRG(res, irg);
   return res;
 {
   ir_node *res;
 
   res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
   IRN_VRFY_IRG(res, irg);
   return res;

-}
+}  /* new_rd_Phi0 */

 
 /* There are two implementations of the Phi node construction.  The first
    is faster, but does not work for blocks with more than 2 predecessors.
 
 /* There are two implementations of the Phi node construction.  The first
    is faster, but does not work for blocks with more than 2 predecessors.


@@ -1262,13 +1866,14 @@ new_Phi_in_stack(void) {
   res->pos = 0;
 
   return res;
   res->pos = 0;
 
   return res;

-}
+}  /* new_Phi_in_stack */

 
 void
 free_Phi_in_stack(Phi_in_stack *s) {
   DEL_ARR_F(s->stack);
   free(s);
 
 void
 free_Phi_in_stack(Phi_in_stack *s) {
   DEL_ARR_F(s->stack);
   free(s);

-}
+}  /* free_Phi_in_stack */
+

 static INLINE void
 free_to_Phi_in_stack(ir_node *phi) {
   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
 static INLINE void
 free_to_Phi_in_stack(ir_node *phi) {
   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==


@@ -1278,7 +1883,7 @@ free_to_Phi_in_stack(ir_node *phi) {
     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 
   (current_ir_graph->Phi_in_stack->pos)++;
     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 
   (current_ir_graph->Phi_in_stack->pos)++;

-}
+}  /* free_to_Phi_in_stack */

 
 static INLINE ir_node *
 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
 
 static INLINE ir_node *
 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,


@@ -1310,29 +1915,30 @@ alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
     (current_ir_graph->Phi_in_stack->pos)--;
   }
   return res;
     (current_ir_graph->Phi_in_stack->pos)--;
   }
   return res;

-}
+}  /* alloc_or_pop_from_Phi_in_stack */

 #endif /* USE_EXPLICIT_PHI_IN_STACK */
 
 #endif /* USE_EXPLICIT_PHI_IN_STACK */
 

-/* Creates a Phi node with a given, fixed array **in of predecessors.
-   If the Phi node is unnecessary, as the same value reaches the block
-   through all control flow paths, it is eliminated and the value
-   returned directly.  This constructor is only intended for use in
-   the automatic Phi node generation triggered by get_value or mature.
-   The implementation is quite tricky and depends on the fact, that
-   the nodes are allocated on a stack:
-   The in array contains predecessors and NULLs.  The NULLs appear,
-   if get_r_value_internal, that computed the predecessors, reached
-   the same block on two paths.  In this case the same value reaches
-   this block on both paths, there is no definition in between.  We need
-   not allocate a Phi where these path's merge, but we have to communicate
-   this fact to the caller.  This happens by returning a pointer to the
-   node the caller _will_ allocate.  (Yes, we predict the address. We can
-   do so because the nodes are allocated on the obstack.)  The caller then
-   finds a pointer to itself and, when this routine is called again,
-   eliminates itself.
-   */
+/**
+ * Creates a Phi node with a given, fixed array **in of predecessors.
+ * If the Phi node is unnecessary, as the same value reaches the block
+ * through all control flow paths, it is eliminated and the value
+ * returned directly.  This constructor is only intended for use in
+ * the automatic Phi node generation triggered by get_value or mature.
+ * The implementation is quite tricky and depends on the fact, that
+ * the nodes are allocated on a stack:
+ * The in array contains predecessors and NULLs.  The NULLs appear,
+ * if get_r_value_internal, that computed the predecessors, reached
+ * the same block on two paths.  In this case the same value reaches
+ * this block on both paths, there is no definition in between.  We need
+ * not allocate a Phi where these path's merge, but we have to communicate
+ * this fact to the caller.  This happens by returning a pointer to the
+ * node the caller _will_ allocate.  (Yes, we predict the address. We can
+ * do so because the nodes are allocated on the obstack.)  The caller then
+ * finds a pointer to itself and, when this routine is called again,
+ * eliminates itself.
+ */

 static INLINE ir_node *
 static INLINE ir_node *

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

 {
   int i;
   ir_node *res, *known;
 {
   int i;
   ir_node *res, *known;


@@ -1390,16 +1996,17 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int i
 
   /* return the pointer to the Phi node.  This node might be deallocated! */
   return res;
 
   /* return the pointer to the Phi node.  This node might be deallocated! */
   return res;

-}
+}  /* new_rd_Phi_in */

 
 static ir_node *
 
 static ir_node *

-get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
+get_r_value_internal(ir_node *block, int pos, ir_mode *mode);

 
 /**
 
 /**

-    allocates and returns this node.  The routine called to allocate the
-    node might optimize it away and return a real value, or even a pointer
-    to a deallocated Phi node on top of the obstack!
-    This function is called with an in-array of proper size. **/
+ * Allocates and returns this node.  The routine called to allocate the
+ * node might optimize it away and return a real value, or even a pointer
+ * to a deallocated Phi node on top of the obstack!
+ * This function is called with an in-array of proper size.
+ */

 static ir_node *
 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 {
 static ir_node *
 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 {


@@ -1429,8 +2036,8 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 
   /* Now we now the value for "pos" and can enter it in the array with
      all known local variables.  Attention: this might be a pointer to
 
   /* Now we now the value for "pos" and can enter it in the array with
      all known local variables.  Attention: this might be a pointer to

-     a node, that later will be allocated!!! See new_rd_Phi_in.
-     If this is called in mature, after some set_value in the same block,
+     a node, that later will be allocated!!! See new_rd_Phi_in().
+     If this is called in mature, after some set_value() in the same block,

      the proper value must not be overwritten:
      The call order
        get_value    (makes Phi0, put's it into graph_arr)
      the proper value must not be overwritten:
      The call order
        get_value    (makes Phi0, put's it into graph_arr)


@@ -1448,12 +2055,14 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
   return res;
 }
 
   return res;
 }
 

-/* This function returns the last definition of a variable.  In case
-   this variable was last defined in a previous block, Phi nodes are
-   inserted.  If the part of the firm graph containing the definition
-   is not yet constructed, a dummy Phi node is returned. */
+/**
+ * This function returns the last definition of a variable.  In case
+ * this variable was last defined in a previous block, Phi nodes are
+ * inserted.  If the part of the firm graph containing the definition
+ * is not yet constructed, a dummy Phi node is returned.
+ */

 static ir_node *
 static ir_node *

-get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
+get_r_value_internal(ir_node *block, int pos, ir_mode *mode)

 {
   ir_node *res;
   /* There are 4 cases to treat.
 {
   ir_node *res;
   /* There are 4 cases to treat.


@@ -1551,7 +2160,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
   block->attr.block.graph_arr[pos] = res;
 
   return res;
   block->attr.block.graph_arr[pos] = res;
 
   return res;

-}
+}  /* get_r_value_internal */

 
 #else /* if 0 */
 
 
 #else /* if 0 */
 


@@ -1566,7 +2175,7 @@ void free_Phi_in_stack(Phi_in_stack *s) { }
 #endif
 
 static INLINE ir_node *
 #endif
 
 static INLINE ir_node *

-new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
+new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode,

            ir_node **in, int ins, ir_node *phi0)
 {
   int i;
            ir_node **in, int ins, ir_node *phi0)
 {
   int i;


@@ -1625,27 +2234,28 @@ 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;

-}
+}  /* new_rd_Phi_in */

 
 static ir_node *
 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 
 #if PRECISE_EXC_CONTEXT
 static ir_node *
 
 static ir_node *
 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 
 #if PRECISE_EXC_CONTEXT
 static ir_node *

-phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
-
-/* Construct a new frag_array for node n.
-   Copy the content from the current graph_arr of the corresponding block:
-   this is the current state.
-   Set ProjM(n) as current memory state.
-   Further the last entry in frag_arr of current block points to n.  This
-   constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block.
+phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
+
+/**
+ * Construct a new frag_array for node n.
+ * Copy the content from the current graph_arr of the corresponding block:
+ * this is the current state.
+ * Set ProjM(n) as current memory state.
+ * Further the last entry in frag_arr of current block points to n.  This
+ * constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block.

  */
  */

-static INLINE ir_node ** new_frag_arr (ir_node *n)
+static INLINE ir_node ** new_frag_arr(ir_node *n)

 {
   ir_node **arr;
   int opt;
 {
   ir_node **arr;
   int opt;


@@ -1660,31 +2270,33 @@ 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 {
     assert((pn_Quot_M == pn_DivMod_M) &&
        (pn_Quot_M == pn_Div_M)    &&
        (pn_Quot_M == pn_Mod_M)    &&
        (pn_Quot_M == pn_Load_M)   &&
        (pn_Quot_M == pn_Store_M)  &&
   else {
     assert((pn_Quot_M == pn_DivMod_M) &&
        (pn_Quot_M == pn_Div_M)    &&
        (pn_Quot_M == pn_Mod_M)    &&
        (pn_Quot_M == pn_Load_M)   &&
        (pn_Quot_M == pn_Store_M)  &&

-       (pn_Quot_M == pn_Alloc_M)    );
+       (pn_Quot_M == pn_Alloc_M)  &&
+       (pn_Quot_M == pn_Bound_M));

     arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
   }
   set_optimize(opt);
 
   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
   return arr;
     arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
   }
   set_optimize(opt);
 
   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
   return arr;

-}
+}  /* new_frag_arr */

 
 /**
 
 /**

- * returns the frag_arr from a node
+ * Returns the frag_arr from a node.

  */
  */

-static INLINE ir_node **
-get_frag_arr (ir_node *n) {
+static INLINE ir_node **get_frag_arr(ir_node *n) {

   switch (get_irn_opcode(n)) {
   case iro_Call:
     return n->attr.call.exc.frag_arr;
   case iro_Alloc:
   switch (get_irn_opcode(n)) {
   case iro_Call:
     return n->attr.call.exc.frag_arr;
   case iro_Alloc:

-    return n->attr.a.exc.frag_arr;
+    return n->attr.alloc.exc.frag_arr;

   case iro_Load:
     return n->attr.load.exc.frag_arr;
   case iro_Store:
   case iro_Load:
     return n->attr.load.exc.frag_arr;
   case iro_Store:


@@ -1692,7 +2304,7 @@ get_frag_arr (ir_node *n) {
   default:
     return n->attr.except.frag_arr;
   }
   default:
     return n->attr.except.frag_arr;
   }

-}
+}  /* get_frag_arr */

 
 static void
 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
 
 static void
 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {


@@ -1719,10 +2331,10 @@ set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
   }
   assert(0 && "potential endless recursion");
 #endif
   }
   assert(0 && "potential endless recursion");
 #endif

-}
+}  /* set_frag_value */

 
 static ir_node *
 
 static ir_node *

-get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
+get_r_frag_value_internal(ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {

   ir_node *res;
   ir_node **frag_arr;
 
   ir_node *res;
   ir_node **frag_arr;
 


@@ -1732,8 +2344,8 @@ get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode
   res = frag_arr[pos];
   if (!res) {
     if (block->attr.block.graph_arr[pos]) {
   res = frag_arr[pos];
   if (!res) {
     if (block->attr.block.graph_arr[pos]) {

-      /* There was a set_value after the cfOp and no get_value before that
-         set_value.  We must build a Phi node now. */
+      /* There was a set_value() after the cfOp and no get_value before that
+         set_value().  We must build a Phi node now. */

       if (block->attr.block.matured) {
         int ins = get_irn_arity(block);
         ir_node **nin;
       if (block->attr.block.matured) {
         int ins = get_irn_arity(block);
         ir_node **nin;


@@ -1756,16 +2368,17 @@ get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode
     }
   }
   return res;
     }
   }
   return res;

-}
-#endif
+}  /* get_r_frag_value_internal */
+#endif /* PRECISE_EXC_CONTEXT */

 
 /**
 
 /**

-    computes the predecessors for the real phi node, and then
-    allocates and returns this node.  The routine called to allocate the
-    node might optimize it away and return a real value.
-    This function must be called with an in-array of proper size. **/
+ * Computes the predecessors for the real phi node, and then
+ * allocates and returns this node.  The routine called to allocate the
+ * node might optimize it away and return a real value.
+ * This function must be called with an in-array of proper size.
+ */

 static ir_node *
 static ir_node *

-phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
+phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)

 {
   ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
   int i;
 {
   ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
   int i;


@@ -1786,10 +2399,15 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
          (bad, jmp).  In this case we call the function needlessly, eventually
          generating an non existent error.
          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
          (bad, jmp).  In this case we call the function needlessly, eventually
          generating an non existent error.
          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.


@@ -1868,14 +2486,16 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
   }
 
   return res;
   }
 
   return res;

-}
+}  /* phi_merge */

 
 

-/* This function returns the last definition of a variable.  In case
-   this variable was last defined in a previous block, Phi nodes are
-   inserted.  If the part of the firm graph containing the definition
-   is not yet constructed, a dummy Phi node is returned. */
+/**
+ * This function returns the last definition of a variable.  In case
+ * this variable was last defined in a previous block, Phi nodes are
+ * inserted.  If the part of the firm graph containing the definition
+ * is not yet constructed, a dummy Phi node is returned.
+ */

 static ir_node *
 static ir_node *

-get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
+get_r_value_internal(ir_node *block, int pos, ir_mode *mode)

 {
   ir_node *res;
   /* There are 4 cases to treat.
 {
   ir_node *res;
   /* There are 4 cases to treat.


@@ -1961,7 +2581,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
   block->attr.block.graph_arr[pos] = res;
 
   return res;
   block->attr.block.graph_arr[pos] = res;
 
   return res;

-}
+}  /* get_r_value_internal */

 
 #endif /* USE_FAST_PHI_CONSTRUCTION */
 
 
 #endif /* USE_FAST_PHI_CONSTRUCTION */
 


@@ -1972,7 +2592,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
  * Acceptable parameters are only Block nodes.
  */
 void
  * Acceptable parameters are only Block nodes.
  */
 void

-mature_immBlock (ir_node *block)
+mature_immBlock(ir_node *block)

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


@@ -2010,112 +2630,76 @@ mature_immBlock (ir_node *block)
     block = optimize_in_place_2(block);
     IRN_VRFY_IRG(block, current_ir_graph);
   }
     block = optimize_in_place_2(block);
     IRN_VRFY_IRG(block, current_ir_graph);
   }

-}
+}  /* mature_immBlock */

 
 ir_node *
 
 ir_node *

-new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
-{
-  return new_rd_Phi(db, current_ir_graph, current_ir_graph->current_block,
-            arity, in, mode);
-}
+new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode) {
+  return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);
+}  /* new_d_Phi */

 
 ir_node *
 
 ir_node *

-new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
-{
-  return new_rd_Const(db, current_ir_graph, current_ir_graph->start_block,
-              mode, con);
-}
+new_d_Const(dbg_info *db, ir_mode *mode, tarval *con) {
+  return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con);
+}  /* new_d_Const */

 
 ir_node *
 
 ir_node *

-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);
-}
+new_d_Const_long(dbg_info *db, ir_mode *mode, long value) {
+  return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value);
+}  /* new_d_Const_long */

 
 ir_node *
 
 ir_node *

-new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
-{
-  return new_rd_Const_type(db, current_ir_graph, current_ir_graph->start_block,
-                mode, con, tp);
-}
+new_d_Const_type(dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp) {
+  return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp);
+}  /* new_d_Const_type */

 
 
 ir_node *
 
 
 ir_node *

-new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
-{
-  return new_rd_Id(db, current_ir_graph, current_ir_graph->current_block,
-           val, mode);
-}
+new_d_Id(dbg_info *db, ir_node *val, ir_mode *mode) {
+  return new_bd_Id(db, current_ir_graph->current_block, val, mode);
+}  /* new_d_Id */

 
 ir_node *
 
 ir_node *

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

-  arg->attr.c.kind = fragmentary;
-  arg->attr.c.default_proj = max_proj;
+  arg->attr.cond.kind = fragmentary;
+  arg->attr.cond.default_proj = max_proj;

   res = new_Proj (arg, mode_X, max_proj);
   return res;
   res = new_Proj (arg, mode_X, max_proj);
   return res;

-}
-
-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);
-}
+}  /* new_d_defaultProj */

 
 ir_node *
 
 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);
+new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode) {
+  return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 0);

 }
 
 ir_node *
 }
 
 ir_node *

-new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  return new_rd_Add(db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
-}
+new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode) {
+  return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 1);
+}  /* new_d_strictConv */

 
 ir_node *
 
 ir_node *

-new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
-{
-  return new_rd_Sub(db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2, mode);
-}
-
+new_d_Cast(dbg_info *db, ir_node *op, ir_type *to_tp) {
+  return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
+}  /* new_d_Cast */

 
 ir_node *
 
 ir_node *

-new_d_Minus (dbg_info* db, ir_node *op,  ir_mode *mode)
-{
-  return new_rd_Minus(db, current_ir_graph, current_ir_graph->current_block,
-              op, mode);
-}
+new_d_Tuple(dbg_info *db, int arity, ir_node **in) {
+  return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);
+}  /* new_d_Tuple */

 
 

-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.

  */
 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
   if (get_opt_precise_exc_context()) {
  */
 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
   if (get_opt_precise_exc_context()) {


@@ -2125,44 +2709,35 @@ static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
       *frag_store = new_frag_arr(res);
     }
   }
       *frag_store = new_frag_arr(res);
     }
   }

-}
-
+}  /* allocate_frag_arr */

 
 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->attr.except.pin_state = op_pin_state_pinned;
+  res = new_bd_Quot (db, current_ir_graph->current_block, memop, op1, op2);

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

-}
+}  /* new_d_Quot */

 
 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->attr.except.pin_state = op_pin_state_pinned;
+  res = new_bd_DivMod (db, current_ir_graph->current_block, memop, op1, op2);

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

-}
+}  /* new_d_DivMod */

 
 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->attr.except.pin_state = op_pin_state_pinned;
+  res = new_bd_Div (db, current_ir_graph->current_block, memop, op1, op2);

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


@@ -2171,295 +2746,247 @@ 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->attr.except.pin_state = op_pin_state_pinned;
+  res = new_bd_Mod (db, current_ir_graph->current_block, memop, op1, op2);

 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
 #endif
 
   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_Mod */

 
 

-ir_node *
-new_d_Abs (dbg_info* db, ir_node *op, ir_mode *mode)
-{
-  return new_rd_Abs (db, current_ir_graph, current_ir_graph->current_block,
-            op, 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_Cmp (dbg_info* db, ir_node *op1, ir_node *op2)
-{
-  return new_rd_Cmp (db, current_ir_graph, current_ir_graph->current_block,
-            op1, op2);
-}
+new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2) {
+  return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
+}  /* new_d_Cmp */

 
 ir_node *
 
 ir_node *

-new_d_Jmp (dbg_info* db)
-{
-  return new_rd_Jmp (db, current_ir_graph, current_ir_graph->current_block);
-}
+new_d_Jmp(dbg_info *db) {
+  return new_bd_Jmp(db, current_ir_graph->current_block);
+}  /* new_d_Jmp */

 
 ir_node *
 
 ir_node *

-new_d_IJmp (dbg_info* db, ir_node *tgt)
-{
-  return new_rd_IJmp (db, current_ir_graph, current_ir_graph->current_block, tgt);
-}
+new_d_IJmp(dbg_info *db, ir_node *tgt) {
+  return new_bd_IJmp(db, current_ir_graph->current_block, tgt);
+}  /* new_d_IJmp */

 
 ir_node *
 
 ir_node *

-new_d_Cond (dbg_info* db, ir_node *c)
-{
-  return new_rd_Cond (db, current_ir_graph, current_ir_graph->current_block, c);
-}
+new_d_Cond(dbg_info *db, ir_node *c) {
+  return new_bd_Cond(db, current_ir_graph->current_block, c);
+}  /* new_d_Cond */

 
 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. */
 #endif
 
   return res;
              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. */
 #endif
 
   return res;

-}
-
-ir_node *
-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,
-               store, arity, in);
-}
+}  /* new_d_Call */

 
 ir_node *
 
 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);
-}
+new_d_Return(dbg_info *db, ir_node* store, int arity, ir_node **in) {
+  return new_bd_Return(db, current_ir_graph->current_block,
+                       store, arity, in);
+}  /* new_d_Return */

 
 ir_node *
 
 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,
-             store, addr, mode);
+  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. */
 #endif
 
   return res;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;

-}
+}  /* new_d_Load */

 
 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,
-              store, addr, val);
+  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. */
 #endif
 
   return res;
 #if PRECISE_EXC_CONTEXT
   allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
 #endif
 
   return res;

-}
+}  /* new_d_Store */

 
 ir_node *
 
 ir_node *

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

 {
   ir_node *res;
 {
   ir_node *res;

-  res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
-              store, size, alloc_type, where);
+  res = new_bd_Alloc(db, current_ir_graph->current_block,
+                     store, size, alloc_type, where);

 #if PRECISE_EXC_CONTEXT
 #if PRECISE_EXC_CONTEXT

-  allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */
+  allocate_frag_arr(res, op_Alloc, &res->attr.alloc.exc.frag_arr);  /* Could be optimized away. */

 #endif
 
   return res;
 #endif
 
   return res;

-}
+}  /* new_d_Alloc */

 
 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);
             store, objptr, 0, NULL, ent);

-}
+}  /* new_d_simpleSel */

 
 ir_node *
 
 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);
             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));
-}
+}  /* new_d_Sel */

 
 ir_node *
 
 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);
                          value, kind, tp);

-}
+}  /* new_d_SymConst_type */

 
 ir_node *
 
 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);
                          value, kind);

-}
+}  /* new_d_SymConst */

 
 ir_node *
 
 ir_node *

-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);
-}
+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);
+}  /* new_d_Sync */

 
 
 ir_node *
 (new_d_Bad)(void) {
   return _new_d_Bad();
 
 
 ir_node *
 (new_d_Bad)(void) {
   return _new_d_Bad();

-}
+}  /* new_d_Bad */

 
 ir_node *
 
 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,
+new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) {
+  return new_bd_Confirm(db, current_ir_graph->current_block,

              val, bound, cmp);
              val, bound, cmp);

-}
+}  /* new_d_Confirm */

 
 ir_node *
 
 ir_node *

-new_d_Unknown (ir_mode *m)
-{
-  return new_rd_Unknown(current_ir_graph, m);
-}
+new_d_Unknown(ir_mode *m) {
+  return new_bd_Unknown(m);
+}  /* new_d_Unknown */

 
 ir_node *
 
 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);
-  return res;
-}
+new_d_CallBegin(dbg_info *db, ir_node *call) {
+  return new_bd_CallBegin(db, current_ir_graph->current_block, call);
+}  /* new_d_CallBegin */

 
 ir_node *
 
 ir_node *

-new_d_EndReg (dbg_info *db)
-{
-  ir_node *res;
-  res = new_rd_EndReg(db, current_ir_graph, current_ir_graph->current_block);
-  return res;
-}
+new_d_EndReg(dbg_info *db) {
+  return new_bd_EndReg(db, current_ir_graph->current_block);
+}  /* new_d_EndReg */

 
 ir_node *
 
 ir_node *

-new_d_EndExcept (dbg_info *db)
-{
-  ir_node *res;
-  res = new_rd_EndExcept(db, current_ir_graph, current_ir_graph->current_block);
-  return res;
-}
+new_d_EndExcept(dbg_info *db) {
+  return new_bd_EndExcept(db, current_ir_graph->current_block);
+}  /* new_d_EndExcept */

 
 ir_node *
 
 ir_node *

-new_d_Break (dbg_info *db)
-{
-  return new_rd_Break (db, current_ir_graph, current_ir_graph->current_block);
-}
+new_d_Break(dbg_info *db) {
+  return new_bd_Break(db, current_ir_graph->current_block);
+}  /* new_d_Break */

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

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

-}
+}  /* new_d_Filter */

 
 ir_node *
 
 ir_node *

-(new_d_NoMem)(void)
-{
+(new_d_NoMem)(void) {

   return _new_d_NoMem();
   return _new_d_NoMem();

-}
+}  /* new_d_NoMem */

 
 ir_node *
 
 ir_node *

-new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
+new_d_Mux(dbg_info *db, ir_node *sel, ir_node *ir_false,

     ir_node *ir_true, ir_mode *mode) {
     ir_node *ir_true, ir_mode *mode) {

-  return new_rd_Mux (db, current_ir_graph, current_ir_graph->current_block,
-      sel, ir_false, ir_true, mode);
-}
+  return new_bd_Mux(db, current_ir_graph->current_block,
+                    sel, ir_false, ir_true, mode);
+}  /* new_d_Mux */
+
+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);
+}  /* new_d_Psi */
+
+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;
+}  /* new_d_CopyB */
+
+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);
+}  /* new_d_InstOf */
+
+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);
+}  /* new_d_Raise */
+
+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;
+}  /* new_d_Bound */
+
+ir_node *
+new_d_Pin(dbg_info *db, ir_node *node) {
+  return new_bd_Pin(db, current_ir_graph->current_block, node);
+}  /* new_d_Pin */

 
 /* ********************************************************************* */
 /* Comfortable interface with automatic Phi node construction.           */
 
 /* ********************************************************************* */
 /* Comfortable interface with automatic Phi node construction.           */


@@ -2468,7 +2995,7 @@ new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
 
 /*  Block construction */
 /* immature Block without predecessors */
 
 /*  Block construction */
 /* 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);


@@ -2494,16 +3021,16 @@ ir_node *new_d_immBlock (dbg_info* db) {
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;
   IRN_VRFY_IRG(res, current_ir_graph);
 
   return res;

-}
+}  /* new_d_immBlock */

 
 ir_node *
 
 ir_node *

-new_immBlock (void) {
+new_immBlock(void) {

   return new_d_immBlock(NULL);
   return new_d_immBlock(NULL);

-}
+}  /* new_immBlock */

 
 /* add an edge to a jmp/control flow node */
 void
 
 /* add an edge to a jmp/control flow node */
 void

-add_immBlock_pred (ir_node *block, ir_node *jmp)
+add_immBlock_pred(ir_node *block, ir_node *jmp)

 {
   if (block->attr.block.matured) {
     assert(0 && "Error: Block already matured!\n");
 {
   if (block->attr.block.matured) {
     assert(0 && "Error: Block already matured!\n");


@@ -2512,77 +3039,115 @@ add_immBlock_pred (ir_node *block, ir_node *jmp)
     assert(jmp != NULL);
     ARR_APP1(ir_node *, block->in, jmp);
   }
     assert(jmp != NULL);
     ARR_APP1(ir_node *, block->in, jmp);
   }

-}
+}  /* add_immBlock_pred */

 
 /* 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;

-}
+}  /* set_cur_block */

 
 /* ************************ */
 /* parameter administration */
 
 /* get a value from the parameter array from the current block by its index */
 ir_node *
 
 /* ************************ */
 /* parameter administration */
 
 /* 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);
 
   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   inc_irg_visited(current_ir_graph);
 
   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);

-}
+}  /* get_d_value */
+

 /* 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_value (int pos, ir_mode *mode)
-{
+get_value(int pos, ir_mode *mode) {

   return get_d_value(NULL, pos, mode);
   return get_d_value(NULL, pos, mode);

-}
+}  /* get_value */

 
 /* set a value at position pos in the parameter array from the current block */
 void
 
 /* set a value at position pos in the parameter array from the current block */
 void

-set_value (int pos, ir_node *value)
-{
+set_value(int pos, ir_node *value) {

   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   assert(pos+1 < current_ir_graph->n_loc);
   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   assert(pos+1 < current_ir_graph->n_loc);
   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;

-}
+}  /* set_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;
+}  /* find_value */

 
 /* get the current store */
 ir_node *
 
 /* get the current store */
 ir_node *

-get_store (void)
+get_store(void)

 {
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   /* GL: one could call get_value instead */
   inc_irg_visited(current_ir_graph);
   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
 {
   assert(get_irg_phase_state (current_ir_graph) == phase_building);
   /* GL: one could call get_value instead */
   inc_irg_visited(current_ir_graph);
   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);

-}
+}  /* get_store */

 
 

-/* set the current store */
+/* set the current store: handles automatic Sync construction for Load nodes */

 void
 void

-set_store (ir_node *store)
+set_store(ir_node *store)

 {
 {

-  /* GL: one could call set_value instead */
+  ir_node *load, *pload, *pred, *in[2];
+

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

+
+  if (get_opt_auto_create_sync()) {
+    /* handle non-volatile Load nodes by automatically creating Sync's */
+    load = skip_Proj(store);
+    if (is_Load(load) && get_Load_volatility(load) == volatility_non_volatile) {
+      pred = get_Load_mem(load);
+
+      if (is_Sync(pred)) {
+        /* a Load after a Sync: move it up */
+        ir_node *mem = skip_Proj(get_Sync_pred(pred, 0));
+
+        set_Load_mem(load, get_memop_mem(mem));
+        add_Sync_pred(pred, store);
+        store = pred;
+      }
+      else {
+        pload = skip_Proj(pred);
+        if (is_Load(pload) && get_Load_volatility(pload) == volatility_non_volatile) {
+          /* a Load after a Load: create a new Sync */
+          set_Load_mem(load, get_Load_mem(pload));
+
+          in[0] = pred;
+          in[1] = store;
+          store = new_Sync(2, in);
+        }
+      }
+    }
+  }

   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
   current_ir_graph->current_block->attr.block.graph_arr[0] = store;

-}
+}  /* set_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);
+}  /* keep_alive */

 
 /* --- Useful access routines --- */
 /* Returns the current block of the current graph.  To set the current
    block use set_cur_block. */
 ir_node *get_cur_block(void) {
   return get_irg_current_block(current_ir_graph);
 
 /* --- Useful access routines --- */
 /* Returns the current block of the current graph.  To set the current
    block use set_cur_block. */
 ir_node *get_cur_block(void) {
   return get_irg_current_block(current_ir_graph);

-}
+}  /* get_cur_block */

 
 /* Returns the frame type of the current graph */
 
 /* Returns the frame type of the current graph */

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

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

-}
+}  /* get_cur_frame_type */

 
 
 /* ********************************************************************* */
 
 
 /* ********************************************************************* */


@@ -2590,27 +3155,18 @@ type *get_cur_frame_type(void) {
 
 /* call once for each run of the library */
 void
 
 /* call once for each run of the library */
 void

-init_cons(uninitialized_local_variable_func_t *func)
-{
+init_cons(uninitialized_local_variable_func_t *func) {

   default_initialize_local_variable = func;
   default_initialize_local_variable = func;

-}
+}  /* init_cons */

 
 

-/* call for each graph */

 void
 void

-irg_finalize_cons (ir_graph *irg) {
-  irg->phase_state = phase_high;
-}
-
-void
-irp_finalize_cons (void) {
-  int i, n_irgs = get_irp_n_irgs();
-  for (i = 0; i < n_irgs; i++) {
+irp_finalize_cons(void) {
+  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;
+}  /* irp_finalize_cons */

 
 
 ir_node *new_Block(int arity, ir_node **in) {
 
 
 ir_node *new_Block(int arity, ir_node **in) {


@@ -2634,9 +3190,6 @@ ir_node *new_Cond   (ir_node *c) {
 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
   return new_d_Return(NULL, store, arity, in);
 }
 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);
 }


@@ -2646,7 +3199,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);
 }
 


@@ -2660,11 +3213,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) {


@@ -2718,13 +3268,22 @@ ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *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_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_strictConv   (ir_node *op, ir_mode *mode) {
+  return new_d_strictConv(NULL, op, mode);
+}
+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) {


@@ -2736,15 +3295,15 @@ 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);
 }
   return new_d_Free(NULL, store, ptr, size, free_type, where);
 }

-ir_node *new_Sync   (int arity, ir_node **in) {
+ir_node *new_Sync   (int arity, ir_node *in[]) {

   return new_d_Sync(NULL, arity, in);
 }
 ir_node *new_Proj   (ir_node *arg, ir_mode *mode, long proj) {
   return new_d_Sync(NULL, arity, in);
 }
 ir_node *new_Proj   (ir_node *arg, ir_mode *mode, long proj) {


@@ -2789,3 +3348,21 @@ 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);
+}
+ir_node *new_Pin(ir_node *node) {
+  return new_d_Pin(NULL, node);
+}