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

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