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