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