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