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