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(irg->end, 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, irg->start_block, 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, irg->start_block, 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   irg->end_reg = 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   irg->end_except = 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, irg->start_block, 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, irg->start_block, 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, irg->start_block, 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, irg->start_block, 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 {
1277   return irg->bad;
1278 }
1279
1280 ir_node *
1281 new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
1282 {
1283   ir_node  *res;
1284   ir_graph *rem = current_ir_graph;
1285
1286   current_ir_graph = irg;
1287   res = new_bd_Confirm(db, block, val, bound, cmp);
1288   current_ir_graph = rem;
1289
1290   return res;
1291 }
1292
1293 /* this function is often called with current_ir_graph unset */
1294 ir_node *
1295 new_rd_Unknown (ir_graph *irg, ir_mode *m)
1296 {
1297   ir_node  *res;
1298   ir_graph *rem = current_ir_graph;
1299
1300   current_ir_graph = irg;
1301   res = new_bd_Unknown(m);
1302   current_ir_graph = rem;
1303
1304   return res;
1305 }
1306
1307 ir_node *
1308 new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
1309 {
1310   ir_node  *res;
1311   ir_graph *rem = current_ir_graph;
1312
1313   current_ir_graph = irg;
1314   res = new_bd_CallBegin(db, block, call);
1315   current_ir_graph = rem;
1316
1317   return res;
1318 }
1319
1320 ir_node *
1321 new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
1322 {
1323   ir_node *res;
1324
1325   res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
1326   irg->end_reg = res;
1327   IRN_VRFY_IRG(res, irg);
1328   return res;
1329 }
1330
1331 ir_node *
1332 new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
1333 {
1334   ir_node *res;
1335
1336   res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
1337   irg->end_except = res;
1338   IRN_VRFY_IRG (res, irg);
1339   return res;
1340 }
1341
1342 ir_node *
1343 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
1344 {
1345   ir_node  *res;
1346   ir_graph *rem = current_ir_graph;
1347
1348   current_ir_graph = irg;
1349   res = new_bd_Break(db, block);
1350   current_ir_graph = rem;
1351
1352   return res;
1353 }
1354
1355 ir_node *
1356 new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
1357            long proj)
1358 {
1359   ir_node  *res;
1360   ir_graph *rem = current_ir_graph;
1361
1362   current_ir_graph = irg;
1363   res = new_bd_Filter(db, block, arg, mode, proj);
1364   current_ir_graph = rem;
1365
1366   return res;
1367 }
1368
1369 ir_node *
1370 new_rd_NoMem (ir_graph *irg) {
1371   return irg->no_mem;
1372 }
1373
1374 ir_node *
1375 new_rd_Mux  (dbg_info *db, ir_graph *irg, ir_node *block,
1376     ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode)
1377 {
1378   ir_node  *res;
1379   ir_graph *rem = current_ir_graph;
1380
1381   current_ir_graph = irg;
1382   res = new_bd_Mux(db, block, sel, ir_false, ir_true, mode);
1383   current_ir_graph = rem;
1384
1385   return res;
1386 }
1387
1388 ir_node *
1389 new_rd_Psi (dbg_info *db, ir_graph *irg, ir_node *block,
1390     int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode)
1391 {
1392   ir_node  *res;
1393   ir_graph *rem = current_ir_graph;
1394
1395   current_ir_graph = irg;
1396   res = new_bd_Psi(db, block, arity, cond, vals, mode);
1397   current_ir_graph = rem;
1398
1399   return res;
1400 }
1401
1402 ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
1403     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
1404 {
1405   ir_node  *res;
1406   ir_graph *rem = current_ir_graph;
1407
1408   current_ir_graph = irg;
1409   res = new_bd_CopyB(db, block, store, dst, src, data_type);
1410   current_ir_graph = rem;
1411
1412   return res;
1413 }
1414
1415 ir_node *
1416 new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1417            ir_node *objptr, ir_type *type)
1418 {
1419   ir_node  *res;
1420   ir_graph *rem = current_ir_graph;
1421
1422   current_ir_graph = irg;
1423   res = new_bd_InstOf(db, block, store, objptr, type);
1424   current_ir_graph = rem;
1425
1426   return res;
1427 }
1428
1429 ir_node *
1430 new_rd_Raise (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
1431 {
1432   ir_node  *res;
1433   ir_graph *rem = current_ir_graph;
1434
1435   current_ir_graph = irg;
1436   res = new_bd_Raise(db, block, store, obj);
1437   current_ir_graph = rem;
1438
1439   return res;
1440 }
1441
1442 ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block,
1443     ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper)
1444 {
1445   ir_node  *res;
1446   ir_graph *rem = current_ir_graph;
1447
1448   current_ir_graph = irg;
1449   res = new_bd_Bound(db, block, store, idx, lower, upper);
1450   current_ir_graph = rem;
1451
1452   return res;
1453 }
1454
1455 ir_node *new_r_Block  (ir_graph *irg,  int arity, ir_node **in) {
1456   return new_rd_Block(NULL, irg, arity, in);
1457 }
1458 ir_node *new_r_Start  (ir_graph *irg, ir_node *block) {
1459   return new_rd_Start(NULL, irg, block);
1460 }
1461 ir_node *new_r_End    (ir_graph *irg, ir_node *block) {
1462   return new_rd_End(NULL, irg, block);
1463 }
1464 ir_node *new_r_Jmp    (ir_graph *irg, ir_node *block) {
1465   return new_rd_Jmp(NULL, irg, block);
1466 }
1467 ir_node *new_r_IJmp   (ir_graph *irg, ir_node *block, ir_node *tgt) {
1468   return new_rd_IJmp(NULL, irg, block, tgt);
1469 }
1470 ir_node *new_r_Cond   (ir_graph *irg, ir_node *block, ir_node *c) {
1471   return new_rd_Cond(NULL, irg, block, c);
1472 }
1473 ir_node *new_r_Return (ir_graph *irg, ir_node *block,
1474                ir_node *store, int arity, ir_node **in) {
1475   return new_rd_Return(NULL, irg, block, store, arity, in);
1476 }
1477 ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
1478                ir_mode *mode, tarval *con) {
1479   return new_rd_Const(NULL, irg, block, mode, con);
1480 }
1481 ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
1482                ir_mode *mode, long value) {
1483   return new_rd_Const_long(NULL, irg, block, mode, value);
1484 }
1485 ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
1486                ir_mode *mode, tarval *con, ir_type *tp) {
1487   return new_rd_Const_type(NULL, irg, block, mode, con, tp);
1488 }
1489 ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
1490                        symconst_symbol value, symconst_kind symkind) {
1491   return new_rd_SymConst(NULL, irg, block, value, symkind);
1492 }
1493 ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
1494                          ir_node *objptr, entity *ent) {
1495   return new_rd_Sel(NULL, irg, block, store, objptr, 0, NULL, ent);
1496 }
1497 ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
1498                   ir_node *objptr, int n_index, ir_node **index,
1499                   entity *ent) {
1500   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
1501 }
1502 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
1503                   ir_node *callee, int arity, ir_node **in,
1504                   ir_type *tp) {
1505   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
1506 }
1507 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
1508                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1509   return new_rd_Add(NULL, irg, block, op1, op2, mode);
1510 }
1511 ir_node *new_r_Sub    (ir_graph *irg, ir_node *block,
1512                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1513   return new_rd_Sub(NULL, irg, block, op1, op2, mode);
1514 }
1515 ir_node *new_r_Minus  (ir_graph *irg, ir_node *block,
1516                   ir_node *op,  ir_mode *mode) {
1517   return new_rd_Minus(NULL, irg, block,  op, mode);
1518 }
1519 ir_node *new_r_Mul    (ir_graph *irg, ir_node *block,
1520                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1521   return new_rd_Mul(NULL, irg, block, op1, op2, mode);
1522 }
1523 ir_node *new_r_Quot   (ir_graph *irg, ir_node *block,
1524                   ir_node *memop, ir_node *op1, ir_node *op2) {
1525   return new_rd_Quot(NULL, irg, block, memop, op1, op2);
1526 }
1527 ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
1528                   ir_node *memop, ir_node *op1, ir_node *op2) {
1529   return new_rd_DivMod(NULL, irg, block, memop, op1, op2);
1530 }
1531 ir_node *new_r_Div    (ir_graph *irg, ir_node *block,
1532                   ir_node *memop, ir_node *op1, ir_node *op2) {
1533   return new_rd_Div(NULL, irg, block, memop, op1, op2);
1534 }
1535 ir_node *new_r_Mod    (ir_graph *irg, ir_node *block,
1536                   ir_node *memop, ir_node *op1, ir_node *op2) {
1537   return new_rd_Mod(NULL, irg, block, memop, op1, op2);
1538 }
1539 ir_node *new_r_Abs    (ir_graph *irg, ir_node *block,
1540                   ir_node *op, ir_mode *mode) {
1541   return new_rd_Abs(NULL, irg, block, op, mode);
1542 }
1543 ir_node *new_r_And    (ir_graph *irg, ir_node *block,
1544                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1545   return new_rd_And(NULL, irg, block,  op1, op2, mode);
1546 }
1547 ir_node *new_r_Or     (ir_graph *irg, ir_node *block,
1548                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1549   return new_rd_Or(NULL, irg, block,  op1, op2, mode);
1550 }
1551 ir_node *new_r_Eor    (ir_graph *irg, ir_node *block,
1552                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1553   return new_rd_Eor(NULL, irg, block,  op1, op2, mode);
1554 }
1555 ir_node *new_r_Not    (ir_graph *irg, ir_node *block,
1556                ir_node *op, ir_mode *mode) {
1557   return new_rd_Not(NULL, irg, block, op, mode);
1558 }
1559 ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
1560                ir_node *op, ir_node *k, ir_mode *mode) {
1561   return new_rd_Shl(NULL, irg, block, op, k, mode);
1562 }
1563 ir_node *new_r_Shr    (ir_graph *irg, ir_node *block,
1564                ir_node *op, ir_node *k, ir_mode *mode) {
1565   return new_rd_Shr(NULL, irg, block, op, k, mode);
1566 }
1567 ir_node *new_r_Shrs   (ir_graph *irg, ir_node *block,
1568                ir_node *op, ir_node *k, ir_mode *mode) {
1569   return new_rd_Shrs(NULL, irg, block, op, k, mode);
1570 }
1571 ir_node *new_r_Rot    (ir_graph *irg, ir_node *block,
1572                ir_node *op, ir_node *k, ir_mode *mode) {
1573   return new_rd_Rot(NULL, irg, block, op, k, mode);
1574 }
1575 ir_node *new_r_Carry  (ir_graph *irg, ir_node *block,
1576                ir_node *op, ir_node *k, ir_mode *mode) {
1577   return new_rd_Carry(NULL, irg, block, op, k, mode);
1578 }
1579 ir_node *new_r_Borrow (ir_graph *irg, ir_node *block,
1580                ir_node *op, ir_node *k, ir_mode *mode) {
1581   return new_rd_Borrow(NULL, irg, block, op, k, mode);
1582 }
1583 ir_node *new_r_Cmp    (ir_graph *irg, ir_node *block,
1584                ir_node *op1, ir_node *op2) {
1585   return new_rd_Cmp(NULL, irg, block, op1, op2);
1586 }
1587 ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
1588                ir_node *op, ir_mode *mode) {
1589   return new_rd_Conv(NULL, irg, block, op, mode);
1590 }
1591 ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
1592   return new_rd_Cast(NULL, irg, block, op, to_tp);
1593 }
1594 ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
1595                ir_node **in, ir_mode *mode) {
1596   return new_rd_Phi(NULL, irg, block, arity, in, mode);
1597 }
1598 ir_node *new_r_Load   (ir_graph *irg, ir_node *block,
1599                ir_node *store, ir_node *adr, ir_mode *mode) {
1600   return new_rd_Load(NULL, irg, block, store, adr, mode);
1601 }
1602 ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
1603                ir_node *store, ir_node *adr, ir_node *val) {
1604   return new_rd_Store(NULL, irg, block, store, adr, val);
1605 }
1606 ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,
1607                ir_node *size, ir_type *alloc_type, where_alloc where) {
1608   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
1609 }
1610 ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,
1611                ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
1612   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
1613 }
1614 ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
1615   return new_rd_Sync(NULL, irg, block, arity, in);
1616 }
1617 ir_node *new_r_Proj   (ir_graph *irg, ir_node *block, ir_node *arg,
1618                ir_mode *mode, long proj) {
1619   return new_rd_Proj(NULL, irg, block, arg, mode, proj);
1620 }
1621 ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
1622                 long max_proj) {
1623   return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
1624 }
1625 ir_node *new_r_Tuple  (ir_graph *irg, ir_node *block,
1626                int arity, ir_node **in) {
1627   return new_rd_Tuple(NULL, irg, block, arity, in );
1628 }
1629 ir_node *new_r_Id     (ir_graph *irg, ir_node *block,
1630                ir_node *val, ir_mode *mode) {
1631   return new_rd_Id(NULL, irg, block, val, mode);
1632 }
1633 ir_node *new_r_Bad    (ir_graph *irg) {
1634   return new_rd_Bad(irg);
1635 }
1636 ir_node *new_r_Confirm (ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
1637   return new_rd_Confirm (NULL, irg, block, val, bound, cmp);
1638 }
1639 ir_node *new_r_Unknown (ir_graph *irg, ir_mode *m) {
1640   return new_rd_Unknown(irg, m);
1641 }
1642 ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
1643   return new_rd_CallBegin(NULL, irg, block, callee);
1644 }
1645 ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
1646   return new_rd_EndReg(NULL, irg, block);
1647 }
1648 ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
1649   return new_rd_EndExcept(NULL, irg, block);
1650 }
1651 ir_node *new_r_Break  (ir_graph *irg, ir_node *block) {
1652   return new_rd_Break(NULL, irg, block);
1653 }
1654 ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
1655                ir_mode *mode, long proj) {
1656   return new_rd_Filter(NULL, irg, block, arg, mode, proj);
1657 }
1658 ir_node *new_r_NoMem  (ir_graph *irg) {
1659   return new_rd_NoMem(irg);
1660 }
1661 ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
1662     ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
1663   return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
1664 }
1665 ir_node *new_r_Psi (ir_graph *irg, ir_node *block,
1666     int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
1667   return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
1668 }
1669 ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
1670     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
1671   return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
1672 }
1673 ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
1674                   ir_type *type) {
1675   return (new_rd_InstOf (NULL, irg, block, store, objptr, type));
1676 }
1677 ir_node *new_r_Raise  (ir_graph *irg, ir_node *block,
1678                ir_node *store, ir_node *obj) {
1679   return new_rd_Raise(NULL, irg, block, store, obj);
1680 }
1681 ir_node *new_r_Bound(ir_graph *irg, ir_node *block,
1682     ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
1683   return new_rd_Bound(NULL, irg, block, store, idx, lower, upper);
1684 }
1685
1686 /** ********************/
1687 /** public interfaces  */
1688 /** construction tools */
1689
1690 /**
1691  *
1692  *   - create a new Start node in the current block
1693  *
1694  *   @return s - pointer to the created Start node
1695  *
1696  *
1697  */
1698 ir_node *
1699 new_d_Start (dbg_info *db)
1700 {
1701   ir_node *res;
1702
1703   res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
1704              op_Start, mode_T, 0, NULL);
1705   /* res->attr.start.irg = current_ir_graph; */
1706
1707   res = optimize_node(res);
1708   IRN_VRFY_IRG(res, current_ir_graph);
1709   return res;
1710 }
1711
1712 ir_node *
1713 new_d_End (dbg_info *db)
1714 {
1715   ir_node *res;
1716   res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
1717              op_End, mode_X, -1, NULL);
1718   res = optimize_node(res);
1719   IRN_VRFY_IRG(res, current_ir_graph);
1720
1721   return res;
1722 }
1723
1724 /* Constructs a Block with a fixed number of predecessors.
1725    Does set current_block.  Can be used with automatic Phi
1726    node construction. */
1727 ir_node *
1728 new_d_Block (dbg_info *db, int arity, ir_node **in)
1729 {
1730   ir_node *res;
1731   int i;
1732   int has_unknown = 0;
1733
1734   res = new_bd_Block(db, arity, in);
1735
1736   /* Create and initialize array for Phi-node construction. */
1737   if (get_irg_phase_state(current_ir_graph) == phase_building) {
1738     res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
1739                       current_ir_graph->n_loc);
1740     memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1741   }
1742
1743   for (i = arity-1; i >= 0; i--)
1744     if (get_irn_op(in[i]) == op_Unknown) {
1745       has_unknown = 1;
1746       break;
1747     }
1748
1749   if (!has_unknown) res = optimize_node(res);
1750   current_ir_graph->current_block = res;
1751
1752   IRN_VRFY_IRG(res, current_ir_graph);
1753
1754   return res;
1755 }
1756
1757 /* ***********************************************************************/
1758 /* Methods necessary for automatic Phi node creation                     */
1759 /*
1760   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1761   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1762   ir_node *new_rd_Phi0          (ir_graph *irg, ir_node *block, ir_mode *mode)
1763   ir_node *new_rd_Phi_in        (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
1764
1765   Call Graph:   ( A ---> B == A "calls" B)
1766
1767        get_value         mature_immBlock
1768           |                   |
1769           |                   |
1770           |                   |
1771           |          ---> phi_merge
1772           |         /       /   \
1773           |        /       /     \
1774          \|/      /      |/_      \
1775        get_r_value_internal        |
1776                 |                  |
1777             |                  |
1778            \|/                \|/
1779         new_rd_Phi0          new_rd_Phi_in
1780
1781 * *************************************************************************** */
1782
1783 /** Creates a Phi node with 0 predecessors */
1784 static INLINE ir_node *
1785 new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
1786 {
1787   ir_node *res;
1788
1789   res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
1790   IRN_VRFY_IRG(res, irg);
1791   return res;
1792 }
1793
1794 /* There are two implementations of the Phi node construction.  The first
1795    is faster, but does not work for blocks with more than 2 predecessors.
1796    The second works always but is slower and causes more unnecessary Phi
1797    nodes.
1798    Select the implementations by the following preprocessor flag set in
1799    common/common.h: */
1800 #if USE_FAST_PHI_CONSTRUCTION
1801
1802 /* This is a stack used for allocating and deallocating nodes in
1803    new_rd_Phi_in.  The original implementation used the obstack
1804    to model this stack, now it is explicit.  This reduces side effects.
1805 */
1806 #if USE_EXPLICIT_PHI_IN_STACK
1807 Phi_in_stack *
1808 new_Phi_in_stack(void) {
1809   Phi_in_stack *res;
1810
1811   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
1812
1813   res->stack = NEW_ARR_F (ir_node *, 0);
1814   res->pos = 0;
1815
1816   return res;
1817 }
1818
1819 void
1820 free_Phi_in_stack(Phi_in_stack *s) {
1821   DEL_ARR_F(s->stack);
1822   free(s);
1823 }
1824 static INLINE void
1825 free_to_Phi_in_stack(ir_node *phi) {
1826   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
1827       current_ir_graph->Phi_in_stack->pos)
1828     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
1829   else
1830     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
1831
1832   (current_ir_graph->Phi_in_stack->pos)++;
1833 }
1834
1835 static INLINE ir_node *
1836 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
1837          int arity, ir_node **in) {
1838   ir_node *res;
1839   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
1840   int pos = current_ir_graph->Phi_in_stack->pos;
1841
1842
1843   if (pos == 0) {
1844     /* We need to allocate a new node */
1845     res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
1846     res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
1847   } else {
1848     /* reuse the old node and initialize it again. */
1849     res = stack[pos-1];
1850
1851     assert (res->kind == k_ir_node);
1852     assert (res->op == op_Phi);
1853     res->mode = mode;
1854     res->visited = 0;
1855     res->link = NULL;
1856     assert (arity >= 0);
1857     /* ???!!! How to free the old in array??  Not at all: on obstack ?!! */
1858     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
1859     res->in[0] = block;
1860     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
1861
1862     (current_ir_graph->Phi_in_stack->pos)--;
1863   }
1864   return res;
1865 }
1866 #endif /* USE_EXPLICIT_PHI_IN_STACK */
1867
1868 /* Creates a Phi node with a given, fixed array **in of predecessors.
1869    If the Phi node is unnecessary, as the same value reaches the block
1870    through all control flow paths, it is eliminated and the value
1871    returned directly.  This constructor is only intended for use in
1872    the automatic Phi node generation triggered by get_value or mature.
1873    The implementation is quite tricky and depends on the fact, that
1874    the nodes are allocated on a stack:
1875    The in array contains predecessors and NULLs.  The NULLs appear,
1876    if get_r_value_internal, that computed the predecessors, reached
1877    the same block on two paths.  In this case the same value reaches
1878    this block on both paths, there is no definition in between.  We need
1879    not allocate a Phi where these path's merge, but we have to communicate
1880    this fact to the caller.  This happens by returning a pointer to the
1881    node the caller _will_ allocate.  (Yes, we predict the address. We can
1882    do so because the nodes are allocated on the obstack.)  The caller then
1883    finds a pointer to itself and, when this routine is called again,
1884    eliminates itself.
1885    */
1886 static INLINE ir_node *
1887 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
1888 {
1889   int i;
1890   ir_node *res, *known;
1891
1892   /* Allocate a new node on the obstack.  This can return a node to
1893      which some of the pointers in the in-array already point.
1894      Attention: the constructor copies the in array, i.e., the later
1895      changes to the array in this routine do not affect the
1896      constructed node!  If the in array contains NULLs, there will be
1897      missing predecessors in the returned node.  Is this a possible
1898      internal state of the Phi node generation? */
1899 #if USE_EXPLICIT_PHI_IN_STACK
1900   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
1901 #else
1902   res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
1903   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
1904 #endif
1905
1906   /* The in-array can contain NULLs.  These were returned by
1907      get_r_value_internal if it reached the same block/definition on a
1908      second path.  The NULLs are replaced by the node itself to
1909      simplify the test in the next loop. */
1910   for (i = 0;  i < ins;  ++i) {
1911     if (in[i] == NULL)
1912       in[i] = res;
1913   }
1914
1915   /* This loop checks whether the Phi has more than one predecessor.
1916      If so, it is a real Phi node and we break the loop.  Else the Phi
1917      node merges the same definition on several paths and therefore is
1918      not needed. */
1919   for (i = 0;  i < ins;  ++i) {
1920     if (in[i] == res || in[i] == known)
1921       continue;
1922
1923     if (known == res)
1924       known = in[i];
1925     else
1926       break;
1927   }
1928
1929   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1930   if (i==ins) {
1931 #if USE_EXPLICIT_PHI_IN_STACK
1932     free_to_Phi_in_stack(res);
1933 #else
1934     edges_node_deleted(res, current_ir_graph);
1935     obstack_free(current_ir_graph->obst, res);
1936 #endif
1937     res = known;
1938   } else {
1939     res = optimize_node (res);
1940     IRN_VRFY_IRG(res, irg);
1941   }
1942
1943   /* return the pointer to the Phi node.  This node might be deallocated! */
1944   return res;
1945 }
1946
1947 static ir_node *
1948 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1949
1950 /**
1951     allocates and returns this node.  The routine called to allocate the
1952     node might optimize it away and return a real value, or even a pointer
1953     to a deallocated Phi node on top of the obstack!
1954     This function is called with an in-array of proper size. **/
1955 static ir_node *
1956 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1957 {
1958   ir_node *prevBlock, *res;
1959   int i;
1960
1961   /* This loop goes to all predecessor blocks of the block the Phi node is in
1962      and there finds the operands of the Phi node by calling
1963      get_r_value_internal. */
1964   for (i = 1;  i <= ins;  ++i) {
1965     assert (block->in[i]);
1966     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1967     assert (prevBlock);
1968     nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1969   }
1970
1971   /* After collecting all predecessors into the array nin a new Phi node
1972      with these predecessors is created.  This constructor contains an
1973      optimization: If all predecessors of the Phi node are identical it
1974      returns the only operand instead of a new Phi node.  If the value
1975      passes two different control flow edges without being defined, and
1976      this is the second path treated, a pointer to the node that will be
1977      allocated for the first path (recursion) is returned.  We already
1978      know the address of this node, as it is the next node to be allocated
1979      and will be placed on top of the obstack. (The obstack is a _stack_!) */
1980   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
1981
1982   /* Now we now the value for "pos" and can enter it in the array with
1983      all known local variables.  Attention: this might be a pointer to
1984      a node, that later will be allocated!!! See new_rd_Phi_in.
1985      If this is called in mature, after some set_value in the same block,
1986      the proper value must not be overwritten:
1987      The call order
1988        get_value    (makes Phi0, put's it into graph_arr)
1989        set_value    (overwrites Phi0 in graph_arr)
1990        mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
1991                      the proper value.)
1992      fails. */
1993   if (!block->attr.block.graph_arr[pos]) {
1994     block->attr.block.graph_arr[pos] = res;
1995   } else {
1996     /*  printf(" value already computed by %s\n",
1997         get_id_str(block->attr.block.graph_arr[pos]->op->name));  */
1998   }
1999
2000   return res;
2001 }
2002
2003 /* This function returns the last definition of a variable.  In case
2004    this variable was last defined in a previous block, Phi nodes are
2005    inserted.  If the part of the firm graph containing the definition
2006    is not yet constructed, a dummy Phi node is returned. */
2007 static ir_node *
2008 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
2009 {
2010   ir_node *res;
2011   /* There are 4 cases to treat.
2012
2013      1. The block is not mature and we visit it the first time.  We can not
2014         create a proper Phi node, therefore a Phi0, i.e., a Phi without
2015         predecessors is returned.  This node is added to the linked list (field
2016         "link") of the containing block to be completed when this block is
2017         matured. (Completion will add a new Phi and turn the Phi0 into an Id
2018         node.)
2019
2020      2. The value is already known in this block, graph_arr[pos] is set and we
2021         visit the block the first time.  We can return the value without
2022         creating any new nodes.
2023
2024      3. The block is mature and we visit it the first time.  A Phi node needs
2025         to be created (phi_merge).  If the Phi is not needed, as all it's
2026         operands are the same value reaching the block through different
2027         paths, it's optimized away and the value itself is returned.
2028
2029      4. The block is mature, and we visit it the second time.  Now two
2030         subcases are possible:
2031         * The value was computed completely the last time we were here. This
2032           is the case if there is no loop.  We can return the proper value.
2033         * The recursion that visited this node and set the flag did not
2034           return yet.  We are computing a value in a loop and need to
2035           break the recursion without knowing the result yet.
2036       @@@ strange case.  Straight forward we would create a Phi before
2037       starting the computation of it's predecessors.  In this case we will
2038       find a Phi here in any case.  The problem is that this implementation
2039       only creates a Phi after computing the predecessors, so that it is
2040       hard to compute self references of this Phi.  @@@
2041         There is no simple check for the second subcase.  Therefore we check
2042         for a second visit and treat all such cases as the second subcase.
2043         Anyways, the basic situation is the same:  we reached a block
2044         on two paths without finding a definition of the value:  No Phi
2045         nodes are needed on both paths.
2046         We return this information "Two paths, no Phi needed" by a very tricky
2047         implementation that relies on the fact that an obstack is a stack and
2048         will return a node with the same address on different allocations.
2049         Look also at phi_merge and new_rd_phi_in to understand this.
2050     @@@ Unfortunately this does not work, see testprogram
2051     three_cfpred_example.
2052
2053   */
2054
2055   /* case 4 -- already visited. */
2056   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
2057
2058   /* visited the first time */
2059   set_irn_visited(block, get_irg_visited(current_ir_graph));
2060
2061   /* Get the local valid value */
2062   res = block->attr.block.graph_arr[pos];
2063
2064   /* case 2 -- If the value is actually computed, return it. */
2065   if (res) return res;
2066
2067   if (block->attr.block.matured) { /* case 3 */
2068
2069     /* The Phi has the same amount of ins as the corresponding block. */
2070     int ins = get_irn_arity(block);
2071     ir_node **nin;
2072     NEW_ARR_A (ir_node *, nin, ins);
2073
2074     /* Phi merge collects the predecessors and then creates a node. */
2075     res = phi_merge (block, pos, mode, nin, ins);
2076
2077   } else {  /* case 1 */
2078     /* The block is not mature, we don't know how many in's are needed.  A Phi
2079        with zero predecessors is created.  Such a Phi node is called Phi0
2080        node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
2081        to the list of Phi0 nodes in this block to be matured by mature_immBlock
2082        later.
2083        The Phi0 has to remember the pos of it's internal value.  If the real
2084        Phi is computed, pos is used to update the array with the local
2085        values. */
2086
2087     res = new_rd_Phi0 (current_ir_graph, block, mode);
2088     res->attr.phi0_pos = pos;
2089     res->link = block->link;
2090     block->link = res;
2091   }
2092
2093   /* If we get here, the frontend missed a use-before-definition error */
2094   if (!res) {
2095     /* Error Message */
2096     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2097     assert (mode->code >= irm_F && mode->code <= irm_P);
2098     res = new_rd_Const (NULL, current_ir_graph, block, mode,
2099                tarval_mode_null[mode->code]);
2100   }
2101
2102   /* The local valid value is available now. */
2103   block->attr.block.graph_arr[pos] = res;
2104
2105   return res;
2106 }
2107
2108 #else /* if 0 */
2109
2110 /**
2111     it starts the recursion.  This causes an Id at the entry of
2112     every block that has no definition of the value! **/
2113
2114 #if USE_EXPLICIT_PHI_IN_STACK
2115 /* Just dummies */
2116 Phi_in_stack * new_Phi_in_stack() {  return NULL; }
2117 void free_Phi_in_stack(Phi_in_stack *s) { }
2118 #endif
2119
2120 static INLINE ir_node *
2121 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
2122            ir_node **in, int ins, ir_node *phi0)
2123 {
2124   int i;
2125   ir_node *res, *known;
2126
2127   /* Allocate a new node on the obstack.  The allocation copies the in
2128      array. */
2129   res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
2130   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
2131
2132   /* This loop checks whether the Phi has more than one predecessor.
2133      If so, it is a real Phi node and we break the loop.  Else the
2134      Phi node merges the same definition on several paths and therefore
2135      is not needed. Don't consider Bad nodes! */
2136   known = res;
2137   for (i=0;  i < ins;  ++i)
2138   {
2139     assert(in[i]);
2140
2141     in[i] = skip_Id(in[i]);  /* increases the number of freed Phis. */
2142
2143     /* Optimize self referencing Phis:  We can't detect them yet properly, as
2144        they still refer to the Phi0 they will replace.  So replace right now. */
2145     if (phi0 && in[i] == phi0) in[i] = res;
2146
2147     if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
2148
2149     if (known==res)
2150       known = in[i];
2151     else
2152       break;
2153   }
2154
2155   /* i==ins: there is at most one predecessor, we don't need a phi node. */
2156   if (i == ins) {
2157     if (res != known) {
2158       edges_node_deleted(res, current_ir_graph);
2159       obstack_free (current_ir_graph->obst, res);
2160       if (is_Phi(known)) {
2161         /* If pred is a phi node we want to optimize it: If loops are matured in a bad
2162            order, an enclosing Phi know may get superfluous. */
2163         res = optimize_in_place_2(known);
2164         if (res != known)
2165           exchange(known, res);
2166
2167       }
2168       else
2169         res = known;
2170     } else {
2171       /* A undefined value, e.g., in unreachable code. */
2172       res = new_Bad();
2173     }
2174   } else {
2175     res = optimize_node (res);  /* This is necessary to add the node to the hash table for cse. */
2176     IRN_VRFY_IRG(res, irg);
2177     /* Memory Phis in endless loops must be kept alive.
2178        As we can't distinguish these easily we keep all of them alive. */
2179     if ((res->op == op_Phi) && (mode == mode_M))
2180       add_End_keepalive(irg->end, res);
2181   }
2182
2183   return res;
2184 }
2185
2186 static ir_node *
2187 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
2188
2189 #if PRECISE_EXC_CONTEXT
2190 static ir_node *
2191 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
2192
2193 /* Construct a new frag_array for node n.
2194    Copy the content from the current graph_arr of the corresponding block:
2195    this is the current state.
2196    Set ProjM(n) as current memory state.
2197    Further the last entry in frag_arr of current block points to n.  This
2198    constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block.
2199  */
2200 static INLINE ir_node ** new_frag_arr (ir_node *n)
2201 {
2202   ir_node **arr;
2203   int opt;
2204
2205   arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
2206   memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
2207      sizeof(ir_node *)*current_ir_graph->n_loc);
2208
2209   /* turn off optimization before allocating Proj nodes, as res isn't
2210      finished yet. */
2211   opt = get_opt_optimize(); set_optimize(0);
2212   /* Here we rely on the fact that all frag ops have Memory as first result! */
2213   if (get_irn_op(n) == op_Call)
2214     arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
2215   else if (get_irn_op(n) == op_CopyB)
2216     arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
2217   else if (get_irn_op(n) == op_Bound)
2218     arr[0] = new_Proj(n, mode_M, pn_Bound_M_except);
2219   else {
2220     assert((pn_Quot_M == pn_DivMod_M) &&
2221        (pn_Quot_M == pn_Div_M)    &&
2222        (pn_Quot_M == pn_Mod_M)    &&
2223        (pn_Quot_M == pn_Load_M)   &&
2224        (pn_Quot_M == pn_Store_M)  &&
2225        (pn_Quot_M == pn_Alloc_M)    );
2226     arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
2227   }
2228   set_optimize(opt);
2229
2230   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
2231   return arr;
2232 }
2233
2234 /**
2235  * returns the frag_arr from a node
2236  */
2237 static INLINE ir_node **
2238 get_frag_arr (ir_node *n) {
2239   switch (get_irn_opcode(n)) {
2240   case iro_Call:
2241     return n->attr.call.exc.frag_arr;
2242   case iro_Alloc:
2243     return n->attr.a.exc.frag_arr;
2244   case iro_Load:
2245     return n->attr.load.exc.frag_arr;
2246   case iro_Store:
2247     return n->attr.store.exc.frag_arr;
2248   default:
2249     return n->attr.except.frag_arr;
2250   }
2251 }
2252
2253 static void
2254 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
2255 #if 0
2256   if (!frag_arr[pos]) frag_arr[pos] = val;
2257   if (frag_arr[current_ir_graph->n_loc - 1]) {
2258     ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2259     assert(arr != frag_arr && "Endless recursion detected");
2260     set_frag_value(arr, pos, val);
2261   }
2262 #else
2263   int i;
2264
2265   for (i = 0; i < 1000; ++i) {
2266     if (!frag_arr[pos]) {
2267       frag_arr[pos] = val;
2268     }
2269     if (frag_arr[current_ir_graph->n_loc - 1]) {
2270       ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2271       frag_arr = arr;
2272     }
2273     else
2274       return;
2275   }
2276   assert(0 && "potential endless recursion");
2277 #endif
2278 }
2279
2280 static ir_node *
2281 get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
2282   ir_node *res;
2283   ir_node **frag_arr;
2284
2285   assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
2286
2287   frag_arr = get_frag_arr(cfOp);
2288   res = frag_arr[pos];
2289   if (!res) {
2290     if (block->attr.block.graph_arr[pos]) {
2291       /* There was a set_value after the cfOp and no get_value before that
2292          set_value.  We must build a Phi node now. */
2293       if (block->attr.block.matured) {
2294         int ins = get_irn_arity(block);
2295         ir_node **nin;
2296         NEW_ARR_A (ir_node *, nin, ins);
2297         res = phi_merge(block, pos, mode, nin, ins);
2298       } else {
2299         res = new_rd_Phi0 (current_ir_graph, block, mode);
2300         res->attr.phi0_pos = pos;
2301         res->link = block->link;
2302         block->link = res;
2303       }
2304       assert(res);
2305       /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
2306          but this should be better: (remove comment if this works) */
2307       /* It's a Phi, we can write this into all graph_arrs with NULL */
2308       set_frag_value(block->attr.block.graph_arr, pos, res);
2309     } else {
2310       res = get_r_value_internal(block, pos, mode);
2311       set_frag_value(block->attr.block.graph_arr, pos, res);
2312     }
2313   }
2314   return res;
2315 }
2316 #endif /* PRECISE_EXC_CONTEXT */
2317
2318 /**
2319     computes the predecessors for the real phi node, and then
2320     allocates and returns this node.  The routine called to allocate the
2321     node might optimize it away and return a real value.
2322     This function must be called with an in-array of proper size. **/
2323 static ir_node *
2324 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
2325 {
2326   ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
2327   int i;
2328
2329   /* If this block has no value at pos create a Phi0 and remember it
2330      in graph_arr to break recursions.
2331      Else we may not set graph_arr as there a later value is remembered. */
2332   phi0 = NULL;
2333   if (!block->attr.block.graph_arr[pos]) {
2334     if (block == get_irg_start_block(current_ir_graph)) {
2335       /* Collapsing to Bad tarvals is no good idea.
2336          So we call a user-supplied routine here that deals with this case as
2337          appropriate for the given language. Sorrily the only help we can give
2338          here is the position.
2339
2340          Even if all variables are defined before use, it can happen that
2341          we get to the start block, if a Cond has been replaced by a tuple
2342          (bad, jmp).  In this case we call the function needlessly, eventually
2343          generating an non existent error.
2344          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
2345          before recurring.
2346       */
2347       if (default_initialize_local_variable) {
2348         ir_node *rem = get_cur_block();
2349
2350         set_cur_block(block);
2351         block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);
2352         set_cur_block(rem);
2353       }
2354       else
2355         block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
2356       /* We don't need to care about exception ops in the start block.
2357          There are none by definition. */
2358       return block->attr.block.graph_arr[pos];
2359     } else {
2360       phi0 = new_rd_Phi0(current_ir_graph, block, mode);
2361       block->attr.block.graph_arr[pos] = phi0;
2362 #if PRECISE_EXC_CONTEXT
2363       if (get_opt_precise_exc_context()) {
2364         /* Set graph_arr for fragile ops.  Also here we should break recursion.
2365            We could choose a cyclic path through an cfop.  But the recursion would
2366            break at some point. */
2367         set_frag_value(block->attr.block.graph_arr, pos, phi0);
2368       }
2369 #endif
2370     }
2371   }
2372
2373   /* This loop goes to all predecessor blocks of the block the Phi node
2374      is in and there finds the operands of the Phi node by calling
2375      get_r_value_internal.  */
2376   for (i = 1;  i <= ins;  ++i) {
2377     prevCfOp = skip_Proj(block->in[i]);
2378     assert (prevCfOp);
2379     if (is_Bad(prevCfOp)) {
2380       /* In case a Cond has been optimized we would get right to the start block
2381          with an invalid definition. */
2382       nin[i-1] = new_Bad();
2383       continue;
2384     }
2385     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
2386     assert (prevBlock);
2387     if (!is_Bad(prevBlock)) {
2388 #if PRECISE_EXC_CONTEXT
2389       if (get_opt_precise_exc_context() &&
2390           is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
2391         assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
2392         nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
2393       } else
2394 #endif
2395       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
2396     } else {
2397       nin[i-1] = new_Bad();
2398     }
2399   }
2400
2401   /* We want to pass the Phi0 node to the constructor: this finds additional
2402      optimization possibilities.
2403      The Phi0 node either is allocated in this function, or it comes from
2404      a former call to get_r_value_internal. In this case we may not yet
2405      exchange phi0, as this is done in mature_immBlock. */
2406   if (!phi0) {
2407     phi0_all = block->attr.block.graph_arr[pos];
2408     if (!((get_irn_op(phi0_all) == op_Phi) &&
2409       (get_irn_arity(phi0_all) == 0)   &&
2410       (get_nodes_block(phi0_all) == block)))
2411       phi0_all = NULL;
2412   } else {
2413     phi0_all = phi0;
2414   }
2415
2416   /* After collecting all predecessors into the array nin a new Phi node
2417      with these predecessors is created.  This constructor contains an
2418      optimization: If all predecessors of the Phi node are identical it
2419      returns the only operand instead of a new Phi node.  */
2420   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins, phi0_all);
2421
2422   /* In case we allocated a Phi0 node at the beginning of this procedure,
2423      we need to exchange this Phi0 with the real Phi. */
2424   if (phi0) {
2425     exchange(phi0, res);
2426     block->attr.block.graph_arr[pos] = res;
2427     /* Don't set_frag_value as it does not overwrite.  Doesn't matter, is
2428        only an optimization. */
2429   }
2430
2431   return res;
2432 }
2433
2434 /* This function returns the last definition of a variable.  In case
2435    this variable was last defined in a previous block, Phi nodes are
2436    inserted.  If the part of the firm graph containing the definition
2437    is not yet constructed, a dummy Phi node is returned. */
2438 static ir_node *
2439 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
2440 {
2441   ir_node *res;
2442   /* There are 4 cases to treat.
2443
2444      1. The block is not mature and we visit it the first time.  We can not
2445         create a proper Phi node, therefore a Phi0, i.e., a Phi without
2446         predecessors is returned.  This node is added to the linked list (field
2447         "link") of the containing block to be completed when this block is
2448         matured. (Completion will add a new Phi and turn the Phi0 into an Id
2449         node.)
2450
2451      2. The value is already known in this block, graph_arr[pos] is set and we
2452         visit the block the first time.  We can return the value without
2453         creating any new nodes.
2454
2455      3. The block is mature and we visit it the first time.  A Phi node needs
2456         to be created (phi_merge).  If the Phi is not needed, as all it's
2457         operands are the same value reaching the block through different
2458         paths, it's optimized away and the value itself is returned.
2459
2460      4. The block is mature, and we visit it the second time.  Now two
2461         subcases are possible:
2462         * The value was computed completely the last time we were here. This
2463           is the case if there is no loop.  We can return the proper value.
2464         * The recursion that visited this node and set the flag did not
2465           return yet.  We are computing a value in a loop and need to
2466           break the recursion.  This case only happens if we visited
2467       the same block with phi_merge before, which inserted a Phi0.
2468       So we return the Phi0.
2469   */
2470
2471   /* case 4 -- already visited. */
2472   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
2473     /* As phi_merge allocates a Phi0 this value is always defined. Here
2474      is the critical difference of the two algorithms. */
2475     assert(block->attr.block.graph_arr[pos]);
2476     return block->attr.block.graph_arr[pos];
2477   }
2478
2479   /* visited the first time */
2480   set_irn_visited(block, get_irg_visited(current_ir_graph));
2481
2482   /* Get the local valid value */
2483   res = block->attr.block.graph_arr[pos];
2484
2485   /* case 2 -- If the value is actually computed, return it. */
2486   if (res) { return res; };
2487
2488   if (block->attr.block.matured) { /* case 3 */
2489
2490     /* The Phi has the same amount of ins as the corresponding block. */
2491     int ins = get_irn_arity(block);
2492     ir_node **nin;
2493     NEW_ARR_A (ir_node *, nin, ins);
2494
2495     /* Phi merge collects the predecessors and then creates a node. */
2496     res = phi_merge (block, pos, mode, nin, ins);
2497
2498   } else {  /* case 1 */
2499     /* The block is not mature, we don't know how many in's are needed.  A Phi
2500        with zero predecessors is created.  Such a Phi node is called Phi0
2501        node.  The Phi0 is then added to the list of Phi0 nodes in this block
2502        to be matured by mature_immBlock later.
2503        The Phi0 has to remember the pos of it's internal value.  If the real
2504        Phi is computed, pos is used to update the array with the local
2505        values. */
2506     res = new_rd_Phi0 (current_ir_graph, block, mode);
2507     res->attr.phi0_pos = pos;
2508     res->link = block->link;
2509     block->link = res;
2510   }
2511
2512   /* If we get here, the frontend missed a use-before-definition error */
2513   if (!res) {
2514     /* Error Message */
2515     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2516     assert (mode->code >= irm_F && mode->code <= irm_P);
2517     res = new_rd_Const (NULL, current_ir_graph, block, mode,
2518             get_mode_null(mode));
2519   }
2520
2521   /* The local valid value is available now. */
2522   block->attr.block.graph_arr[pos] = res;
2523
2524   return res;
2525 }
2526
2527 #endif /* USE_FAST_PHI_CONSTRUCTION */
2528
2529 /* ************************************************************************** */
2530
2531 /*
2532  * Finalize a Block node, when all control flows are known.
2533  * Acceptable parameters are only Block nodes.
2534  */
2535 void
2536 mature_immBlock (ir_node *block)
2537 {
2538   int ins;
2539   ir_node *n, **nin;
2540   ir_node *next;
2541
2542   assert (get_irn_opcode(block) == iro_Block);
2543   /* @@@ should be commented in
2544      assert (!get_Block_matured(block) && "Block already matured"); */
2545
2546   if (!get_Block_matured(block)) {
2547     ins = ARR_LEN (block->in)-1;
2548     /* Fix block parameters */
2549     block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
2550
2551     /* An array for building the Phi nodes. */
2552     NEW_ARR_A (ir_node *, nin, ins);
2553
2554     /* Traverse a chain of Phi nodes attached to this block and mature
2555        these, too. **/
2556     for (n = block->link;  n;  n=next) {
2557       inc_irg_visited(current_ir_graph);
2558       next = n->link;
2559       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
2560     }
2561
2562     block->attr.block.matured = 1;
2563
2564     /* Now, as the block is a finished firm node, we can optimize it.
2565        Since other nodes have been allocated since the block was created
2566        we can not free the node on the obstack.  Therefore we have to call
2567        optimize_in_place.
2568        Unfortunately the optimization does not change a lot, as all allocated
2569        nodes refer to the unoptimized node.
2570        We can call _2, as global cse has no effect on blocks. */
2571     block = optimize_in_place_2(block);
2572     IRN_VRFY_IRG(block, current_ir_graph);
2573   }
2574 }
2575
2576 ir_node *
2577 new_d_Phi (dbg_info *db, int arity, ir_node **in, ir_mode *mode)
2578 {
2579   return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);
2580 }
2581
2582 ir_node *
2583 new_d_Const (dbg_info *db, ir_mode *mode, tarval *con)
2584 {
2585   return new_bd_Const(db, current_ir_graph->start_block, mode, con);
2586 }
2587
2588 ir_node *
2589 new_d_Const_long(dbg_info *db, ir_mode *mode, long value)
2590 {
2591   return new_bd_Const_long(db, current_ir_graph->start_block, mode, value);
2592 }
2593
2594 ir_node *
2595 new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp)
2596 {
2597   return new_bd_Const_type(db, current_ir_graph->start_block, mode, con, tp);
2598 }
2599
2600
2601 ir_node *
2602 new_d_Id (dbg_info *db, ir_node *val, ir_mode *mode)
2603 {
2604   return new_bd_Id(db, current_ir_graph->current_block, val, mode);
2605 }
2606
2607 ir_node *
2608 new_d_Proj (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
2609 {
2610   return new_bd_Proj(db, current_ir_graph->current_block, arg, mode, proj);
2611 }
2612
2613 ir_node *
2614 new_d_defaultProj (dbg_info *db, ir_node *arg, long max_proj)
2615 {
2616   ir_node *res;
2617   assert(arg->op == op_Cond);
2618   arg->attr.c.kind = fragmentary;
2619   arg->attr.c.default_proj = max_proj;
2620   res = new_Proj (arg, mode_X, max_proj);
2621   return res;
2622 }
2623
2624 ir_node *
2625 new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode)
2626 {
2627   return new_bd_Conv(db, current_ir_graph->current_block, op, mode);
2628 }
2629
2630 ir_node *
2631 new_d_Cast (dbg_info *db, ir_node *op, ir_type *to_tp)
2632 {
2633   return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
2634 }
2635
2636 ir_node *
2637 new_d_Tuple (dbg_info *db, int arity, ir_node **in)
2638 {
2639   return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);
2640 }
2641
2642 NEW_D_BINOP(Add)
2643 NEW_D_BINOP(Sub)
2644 NEW_D_UNOP(Minus)
2645 NEW_D_BINOP(Mul)
2646
2647 /**
2648  * allocate the frag array
2649  */
2650 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
2651   if (get_opt_precise_exc_context()) {
2652     if ((current_ir_graph->phase_state == phase_building) &&
2653         (get_irn_op(res) == op) && /* Could be optimized away. */
2654         !*frag_store)    /* Could be a cse where the arr is already set. */ {
2655       *frag_store = new_frag_arr(res);
2656     }
2657   }
2658 }
2659
2660 ir_node *
2661 new_d_Quot (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2662 {
2663   ir_node *res;
2664   res = new_bd_Quot (db, current_ir_graph->current_block, memop, op1, op2);
2665   res->attr.except.pin_state = op_pin_state_pinned;
2666 #if PRECISE_EXC_CONTEXT
2667   allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */
2668 #endif
2669
2670   return res;
2671 }
2672
2673 ir_node *
2674 new_d_DivMod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2675 {
2676   ir_node *res;
2677   res = new_bd_DivMod (db, current_ir_graph->current_block, memop, op1, op2);
2678   res->attr.except.pin_state = op_pin_state_pinned;
2679 #if PRECISE_EXC_CONTEXT
2680   allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2681 #endif
2682
2683   return res;
2684 }
2685
2686 ir_node *
2687 new_d_Div (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2688 {
2689   ir_node *res;
2690   res = new_bd_Div (db, current_ir_graph->current_block, memop, op1, op2);
2691   res->attr.except.pin_state = op_pin_state_pinned;
2692 #if PRECISE_EXC_CONTEXT
2693   allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */
2694 #endif
2695
2696   return res;
2697 }
2698
2699 ir_node *
2700 new_d_Mod (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2)
2701 {
2702   ir_node *res;
2703   res = new_bd_Mod (db, current_ir_graph->current_block, memop, op1, op2);
2704   res->attr.except.pin_state = op_pin_state_pinned;
2705 #if PRECISE_EXC_CONTEXT
2706   allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2707 #endif
2708
2709   return res;
2710 }
2711
2712 NEW_D_BINOP(And)
2713 NEW_D_BINOP(Or)
2714 NEW_D_BINOP(Eor)
2715 NEW_D_UNOP(Not)
2716 NEW_D_BINOP(Shl)
2717 NEW_D_BINOP(Shr)
2718 NEW_D_BINOP(Shrs)
2719 NEW_D_BINOP(Rot)
2720 NEW_D_UNOP(Abs)
2721 NEW_D_BINOP(Carry)
2722 NEW_D_BINOP(Borrow)
2723
2724 ir_node *
2725 new_d_Cmp (dbg_info *db, ir_node *op1, ir_node *op2)
2726 {
2727   return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
2728 }
2729
2730 ir_node *
2731 new_d_Jmp (dbg_info *db)
2732 {
2733   return new_bd_Jmp (db, current_ir_graph->current_block);
2734 }
2735
2736 ir_node *
2737 new_d_IJmp (dbg_info *db, ir_node *tgt)
2738 {
2739   return new_bd_IJmp (db, current_ir_graph->current_block, tgt);
2740 }
2741
2742 ir_node *
2743 new_d_Cond (dbg_info *db, ir_node *c)
2744 {
2745   return new_bd_Cond (db, current_ir_graph->current_block, c);
2746 }
2747
2748 ir_node *
2749 new_d_Call (dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
2750       ir_type *tp)
2751 {
2752   ir_node *res;
2753   res = new_bd_Call (db, current_ir_graph->current_block,
2754              store, callee, arity, in, tp);
2755 #if PRECISE_EXC_CONTEXT
2756   allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */
2757 #endif
2758
2759   return res;
2760 }
2761
2762 ir_node *
2763 new_d_Return (dbg_info *db, ir_node* store, int arity, ir_node **in)
2764 {
2765   return new_bd_Return (db, current_ir_graph->current_block,
2766                store, arity, in);
2767 }
2768
2769 ir_node *
2770 new_d_Load (dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode)
2771 {
2772   ir_node *res;
2773   res = new_bd_Load (db, current_ir_graph->current_block,
2774              store, addr, mode);
2775 #if PRECISE_EXC_CONTEXT
2776   allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
2777 #endif
2778
2779   return res;
2780 }
2781
2782 ir_node *
2783 new_d_Store (dbg_info *db, ir_node *store, ir_node *addr, ir_node *val)
2784 {
2785   ir_node *res;
2786   res = new_bd_Store (db, current_ir_graph->current_block,
2787               store, addr, val);
2788 #if PRECISE_EXC_CONTEXT
2789   allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
2790 #endif
2791
2792   return res;
2793 }
2794
2795 ir_node *
2796 new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
2797            where_alloc where)
2798 {
2799   ir_node *res;
2800   res = new_bd_Alloc (db, current_ir_graph->current_block,
2801               store, size, alloc_type, where);
2802 #if PRECISE_EXC_CONTEXT
2803   allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr);  /* Could be optimized away. */
2804 #endif
2805
2806   return res;
2807 }
2808
2809 ir_node *
2810 new_d_Free (dbg_info *db, ir_node *store, ir_node *ptr,
2811     ir_node *size, ir_type *free_type, where_alloc where)
2812 {
2813   return new_bd_Free (db, current_ir_graph->current_block,
2814              store, ptr, size, free_type, where);
2815 }
2816
2817 ir_node *
2818 new_d_simpleSel (dbg_info *db, ir_node *store, ir_node *objptr, entity *ent)
2819 /* GL: objptr was called frame before.  Frame was a bad choice for the name
2820    as the operand could as well be a pointer to a dynamic object. */
2821 {
2822   return new_bd_Sel (db, current_ir_graph->current_block,
2823             store, objptr, 0, NULL, ent);
2824 }
2825
2826 ir_node *
2827 new_d_Sel (dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
2828 {
2829   return new_bd_Sel (db, current_ir_graph->current_block,
2830             store, objptr, n_index, index, sel);
2831 }
2832
2833 ir_node *
2834 new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp)
2835 {
2836   return new_bd_SymConst_type (db, current_ir_graph->start_block,
2837                          value, kind, tp);
2838 }
2839
2840 ir_node *
2841 new_d_SymConst (dbg_info *db, symconst_symbol value, symconst_kind kind)
2842 {
2843   return new_bd_SymConst (db, current_ir_graph->start_block,
2844                          value, kind);
2845 }
2846
2847 ir_node *
2848 new_d_Sync (dbg_info *db, int arity, ir_node** in)
2849 {
2850   return new_bd_Sync (db, current_ir_graph->current_block, arity, in);
2851 }
2852
2853
2854 ir_node *
2855 (new_d_Bad)(void) {
2856   return _new_d_Bad();
2857 }
2858
2859 ir_node *
2860 new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
2861 {
2862   return new_bd_Confirm (db, current_ir_graph->current_block,
2863              val, bound, cmp);
2864 }
2865
2866 ir_node *
2867 new_d_Unknown (ir_mode *m)
2868 {
2869   return new_bd_Unknown(m);
2870 }
2871
2872 ir_node *
2873 new_d_CallBegin (dbg_info *db, ir_node *call)
2874 {
2875   ir_node *res;
2876   res = new_bd_CallBegin (db, current_ir_graph->current_block, call);
2877   return res;
2878 }
2879
2880 ir_node *
2881 new_d_EndReg (dbg_info *db)
2882 {
2883   ir_node *res;
2884   res = new_bd_EndReg(db, current_ir_graph->current_block);
2885   return res;
2886 }
2887
2888 ir_node *
2889 new_d_EndExcept (dbg_info *db)
2890 {
2891   ir_node *res;
2892   res = new_bd_EndExcept(db, current_ir_graph->current_block);
2893   return res;
2894 }
2895
2896 ir_node *
2897 new_d_Break (dbg_info *db)
2898 {
2899   return new_bd_Break (db, current_ir_graph->current_block);
2900 }
2901
2902 ir_node *
2903 new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
2904 {
2905   return new_bd_Filter (db, current_ir_graph->current_block,
2906             arg, mode, proj);
2907 }
2908
2909 ir_node *
2910 (new_d_NoMem)(void)
2911 {
2912   return _new_d_NoMem();
2913 }
2914
2915 ir_node *
2916 new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
2917     ir_node *ir_true, ir_mode *mode) {
2918   return new_bd_Mux (db, current_ir_graph->current_block,
2919       sel, ir_false, ir_true, mode);
2920 }
2921
2922 ir_node *
2923 new_d_Psi (dbg_info *db,int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
2924   return new_bd_Psi (db, current_ir_graph->current_block,
2925       arity, conds, vals, mode);
2926 }
2927
2928 ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
2929     ir_node *dst, ir_node *src, ir_type *data_type) {
2930   ir_node *res;
2931   res = new_bd_CopyB(db, current_ir_graph->current_block,
2932     store, dst, src, data_type);
2933 #if PRECISE_EXC_CONTEXT
2934   allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
2935 #endif
2936   return res;
2937 }
2938
2939 ir_node *
2940 new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type)
2941 {
2942   return new_bd_InstOf (db, current_ir_graph->current_block,
2943                         store, objptr, type);
2944 }
2945
2946 ir_node *
2947 new_d_Raise (dbg_info *db, ir_node *store, ir_node *obj)
2948 {
2949   return new_bd_Raise (db, current_ir_graph->current_block,
2950               store, obj);
2951 }
2952
2953 ir_node *new_d_Bound(dbg_info *db,ir_node *store,
2954     ir_node *idx, ir_node *lower, ir_node *upper) {
2955   ir_node *res;
2956   res = new_bd_Bound(db, current_ir_graph->current_block,
2957     store, idx, lower, upper);
2958 #if PRECISE_EXC_CONTEXT
2959   allocate_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
2960 #endif
2961   return res;
2962 }
2963
2964 /* ********************************************************************* */
2965 /* Comfortable interface with automatic Phi node construction.           */
2966 /* (Uses also constructors of ?? interface, except new_Block.            */
2967 /* ********************************************************************* */
2968
2969 /*  Block construction */
2970 /* immature Block without predecessors */
2971 ir_node *new_d_immBlock (dbg_info *db) {
2972   ir_node *res;
2973
2974   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2975   /* creates a new dynamic in-array as length of in is -1 */
2976   res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
2977   current_ir_graph->current_block = res;
2978   res->attr.block.matured     = 0;
2979   res->attr.block.dead        = 0;
2980   /* res->attr.block.exc = exc_normal; */
2981   /* res->attr.block.handler_entry = 0; */
2982   res->attr.block.irg         = current_ir_graph;
2983   res->attr.block.backedge    = NULL;
2984   res->attr.block.in_cg       = NULL;
2985   res->attr.block.cg_backedge = NULL;
2986   set_Block_block_visited(res, 0);
2987
2988   /* Create and initialize array for Phi-node construction. */
2989   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
2990                                          current_ir_graph->n_loc);
2991   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
2992
2993   /* Immature block may not be optimized! */
2994   IRN_VRFY_IRG(res, current_ir_graph);
2995
2996   return res;
2997 }
2998
2999 ir_node *
3000 new_immBlock (void) {
3001   return new_d_immBlock(NULL);
3002 }
3003
3004 /* add an edge to a jmp/control flow node */
3005 void
3006 add_immBlock_pred (ir_node *block, ir_node *jmp)
3007 {
3008   if (block->attr.block.matured) {
3009     assert(0 && "Error: Block already matured!\n");
3010   }
3011   else {
3012     assert(jmp != NULL);
3013     ARR_APP1(ir_node *, block->in, jmp);
3014   }
3015 }
3016
3017 /* changing the current block */
3018 void
3019 set_cur_block (ir_node *target) {
3020   current_ir_graph->current_block = target;
3021 }
3022
3023 /* ************************ */
3024 /* parameter administration */
3025
3026 /* get a value from the parameter array from the current block by its index */
3027 ir_node *
3028 get_d_value (dbg_info *db, int pos, ir_mode *mode)
3029 {
3030   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3031   inc_irg_visited(current_ir_graph);
3032
3033   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
3034 }
3035 /* get a value from the parameter array from the current block by its index */
3036 ir_node *
3037 get_value (int pos, ir_mode *mode)
3038 {
3039   return get_d_value(NULL, pos, mode);
3040 }
3041
3042 /* set a value at position pos in the parameter array from the current block */
3043 void
3044 set_value (int pos, ir_node *value)
3045 {
3046   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3047   assert(pos+1 < current_ir_graph->n_loc);
3048   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
3049 }
3050
3051 int
3052 find_value(ir_node *value)
3053 {
3054   int i;
3055   ir_node *bl = current_ir_graph->current_block;
3056
3057   for (i = 1; i < ARR_LEN(bl->attr.block.graph_arr); ++i)
3058     if (bl->attr.block.graph_arr[i] == value)
3059       return i - 1;
3060   return -1;
3061 }
3062
3063 /* get the current store */
3064 ir_node *
3065 get_store (void)
3066 {
3067   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3068   /* GL: one could call get_value instead */
3069   inc_irg_visited(current_ir_graph);
3070   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
3071 }
3072
3073 /* set the current store */
3074 void
3075 set_store (ir_node *store)
3076 {
3077   /* GL: one could call set_value instead */
3078   assert(get_irg_phase_state (current_ir_graph) == phase_building);
3079   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
3080 }
3081
3082 void
3083 keep_alive (ir_node *ka) {
3084   add_End_keepalive(current_ir_graph->end, ka);
3085 }
3086
3087 /* --- Useful access routines --- */
3088 /* Returns the current block of the current graph.  To set the current
3089    block use set_cur_block. */
3090 ir_node *get_cur_block(void) {
3091   return get_irg_current_block(current_ir_graph);
3092 }
3093
3094 /* Returns the frame type of the current graph */
3095 ir_type *get_cur_frame_type(void) {
3096   return get_irg_frame_type(current_ir_graph);
3097 }
3098
3099
3100 /* ********************************************************************* */
3101 /* initialize */
3102
3103 /* call once for each run of the library */
3104 void
3105 init_cons(uninitialized_local_variable_func_t *func)
3106 {
3107   default_initialize_local_variable = func;
3108 }
3109
3110 /* call for each graph */
3111 void
3112 irg_finalize_cons (ir_graph *irg) {
3113   irg->phase_state = phase_high;
3114 }
3115
3116 void
3117 irp_finalize_cons (void) {
3118   int i, n_irgs = get_irp_n_irgs();
3119   for (i = 0; i < n_irgs; i++) {
3120     irg_finalize_cons(get_irp_irg(i));
3121   }
3122   irp->phase_state = phase_high;
3123 }
3124
3125
3126 ir_node *new_Block(int arity, ir_node **in) {
3127   return new_d_Block(NULL, arity, in);
3128 }
3129 ir_node *new_Start  (void) {
3130   return new_d_Start(NULL);
3131 }
3132 ir_node *new_End    (void) {
3133   return new_d_End(NULL);
3134 }
3135 ir_node *new_Jmp    (void) {
3136   return new_d_Jmp(NULL);
3137 }
3138 ir_node *new_IJmp   (ir_node *tgt) {
3139   return new_d_IJmp(NULL, tgt);
3140 }
3141 ir_node *new_Cond   (ir_node *c) {
3142   return new_d_Cond(NULL, c);
3143 }
3144 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
3145   return new_d_Return(NULL, store, arity, in);
3146 }
3147 ir_node *new_Const  (ir_mode *mode, tarval *con) {
3148   return new_d_Const(NULL, mode, con);
3149 }
3150
3151 ir_node *new_Const_long(ir_mode *mode, long value)
3152 {
3153     return new_d_Const_long(NULL, mode, value);
3154 }
3155
3156 ir_node *new_Const_type(tarval *con, ir_type *tp) {
3157   return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
3158 }
3159
3160 ir_node *new_SymConst (symconst_symbol value, symconst_kind kind) {
3161   return new_d_SymConst(NULL, value, kind);
3162 }
3163 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, entity *ent) {
3164   return new_d_simpleSel(NULL, store, objptr, ent);
3165 }
3166 ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
3167                      entity *ent) {
3168   return new_d_Sel(NULL, store, objptr, arity, in, ent);
3169 }
3170 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
3171              ir_type *tp) {
3172   return new_d_Call(NULL, store, callee, arity, in, tp);
3173 }
3174 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3175   return new_d_Add(NULL, op1, op2, mode);
3176 }
3177 ir_node *new_Sub    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3178   return new_d_Sub(NULL, op1, op2, mode);
3179 }
3180 ir_node *new_Minus  (ir_node *op,  ir_mode *mode) {
3181   return new_d_Minus(NULL, op, mode);
3182 }
3183 ir_node *new_Mul    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3184   return new_d_Mul(NULL, op1, op2, mode);
3185 }
3186 ir_node *new_Quot   (ir_node *memop, ir_node *op1, ir_node *op2) {
3187   return new_d_Quot(NULL, memop, op1, op2);
3188 }
3189 ir_node *new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2) {
3190   return new_d_DivMod(NULL, memop, op1, op2);
3191 }
3192 ir_node *new_Div    (ir_node *memop, ir_node *op1, ir_node *op2) {
3193   return new_d_Div(NULL, memop, op1, op2);
3194 }
3195 ir_node *new_Mod    (ir_node *memop, ir_node *op1, ir_node *op2) {
3196   return new_d_Mod(NULL, memop, op1, op2);
3197 }
3198 ir_node *new_Abs    (ir_node *op, ir_mode *mode) {
3199   return new_d_Abs(NULL, op, mode);
3200 }
3201 ir_node *new_And    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3202   return new_d_And(NULL, op1, op2, mode);
3203 }
3204 ir_node *new_Or     (ir_node *op1, ir_node *op2, ir_mode *mode) {
3205   return new_d_Or(NULL, op1, op2, mode);
3206 }
3207 ir_node *new_Eor    (ir_node *op1, ir_node *op2, ir_mode *mode) {
3208   return new_d_Eor(NULL, op1, op2, mode);
3209 }
3210 ir_node *new_Not    (ir_node *op,                ir_mode *mode) {
3211   return new_d_Not(NULL, op, mode);
3212 }
3213 ir_node *new_Shl    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3214   return new_d_Shl(NULL, op, k, mode);
3215 }
3216 ir_node *new_Shr    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3217   return new_d_Shr(NULL, op, k, mode);
3218 }
3219 ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *mode) {
3220   return new_d_Shrs(NULL, op, k, mode);
3221 }
3222 ir_node *new_Rot    (ir_node *op,  ir_node *k,   ir_mode *mode) {
3223   return new_d_Rot(NULL, op, k, mode);
3224 }
3225 ir_node *new_Carry  (ir_node *op1, ir_node *op2, ir_mode *mode) {
3226   return new_d_Carry(NULL, op1, op2, mode);
3227 }
3228 ir_node *new_Borrow (ir_node *op1, ir_node *op2, ir_mode *mode) {
3229   return new_d_Borrow(NULL, op1, op2, mode);
3230 }
3231 ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
3232   return new_d_Cmp(NULL, op1, op2);
3233 }
3234 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
3235   return new_d_Conv(NULL, op, mode);
3236 }
3237 ir_node *new_Cast   (ir_node *op, ir_type *to_tp) {
3238   return new_d_Cast(NULL, op, to_tp);
3239 }
3240 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
3241   return new_d_Phi(NULL, arity, in, mode);
3242 }
3243 ir_node *new_Load   (ir_node *store, ir_node *addr, ir_mode *mode) {
3244   return new_d_Load(NULL, store, addr, mode);
3245 }
3246 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
3247   return new_d_Store(NULL, store, addr, val);
3248 }
3249 ir_node *new_Alloc  (ir_node *store, ir_node *size, ir_type *alloc_type,
3250                      where_alloc where) {
3251   return new_d_Alloc(NULL, store, size, alloc_type, where);
3252 }
3253 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,
3254              ir_type *free_type, where_alloc where) {
3255   return new_d_Free(NULL, store, ptr, size, free_type, where);
3256 }
3257 ir_node *new_Sync   (int arity, ir_node **in) {
3258   return new_d_Sync(NULL, arity, in);
3259 }
3260 ir_node *new_Proj   (ir_node *arg, ir_mode *mode, long proj) {
3261   return new_d_Proj(NULL, arg, mode, proj);
3262 }
3263 ir_node *new_defaultProj (ir_node *arg, long max_proj) {
3264   return new_d_defaultProj(NULL, arg, max_proj);
3265 }
3266 ir_node *new_Tuple  (int arity, ir_node **in) {
3267   return new_d_Tuple(NULL, arity, in);
3268 }
3269 ir_node *new_Id     (ir_node *val, ir_mode *mode) {
3270   return new_d_Id(NULL, val, mode);
3271 }
3272 ir_node *new_Bad    (void) {
3273   return new_d_Bad();
3274 }
3275 ir_node *new_Confirm (ir_node *val, ir_node *bound, pn_Cmp cmp) {
3276   return new_d_Confirm (NULL, val, bound, cmp);
3277 }
3278 ir_node *new_Unknown(ir_mode *m) {
3279   return new_d_Unknown(m);
3280 }
3281 ir_node *new_CallBegin (ir_node *callee) {
3282   return new_d_CallBegin(NULL, callee);
3283 }
3284 ir_node *new_EndReg (void) {
3285   return new_d_EndReg(NULL);
3286 }
3287 ir_node *new_EndExcept (void) {
3288   return new_d_EndExcept(NULL);
3289 }
3290 ir_node *new_Break  (void) {
3291   return new_d_Break(NULL);
3292 }
3293 ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
3294   return new_d_Filter(NULL, arg, mode, proj);
3295 }
3296 ir_node *new_NoMem  (void) {
3297   return new_d_NoMem();
3298 }
3299 ir_node *new_Mux (ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
3300   return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
3301 }
3302 ir_node *new_Psi (int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
3303   return new_d_Psi(NULL, arity, conds, vals, mode);
3304 }
3305 ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
3306   return new_d_CopyB(NULL, store, dst, src, data_type);
3307 }
3308 ir_node *new_InstOf (ir_node *store, ir_node *objptr, ir_type *ent) {
3309   return new_d_InstOf (NULL, store, objptr, ent);
3310 }
3311 ir_node *new_Raise  (ir_node *store, ir_node *obj) {
3312   return new_d_Raise(NULL, store, obj);
3313 }
3314 ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
3315   return new_d_Bound(NULL, store, idx, lower, upper);
3316 }