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