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