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

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