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