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