nsz Git - libfirm/blob - ir/ir/ircons.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/ircons.c
   4  * Purpose:     Various irnode constructors.  Automatic construction
   5  *              of SSA representation.
   6  * Author:      Martin Trapp, Christian Schaefer
   7  * Modified by: Goetz Lindenmaier, Boris Boesler
   8  * Created:
   9  * CVS-ID:      $Id$
  10  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  11  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include "config.h"
  16 #endif
  17
  18 #ifdef HAVE_ALLOCA_H
  19 #include <alloca.h>
  20 #endif
  21 #ifdef HAVE_MALLOC_H
  22 #include <malloc.h>
  23 #endif
  24 #ifdef HAVE_STRING_H
  25 #include <string.h>
  26 #endif
  27
  28 # include "irprog_t.h"
  29 # include "irgraph_t.h"
  30 # include "irnode_t.h"
  31 # include "irmode_t.h"
  32 # include "ircons_t.h"
  33 # include "firm_common_t.h"
  34 # include "irvrfy.h"
  35 # include "irop_t.h"
  36 # include "iropt_t.h"
  37 # include "irgmod.h"
  38 # include "array.h"
  39 # include "irbackedge_t.h"
  40 # include "irflag_t.h"
  41 # include "iredges_t.h"
  42
  43 #if USE_EXPLICIT_PHI_IN_STACK
  44 /* A stack needed for the automatic Phi node construction in constructor
  45    Phi_in. Redefinition in irgraph.c!! */
  46 struct Phi_in_stack {
  47   ir_node **stack;
  48   int       pos;
  49 };
  50 typedef struct Phi_in_stack Phi_in_stack;
  51 #endif
  52
  53 /* when we need verifying */
  54 #ifdef NDEBUG
  55 # define IRN_VRFY_IRG(res, irg)
  56 #else
  57 # define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)
  58 #endif /* NDEBUG */
  59
  60 /**
  61  * Language dependent variable initialization callback.
  62  */
  63 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
  64
  65 /* creates a bd constructor for a binop */
  66 #define NEW_BD_BINOP(instr)                                     \
  67 static ir_node *                                                \
  68 new_bd_##instr (dbg_info *db, ir_node *block,                   \
  69        ir_node *op1, ir_node *op2, ir_mode *mode)               \
  70 {                                                               \
  71   ir_node  *in[2];                                              \
  72   ir_node  *res;                                                \
  73   ir_graph *irg = current_ir_graph;                             \
  74   in[0] = op1;                                                  \
  75   in[1] = op2;                                                  \
  76   res = new_ir_node(db, irg, block, op_##instr, mode, 2, in);   \
  77   res = optimize_node(res);                                     \
  78   IRN_VRFY_IRG(res, irg);                                       \
  79   return res;                                                   \
  80 }
  81
  82 /* creates a bd constructor for an unop */
  83 #define NEW_BD_UNOP(instr)                                      \
  84 static ir_node *                                                \
  85 new_bd_##instr (dbg_info *db, ir_node *block,                   \
  86               ir_node *op, ir_mode *mode)                       \
  87 {                                                               \
  88   ir_node  *res;                                                \
  89   ir_graph *irg = current_ir_graph;                             \
  90   res = new_ir_node(db, irg, block, op_##instr, mode, 1, &op);  \
  91   res = optimize_node(res);                                     \
  92   IRN_VRFY_IRG(res, irg);                                       \
  93   return res;                                                   \
  94 }
  95
  96 /* creates a bd constructor for an divop */
  97 #define NEW_BD_DIVOP(instr)                                     \
  98 static ir_node *                                                \
  99 new_bd_##instr (dbg_info *db, ir_node *block,                   \
 100             ir_node *memop, ir_node *op1, ir_node *op2)         \
 101 {                                                               \
 102   ir_node  *in[3];                                              \
 103   ir_node  *res;                                                \
 104   ir_graph *irg = current_ir_graph;                             \
 105   in[0] = memop;                                                \
 106   in[1] = op1;                                                  \
 107   in[2] = op2;                                                  \
 108   res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
 109   res = optimize_node(res);                                     \
 110   IRN_VRFY_IRG(res, irg);                                       \
 111   return res;                                                   \
 112 }
 113
 114 /* creates a rd constructor for a binop */
 115 #define NEW_RD_BINOP(instr)                                     \
 116 ir_node *                                                       \
 117 new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
 118        ir_node *op1, ir_node *op2, ir_mode *mode)               \
 119 {                                                               \
 120   ir_node  *res;                                                \
 121   ir_graph *rem = current_ir_graph;                             \
 122   current_ir_graph = irg;                                       \
 123   res = new_bd_##instr(db, block, op1, op2, mode);              \
 124   current_ir_graph = rem;                                       \
 125   return res;                                                   \
 126 }
 127
 128 /* creates a rd constructor for an unop */
 129 #define NEW_RD_UNOP(instr)                                      \
 130 ir_node *                                                       \
 131 new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
 132               ir_node *op, ir_mode *mode)                       \
 133 {                                                               \
 134   ir_node  *res;                                                \
 135   ir_graph *rem = current_ir_graph;                             \
 136   current_ir_graph = irg;                                       \
 137   res = new_bd_##instr(db, block, op, mode);                    \
 138   current_ir_graph = rem;                                       \
 139   return res;                                                   \
 140 }
 141
 142 /* creates a rd constructor for an divop */
 143 #define NEW_RD_DIVOP(instr)                                     \
 144 ir_node *                                                       \
 145 new_rd_##instr (dbg_info *db, ir_graph *irg, ir_node *block,    \
 146             ir_node *memop, ir_node *op1, ir_node *op2)         \
 147 {                                                               \
 148   ir_node  *res;                                                \
 149   ir_graph *rem = current_ir_graph;                             \
 150   current_ir_graph = irg;                                       \
 151   res = new_bd_##instr(db, block, memop, op1, op2);             \
 152   current_ir_graph = rem;                                       \
 153   return res;                                                   \
 154 }
 155
 156 /* creates a d constructor for an binop */
 157 #define NEW_D_BINOP(instr)                                                    \
 158 ir_node *                                                                     \
 159 new_d_##instr (dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {     \
 160   return new_bd_##instr(db, current_ir_graph->current_block, op1, op2, mode); \
 161 }
 162
 163 /* creates a d constructor for an unop */
 164 #define NEW_D_UNOP(instr)                                                     \
 165 ir_node *                                                                     \
 166 new_d_##instr (dbg_info *db, ir_node *op, ir_mode *mode) {                    \
 167   return new_bd_##instr(db, current_ir_graph->current_block, op, mode);         \
 168 }
 169
 170
 171 /* Constructs a Block with a fixed number of predecessors.
 172    Does not set current_block.  Can not be used with automatic
 173    Phi node construction. */
 174 static ir_node *
 175 new_bd_Block (dbg_info *db,  int arity, ir_node **in)
 176 {
 177   ir_node  *res;
 178   ir_graph *irg = current_ir_graph;
 179
 180   res = new_ir_node (db, irg, NULL, op_Block, mode_BB, arity, in);
 181   set_Block_matured(res, 1);
 182   set_Block_block_visited(res, 0);
 183
 184   /* res->attr.block.exc = exc_normal; */
 185   /* res->attr.block.handler_entry = 0; */
 186   res->attr.block.dead        = 0;
 187   res->attr.block.irg         = irg;
 188   res->attr.block.backedge    = new_backedge_arr(irg->obst, arity);
 189   res->attr.block.in_cg       = NULL;
 190   res->attr.block.cg_backedge = NULL;
 191   res->attr.block.extblk      = NULL;
 192
 193   IRN_VRFY_IRG(res, irg);
 194   return res;
 195 }
 196
 197 static ir_node *
 198 new_bd_Start (dbg_info *db, ir_node *block)
 199 {
 200   ir_node  *res;
 201   ir_graph *irg = current_ir_graph;
 202
 203   res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
 204   /* res->attr.start.irg = irg; */
 205
 206   IRN_VRFY_IRG(res, irg);
 207   return res;
 208 }
 209
 210 static ir_node *
 211 new_bd_End (dbg_info *db, ir_node *block)
 212 {
 213   ir_node  *res;
 214   ir_graph *irg = current_ir_graph;
 215
 216   res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
 217
 218   IRN_VRFY_IRG(res, irg);
 219   return res;
 220 }
 221
 222 /* Creates a Phi node with all predecessors.  Calling this constructor
 223    is only allowed if the corresponding block is mature.  */
 224 static ir_node *
 225 new_bd_Phi (dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
 226 {
 227   ir_node  *res;
 228   ir_graph *irg = current_ir_graph;
 229   int i;
 230   int has_unknown = 0;
 231
 232   /* Don't assert that block matured: the use of this constructor is strongly
 233      restricted ... */
 234   if ( get_Block_matured(block) )
 235     assert( get_irn_arity(block) == arity );
 236
 237   res = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
 238
 239   res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
 240
 241   for (i = arity-1; i >= 0; i--)
 242     if (get_irn_op(in[i]) == op_Unknown) {
 243       has_unknown = 1;
 244       break;
 245     }
 246
 247   if (!has_unknown) res = optimize_node (res);
 248   IRN_VRFY_IRG(res, irg);
 249
 250   /* Memory Phis in endless loops must be kept alive.
 251      As we can't distinguish these easily we keep all of them alive. */
 252   if ((res->op == op_Phi) && (mode == mode_M))
 253     add_End_keepalive(get_irg_end(irg), res);
 254   return res;
 255 }
 256
 257 static ir_node *
 258 new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)
 259 {
 260   ir_node  *res;
 261   ir_graph *irg = current_ir_graph;
 262
 263   res = new_ir_node (db, irg, get_irg_start_block(irg), op_Const, mode, 0, NULL);
 264   res->attr.con.tv = con;
 265   set_Const_type(res, tp);  /* Call method because of complex assertion. */
 266   res = optimize_node (res);
 267   assert(get_Const_type(res) == tp);
 268   IRN_VRFY_IRG(res, irg);
 269
 270   return res;
 271 }
 272
 273 static ir_node *
 274 new_bd_Const (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con)
 275 {
 276   ir_graph *irg = current_ir_graph;
 277
 278   return new_rd_Const_type (db, irg, block, mode, con, firm_unknown_type);
 279 }
 280
 281 static ir_node *
 282 new_bd_Const_long (dbg_info *db, ir_node *block, ir_mode *mode, long value)
 283 {
 284   ir_graph *irg = current_ir_graph;
 285
 286   return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
 287 }
 288
 289 static ir_node *
 290 new_bd_Id (dbg_info *db, ir_node *block, ir_node *val, ir_mode *mode)
 291 {
 292   ir_node  *res;
 293   ir_graph *irg = current_ir_graph;
 294
 295   res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
 296   res = optimize_node(res);
 297   IRN_VRFY_IRG(res, irg);
 298   return res;
 299 }
 300
 301 static ir_node *
 302 new_bd_Proj (dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
 303         long proj)
 304 {
 305   ir_node  *res;
 306   ir_graph *irg = current_ir_graph;
 307
 308   res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
 309   res->attr.proj = proj;
 310
 311   assert(res);
 312   assert(get_Proj_pred(res));
 313   assert(get_nodes_block(get_Proj_pred(res)));
 314
 315   res = optimize_node(res);
 316
 317   IRN_VRFY_IRG(res, irg);
 318   return res;
 319
 320 }
 321
 322 static ir_node *
 323 new_bd_defaultProj (dbg_info *db, ir_node *block, ir_node *arg,
 324            long max_proj)
 325 {
 326   ir_node  *res;
 327   ir_graph *irg = current_ir_graph;
 328
 329   assert(arg->op == op_Cond);
 330   arg->attr.c.kind = fragmentary;
 331   arg->attr.c.default_proj = max_proj;
 332   res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
 333   return res;
 334 }
 335
 336 static ir_node *
 337 new_bd_Conv (dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode)
 338 {
 339   ir_node  *res;
 340   ir_graph *irg = current_ir_graph;
 341
 342   res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
 343   res = optimize_node(res);
 344   IRN_VRFY_IRG(res, irg);
 345   return res;
 346 }
 347
 348 static ir_node *
 349 new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp)
 350 {
 351   ir_node  *res;
 352   ir_graph *irg = current_ir_graph;
 353
 354   assert(is_atomic_type(to_tp));
 355
 356   res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
 357   res->attr.cast.totype = to_tp;
 358   res = optimize_node(res);
 359   IRN_VRFY_IRG(res, irg);
 360   return res;
 361 }
 362
 363 static ir_node *
 364 new_bd_Tuple (dbg_info *db, ir_node *block, int arity, ir_node **in)
 365 {
 366   ir_node  *res;
 367   ir_graph *irg = current_ir_graph;
 368
 369   res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
 370   res = optimize_node (res);
 371   IRN_VRFY_IRG(res, irg);
 372   return res;
 373 }
 374
 375 NEW_BD_BINOP(Add)
 376 NEW_BD_BINOP(Sub)
 377 NEW_BD_UNOP(Minus)
 378 NEW_BD_BINOP(Mul)
 379 NEW_BD_DIVOP(Quot)
 380 NEW_BD_DIVOP(DivMod)
 381 NEW_BD_DIVOP(Div)
 382 NEW_BD_DIVOP(Mod)
 383 NEW_BD_BINOP(And)
 384 NEW_BD_BINOP(Or)
 385 NEW_BD_BINOP(Eor)
 386 NEW_BD_UNOP(Not)
 387 NEW_BD_BINOP(Shl)
 388 NEW_BD_BINOP(Shr)
 389 NEW_BD_BINOP(Shrs)
 390 NEW_BD_BINOP(Rot)
 391 NEW_BD_UNOP(Abs)
 392 NEW_BD_BINOP(Carry)
 393 NEW_BD_BINOP(Borrow)
 394
 395 static ir_node *
 396 new_bd_Cmp (dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2)
 397 {
 398   ir_node  *in[2];
 399   ir_node  *res;
 400   ir_graph *irg = current_ir_graph;
 401   in[0] = op1;
 402   in[1] = op2;
 403   res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);
 404   res = optimize_node(res);
 405   IRN_VRFY_IRG(res, irg);
 406   return res;
 407 }
 408
 409 static ir_node *
 410 new_bd_Jmp (dbg_info *db, ir_node *block)
 411 {
 412   ir_node  *res;
 413   ir_graph *irg = current_ir_graph;
 414
 415   res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
 416   res = optimize_node (res);
 417   IRN_VRFY_IRG (res, irg);
 418   return res;
 419 }
 420
 421 static ir_node *
 422 new_bd_IJmp (dbg_info *db, ir_node *block, ir_node *tgt)
 423 {
 424   ir_node  *res;
 425   ir_graph *irg = current_ir_graph;
 426
 427   res = new_ir_node (db, irg, block, op_IJmp, mode_X, 1, &tgt);
 428   res = optimize_node (res);
 429   IRN_VRFY_IRG (res, irg);
 430
 431   if (get_irn_op(res) == op_IJmp) /* still an IJmp */
 432     keep_alive(res);
 433   return res;
 434 }
 435
 436 static ir_node *
 437 new_bd_Cond (dbg_info *db, ir_node *block, ir_node *c)
 438 {
 439   ir_node  *res;
 440   ir_graph *irg = current_ir_graph;
 441
 442   res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, &c);
 443   res->attr.c.kind         = dense;
 444   res->attr.c.default_proj = 0;
 445   res->attr.c.pred         = COND_JMP_PRED_NONE;
 446   res = optimize_node (res);
 447   IRN_VRFY_IRG(res, irg);
 448   return res;
 449 }
 450
 451 static ir_node *
 452 new_bd_Call (dbg_info *db, ir_node *block, ir_node *store,
 453         ir_node *callee, int arity, ir_node **in, ir_type *tp)
 454 {
 455   ir_node  **r_in;
 456   ir_node  *res;
 457   int      r_arity;
 458   ir_graph *irg = current_ir_graph;
 459
 460   r_arity = arity+2;
 461   NEW_ARR_A(ir_node *, r_in, r_arity);
 462   r_in[0] = store;
 463   r_in[1] = callee;
 464   memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 465
 466   res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
 467
 468   assert((get_unknown_type() == tp) || is_Method_type(tp));
 469   set_Call_type(res, tp);
 470   res->attr.call.exc.pin_state = op_pin_state_pinned;
 471   res->attr.call.callee_arr    = NULL;
 472   res = optimize_node(res);
 473   IRN_VRFY_IRG(res, irg);
 474   return res;
 475 }
 476
 477 static ir_node *
 478 new_bd_Return (dbg_info *db, ir_node *block,
 479               ir_node *store, int arity, ir_node **in)
 480 {
 481   ir_node  **r_in;
 482   ir_node  *res;
 483   int      r_arity;
 484   ir_graph *irg = current_ir_graph;
 485
 486   r_arity = arity+1;
 487   NEW_ARR_A (ir_node *, r_in, r_arity);
 488   r_in[0] = store;
 489   memcpy(&r_in[1], in, sizeof(ir_node *) * arity);
 490   res = new_ir_node(db, irg, block, op_Return, mode_X, r_arity, r_in);
 491   res = optimize_node(res);
 492   IRN_VRFY_IRG(res, irg);
 493   return res;
 494 }
 495
 496 static ir_node *
 497 new_bd_Load (dbg_info *db, ir_node *block,
 498         ir_node *store, ir_node *adr, ir_mode *mode)
 499 {
 500   ir_node  *in[2];
 501   ir_node  *res;
 502   ir_graph *irg = current_ir_graph;
 503
 504   in[0] = store;
 505   in[1] = adr;
 506   res = new_ir_node(db, irg, block, op_Load, mode_T, 2, in);
 507   res->attr.load.exc.pin_state = op_pin_state_pinned;
 508   res->attr.load.load_mode     = mode;
 509   res->attr.load.volatility    = volatility_non_volatile;
 510   res = optimize_node(res);
 511   IRN_VRFY_IRG(res, irg);
 512   return res;
 513 }
 514
 515 static ir_node *
 516 new_bd_Store (dbg_info *db, ir_node *block,
 517          ir_node *store, ir_node *adr, ir_node *val)
 518 {
 519   ir_node  *in[3];
 520   ir_node  *res;
 521   ir_graph *irg = current_ir_graph;
 522
 523   in[0] = store;
 524   in[1] = adr;
 525   in[2] = val;
 526   res = new_ir_node(db, irg, block, op_Store, mode_T, 3, in);
 527   res->attr.store.exc.pin_state = op_pin_state_pinned;
 528   res->attr.store.volatility    = volatility_non_volatile;
 529   res = optimize_node(res);
 530   IRN_VRFY_IRG(res, irg);
 531   return res;
 532 }
 533
 534 static ir_node *
 535 new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store,
 536         ir_node *size, ir_type *alloc_type, where_alloc where)
 537 {
 538   ir_node  *in[2];
 539   ir_node  *res;
 540   ir_graph *irg = current_ir_graph;
 541
 542   in[0] = store;
 543   in[1] = size;
 544   res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in);
 545   res->attr.a.exc.pin_state = op_pin_state_pinned;
 546   res->attr.a.where         = where;
 547   res->attr.a.type          = alloc_type;
 548   res = optimize_node(res);
 549   IRN_VRFY_IRG(res, irg);
 550   return res;
 551 }
 552
 553 static ir_node *
 554 new_bd_Free (dbg_info *db, ir_node *block, ir_node *store,
 555         ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)
 556 {
 557   ir_node  *in[3];
 558   ir_node  *res;
 559   ir_graph *irg = current_ir_graph;
 560
 561   in[0] = store;
 562   in[1] = ptr;
 563   in[2] = size;
 564   res = new_ir_node (db, irg, block, op_Free, mode_M, 3, in);
 565   res->attr.f.where = where;
 566   res->attr.f.type  = free_type;
 567   res = optimize_node(res);
 568   IRN_VRFY_IRG(res, irg);
 569   return res;
 570 }
 571
 572 static ir_node *
 573 new_bd_Sel (dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
 574            int arity, ir_node **in, entity *ent)
 575 {
 576   ir_node  **r_in;
 577   ir_node  *res;
 578   int      r_arity;
 579   ir_graph *irg = current_ir_graph;
 580
 581   assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
 582
 583   r_arity = arity + 2;
 584   NEW_ARR_A(ir_node *, r_in, r_arity);  /* uses alloca */
 585   r_in[0] = store;
 586   r_in[1] = objptr;
 587   memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 588   /*
 589    * FIXM: Sel's can select functions which should be of mode mode_P_code.
 590    */
 591   res = new_ir_node(db, irg, block, op_Sel, mode_P_data, r_arity, r_in);
 592   res->attr.s.ent = ent;
 593   res = optimize_node(res);
 594   IRN_VRFY_IRG(res, irg);
 595   return res;
 596 }
 597
 598 static ir_node *
 599 new_bd_SymConst_type (dbg_info *db, ir_node *block, symconst_symbol value,
 600               symconst_kind symkind, ir_type *tp) {
 601   ir_node  *res;
 602   ir_mode  *mode;
 603   ir_graph *irg = current_ir_graph;
 604
 605   if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
 606     mode = mode_P_data;   /* FIXME: can be mode_P_code */
 607   else
 608     mode = mode_Iu;
 609
 610   res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
 611
 612   res->attr.i.num = symkind;
 613   res->attr.i.sym = value;
 614   res->attr.i.tp  = tp;
 615
 616   res = optimize_node(res);
 617   IRN_VRFY_IRG(res, irg);
 618   return res;
 619 }
 620
 621 static ir_node *
 622 new_bd_SymConst (dbg_info *db, ir_node *block, symconst_symbol value,
 623          symconst_kind symkind)
 624 {
 625   ir_graph *irg = current_ir_graph;
 626
 627   ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
 628   return res;
 629 }
 630
 631 static ir_node *
 632 new_bd_Sync (dbg_info *db, ir_node *block, int arity, ir_node **in)
 633 {
 634   ir_node  *res;
 635   ir_graph *irg = current_ir_graph;
 636
 637   res = new_ir_node(db, irg, block, op_Sync, mode_M, arity, in);
 638   res = optimize_node(res);
 639   IRN_VRFY_IRG(res, irg);
 640   return res;
 641 }
 642
 643 static ir_node *
 644 new_bd_Confirm (dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
 645 {
 646   ir_node  *in[2], *res;
 647   ir_graph *irg = current_ir_graph;
 648
 649   in[0] = val;
 650   in[1] = bound;
 651   res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
 652   res->attr.confirm_cmp = cmp;
 653   res = optimize_node (res);
 654   IRN_VRFY_IRG(res, irg);
 655   return res;
 656 }
 657
 658 /* this function is often called with current_ir_graph unset */
 659 static ir_node *
 660 new_bd_Unknown (ir_mode *m)
 661 {
 662   ir_node  *res;
 663   ir_graph *irg = current_ir_graph;
 664
 665   res = new_ir_node(NULL, irg, get_irg_start_block(irg), op_Unknown, m, 0, NULL);
 666   res = optimize_node(res);
 667   return res;
 668 }
 669
 670 static ir_node *
 671 new_bd_CallBegin (dbg_info *db, ir_node *block, ir_node *call)
 672 {
 673   ir_node  *in[1];
 674   ir_node  *res;
 675   ir_graph *irg = current_ir_graph;
 676
 677   in[0] = get_Call_ptr(call);
 678   res = new_ir_node(db, irg, block, op_CallBegin, mode_T, 1, in);
 679   /* res->attr.callbegin.irg = irg; */
 680   res->attr.callbegin.call = call;
 681   res = optimize_node(res);
 682   IRN_VRFY_IRG(res, irg);
 683   return res;
 684 }
 685
 686 static ir_node *
 687 new_bd_EndReg (dbg_info *db, ir_node *block)
 688 {
 689   ir_node  *res;
 690   ir_graph *irg = current_ir_graph;
 691
 692   res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
 693   set_irg_end_reg(irg, res);
 694   IRN_VRFY_IRG(res, irg);
 695   return res;
 696 }
 697
 698 static ir_node *
 699 new_bd_EndExcept (dbg_info *db, ir_node *block)
 700 {
 701   ir_node  *res;
 702   ir_graph *irg = current_ir_graph;
 703
 704   res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
 705   set_irg_end_except(irg, res);
 706   IRN_VRFY_IRG (res, irg);
 707   return res;
 708 }
 709
 710 static ir_node *
 711 new_bd_Break (dbg_info *db, ir_node *block)
 712 {
 713   ir_node  *res;
 714   ir_graph *irg = current_ir_graph;
 715
 716   res = new_ir_node(db, irg, block, op_Break, mode_X, 0, NULL);
 717   res = optimize_node(res);
 718   IRN_VRFY_IRG(res, irg);
 719   return res;
 720 }
 721
 722 static ir_node *
 723 new_bd_Filter (dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
 724            long proj)
 725 {
 726   ir_node  *res;
 727   ir_graph *irg = current_ir_graph;
 728
 729   res = new_ir_node(db, irg, block, op_Filter, mode, 1, &arg);
 730   res->attr.filter.proj = proj;
 731   res->attr.filter.in_cg = NULL;
 732   res->attr.filter.backedge = NULL;
 733
 734   assert(res);
 735   assert(get_Proj_pred(res));
 736   assert(get_nodes_block(get_Proj_pred(res)));
 737
 738   res = optimize_node(res);
 739   IRN_VRFY_IRG(res, irg);
 740   return res;
 741 }
 742
 743 static ir_node *
 744 new_bd_Mux  (dbg_info *db, ir_node *block,
 745     ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)
 746 {
 747   ir_node  *in[3];
 748   ir_node  *res;
 749   ir_graph *irg = current_ir_graph;
 750
 751   in[0] = sel;
 752   in[1] = ir_false;
 753   in[2] = ir_true;
 754
 755   res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
 756   assert(res);
 757
 758   res = optimize_node(res);
 759   IRN_VRFY_IRG(res, irg);
 760   return res;
 761 }
 762
 763 static ir_node *
 764 new_bd_Psi (dbg_info *db, ir_node *block,
 765     int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)
 766 {
 767   ir_node  **in;
 768   ir_node  *res;
 769   ir_graph *irg = current_ir_graph;
 770   int i;
 771
 772   NEW_ARR_A(ir_node *, in, 2 * arity + 1);
 773
 774   for (i = 0; i < arity; ++i) {
 775     in[2 * i]     = cond[i];
 776     in[2 * i + 1] = vals[i];
 777   }
 778   in[2 * i] = vals[i];
 779
 780   res = new_ir_node(db, irg, block, op_Psi, mode, 2 * arity + 1, in);
 781   assert(res);
 782
 783   res = optimize_node(res);
 784   IRN_VRFY_IRG(res, irg);
 785   return res;
 786 }
 787
 788 static ir_node *
 789 new_bd_CopyB  (dbg_info *db, ir_node *block,
 790     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
 791 {
 792   ir_node  *in[3];
 793   ir_node  *res;
 794   ir_graph *irg = current_ir_graph;
 795
 796   in[0] = store;
 797   in[1] = dst;
 798   in[2] = src;
 799
 800   res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in);
 801
 802   res->attr.copyb.exc.pin_state = op_pin_state_pinned;
 803   res->attr.copyb.data_type     = data_type;
 804   res = optimize_node(res);
 805   IRN_VRFY_IRG(res, irg);
 806   return res;
 807 }
 808
 809 static ir_node *
 810 new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store,
 811            ir_node *objptr, ir_type *type)
 812 {
 813   ir_node  *in[2];
 814   ir_node  *res;
 815   ir_graph *irg = current_ir_graph;
 816
 817   in[0] = store;
 818   in[1] = objptr;
 819   res = new_ir_node(db, irg, block, op_Sel, mode_T, 2, in);
 820   res->attr.io.type = type;
 821   res = optimize_node(res);
 822   IRN_VRFY_IRG(res, irg);
 823   return res;
 824 }
 825
 826 static ir_node *
 827 new_bd_Raise (dbg_info *db, ir_node *block, ir_node *store, ir_node *obj)
 828 {
 829   ir_node  *in[2];
 830   ir_node  *res;
 831   ir_graph *irg = current_ir_graph;
 832
 833   in[0] = store;
 834   in[1] = obj;
 835   res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);
 836   res = optimize_node(res);
 837   IRN_VRFY_IRG(res, irg);
 838   return res;
 839 }
 840
 841 static ir_node *
 842 new_bd_Bound (dbg_info *db, ir_node *block,
 843     ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper)
 844 {
 845   ir_node  *in[4];
 846   ir_node  *res;
 847   ir_graph *irg = current_ir_graph;
 848
 849   in[0] = store;
 850   in[1] = idx;
 851   in[2] = lower;
 852   in[3] = upper;
 853   res = new_ir_node(db, irg, block, op_Bound, mode_T, 4, in);
 854   res->attr.bound.exc.pin_state = op_pin_state_pinned;
 855   res = optimize_node(res);
 856   IRN_VRFY_IRG(res, irg);
 857   return res;
 858 }
 859
 860 /* --------------------------------------------- */
 861 /* private interfaces, for professional use only */
 862 /* --------------------------------------------- */
 863
 864 /* Constructs a Block with a fixed number of predecessors.
 865    Does not set current_block.  Can not be used with automatic
 866    Phi node construction. */
 867 ir_node *
 868 new_rd_Block (dbg_info *db, ir_graph *irg,  int arity, ir_node **in)
 869 {
 870   ir_graph *rem    = current_ir_graph;
 871   ir_node  *res;
 872
 873   current_ir_graph = irg;
 874   res = new_bd_Block (db, arity, in);
 875   current_ir_graph = rem;
 876
 877   return res;
 878 }
 879
 880 ir_node *
 881 new_rd_Start (dbg_info *db, ir_graph *irg, ir_node *block)
 882 {
 883   ir_graph *rem = current_ir_graph;
 884   ir_node  *res;
 885
 886   current_ir_graph = irg;
 887   res = new_bd_Start (db, block);
 888   current_ir_graph = rem;
 889
 890   return res;
 891 }
 892
 893 ir_node *
 894 new_rd_End (dbg_info *db, ir_graph *irg, ir_node *block)
 895 {
 896   ir_node  *res;
 897   ir_graph *rem = current_ir_graph;
 898
 899   current_ir_graph = rem;
 900   res = new_bd_End (db, block);
 901   current_ir_graph = rem;
 902
 903   return res;
 904 }
 905
 906 /* Creates a Phi node with all predecessors.  Calling this constructor
 907    is only allowed if the corresponding block is mature.  */
 908 ir_node *
 909 new_rd_Phi (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
 910 {
 911   ir_node  *res;
 912   ir_graph *rem = current_ir_graph;
 913
 914   current_ir_graph  = irg;
 915   res = new_bd_Phi (db, block,arity, in, mode);
 916   current_ir_graph = rem;
 917
 918   return res;
 919 }
 920
 921 ir_node *
 922 new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)
 923 {
 924   ir_node  *res;
 925   ir_graph *rem = current_ir_graph;
 926
 927   current_ir_graph  = irg;
 928   res = new_bd_Const_type (db, block, mode, con, tp);
 929   current_ir_graph = rem;
 930
 931   return res;
 932 }
 933
 934 ir_node *
 935 new_rd_Const (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
 936 {
 937   ir_node  *res;
 938   ir_graph *rem = current_ir_graph;
 939
 940   current_ir_graph = irg;
 941   res = new_bd_Const_type (db, block, mode, con, firm_unknown_type);
 942   current_ir_graph = rem;
 943
 944   return res;
 945 }
 946
 947 ir_node *
 948 new_rd_Const_long (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, long value)
 949 {
 950     return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
 951 }
 952
 953 ir_node *
 954 new_rd_Id (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 955 {
 956   ir_node  *res;
 957   ir_graph *rem = current_ir_graph;
 958
 959   current_ir_graph = irg;
 960   res = new_bd_Id(db, block, val, mode);
 961   current_ir_graph = rem;
 962
 963   return res;
 964 }
 965
 966 ir_node *
 967 new_rd_Proj (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
 968         long proj)
 969 {
 970   ir_node  *res;
 971   ir_graph *rem = current_ir_graph;
 972
 973   current_ir_graph = irg;
 974   res = new_bd_Proj(db, block, arg, mode, proj);
 975   current_ir_graph = rem;
 976
 977   return res;
 978 }
 979
 980 ir_node *
 981 new_rd_defaultProj (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg,
 982            long max_proj)
 983 {
 984   ir_node  *res;
 985   ir_graph *rem = current_ir_graph;
 986
 987   current_ir_graph = irg;
 988   res = new_bd_defaultProj(db, block, arg, max_proj);
 989   current_ir_graph = rem;
 990
 991   return res;
 992 }
 993
 994 ir_node *
 995 new_rd_Conv (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 996 {
 997   ir_node  *res;
 998   ir_graph *rem = current_ir_graph;
 999
1000   current_ir_graph = irg;
1001   res = new_bd_Conv(db, block, op, mode);
1002   current_ir_graph = rem;
1003
1004   return res;
1005 }
1006
1007 ir_node *
1008 new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp)
1009 {
1010   ir_node  *res;
1011   ir_graph *rem = current_ir_graph;
1012
1013   current_ir_graph = irg;
1014   res = new_bd_Cast(db, block, op, to_tp);
1015   current_ir_graph = rem;
1016
1017   return res;
1018 }
1019
1020 ir_node *
1021 new_rd_Tuple (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
1022 {
1023   ir_node  *res;
1024   ir_graph *rem = current_ir_graph;
1025
1026   current_ir_graph = irg;
1027   res = new_bd_Tuple(db, block, arity, in);
1028   current_ir_graph = rem;
1029
1030   return res;
1031 }
1032
1033 NEW_RD_BINOP(Add)
1034 NEW_RD_BINOP(Sub)
1035 NEW_RD_UNOP(Minus)
1036 NEW_RD_BINOP(Mul)
1037 NEW_RD_DIVOP(Quot)
1038 NEW_RD_DIVOP(DivMod)
1039 NEW_RD_DIVOP(Div)
1040 NEW_RD_DIVOP(Mod)
1041 NEW_RD_BINOP(And)
1042 NEW_RD_BINOP(Or)
1043 NEW_RD_BINOP(Eor)
1044 NEW_RD_UNOP(Not)
1045 NEW_RD_BINOP(Shl)
1046 NEW_RD_BINOP(Shr)
1047 NEW_RD_BINOP(Shrs)
1048 NEW_RD_BINOP(Rot)
1049 NEW_RD_UNOP(Abs)
1050 NEW_RD_BINOP(Carry)
1051 NEW_RD_BINOP(Borrow)
1052
1053 ir_node *
1054 new_rd_Cmp (dbg_info *db, ir_graph *irg, ir_node *block,
1055        ir_node *op1, ir_node *op2)
1056 {
1057   ir_node  *res;
1058   ir_graph *rem = current_ir_graph;
1059
1060   current_ir_graph = irg;
1061   res = new_bd_Cmp(db, block, op1, op2);
1062   current_ir_graph = rem;
1063
1064   return res;
1065 }
1066
1067 ir_node *
1068 new_rd_Jmp (dbg_info *db, ir_graph *irg, ir_node *block)
1069 {
1070   ir_node  *res;
1071   ir_graph *rem = current_ir_graph;
1072
1073   current_ir_graph = irg;
1074   res = new_bd_Jmp(db, block);
1075   current_ir_graph = rem;
1076
1077   return res;
1078 }
1079
1080 ir_node *
1081 new_rd_IJmp (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *tgt)
1082 {
1083   ir_node  *res;
1084   ir_graph *rem = current_ir_graph;
1085
1086   current_ir_graph = irg;
1087   res = new_bd_IJmp(db, block, tgt);
1088   current_ir_graph = rem;
1089
1090   return res;
1091 }
1092
1093 ir_node *
1094 new_rd_Cond (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c)
1095 {
1096   ir_node  *res;
1097   ir_graph *rem = current_ir_graph;
1098
1099   current_ir_graph = irg;
1100   res = new_bd_Cond(db, block, c);
1101   current_ir_graph = rem;
1102
1103   return res;
1104 }
1105
1106 ir_node *
1107 new_rd_Call (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1108         ir_node *callee, int arity, ir_node **in, ir_type *tp)
1109 {
1110   ir_node  *res;
1111   ir_graph *rem = current_ir_graph;
1112
1113   current_ir_graph = irg;
1114   res = new_bd_Call(db, block, store, callee, arity, in, tp);
1115   current_ir_graph = rem;
1116
1117   return res;
1118 }
1119
1120 ir_node *
1121 new_rd_Return (dbg_info *db, ir_graph *irg, ir_node *block,
1122               ir_node *store, int arity, ir_node **in)
1123 {
1124   ir_node  *res;
1125   ir_graph *rem = current_ir_graph;
1126
1127   current_ir_graph = irg;
1128   res = new_bd_Return(db, block, store, arity, in);
1129   current_ir_graph = rem;
1130
1131   return res;
1132 }
1133
1134 ir_node *
1135 new_rd_Load (dbg_info *db, ir_graph *irg, ir_node *block,
1136         ir_node *store, ir_node *adr, ir_mode *mode)
1137 {
1138   ir_node  *res;
1139   ir_graph *rem = current_ir_graph;
1140
1141   current_ir_graph = irg;
1142   res = new_bd_Load(db, block, store, adr, mode);
1143   current_ir_graph = rem;
1144
1145   return res;
1146 }
1147
1148 ir_node *
1149 new_rd_Store (dbg_info *db, ir_graph *irg, ir_node *block,
1150          ir_node *store, ir_node *adr, ir_node *val)
1151 {
1152   ir_node  *res;
1153   ir_graph *rem = current_ir_graph;
1154
1155   current_ir_graph = irg;
1156   res = new_bd_Store(db, block, store, adr, val);
1157   current_ir_graph = rem;
1158
1159   return res;
1160 }
1161
1162 ir_node *
1163 new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1164         ir_node *size, ir_type *alloc_type, where_alloc where)
1165 {
1166   ir_node  *res;
1167   ir_graph *rem = current_ir_graph;
1168
1169   current_ir_graph = irg;
1170   res = new_bd_Alloc (db, block, store, size, alloc_type, where);
1171   current_ir_graph = rem;
1172
1173   return res;
1174 }
1175
1176 ir_node *
1177 new_rd_Free (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1178         ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)
1179 {
1180   ir_node  *res;
1181   ir_graph *rem = current_ir_graph;
1182
1183   current_ir_graph = irg;
1184   res = new_bd_Free(db, block, store, ptr, size, free_type, where);
1185   current_ir_graph = rem;
1186
1187   return res;
1188 }
1189
1190 ir_node *
1191 new_rd_simpleSel (dbg_info *db, ir_graph *irg, ir_node *block,
1192                   ir_node *store, ir_node *objptr, entity *ent)
1193 {
1194   ir_node  *res;
1195   ir_graph *rem = current_ir_graph;
1196
1197   current_ir_graph = irg;
1198   res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
1199   current_ir_graph = rem;
1200
1201   return res;
1202 }
1203
1204 ir_node *
1205 new_rd_Sel (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
1206            int arity, ir_node **in, entity *ent)
1207 {
1208   ir_node  *res;
1209   ir_graph *rem = current_ir_graph;
1210
1211   current_ir_graph = irg;
1212   res = new_bd_Sel(db, block, store, objptr, arity, in, ent);
1213   current_ir_graph = rem;
1214
1215   return res;
1216 }
1217
1218 ir_node *
1219 new_rd_SymConst_type (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
1220               symconst_kind symkind, ir_type *tp)
1221 {
1222   ir_node  *res;
1223   ir_graph *rem = current_ir_graph;
1224
1225   current_ir_graph = irg;
1226   res = new_bd_SymConst_type(db, block, value, symkind, tp);
1227   current_ir_graph = rem;
1228
1229   return res;
1230 }
1231
1232 ir_node *
1233 new_rd_SymConst (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
1234          symconst_kind symkind)
1235 {
1236   ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
1237   return res;
1238 }
1239
1240 ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp)
1241 {
1242   symconst_symbol sym = {(ir_type *)symbol};
1243   return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp);
1244 }
1245
1246 ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
1247   symconst_symbol sym = {(ir_type *)symbol};
1248   return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);
1249 }
1250
1251 ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
1252   symconst_symbol sym = {symbol};
1253   return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);
1254 }
1255
1256 ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
1257   symconst_symbol sym = {symbol};
1258   return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_size, tp);
1259 }
1260
1261 ir_node *
1262 new_rd_Sync (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
1263 {
1264   ir_node  *res;
1265   ir_graph *rem = current_ir_graph;
1266
1267   current_ir_graph = irg;
1268   res = new_bd_Sync(db, block, arity, in);
1269   current_ir_graph = rem;
1270
1271   return res;
1272 }
1273
1274 ir_node *
1275 new_rd_Bad (ir_graph *irg) {
1276   return get_irg_bad(irg);
1277 }
1278
1279 ir_node *
1280 new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
1281 {
1282   ir_node  *res;
1283   ir_graph *rem = current_ir_graph;
1284
1285   current_ir_graph = irg;
1286   res = new_bd_Confirm(db, block, val, bound, cmp);
1287   current_ir_graph = rem;
1288
1289   return res;
1290 }
1291
1292 /* this function is often called with current_ir_graph unset */
1293 ir_node *
1294 new_rd_Unknown (ir_graph *irg, ir_mode *m)
1295 {
1296   ir_node  *res;
1297   ir_graph *rem = current_ir_graph;
1298
1299   current_ir_graph = irg;
1300   res = new_bd_Unknown(m);
1301   current_ir_graph = rem;
1302
1303   return res;
1304 }
1305
1306 ir_node *
1307 new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
1308 {
1309   ir_node  *res;
1310   ir_graph *rem = current_ir_graph;
1311
1312   current_ir_graph = irg;
1313   res = new_bd_CallBegin(db, block, call);
1314   current_ir_graph = rem;
1315
1316   return res;
1317 }
1318
1319 ir_node *
1320 new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
1321 {
1322   ir_node *res;
1323
1324   res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
1325   set_irg_end_reg(irg, res);
1326   IRN_VRFY_IRG(res, irg);
1327   return res;
1328 }
1329
1330 ir_node *
1331 new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
1332 {
1333   ir_node *res;
1334
1335   res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
1336   set_irg_end_except(irg, res);
1337   IRN_VRFY_IRG (res, irg);
1338   return res;
1339 }
1340
1341 ir_node *
1342 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
1343 {
1344   ir_node  *res;
1345   ir_graph *rem = current_ir_graph;
1346
1347   current_ir_graph = irg;
1348   res = new_bd_Break(db, block);
1349   current_ir_graph = rem;
1350
1351   return res;
1352 }
1353
1354 ir_node *
1355 new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
1356            long proj)
1357 {
1358   ir_node  *res;
1359   ir_graph *rem = current_ir_graph;
1360
1361   current_ir_graph = irg;
1362   res = new_bd_Filter(db, block, arg, mode, proj);
1363   current_ir_graph = rem;
1364
1365   return res;
1366 }
1367
1368 ir_node *
1369 new_rd_NoMem (ir_graph *irg) {
1370   return get_irg_no_mem(irg);
1371 }
1372
1373 ir_node *
1374 new_rd_Mux  (dbg_info *db, ir_graph *irg, ir_node *block,
1375     ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)
1376 {
1377   ir_node  *res;
1378   ir_graph *rem = current_ir_graph;
1379
1380   current_ir_graph = irg;
1381   res = new_bd_Mux(db, block, sel, ir_false, ir_true, mode);
1382   current_ir_graph = rem;
1383
1384   return res;
1385 }
1386
1387 ir_node *
1388 new_rd_Psi (dbg_info *db, ir_graph *irg, ir_node *block,
1389     int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)
1390 {
1391   ir_node  *res;
1392   ir_graph *rem = current_ir_graph;
1393
1394   current_ir_graph = irg;
1395   res = new_bd_Psi(db, block, arity, cond, vals, mode);
1396   current_ir_graph = rem;
1397
1398   return res;
1399 }
1400
1401 ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
1402     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
1403 {
1404   ir_node  *res;
1405   ir_graph *rem = current_ir_graph;
1406
1407   current_ir_graph = irg;
1408   res = new_bd_CopyB(db, block, store, dst, src, data_type);
1409   current_ir_graph = rem;
1410
1411   return res;
1412 }
1413
1414 ir_node *
1415 new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1416            ir_node *objptr, ir_type *type)
1417 {
1418   ir_node  *res;
1419   ir_graph *rem = current_ir_graph;
1420
1421   current_ir_graph = irg;
1422   res = new_bd_InstOf(db, block, store, objptr, type);
1423   current_ir_graph = rem;
1424
1425   return res;
1426 }
1427
1428 ir_node *
1429 new_rd_Raise (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
1430 {
1431   ir_node  *res;
1432   ir_graph *rem = current_ir_graph;
1433
1434   current_ir_graph = irg;
1435   res = new_bd_Raise(db, block, store, obj);
1436   current_ir_graph = rem;
1437
1438   return res;
1439 }
1440
1441 ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block,
1442     ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper)
1443 {
1444   ir_node  *res;
1445   ir_graph *rem = current_ir_graph;
1446
1447   current_ir_graph = irg;
1448   res = new_bd_Bound(db, block, store, idx, lower, upper);
1449   current_ir_graph = rem;
1450
1451   return res;
1452 }
1453
1454 ir_node *new_r_Block  (ir_graph *irg,  int arity, ir_node **in) {
1455   return new_rd_Block(NULL, irg, arity, in);
1456 }
1457 ir_node *new_r_Start  (ir_graph *irg, ir_node *block) {
1458   return new_rd_Start(NULL, irg, block);
1459 }
1460 ir_node *new_r_End    (ir_graph *irg, ir_node *block) {
1461   return new_rd_End(NULL, irg, block);
1462 }
1463 ir_node *new_r_Jmp    (ir_graph *irg, ir_node *block) {
1464   return new_rd_Jmp(NULL, irg, block);
1465 }
1466 ir_node *new_r_IJmp   (ir_graph *irg, ir_node *block, ir_node *tgt) {
1467   return new_rd_IJmp(NULL, irg, block, tgt);
1468 }
1469 ir_node *new_r_Cond   (ir_graph *irg, ir_node *block, ir_node *c) {
1470   return new_rd_Cond(NULL, irg, block, c);
1471 }
1472 ir_node *new_r_Return (ir_graph *irg, ir_node *block,
1473                ir_node *store, int arity, ir_node **in) {
1474   return new_rd_Return(NULL, irg, block, store, arity, in);
1475 }
1476 ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
1477                ir_mode *mode, tarval *con) {
1478   return new_rd_Const(NULL, irg, block, mode, con);
1479 }
1480 ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
1481                ir_mode *mode, long value) {
1482   return new_rd_Const_long(NULL, irg, block, mode, value);
1483 }
1484 ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
1485                ir_mode *mode, tarval *con, ir_type *tp) {
1486   return new_rd_Const_type(NULL, irg, block, mode, con, tp);
1487 }
1488 ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
1489                        symconst_symbol value, symconst_kind symkind) {
1490   return new_rd_SymConst(NULL, irg, block, value, symkind);
1491 }
1492 ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
1493                          ir_node *objptr, entity *ent) {
1494   return new_rd_Sel(NULL, irg, block, store, objptr, 0, NULL, ent);
1495 }
1496 ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
1497                   ir_node *objptr, int n_index, ir_node **index,
1498                   entity *ent) {
1499   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
1500 }
1501 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
1502                   ir_node *callee, int arity, ir_node **in,
1503                   ir_type *tp) {
1504   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
1505 }
1506 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
1507                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1508   return new_rd_Add(NULL, irg, block, op1, op2, mode);
1509 }
1510 ir_node *new_r_Sub    (ir_graph *irg, ir_node *block,
1511                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1512   return new_rd_Sub(NULL, irg, block, op1, op2, mode);
1513 }
1514 ir_node *new_r_Minus  (ir_graph *irg, ir_node *block,
1515                   ir_node *op,  ir_mode *mode) {
1516   return new_rd_Minus(NULL, irg, block,  op, mode);
1517 }
1518 ir_node *new_r_Mul    (ir_graph *irg, ir_node *block,
1519                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1520   return new_rd_Mul(NULL, irg, block, op1, op2, mode);
1521 }
1522 ir_node *new_r_Quot   (ir_graph *irg, ir_node *block,
1523                   ir_node *memop, ir_node *op1, ir_node *op2) {
1524   return new_rd_Quot(NULL, irg, block, memop, op1, op2);
1525 }
1526 ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
1527                   ir_node *memop, ir_node *op1, ir_node *op2) {
1528   return new_rd_DivMod(NULL, irg, block, memop, op1, op2);
1529 }
1530 ir_node *new_r_Div    (ir_graph *irg, ir_node *block,
1531                   ir_node *memop, ir_node *op1, ir_node *op2) {
1532   return new_rd_Div(NULL, irg, block, memop, op1, op2);
1533 }
1534 ir_node *new_r_Mod    (ir_graph *irg, ir_node *block,
1535                   ir_node *memop, ir_node *op1, ir_node *op2) {
1536   return new_rd_Mod(NULL, irg, block, memop, op1, op2);
1537 }
1538 ir_node *new_r_Abs    (ir_graph *irg, ir_node *block,
1539                   ir_node *op, ir_mode *mode) {
1540   return new_rd_Abs(NULL, irg, block, op, mode);
1541 }
1542 ir_node *new_r_And    (ir_graph *irg, ir_node *block,
1543                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1544   return new_rd_And(NULL, irg, block,  op1, op2, mode);
1545 }
1546 ir_node *new_r_Or     (ir_graph *irg, ir_node *block,
1547                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1548   return new_rd_Or(NULL, irg, block,  op1, op2, mode);
1549 }
1550 ir_node *new_r_Eor    (ir_graph *irg, ir_node *block,
1551                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1552   return new_rd_Eor(NULL, irg, block,  op1, op2, mode);
1553 }
1554 ir_node *new_r_Not    (ir_graph *irg, ir_node *block,
1555                ir_node *op, ir_mode *mode) {
1556   return new_rd_Not(NULL, irg, block, op, mode);
1557 }
1558 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
1559                ir_node *op, ir_node *k, ir_mode *mode) {
1560   return new_rd_Shl(NULL, irg, block, op, k, mode);
1561 }
1562 ir_node *new_r_Shr    (ir_graph *irg, ir_node *block,
1563                ir_node *op, ir_node *k, ir_mode *mode) {
1564   return new_rd_Shr(NULL, irg, block, op, k, mode);
1565 }
1566 ir_node *new_r_Shrs   (ir_graph *irg, ir_node *block,
1567                ir_node *op, ir_node *k, ir_mode *mode) {
1568   return new_rd_Shrs(NULL, irg, block, op, k, mode);
1569 }
1570 ir_node *new_r_Rot    (ir_graph *irg, ir_node *block,
1571                ir_node *op, ir_node *k, ir_mode *mode) {
1572   return new_rd_Rot(NULL, irg, block, op, k, mode);
1573 }
1574 ir_node *new_r_Carry  (ir_graph *irg, ir_node *block,
1575                ir_node *op, ir_node *k, ir_mode *mode) {
1576   return new_rd_Carry(NULL, irg, block, op, k, mode);
1577 }
1578 ir_node *new_r_Borrow (ir_graph *irg, ir_node *block,
1579                ir_node *op, ir_node *k, ir_mode *mode) {
1580   return new_rd_Borrow(NULL, irg, block, op, k, mode);
1581 }
1582 ir_node *new_r_Cmp    (ir_graph *irg, ir_node *block,
1583                ir_node *op1, ir_node *op2) {
1584   return new_rd_Cmp(NULL, irg, block, op1, op2);
1585 }
1586 ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
1587                ir_node *op, ir_mode *mode) {
1588   return new_rd_Conv(NULL, irg, block, op, mode);
1589 }
1590 ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
1591   return new_rd_Cast(NULL, irg, block, op, to_tp);
1592 }
1593 ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
1594                ir_node **in, ir_mode *mode) {
1595   return new_rd_Phi(NULL, irg, block, arity, in, mode);
1596 }
1597 ir_node *new_r_Load   (ir_graph *irg, ir_node *block,
1598                ir_node *store, ir_node *adr, ir_mode *mode) {
1599   return new_rd_Load(NULL, irg, block, store, adr, mode);
1600 }
1601 ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
1602                ir_node *store, ir_node *adr, ir_node *val) {
1603   return new_rd_Store(NULL, irg, block, store, adr, val);
1604 }
1605 ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,
1606                ir_node *size, ir_type *alloc_type, where_alloc where) {
1607   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
1608 }
1609 ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,
1610                ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
1611   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
1612 }
1613 ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
1614   return new_rd_Sync(NULL, irg, block, arity, in);
1615 }
1616 ir_node *new_r_Proj   (ir_graph *irg, ir_node *block, ir_node *arg,
1617                ir_mode *mode, long proj) {
1618   return new_rd_Proj(NULL, irg, block, arg, mode, proj);
1619 }
1620 ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
1621                 long max_proj) {
1622   return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
1623 }
1624 ir_node *new_r_Tuple  (ir_graph *irg, ir_node *block,
1625                int arity, ir_node **in) {
1626   return new_rd_Tuple(NULL, irg, block, arity, in );
1627 }
1628 ir_node *new_r_Id     (ir_graph *irg, ir_node *block,
1629                ir_node *val, ir_mode *mode) {
1630   return new_rd_Id(NULL, irg, block, val, mode);
1631 }
1632 ir_node *new_r_Bad    (ir_graph *irg) {
1633   return new_rd_Bad(irg);
1634 }
1635 ir_node *new_r_Confirm (ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
1636   return new_rd_Confirm (NULL, irg, block, val, bound, cmp);
1637 }
1638 ir_node *new_r_Unknown (ir_graph *irg, ir_mode *m) {
1639   return new_rd_Unknown(irg, m);
1640 }
1641 ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
1642   return new_rd_CallBegin(NULL, irg, block, callee);
1643 }
1644 ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
1645   return new_rd_EndReg(NULL, irg, block);
1646 }
1647 ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
1648   return new_rd_EndExcept(NULL, irg, block);
1649 }
1650 ir_node *new_r_Break  (ir_graph *irg, ir_node *block) {
1651   return new_rd_Break(NULL, irg, block);
1652 }
1653 ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
1654                ir_mode *mode, long proj) {
1655   return new_rd_Filter(NULL, irg, block, arg, mode, proj);
1656 }
1657 ir_node *new_r_NoMem  (ir_graph *irg) {
1658   return new_rd_NoMem(irg);
1659 }
1660 ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
1661     ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
1662   return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
1663 }
1664 ir_node *new_r_Psi (ir_graph *irg, ir_node *block,
1665     int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
1666   return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
1667 }
1668 ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
1669     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
1670   return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
1671 }
1672 ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
1673                   ir_type *type) {
1674   return (new_rd_InstOf (NULL, irg, block, store, objptr, type));
1675 }
1676 ir_node *new_r_Raise  (ir_graph *irg, ir_node *block,
1677                ir_node *store, ir_node *obj) {
1678   return new_rd_Raise(NULL, irg, block, store, obj);
1679 }
1680 ir_node *new_r_Bound(ir_graph *irg, ir_node *block,
1681     ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
1682   return new_rd_Bound(NULL, irg, block, store, idx, lower, upper);
1683 }
1684
1685 /** ********************/
1686 /** public interfaces  */
1687 /** construction tools */
1688
1689 /**
1690  *
1691  *   - create a new Start node in the current block
1692  *
1693  *   @return s - pointer to the created Start node
1694  *
1695  *
1696  */
1697 ir_node *
1698 new_d_Start (dbg_info *db)
1699 {
1700   ir_node *res;
1701
1702   res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
1703              op_Start, mode_T, 0, NULL);
1704   /* res->attr.start.irg = current_ir_graph; */
1705
1706   res = optimize_node(res);
1707   IRN_VRFY_IRG(res, current_ir_graph);
1708   return res;
1709 }
1710
1711 ir_node *
1712 new_d_End (dbg_info *db)
1713 {
1714   ir_node *res;
1715   res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
1716              op_End, mode_X, -1, NULL);
1717   res = optimize_node(res);
1718   IRN_VRFY_IRG(res, current_ir_graph);
1719
1720   return res;
1721 }
1722
1723 /* Constructs a Block with a fixed number of predecessors.
1724    Does set current_block.  Can be used with automatic Phi
1725    node construction. */
1726 ir_node *
1727 new_d_Block (dbg_info *db, int arity, ir_node **in)
1728 {
1729   ir_node *res;
1730   int i;
1731   int has_unknown = 0;
1732
1733   res = new_bd_Block(db, arity, in);
1734
1735   /* Create and initialize array for Phi-node construction. */
1736   if (get_irg_phase_state(current_ir_graph) == phase_building) {
1737     res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
1738                       current_ir_graph->n_loc);
1739     memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1740   }
1741
1742   for (i = arity-1; i >= 0; i--)
1743     if (get_irn_op(in[i]) == op_Unknown) {
1744       has_unknown = 1;
1745       break;
1746     }
1747
1748   if (!has_unknown) res = optimize_node(res);
1749   current_ir_graph->current_block = res;
1750
1751   IRN_VRFY_IRG(res, current_ir_graph);
1752
1753   return res;
1754 }
1755
1756 /* ***********************************************************************/
1757 /* Methods necessary for automatic Phi node creation                     */
1758 /*
1759   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1760   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1761   ir_node *new_rd_Phi0          (ir_graph *irg, ir_node *block, ir_mode *mode)
1762   ir_node *new_rd_Phi_in        (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
1763
1764   Call Graph:   ( A ---> B == A "calls" B)
1765
1766        get_value         mature_immBlock
1767           |                   |
1768           |                   |
1769           |                   |
1770           |          ---> phi_merge
1771           |         /       /   \
1772           |        /       /     \
1773          \|/      /      |/_      \
1774        get_r_value_internal        |
1775                 |                  |
1776             |                  |
1777            \|/                \|/
1778         new_rd_Phi0          new_rd_Phi_in
1779
1780 * *************************************************************************** */
1781
1782 /** Creates a Phi node with 0 predecessors */
1783 static INLINE ir_node *
1784 new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
1785 {
1786   ir_node *res;
1787
1788   res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
1789   IRN_VRFY_IRG(res, irg);
1790   return res;
1791 }
1792
1793 /* There are two implementations of the Phi node construction.  The first
1794    is faster, but does not work for blocks with more than 2 predecessors.
1795    The second works always but is slower and causes more unnecessary Phi
1796    nodes.
1797    Select the implementations by the following preprocessor flag set in
1798    common/common.h: */
1799 #if USE_FAST_PHI_CONSTRUCTION
1800
1801 /* This is a stack used for allocating and deallocating nodes in
1802    new_rd_Phi_in.  The original implementation used the obstack
1803    to model this stack, now it is explicit.  This reduces side effects.
1804 */
1805 #if USE_EXPLICIT_PHI_IN_STACK
1806 Phi_in_stack *
1807 new_Phi_in_stack(void) {
1808   Phi_in_stack *res;
1809
1810   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
1811
1812   res->stack = NEW_ARR_F (ir_node *, 0);
1813   res->pos = 0;
1814
1815   return res;
1816 }
1817
1818 void
1819 free_Phi_in_stack(Phi_in_stack *s) {
1820   DEL_ARR_F(s->stack);
1821   free(s);
1822 }
1823 static INLINE void
1824 free_to_Phi_in_stack(ir_node *phi) {
1825   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
1826       current_ir_graph->Phi_in_stack->pos)
1827     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
1828   else
1829     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
1830
1831   (current_ir_graph->Phi_in_stack->pos)++;
1832 }
1833
1834 static INLINE ir_node *
1835 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
1836          int arity, ir_node **in) {
1837   ir_node *res;
1838   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
1839   int pos = current_ir_graph->Phi_in_stack->pos;
1840
1841
1842   if (pos == 0) {
1843     /* We need to allocate a new node */
1844     res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
1845     res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
1846   } else {
1847     /* reuse the old node and initialize it again. */
1848     res = stack[pos-1];
1849
1850     assert (res->kind == k_ir_node);
1851     assert (res->op == op_Phi);
1852     res->mode = mode;
1853     res->visited = 0;
1854     res->link = NULL;
1855     assert (arity >= 0);
1856     /* ???!!! How to free the old in array??  Not at all: on obstack ?!! */
1857     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
1858     res->in[0] = block;
1859     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
1860
1861     (current_ir_graph->Phi_in_stack->pos)--;
1862   }
1863   return res;
1864 }
1865 #endif /* USE_EXPLICIT_PHI_IN_STACK */
1866
1867 /* Creates a Phi node with a given, fixed array **in of predecessors.
1868    If the Phi node is unnecessary, as the same value reaches the block
1869    through all control flow paths, it is eliminated and the value
1870    returned directly.  This constructor is only intended for use in
1871    the automatic Phi node generation triggered by get_value or mature.
1872    The implementation is quite tricky and depends on the fact, that
1873    the nodes are allocated on a stack:
1874    The in array contains predecessors and NULLs.  The NULLs appear,
1875    if get_r_value_internal, that computed the predecessors, reached
1876    the same block on two paths.  In this case the same value reaches
1877    this block on both paths, there is no definition in between.  We need
1878    not allocate a Phi where these path's merge, but we have to communicate
1879    this fact to the caller.  This happens by returning a pointer to the
1880    node the caller _will_ allocate.  (Yes, we predict the address. We can
1881    do so because the nodes are allocated on the obstack.)  The caller then
1882    finds a pointer to itself and, when this routine is called again,
1883    eliminates itself.
1884    */
1885 static INLINE ir_node *
1886 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
1887 {
1888   int i;
1889   ir_node *res, *known;
1890
1891   /* Allocate a new node on the obstack.  This can return a node to
1892      which some of the pointers in the in-array already point.
1893      Attention: the constructor copies the in array, i.e., the later
1894      changes to the array in this routine do not affect the
1895      constructed node!  If the in array contains NULLs, there will be
1896      missing predecessors in the returned node.  Is this a possible
1897      internal state of the Phi node generation? */
1898 #if USE_EXPLICIT_PHI_IN_STACK
1899   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
1900 #else
1901   res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
1902   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
1903 #endif
1904
1905   /* The in-array can contain NULLs.  These were returned by
1906      get_r_value_internal if it reached the same block/definition on a
1907      second path.  The NULLs are replaced by the node itself to
1908      simplify the test in the next loop. */
1909   for (i = 0;  i < ins;  ++i) {
1910     if (in[i] == NULL)
1911       in[i] = res;
1912   }
1913
1914   /* This loop checks whether the Phi has more than one predecessor.
1915      If so, it is a real Phi node and we break the loop.  Else the Phi
1916      node merges the same definition on several paths and therefore is
1917      not needed. */
1918   for (i = 0;  i < ins;  ++i) {
1919     if (in[i] == res || in[i] == known)
1920       continue;
1921
1922     if (known == res)
1923       known = in[i];
1924     else
1925       break;
1926   }
1927
1928   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1929   if (i==ins) {
1930 #if USE_EXPLICIT_PHI_IN_STACK
1931     free_to_Phi_in_stack(res);
1932 #else
1933     edges_node_deleted(res, current_ir_graph);
1934     obstack_free(current_ir_graph->obst, res);
1935 #endif
1936     res = known;
1937   } else {
1938     res = optimize_node (res);
1939     IRN_VRFY_IRG(res, irg);
1940   }
1941
1942   /* return the pointer to the Phi node.  This node might be deallocated! */
1943   return res;
1944 }
1945
1946 static ir_node *
1947 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1948
1949 /**
1950     allocates and returns this node.  The routine called to allocate the
1951     node might optimize it away and return a real value, or even a pointer
1952     to a deallocated Phi node on top of the obstack!
1953     This function is called with an in-array of proper size. **/
1954 static ir_node *
1955 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1956 {
1957   ir_node *prevBlock, *res;
1958   int i;
1959
1960   /* This loop goes to all predecessor blocks of the block the Phi node is in
1961      and there finds the operands of the Phi node by calling
1962      get_r_value_internal. */
1963   for (i = 1;  i <= ins;  ++i) {
1964     assert (block->in[i]);
1965     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1966     assert (prevBlock);
1967     nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1968   }
1969
1970   /* After collecting all predecessors into the array nin a new Phi node
1971      with these predecessors is created.  This constructor contains an
1972      optimization: If all predecessors of the Phi node are identical it
1973      returns the only operand instead of a new Phi node.  If the value
1974      passes two different control flow edges without being defined, and
1975      this is the second path treated, a pointer to the node that will be
1976      allocated for the first path (recursion) is returned.  We already
1977      know the address of this node, as it is the next node to be allocated
1978      and will be placed on top of the obstack. (The obstack is a _stack_!) */
1979   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
1980
1981   /* Now we now the value for "pos" and can enter it in the array with
1982      all known local variables.  Attention: this might be a pointer to
1983      a node, that later will be allocated!!! See new_rd_Phi_in.
1984      If this is called in mature, after some set_value in the same block,
1985      the proper value must not be overwritten:
1986      The call order
1987        get_value    (makes Phi0, put's it into graph_arr)
1988        set_value    (overwrites Phi0 in graph_arr)
1989        mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
1990                      the proper value.)
1991      fails. */
1992   if (!block->attr.block.graph_arr[pos]) {
1993     block->attr.block.graph_arr[pos] = res;
1994   } else {
1995     /*  printf(" value already computed by %s\n",
1996         get_id_str(block->attr.block.graph_arr[pos]->op->name));  */
1997   }
1998
1999   return res;
2000 }
2001
2002 /* This function returns the last definition of a variable.  In case
2003    this variable was last defined in a previous block, Phi nodes are
2004    inserted.  If the part of the firm graph containing the definition
2005    is not yet constructed, a dummy Phi node is returned. */
2006 static ir_node *
2007 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
2008 {
2009   ir_node *res;
2010   /* There are 4 cases to treat.
2011
2012      1. The block is not mature and we visit it the first time.  We can not
2013         create a proper Phi node, therefore a Phi0, i.e., a Phi without
2014         predecessors is returned.  This node is added to the linked list (field
2015         "link") of the containing block to be completed when this block is
2016         matured. (Completion will add a new Phi and turn the Phi0 into an Id
2017         node.)
2018
2019      2. The value is already known in this block, graph_arr[pos] is set and we
2020         visit the block the first time.  We can return the value without
2021         creating any new nodes.
2022
2023      3. The block is mature and we visit it the first time.  A Phi node needs
2024         to be created (phi_merge).  If the Phi is not needed, as all it's
2025         operands are the same value reaching the block through different
2026         paths, it's optimized away and the value itself is returned.
2027
2028      4. The block is mature, and we visit it the second time.  Now two
2029         subcases are possible:
2030         * The value was computed completely the last time we were here. This
2031           is the case if there is no loop.  We can return the proper value.
2032         * The recursion that visited this node and set the flag did not
2033           return yet.  We are computing a value in a loop and need to
2034           break the recursion without knowing the result yet.
2035       @@@ strange case.  Straight forward we would create a Phi before
2036       starting the computation of it's predecessors.  In this case we will
2037       find a Phi here in any case.  The problem is that this implementation
2038       only creates a Phi after computing the predecessors, so that it is
2039       hard to compute self references of this Phi.  @@@
2040         There is no simple check for the second subcase.  Therefore we check
2041         for a second visit and treat all such cases as the second subcase.
2042         Anyways, the basic situation is the same:  we reached a block
2043         on two paths without finding a definition of the value:  No Phi
2044         nodes are needed on both paths.
2045         We return this information "Two paths, no Phi needed" by a very tricky
2046         implementation that relies on the fact that an obstack is a stack and
2047         will return a node with the same address on different allocations.
2048         Look also at phi_merge and new_rd_phi_in to understand this.
2049     @@@ Unfortunately this does not work, see testprogram
2050     three_cfpred_example.
2051
2052   */
2053
2054   /* case 4 -- already visited. */
2055   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
2056
2057   /* visited the first time */
2058   set_irn_visited(block, get_irg_visited(current_ir_graph));
2059
2060   /* Get the local valid value */
2061   res = block->attr.block.graph_arr[pos];
2062
2063   /* case 2 -- If the value is actually computed, return it. */
2064   if (res) return res;
2065
2066   if (block->attr.block.matured) { /* case 3 */
2067
2068     /* The Phi has the same amount of ins as the corresponding block. */
2069     int ins = get_irn_arity(block);
2070     ir_node **nin;
2071     NEW_ARR_A (ir_node *, nin, ins);
2072
2073     /* Phi merge collects the predecessors and then creates a node. */
2074     res = phi_merge (block, pos, mode, nin, ins);
2075
2076   } else {  /* case 1 */
2077     /* The block is not mature, we don't know how many in's are needed.  A Phi
2078        with zero predecessors is created.  Such a Phi node is called Phi0
2079        node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
2080        to the list of Phi0 nodes in this block to be matured by mature_immBlock
2081        later.
2082        The Phi0 has to remember the pos of it's internal value.  If the real
2083        Phi is computed, pos is used to update the array with the local
2084        values. */
2085
2086     res = new_rd_Phi0 (current_ir_graph, block, mode);
2087     res->attr.phi0_pos = pos;
2088     res->link = block->link;
2089     block->link = res;
2090   }
2091
2092   /* If we get here, the frontend missed a use-before-definition error */
2093   if (!res) {
2094     /* Error Message */
2095     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2096     assert (mode->code >= irm_F && mode->code <= irm_P);
2097     res = new_rd_Const (NULL, current_ir_graph, block, mode,
2098                tarval_mode_null[mode->code]);
2099   }
2100
2101   /* The local valid value is available now. */
2102   block->attr.block.graph_arr[pos] = res;
2103
2104   return res;
2105 }
2106
2107 #else /* if 0 */
2108
2109 /**
2110     it starts the recursion.  This causes an Id at the entry of
2111     every block that has no definition of the value! **/
2112
2113 #if USE_EXPLICIT_PHI_IN_STACK
2114 /* Just dummies */
2115 Phi_in_stack * new_Phi_in_stack() {  return NULL; }
2116 void free_Phi_in_stack(Phi_in_stack *s) { }
2117 #endif
2118
2119 static INLINE ir_node *
2120 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
2121            ir_node **in, int ins, ir_node *phi0)
2122 {
2123   int i;
2124   ir_node *res, *known;
2125
2126   /* Allocate a new node on the obstack.  The allocation copies the in
2127      array. */
2128   res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
2129   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
2130
2131   /* This loop checks whether the Phi has more than one predecessor.
2132      If so, it is a real Phi node and we break the loop.  Else the
2133      Phi node merges the same definition on several paths and therefore
2134      is not needed. Don't consider Bad nodes! */
2135   known = res;
2136   for (i=0;  i < ins;  ++i)
2137   {
2138     assert(in[i]);
2139
2140     in[i] = skip_Id(in[i]);  /* increases the number of freed Phis. */
2141
2142     /* Optimize self referencing Phis:  We can't detect them yet properly, as
2143        they still refer to the Phi0 they will replace.  So replace right now. */
2144     if (phi0 && in[i] == phi0) in[i] = res;
2145
2146     if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
2147
2148     if (known==res)
2149       known = in[i];
2150     else
2151       break;
2152   }
2153
2154   /* i==ins: there is at most one predecessor, we don't need a phi node. */
2155   if (i == ins) {
2156     if (res != known) {
2157       edges_node_deleted(res, current_ir_graph);
2158       obstack_free (current_ir_graph->obst, res);
2159       if (is_Phi(known)) {
2160         /* If pred is a phi node we want to optimize it: If loops are matured in a bad
2161            order, an enclosing Phi know may get superfluous. */
2162         res = optimize_in_place_2(known);
2163         if (res != known)
2164           exchange(known, res);
2165
2166       }
2167       else
2168         res = known;
2169     } else {
2170       /* A undefined value, e.g., in unreachable code. */
2171       res = new_Bad();
2172     }
2173   } else {
2174     res = optimize_node (res);  /* This is necessary to add the node to the hash table for cse. */
2175     IRN_VRFY_IRG(res, irg);
2176     /* Memory Phis in endless loops must be kept alive.
2177        As we can't distinguish these easily we keep all of them alive. */
2178     if ((res->op == op_Phi) && (mode == mode_M))
2179       add_End_keepalive(get_irg_end(irg), res);
2180   }
2181
2182   return res;
2183 }
2184
2185 static ir_node *
2186 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
2187
2188 #if PRECISE_EXC_CONTEXT
2189 static ir_node *
2190 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
2191
2192 /* Construct a new frag_array for node n.
2193    Copy the content from the current graph_arr of the corresponding block:
2194    this is the current state.
2195    Set ProjM(n) as current memory state.
2196    Further the last entry in frag_arr of current block points to n.  This
2197    constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block.
2198  */
2199 static INLINE ir_node ** new_frag_arr (ir_node *n)
2200 {
2201   ir_node **arr;
2202   int opt;
2203
2204   arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
2205   memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
2206      sizeof(ir_node *)*current_ir_graph->n_loc);
2207
2208   /* turn off optimization before allocating Proj nodes, as res isn't
2209      finished yet. */
2210   opt = get_opt_optimize(); set_optimize(0);
2211   /* Here we rely on the fact that all frag ops have Memory as first result! */
2212   if (get_irn_op(n) == op_Call)
2213     arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
2214   else if (get_irn_op(n) == op_CopyB)
2215     arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
2216   else if (get_irn_op(n) == op_Bound)
2217     arr[0] = new_Proj(n, mode_M, pn_Bound_M_except);
2218   else {
2219     assert((pn_Quot_M == pn_DivMod_M) &&
2220        (pn_Quot_M == pn_Div_M)    &&
2221        (pn_Quot_M == pn_Mod_M)    &&
2222        (pn_Quot_M == pn_Load_M)   &&
2223        (pn_Quot_M == pn_Store_M)  &&
2224        (pn_Quot_M == pn_Alloc_M)    );
2225     arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
2226   }
2227   set_optimize(opt);
2228
2229   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
2230   return arr;
2231 }
2232
2233 /**
2234  * returns the frag_arr from a node
2235  */
2236 static INLINE ir_node **
2237 get_frag_arr (ir_node *n) {
2238   switch (get_irn_opcode(n)) {
2239   case iro_Call:
2240     return n->attr.call.exc.frag_arr;
2241   case iro_Alloc:
2242     return n->attr.a.exc.frag_arr;
2243   case iro_Load:
2244     return n->attr.load.exc.frag_arr;
2245   case iro_Store:
2246     return n->attr.store.exc.frag_arr;
2247   default:
2248     return n->attr.except.frag_arr;
2249   }
2250 }
2251
2252 static void
2253 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
2254 #if 0
2255   if (!frag_arr[pos]) frag_arr[pos] = val;
2256   if (frag_arr[current_ir_graph->n_loc - 1]) {
2257     ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2258     assert(arr != frag_arr && "Endless recursion detected");
2259     set_frag_value(arr, pos, val);
2260   }
2261 #else
2262   int i;
2263
2264   for (i = 0; i < 1000; ++i) {
2265     if (!frag_arr[pos]) {
2266       frag_arr[pos] = val;
2267     }
2268     if (frag_arr[current_ir_graph->n_loc - 1]) {
2269       ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2270       frag_arr = arr;
2271     }
2272     else
2273       return;
2274   }
2275   assert(0 && "potential endless recursion");
2276 #endif
2277 }
2278
2279 static ir_node *
2280 get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
2281   ir_node *res;
2282   ir_node **frag_arr;
2283
2284   assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
2285
2286   frag_arr = get_frag_arr(cfOp);
2287   res = frag_arr[pos];
2288   if (!res) {
2289     if (block->attr.block.graph_arr[pos]) {
2290       /* There was a set_value after the cfOp and no get_value before that
2291          set_value.  We must build a Phi node now. */
2292       if (block->attr.block.matured) {
2293         int ins = get_irn_arity(block);
2294         ir_node **nin;
2295         NEW_ARR_A (ir_node *, nin, ins);
2296         res = phi_merge(block, pos, mode, nin, ins);
2297       } else {
2298         res = new_rd_Phi0 (current_ir_graph, block, mode);
2299         res->attr.phi0_pos = pos;
2300         res->link = block->link;
2301         block->link = res;
2302       }
2303       assert(res);
2304       /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
2305          but this should be better: (remove comment if this works) */
2306       /* It's a Phi, we can write this into all graph_arrs with NULL */
2307       set_frag_value(block->attr.block.graph_arr, pos, res);
2308     } else {
2309       res = get_r_value_internal(block, pos, mode);
2310       set_frag_value(block->attr.block.graph_arr, pos, res);
2311     }
2312   }
2313   return res;
2314 }
2315 #endif /* PRECISE_EXC_CONTEXT */
2316
2317 /**
2318     computes the predecessors for the real phi node, and then
2319     allocates and returns this node.  The routine called to allocate the
2320     node might optimize it away and return a real value.
2321     This function must be called with an in-array of proper size. **/
2322 static ir_node *
2323 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
2324 {
2325   ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
2326   int i;
2327
2328   /* If this block has no value at pos create a Phi0 and remember it
2329      in graph_arr to break recursions.
2330      Else we may not set graph_arr as there a later value is remembered. */
2331   phi0 = NULL;
2332   if (!block->attr.block.graph_arr[pos]) {
2333     if (block == get_irg_start_block(current_ir_graph)) {
2334       /* Collapsing to Bad tarvals is no good idea.
2335          So we call a user-supplied routine here that deals with this case as
2336          appropriate for the given language. Sorrily the only help we can give
2337          here is the position.
2338
2339          Even if all variables are defined before use, it can happen that
2340          we get to the start block, if a Cond has been replaced by a tuple
2341          (bad, jmp).  In this case we call the function needlessly, eventually
2342          generating an non existent error.
2343          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
2344          before recurring.
2345       */
2346       if (default_initialize_local_variable) {
2347         ir_node *rem = get_cur_block();
2348
2349         set_cur_block(block);
2350         block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);
2351         set_cur_block(rem);
2352       }
2353       else
2354         block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
2355       /* We don't need to care about exception ops in the start block.
2356          There are none by definition. */
2357       return block->attr.block.graph_arr[pos];
2358     } else {
2359       phi0 = new_rd_Phi0(current_ir_graph, block, mode);
2360       block->attr.block.graph_arr[pos] = phi0;
2361 #if PRECISE_EXC_CONTEXT
2362       if (get_opt_precise_exc_context()) {
2363         /* Set graph_arr for fragile ops.  Also here we should break recursion.
2364            We could choose a cyclic path through an cfop.  But the recursion would
2365            break at some point. */
2366         set_frag_value(block->attr.block.graph_arr, pos, phi0);
2367       }
2368 #endif
2369     }
2370   }
2371
2372   /* This loop goes to all predecessor blocks of the block the Phi node
2373      is in and there finds the operands of the Phi node by calling
2374      get_r_value_internal.  */
2375   for (i = 1;  i <= ins;  ++i) {
2376     prevCfOp = skip_Proj(block->in[i]);
2377     assert (prevCfOp);
2378     if (is_Bad(prevCfOp)) {
2379       /* In case a Cond has been optimized we would get right to the start block
2380          with an invalid definition. */
2381       nin[i-1] = new_Bad();
2382       continue;
2383     }
2384     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
2385     assert (prevBlock);
2386     if (!is_Bad(prevBlock)) {
2387 #if PRECISE_EXC_CONTEXT
2388       if (get_opt_precise_exc_context() &&
2389           is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
2390         assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
2391         nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
2392       } else
2393 #endif
2394       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
2395     } else {
2396       nin[i-1] = new_Bad();
2397     }
2398   }
2399
2400   /* We want to pass the Phi0 node to the constructor: this finds additional
2401      optimization possibilities.
2402      The Phi0 node either is allocated in this function, or it comes from
2403      a former call to get_r_value_internal. In this case we may not yet
2404      exchange phi0, as this is done in mature_immBlock. */
2405   if (!phi0) {
2406     phi0_all = block->attr.block.graph_arr[pos];
2407     if (!((get_irn_op(phi0_all) == op_Phi) &&
2408       (get_irn_arity(phi0_all) == 0)   &&
2409       (get_nodes_block(phi0_all) == block)))
2410       phi0_all = NULL;
2411   } else {
2412     phi0_all = phi0;
2413   }
2414
2415   /* After collecting all predecessors into the array nin a new Phi node
2416      with these predecessors is created.  This constructor contains an
2417      optimization: If all predecessors of the Phi node are identical it
2418      returns the only operand instead of a new Phi node.  */
2419   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins, phi0_all);
2420
2421   /* In case we allocated a Phi0 node at the beginning of this procedure,
2422      we need to exchange this Phi0 with the real Phi. */
2423   if (phi0) {
2424     exchange(phi0, res);
2425     block->attr.block.graph_arr[pos] = res;
2426     /* Don't set_frag_value as it does not overwrite.  Doesn't matter, is
2427        only an optimization. */
2428   }
2429
2430   return res;
2431 }
2432
2433 /* This function returns the last definition of a variable.  In case
2434    this variable was last defined in a previous block, Phi nodes are
2435    inserted.  If the part of the firm graph containing the definition
2436    is not yet constructed, a dummy Phi node is returned. */
2437 static ir_node *
2438 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
2439 {
2440   ir_node *res;
2441   /* There are 4 cases to treat.
2442
2443      1. The block is not mature and we visit it the first time.  We can not
2444         create a proper Phi node, therefore a Phi0, i.e., a Phi without
2445         predecessors is returned.  This node is added to the linked list (field
2446         "link") of the containing block to be completed when this block is
2447         matured. (Completion will add a new Phi and turn the Phi0 into an Id
2448         node.)
2449
2450      2. The value is already known in this block, graph_arr[pos] is set and we
2451         visit the block the first time.  We can return the value without
2452         creating any new nodes.
2453
2454      3. The block is mature and we visit it the first time.  A Phi node needs
2455         to be created (phi_merge).  If the Phi is not needed, as all it's
2456         operands are the same value reaching the block through different
2457         paths, it's optimized away and the value itself is returned.
2458
2459      4. The block is mature, and we visit it the second time.  Now two
2460         subcases are possible:
2461         * The value was computed completely the last time we were here. This
2462           is the case if there is no loop.  We can return the proper value.
2463         * The recursion that visited this node and set the flag did not
2464           return yet.  We are computing a value in a loop and need to
2465           break the recursion.  This case only happens if we visited
2466       the same block with phi_merge before, which inserted a Phi0.
2467       So we return the Phi0.
2468   */
2469
2470   /* case 4 -- already visited. */
2471   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
2472     /* As phi_merge allocates a Phi0 this value is always defined. Here
2473      is the critical difference of the two algorithms. */
2474     assert(block->attr.block.graph_arr[pos]);
2475     return block->attr.block.graph_arr[pos];
2476   }
2477
2478   /* visited the first time */
2479   set_irn_visited(block, get_irg_visited(current_ir_graph));
2480
2481   /* Get the local valid value */
2482   res = block->attr.block.graph_arr[pos];
2483
2484   /* case 2 -- If the value is actually computed, return it. */
2485   if (res) { return res; };
2486
2487   if (block->attr.block.matured) { /* case 3 */
2488
2489     /* The Phi has the same amount of ins as the corresponding block. */
2490     int ins = get_irn_arity(block);
2491     ir_node **nin;
2492     NEW_ARR_A (ir_node *, nin, ins);
2493
2494     /* Phi merge collects the predecessors and then creates a node. */
2495     res = phi_merge (block, pos, mode, nin, ins);
2496
2497   } else {  /* case 1 */
2498     /* The block is not mature, we don't know how many in's are needed.  A Phi
2499        with zero predecessors is created.  Such a Phi node is called Phi0
2500        node.  The Phi0 is then added to the list of Phi0 nodes in this block
2501        to be matured by mature_immBlock later.
2502        The Phi0 has to remember the pos of it's internal value.  If the real
2503        Phi is computed, pos is used to update the array with the local
2504        values. */
2505     res = new_rd_Phi0 (current_ir_graph, block, mode);
2506     res->attr.phi0_pos = pos;
2507     res->link = block->link;
2508     block->link = res;
2509   }
2510
2511   /* If we get here, the frontend missed a use-before-definition error */
2512   if (!res) {
2513     /* Error Message */
2514     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2515     assert (mode->code >= irm_F && mode->code <= irm_P);
2516     res = new_rd_Const (NULL, current_ir_graph, block, mode,
2517             get_mode_null(mode));
2518   }
2519
2520   /* The local valid value is available now. */
2521   block->attr.block.graph_arr[pos] = res;
2522
2523   return res;
2524 }
2525
2526 #endif /* USE_FAST_PHI_CONSTRUCTION */
2527
2528 /* ************************************************************************** */
2529
2530 /*
2531  * Finalize a Block node, when all control flows are known.
2532  * Acceptable parameters are only Block nodes.
2533  */
2534 void
2535 mature_immBlock (ir_node *block)
2536 {
2537   int ins;
2538   ir_node *n, **nin;
2539   ir_node *next;
2540
2541   assert (get_irn_opcode(block) == iro_Block);
2542   /* @@@ should be commented in
2543      assert (!get_Block_matured(block) && "Block already matured"); */
2544
2545   if (!get_Block_matured(block)) {
2546     ins = ARR_LEN (block->in)-1;
2547     /* Fix block parameters */
2548     block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
2549
2550     /* An array for building the Phi nodes. */
2551     NEW_ARR_A (ir_node *, nin, ins);
2552
2553     /* Traverse a chain of Phi nodes attached to this block and mature
2554        these, too. **/
2555     for (n = block->link;  n;  n=next) {
2556       inc_irg_visited(current_ir_graph);
2557       next = n->link;
2558       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
2559     }
2560
2561     block->attr.block.matured = 1;
2562
2563     /* Now, as the block is a finished firm node, we can optimize it.
2564        Since other nodes have been allocated since the block was created
2565        we can not free the node on the obstack.  Therefore we have to call
2566        optimize_in_place.
2567        Unfortunately the optimization does not change a lot, as all allocated
2568        nodes refer to the unoptimized node.
2569        We can call _2, as global cse has no effect on blocks. */
2570     block = optimize_in_place_2(block);
2571     IRN_VRFY_IRG(block, current_ir_graph);
2572   }
2573 }
2574
2575 ir_node *
2576 new_d_Phi (dbg_info *db, int arity, ir_node **in, ir_mode *mode)
2577 {
2578   return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);
2579 }
2580
2581 ir_node *
2582 new_d_Const (dbg_info *db, ir_mode *mode, tarval *con)
2583 {
2584   return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con);
2585 }
2586
2587 ir_node *
2588 new_d_Const_long(dbg_info *db, ir_mode *mode, long value)
2589 {
2590   return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value);
2591 }
2592
2593 ir_node *
2594 new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp)
2595 {
2596   return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp);
2597 }
2598
2599
2600 ir_node *
2601 new_d_Id (dbg_info *db, ir_node *val, ir_mode *mode)
2602 {
2603   return new_bd_Id(db, current_ir_graph->current_block, val, mode);
2604 }
2605
2606 ir_node *
2607 new_d_Proj (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
2608 {
2609   return new_bd_Proj(db, current_ir_graph->current_block, arg, mode, proj);
2610 }
2611
2612 ir_node *
2613 new_d_defaultProj (dbg_info *db, ir_node *arg, long max_proj)
2614 {
2615   ir_node *res;
2616   assert(arg->op == op_Cond);
2617   arg->attr.c.kind = fragmentary;
2618   arg->attr.c.default_proj = max_proj;
2619   res = new_Proj (arg, mode_X, max_proj);
2620   return res;
2621 }
2622
2623 ir_node *
2624 new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode)
2625 {
2626   return new_bd_Conv(db, current_ir_graph->current_block, op, mode);
2627 }
2628
2629 ir_node *
2630 new_d_Cast (dbg_info *db, ir_node *op, ir_type *to_tp)
2631 {
2632   return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
2633 }
2634
2635 ir_node *
2636 new_d_Tuple (dbg_info *db, int arity, ir_node **in)
2637 {
2638   return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);
2639 }
2640
2641 NEW_D_BINOP(Add)
2642 NEW_D_BINOP(Sub)
2643 NEW_D_UNOP(Minus)
2644 NEW_D_BINOP(Mul)
2645
2646 /**
2647  * allocate the frag array
2648  */
2649 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
2650   if (get_opt_precise_exc_context()) {
2651     if ((current_ir_graph->phase_state == phase_building) &&
2652         (get_irn_op(res) == op) && /* Could be optimized away. */
2653         !*frag_store)    /* Could be a cse where the arr is already set. */ {
2654       *frag_store = new_frag_arr(res);
2655     }
2656   }
2657 }
2658
2659 ir_node *
2660 new_d_Quot (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2661 {
2662   ir_node *res;
2663   res = new_bd_Quot (db, current_ir_graph->current_block, memop, op1, op2);
2664   res->attr.except.pin_state = op_pin_state_pinned;
2665 #if PRECISE_EXC_CONTEXT
2666   allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */
2667 #endif
2668
2669   return res;
2670 }
2671
2672 ir_node *
2673 new_d_DivMod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2674 {
2675   ir_node *res;
2676   res = new_bd_DivMod (db, current_ir_graph->current_block, memop, op1, op2);
2677   res->attr.except.pin_state = op_pin_state_pinned;
2678 #if PRECISE_EXC_CONTEXT
2679   allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2680 #endif
2681
2682   return res;
2683 }
2684
2685 ir_node *
2686 new_d_Div (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2687 {
2688   ir_node *res;
2689   res = new_bd_Div (db, current_ir_graph->current_block, memop, op1, op2);
2690   res->attr.except.pin_state = op_pin_state_pinned;
2691 #if PRECISE_EXC_CONTEXT
2692   allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */
2693 #endif
2694
2695   return res;
2696 }
2697
2698 ir_node *
2699 new_d_Mod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2700 {
2701   ir_node *res;
2702   res = new_bd_Mod (db, current_ir_graph->current_block, memop, op1, op2);
2703   res->attr.except.pin_state = op_pin_state_pinned;
2704 #if PRECISE_EXC_CONTEXT
2705   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2706 #endif
2707
2708   return res;
2709 }
2710
2711 NEW_D_BINOP(And)
2712 NEW_D_BINOP(Or)
2713 NEW_D_BINOP(Eor)
2714 NEW_D_UNOP(Not)
2715 NEW_D_BINOP(Shl)
2716 NEW_D_BINOP(Shr)
2717 NEW_D_BINOP(Shrs)
2718 NEW_D_BINOP(Rot)
2719 NEW_D_UNOP(Abs)
2720 NEW_D_BINOP(Carry)
2721 NEW_D_BINOP(Borrow)
2722
2723 ir_node *
2724 new_d_Cmp (dbg_info *db, ir_node *op1, ir_node *op2)
2725 {
2726   return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
2727 }
2728
2729 ir_node *
2730 new_d_Jmp (dbg_info *db)
2731 {
2732   return new_bd_Jmp (db, current_ir_graph->current_block);
2733 }
2734
2735 ir_node *
2736 new_d_IJmp (dbg_info *db, ir_node *tgt)
2737 {
2738   return new_bd_IJmp (db, current_ir_graph->current_block, tgt);
2739 }
2740
2741 ir_node *
2742 new_d_Cond (dbg_info *db, ir_node *c)
2743 {
2744   return new_bd_Cond (db, current_ir_graph->current_block, c);
2745 }
2746
2747 ir_node *
2748 new_d_Call (dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
2749       ir_type *tp)
2750 {
2751   ir_node *res;
2752   res = new_bd_Call (db, current_ir_graph->current_block,
2753              store, callee, arity, in, tp);
2754 #if PRECISE_EXC_CONTEXT
2755   allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */
2756 #endif
2757
2758   return res;
2759 }
2760
2761 ir_node *
2762 new_d_Return (dbg_info *db, ir_node* store, int arity, ir_node **in)
2763 {
2764   return new_bd_Return (db, current_ir_graph->current_block,
2765                store, arity, in);
2766 }
2767
2768 ir_node *
2769 new_d_Load (dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode)
2770 {
2771   ir_node *res;
2772   res = new_bd_Load (db, current_ir_graph->current_block,
2773              store, addr, mode);
2774 #if PRECISE_EXC_CONTEXT
2775   allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
2776 #endif
2777
2778   return res;
2779 }
2780
2781 ir_node *
2782 new_d_Store (dbg_info *db, ir_node *store, ir_node *addr, ir_node *val)
2783 {
2784   ir_node *res;
2785   res = new_bd_Store (db, current_ir_graph->current_block,
2786               store, addr, val);
2787 #if PRECISE_EXC_CONTEXT
2788   allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
2789 #endif
2790
2791   return res;
2792 }
2793
2794 ir_node *
2795 new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
2796            where_alloc where)
2797 {
2798   ir_node *res;
2799   res = new_bd_Alloc (db, current_ir_graph->current_block,
2800               store, size, alloc_type, where);
2801 #if PRECISE_EXC_CONTEXT
2802   allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */
2803 #endif
2804
2805   return res;
2806 }
2807
2808 ir_node *
2809 new_d_Free (dbg_info *db, ir_node *store, ir_node *ptr,
2810     ir_node *size, ir_type *free_type, where_alloc where)
2811 {
2812   return new_bd_Free (db, current_ir_graph->current_block,
2813              store, ptr, size, free_type, where);
2814 }
2815
2816 ir_node *
2817 new_d_simpleSel (dbg_info *db, ir_node *store, ir_node *objptr, entity *ent)
2818 /* GL: objptr was called frame before.  Frame was a bad choice for the name
2819    as the operand could as well be a pointer to a dynamic object. */
2820 {
2821   return new_bd_Sel (db, current_ir_graph->current_block,
2822             store, objptr, 0, NULL, ent);
2823 }
2824
2825 ir_node *
2826 new_d_Sel (dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
2827 {
2828   return new_bd_Sel (db, current_ir_graph->current_block,
2829             store, objptr, n_index, index, sel);
2830 }
2831
2832 ir_node *
2833 new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp)
2834 {
2835   return new_bd_SymConst_type (db, get_irg_start_block(current_ir_graph),
2836                          value, kind, tp);
2837 }
2838
2839 ir_node *
2840 new_d_SymConst (dbg_info *db, symconst_symbol value, symconst_kind kind)
2841 {
2842   return new_bd_SymConst (db, get_irg_start_block(current_ir_graph),
2843                          value, kind);
2844 }
2845
2846 ir_node *
2847 new_d_Sync (dbg_info *db, int arity, ir_node** in)
2848 {
2849   return new_bd_Sync (db, current_ir_graph->current_block, arity, in);
2850 }
2851
2852
2853 ir_node *
2854 (new_d_Bad)(void) {
2855   return _new_d_Bad();
2856 }
2857
2858 ir_node *
2859 new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
2860 {
2861   return new_bd_Confirm (db, current_ir_graph->current_block,
2862              val, bound, cmp);
2863 }
2864
2865 ir_node *
2866 new_d_Unknown (ir_mode *m)
2867 {
2868   return new_bd_Unknown(m);
2869 }
2870
2871 ir_node *
2872 new_d_CallBegin (dbg_info *db, ir_node *call)
2873 {
2874   ir_node *res;
2875   res = new_bd_CallBegin (db, current_ir_graph->current_block, call);
2876   return res;
2877 }
2878
2879 ir_node *
2880 new_d_EndReg (dbg_info *db)
2881 {
2882   ir_node *res;
2883   res = new_bd_EndReg(db, current_ir_graph->current_block);
2884   return res;
2885 }
2886
2887 ir_node *
2888 new_d_EndExcept (dbg_info *db)
2889 {
2890   ir_node *res;
2891   res = new_bd_EndExcept(db, current_ir_graph->current_block);
2892   return res;
2893 }
2894
2895 ir_node *
2896 new_d_Break (dbg_info *db)
2897 {
2898   return new_bd_Break (db, current_ir_graph->current_block);
2899 }
2900
2901 ir_node *
2902 new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
2903 {
2904   return new_bd_Filter (db, current_ir_graph->current_block,
2905             arg, mode, proj);
2906 }
2907
2908 ir_node *
2909 (new_d_NoMem)(void)
2910 {
2911   return _new_d_NoMem();
2912 }
2913
2914 ir_node *
2915 new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
2916     ir_node *ir_true, ir_mode *mode) {
2917   return new_bd_Mux (db, current_ir_graph->current_block,
2918       sel, ir_false, ir_true, mode);
2919 }
2920
2921 ir_node *
2922 new_d_Psi (dbg_info *db,int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
2923   return new_bd_Psi (db, current_ir_graph->current_block,
2924       arity, conds, vals, mode);
2925 }
2926
2927 ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
2928     ir_node *dst, ir_node *src, ir_type *data_type) {
2929   ir_node *res;
2930   res = new_bd_CopyB(db, current_ir_graph->current_block,
2931     store, dst, src, data_type);
2932 #if PRECISE_EXC_CONTEXT
2933   allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
2934 #endif
2935   return res;
2936 }
2937
2938 ir_node *
2939 new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type)
2940 {
2941   return new_bd_InstOf (db, current_ir_graph->current_block,
2942                         store, objptr, type);
2943 }
2944
2945 ir_node *
2946 new_d_Raise (dbg_info *db, ir_node *store, ir_node *obj)
2947 {
2948   return new_bd_Raise (db, current_ir_graph->current_block,
2949               store, obj);
2950 }
2951
2952 ir_node *new_d_Bound(dbg_info *db,ir_node *store,
2953     ir_node *idx, ir_node *lower, ir_node *upper) {
2954   ir_node *res;
2955   res = new_bd_Bound(db, current_ir_graph->current_block,
2956     store, idx, lower, upper);
2957 #if PRECISE_EXC_CONTEXT
2958   allocate_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
2959 #endif
2960   return res;
2961 }
2962
2963 /* ********************************************************************* */
2964 /* Comfortable interface with automatic Phi node construction.           */
2965 /* (Uses also constructors of ?? interface, except new_Block.            */
2966 /* ********************************************************************* */
2967
2968 /*  Block construction */
2969 /* immature Block without predecessors */
2970 ir_node *new_d_immBlock (dbg_info *db) {
2971   ir_node *res;
2972
2973   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2974   /* creates a new dynamic in-array as length of in is -1 */
2975   res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
2976   current_ir_graph->current_block = res;
2977   res->attr.block.matured     = 0;
2978   res->attr.block.dead        = 0;
2979   /* res->attr.block.exc = exc_normal; */
2980   /* res->attr.block.handler_entry = 0; */
2981   res->attr.block.irg         = current_ir_graph;
2982   res->attr.block.backedge    = NULL;
2983   res->attr.block.in_cg       = NULL;
2984   res->attr.block.cg_backedge = NULL;
2985   set_Block_block_visited(res, 0);
2986
2987   /* Create and initialize array for Phi-node construction. */
2988   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
2989                                          current_ir_graph->n_loc);
2990   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
2991
2992   /* Immature block may not be optimized! */
2993   IRN_VRFY_IRG(res, current_ir_graph);
2994
2995   return res;
2996 }
2997
2998 ir_node *
2999 new_immBlock (void) {
3000   return new_d_immBlock(NULL);
3001 }
3002
3003 /* add an edge to a jmp/control flow node */
3004 void
3005 add_immBlock_pred (ir_node *block, ir_node *jmp)
3006 {
3007   if (block->attr.block.matured) {
3008     assert(0 && "Error: Block already matured!\n");
3009   }
3010   else {
3011     assert(jmp != NULL);
3012     ARR_APP1(ir_node *, block->in, jmp);
3013   }
3014 }
3015
3016 /* changing the current block */
3017 void
3018 set_cur_block (ir_node *target) {
3019   current_ir_graph->current_block = target;
3020 }
3021
3022 /* ************************ */
3023 /* parameter administration */
3024
3025 /* get a value from the parameter array from the current block by its index */
3026 ir_node *
3027 get_d_value (dbg_info *db, int pos, ir_mode *mode)
3028 {
3029   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3030   inc_irg_visited(current_ir_graph);
3031
3032   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
3033 }
3034 /* get a value from the parameter array from the current block by its index */
3035 ir_node *
3036 get_value (int pos, ir_mode *mode)
3037 {
3038   return get_d_value(NULL, pos, mode);
3039 }
3040
3041 /* set a value at position pos in the parameter array from the current block */
3042 void
3043 set_value (int pos, ir_node *value)
3044 {
3045   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3046   assert(pos+1 < current_ir_graph->n_loc);
3047   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
3048 }
3049
3050 int
3051 find_value(ir_node *value)
3052 {
3053   int i;
3054   ir_node *bl = current_ir_graph->current_block;
3055
3056   for (i = 1; i < ARR_LEN(bl->attr.block.graph_arr); ++i)
3057     if (bl->attr.block.graph_arr[i] == value)
3058       return i - 1;
3059   return -1;
3060 }
3061
3062 /* get the current store */
3063 ir_node *
3064 get_store (void)
3065 {
3066   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3067   /* GL: one could call get_value instead */
3068   inc_irg_visited(current_ir_graph);
3069   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
3070 }
3071
3072 /* set the current store */
3073 void
3074 set_store (ir_node *store)
3075 {
3076   /* GL: one could call set_value instead */
3077   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3078   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
3079 }
3080
3081 void
3082 keep_alive (ir_node *ka) {
3083   add_End_keepalive(get_irg_end(current_ir_graph), ka);
3084 }
3085
3086 /* --- Useful access routines --- */
3087 /* Returns the current block of the current graph.  To set the current
3088    block use set_cur_block. */
3089 ir_node *get_cur_block(void) {
3090   return get_irg_current_block(current_ir_graph);
3091 }
3092
3093 /* Returns the frame type of the current graph */
3094 ir_type *get_cur_frame_type(void) {
3095   return get_irg_frame_type(current_ir_graph);
3096 }
3097
3098
3099 /* ********************************************************************* */
3100 /* initialize */
3101
3102 /* call once for each run of the library */
3103 void
3104 init_cons(uninitialized_local_variable_func_t *func)
3105 {
3106   default_initialize_local_variable = func;
3107 }
3108
3109 void
3110 irp_finalize_cons (void) {
3111   int i;
3112   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
3113     irg_finalize_cons(get_irp_irg(i));
3114   }
3115   irp->phase_state = phase_high;
3116 }
3117
3118
3119 ir_node *new_Block(int arity, ir_node **in) {
3120   return new_d_Block(NULL, arity, in);
3121 }
3122 ir_node *new_Start  (void) {
3123   return new_d_Start(NULL);
3124 }
3125 ir_node *new_End    (void) {
3126   return new_d_End(NULL);
3127 }
3128 ir_node *new_Jmp    (void) {
3129   return new_d_Jmp(NULL);
3130 }
3131 ir_node *new_IJmp   (ir_node *tgt) {
3132   return new_d_IJmp(NULL, tgt);
3133 }
3134 ir_node *new_Cond   (ir_node *c) {
3135   return new_d_Cond(NULL, c);
3136 }
3137 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
3138   return new_d_Return(NULL, store, arity, in);
3139 }
3140 ir_node *new_Const  (ir_mode *mode, tarval *con) {
3141   return new_d_Const(NULL, mode, con);
3142 }
3143
3144 ir_node *new_Const_long(ir_mode *mode, long value)
3145 {
3146     return new_d_Const_long(NULL, mode, value);
3147 }
3148
3149 ir_node *new_Const_type(tarval *con, ir_type *tp) {
3150   return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
3151 }
3152
3153 ir_node *new_SymConst (symconst_symbol value, symconst_kind kind) {
3154   return new_d_SymConst(NULL, value, kind);
3155 }
3156 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, entity *ent) {
3157   return new_d_simpleSel(NULL, store, objptr, ent);
3158 }
3159 ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
3160                      entity *ent) {
3161   return new_d_Sel(NULL, store, objptr, arity, in, ent);
3162 }
3163 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
3164              ir_type *tp) {
3165   return new_d_Call(NULL, store, callee, arity, in, tp);
3166 }
3167 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3168   return new_d_Add(NULL, op1, op2, mode);
3169 }
3170 ir_node *new_Sub    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3171   return new_d_Sub(NULL, op1, op2, mode);
3172 }
3173 ir_node *new_Minus  (ir_node *op,  ir_mode *mode) {
3174   return new_d_Minus(NULL, op, mode);
3175 }
3176 ir_node *new_Mul    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3177   return new_d_Mul(NULL, op1, op2, mode);
3178 }
3179 ir_node *new_Quot   (ir_node *memop, ir_node *op1, ir_node *op2) {
3180   return new_d_Quot(NULL, memop, op1, op2);
3181 }
3182 ir_node *new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2) {
3183   return new_d_DivMod(NULL, memop, op1, op2);
3184 }
3185 ir_node *new_Div    (ir_node *memop, ir_node *op1, ir_node *op2) {
3186   return new_d_Div(NULL, memop, op1, op2);
3187 }
3188 ir_node *new_Mod    (ir_node *memop, ir_node *op1, ir_node *op2) {
3189   return new_d_Mod(NULL, memop, op1, op2);
3190 }
3191 ir_node *new_Abs    (ir_node *op, ir_mode *mode) {
3192   return new_d_Abs(NULL, op, mode);
3193 }
3194 ir_node *new_And    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3195   return new_d_And(NULL, op1, op2, mode);
3196 }
3197 ir_node *new_Or     (ir_node *op1, ir_node *op2, ir_mode *mode) {
3198   return new_d_Or(NULL, op1, op2, mode);
3199 }
3200 ir_node *new_Eor    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3201   return new_d_Eor(NULL, op1, op2, mode);
3202 }
3203 ir_node *new_Not    (ir_node *op,                ir_mode *mode) {
3204   return new_d_Not(NULL, op, mode);
3205 }
3206 ir_node *new_Shl    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3207   return new_d_Shl(NULL, op, k, mode);
3208 }
3209 ir_node *new_Shr    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3210   return new_d_Shr(NULL, op, k, mode);
3211 }
3212 ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *mode) {
3213   return new_d_Shrs(NULL, op, k, mode);
3214 }
3215 ir_node *new_Rot    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3216   return new_d_Rot(NULL, op, k, mode);
3217 }
3218 ir_node *new_Carry  (ir_node *op1, ir_node *op2, ir_mode *mode) {
3219   return new_d_Carry(NULL, op1, op2, mode);
3220 }
3221 ir_node *new_Borrow (ir_node *op1, ir_node *op2, ir_mode *mode) {
3222   return new_d_Borrow(NULL, op1, op2, mode);
3223 }
3224 ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
3225   return new_d_Cmp(NULL, op1, op2);
3226 }
3227 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
3228   return new_d_Conv(NULL, op, mode);
3229 }
3230 ir_node *new_Cast   (ir_node *op, ir_type *to_tp) {
3231   return new_d_Cast(NULL, op, to_tp);
3232 }
3233 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
3234   return new_d_Phi(NULL, arity, in, mode);
3235 }
3236 ir_node *new_Load   (ir_node *store, ir_node *addr, ir_mode *mode) {
3237   return new_d_Load(NULL, store, addr, mode);
3238 }
3239 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
3240   return new_d_Store(NULL, store, addr, val);
3241 }
3242 ir_node *new_Alloc  (ir_node *store, ir_node *size, ir_type *alloc_type,
3243                      where_alloc where) {
3244   return new_d_Alloc(NULL, store, size, alloc_type, where);
3245 }
3246 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,
3247              ir_type *free_type, where_alloc where) {
3248   return new_d_Free(NULL, store, ptr, size, free_type, where);
3249 }
3250 ir_node *new_Sync   (int arity, ir_node **in) {
3251   return new_d_Sync(NULL, arity, in);
3252 }
3253 ir_node *new_Proj   (ir_node *arg, ir_mode *mode, long proj) {
3254   return new_d_Proj(NULL, arg, mode, proj);
3255 }
3256 ir_node *new_defaultProj (ir_node *arg, long max_proj) {
3257   return new_d_defaultProj(NULL, arg, max_proj);
3258 }
3259 ir_node *new_Tuple  (int arity, ir_node **in) {
3260   return new_d_Tuple(NULL, arity, in);
3261 }
3262 ir_node *new_Id     (ir_node *val, ir_mode *mode) {
3263   return new_d_Id(NULL, val, mode);
3264 }
3265 ir_node *new_Bad    (void) {
3266   return new_d_Bad();
3267 }
3268 ir_node *new_Confirm (ir_node *val, ir_node *bound, pn_Cmp cmp) {
3269   return new_d_Confirm (NULL, val, bound, cmp);
3270 }
3271 ir_node *new_Unknown(ir_mode *m) {
3272   return new_d_Unknown(m);
3273 }
3274 ir_node *new_CallBegin (ir_node *callee) {
3275   return new_d_CallBegin(NULL, callee);
3276 }
3277 ir_node *new_EndReg (void) {
3278   return new_d_EndReg(NULL);
3279 }
3280 ir_node *new_EndExcept (void) {
3281   return new_d_EndExcept(NULL);
3282 }
3283 ir_node *new_Break  (void) {
3284   return new_d_Break(NULL);
3285 }
3286 ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
3287   return new_d_Filter(NULL, arg, mode, proj);
3288 }
3289 ir_node *new_NoMem  (void) {
3290   return new_d_NoMem();
3291 }
3292 ir_node *new_Mux (ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
3293   return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
3294 }
3295 ir_node *new_Psi (int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
3296   return new_d_Psi(NULL, arity, conds, vals, mode);
3297 }
3298 ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
3299   return new_d_CopyB(NULL, store, dst, src, data_type);
3300 }
3301 ir_node *new_InstOf (ir_node *store, ir_node *objptr, ir_type *ent) {
3302   return new_d_InstOf (NULL, store, objptr, ent);
3303 }
3304 ir_node *new_Raise  (ir_node *store, ir_node *obj) {
3305   return new_d_Raise(NULL, store, obj);
3306 }
3307 ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
3308   return new_d_Bound(NULL, store, idx, lower, upper);
3309 }