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_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
 719 {
 720   ir_node *in[2], *res;
 721   in[0] = val;
 722   in[1] = bound;
 723
 724   res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
 725
 726   res->attr.confirm_cmp = cmp;
 727
 728   res = optimize_node (res);
 729   irn_vrfy_irg(res, irg);
 730   return res;
 731 }
 732
 733 INLINE ir_node *
 734 new_rd_Unknown (ir_graph *irg)
 735 {
 736   return irg->unknown;
 737 }
 738
 739 INLINE ir_node *
 740 new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
 741 {
 742   ir_node *in[1];
 743   ir_node *res;
 744   in[0] = get_Call_ptr(call);
 745   res = new_ir_node (db, irg, block, op_CallBegin, mode_T, 1, in);
 746   res->attr.callbegin.irg = irg;
 747   res->attr.callbegin.call = call;
 748   res = optimize_node (res);
 749   irn_vrfy_irg (res, irg);
 750   return res;
 751 }
 752
 753 INLINE ir_node *
 754 new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
 755 {
 756   ir_node *res;
 757
 758   res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL);
 759   res->attr.end.irg = irg;
 760
 761   irn_vrfy_irg (res, irg);
 762   return res;
 763 }
 764
 765 INLINE ir_node *
 766 new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
 767 {
 768   ir_node *res;
 769
 770   res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL);
 771   res->attr.end.irg = irg;
 772
 773   irn_vrfy_irg (res, irg);
 774   return res;
 775 }
 776
 777 INLINE ir_node *
 778 new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
 779 {
 780   ir_node *res;
 781   res = new_ir_node (db, irg, block, op_Break, mode_X, 0, NULL);
 782   res = optimize_node (res);
 783   irn_vrfy_irg (res, irg);
 784   return res;
 785 }
 786
 787 INLINE ir_node *
 788 new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
 789                long proj)
 790 {
 791   ir_node *in[1];
 792   ir_node *res;
 793   in[0] = arg;
 794   res = new_ir_node (db, irg, block, op_Filter, mode, 1, in);
 795   res->attr.filter.proj = proj;
 796   res->attr.filter.in_cg = NULL;
 797   res->attr.filter.backedge = NULL;
 798
 799   assert(res);
 800   assert(get_Proj_pred(res));
 801   assert(get_nodes_Block(get_Proj_pred(res)));
 802
 803   res = optimize_node (res);
 804
 805   irn_vrfy_irg (res, irg);
 806   return res;
 807
 808 }
 809
 810 INLINE ir_node *new_r_Block  (ir_graph *irg,  int arity, ir_node **in) {
 811   return new_rd_Block(NULL, irg, arity, in);
 812 }
 813 INLINE ir_node *new_r_Start  (ir_graph *irg, ir_node *block) {
 814   return new_rd_Start(NULL, irg, block);
 815 }
 816 INLINE ir_node *new_r_End    (ir_graph *irg, ir_node *block) {
 817   return new_rd_End(NULL, irg, block);
 818 }
 819 INLINE ir_node *new_r_Jmp    (ir_graph *irg, ir_node *block) {
 820   return new_rd_Jmp(NULL, irg, block);
 821 }
 822 INLINE ir_node *new_r_Cond   (ir_graph *irg, ir_node *block, ir_node *c) {
 823   return new_rd_Cond(NULL, irg, block, c);
 824 }
 825 INLINE ir_node *new_r_Return (ir_graph *irg, ir_node *block,
 826                        ir_node *store, int arity, ir_node **in) {
 827   return new_rd_Return(NULL, irg, block, store, arity, in);
 828 }
 829 INLINE ir_node *new_r_Raise  (ir_graph *irg, ir_node *block,
 830                        ir_node *store, ir_node *obj) {
 831   return new_rd_Raise(NULL, irg, block, store, obj);
 832 }
 833 INLINE ir_node *new_r_Const  (ir_graph *irg, ir_node *block,
 834                        ir_mode *mode, tarval *con) {
 835   return new_rd_Const(NULL, irg, block, mode, con);
 836 }
 837 INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
 838                        type_or_id_p value, symconst_kind symkind) {
 839   return new_rd_SymConst(NULL, irg, block, value, symkind);
 840 }
 841 INLINE ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
 842                        ir_node *objptr, int n_index, ir_node **index,
 843                        entity *ent) {
 844   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
 845 }
 846 INLINE ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
 847                                            type *ent) {
 848   return (new_rd_InstOf (NULL, irg, block, store, objptr, ent));
 849 }
 850 INLINE ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
 851                        ir_node *callee, int arity, ir_node **in,
 852                        type *tp) {
 853   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
 854 }
 855 INLINE ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
 856                        ir_node *op1, ir_node *op2, ir_mode *mode) {
 857   return new_rd_Add(NULL, irg, block, op1, op2, mode);
 858 }
 859 INLINE ir_node *new_r_Sub    (ir_graph *irg, ir_node *block,
 860                        ir_node *op1, ir_node *op2, ir_mode *mode) {
 861   return new_rd_Sub(NULL, irg, block, op1, op2, mode);
 862 }
 863 INLINE ir_node *new_r_Minus  (ir_graph *irg, ir_node *block,
 864                        ir_node *op,  ir_mode *mode) {
 865   return new_rd_Minus(NULL, irg, block,  op, mode);
 866 }
 867 INLINE ir_node *new_r_Mul    (ir_graph *irg, ir_node *block,
 868                                            ir_node *op1, ir_node *op2, ir_mode *mode) {
 869   return new_rd_Mul(NULL, irg, block, op1, op2, mode);
 870 }
 871 INLINE ir_node *new_r_Quot   (ir_graph *irg, ir_node *block,
 872                        ir_node *memop, ir_node *op1, ir_node *op2) {
 873   return new_rd_Quot(NULL, irg, block, memop, op1, op2);
 874 }
 875 INLINE ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
 876                        ir_node *memop, ir_node *op1, ir_node *op2) {
 877   return new_rd_DivMod(NULL, irg, block, memop, op1, op2);
 878 }
 879 INLINE ir_node *new_r_Div    (ir_graph *irg, ir_node *block,
 880                        ir_node *memop, ir_node *op1, ir_node *op2) {
 881   return new_rd_Div(NULL, irg, block, memop, op1, op2);
 882 }
 883 INLINE ir_node *new_r_Mod    (ir_graph *irg, ir_node *block,
 884                        ir_node *memop, ir_node *op1, ir_node *op2) {
 885   return new_rd_Mod(NULL, irg, block, memop, op1, op2);
 886 }
 887 INLINE ir_node *new_r_Abs    (ir_graph *irg, ir_node *block,
 888                        ir_node *op, ir_mode *mode) {
 889   return new_rd_Abs(NULL, irg, block, op, mode);
 890 }
 891 INLINE ir_node *new_r_And    (ir_graph *irg, ir_node *block,
 892                        ir_node *op1, ir_node *op2, ir_mode *mode) {
 893   return new_rd_And(NULL, irg, block,  op1, op2, mode);
 894 }
 895 INLINE ir_node *new_r_Or     (ir_graph *irg, ir_node *block,
 896                        ir_node *op1, ir_node *op2, ir_mode *mode) {
 897   return new_rd_Or(NULL, irg, block,  op1, op2, mode);
 898 }
 899 INLINE ir_node *new_r_Eor    (ir_graph *irg, ir_node *block,
 900                        ir_node *op1, ir_node *op2, ir_mode *mode) {
 901   return new_rd_Eor(NULL, irg, block,  op1, op2, mode);
 902 }
 903 INLINE ir_node *new_r_Not    (ir_graph *irg, ir_node *block,
 904                        ir_node *op, ir_mode *mode) {
 905   return new_rd_Not(NULL, irg, block, op, mode);
 906 }
 907 INLINE ir_node *new_r_Cmp    (ir_graph *irg, ir_node *block,
 908                        ir_node *op1, ir_node *op2) {
 909   return new_rd_Cmp(NULL, irg, block, op1, op2);
 910 }
 911 INLINE ir_node *new_r_Shl    (ir_graph *irg, ir_node *block,
 912                        ir_node *op, ir_node *k, ir_mode *mode) {
 913   return new_rd_Shl(NULL, irg, block, op, k, mode);
 914 }
 915 INLINE ir_node *new_r_Shr    (ir_graph *irg, ir_node *block,
 916                        ir_node *op, ir_node *k, ir_mode *mode) {
 917   return new_rd_Shr(NULL, irg, block, op, k, mode);
 918 }
 919 INLINE ir_node *new_r_Shrs   (ir_graph *irg, ir_node *block,
 920                        ir_node *op, ir_node *k, ir_mode *mode) {
 921   return new_rd_Shrs(NULL, irg, block, op, k, mode);
 922 }
 923 INLINE ir_node *new_r_Rot    (ir_graph *irg, ir_node *block,
 924                        ir_node *op, ir_node *k, ir_mode *mode) {
 925   return new_rd_Rot(NULL, irg, block, op, k, mode);
 926 }
 927 INLINE ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
 928                        ir_node *op, ir_mode *mode) {
 929   return new_rd_Conv(NULL, irg, block, op, mode);
 930 }
 931 INLINE ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
 932   return new_rd_Cast(NULL, irg, block, op, to_tp);
 933 }
 934 INLINE ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
 935                        ir_node **in, ir_mode *mode) {
 936   return new_rd_Phi(NULL, irg, block, arity, in, mode);
 937 }
 938 INLINE ir_node *new_r_Load   (ir_graph *irg, ir_node *block,
 939                        ir_node *store, ir_node *adr) {
 940   return new_rd_Load(NULL, irg, block, store, adr);
 941 }
 942 INLINE ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
 943                        ir_node *store, ir_node *adr, ir_node *val) {
 944   return new_rd_Store(NULL, irg, block, store, adr, val);
 945 }
 946 INLINE ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,
 947                        ir_node *size, type *alloc_type, where_alloc where) {
 948   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
 949 }
 950 INLINE ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,
 951                        ir_node *ptr, ir_node *size, type *free_type) {
 952   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type);
 953 }
 954 INLINE ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
 955   return new_rd_Sync(NULL, irg, block, arity, in);
 956 }
 957 INLINE ir_node *new_r_Proj   (ir_graph *irg, ir_node *block, ir_node *arg,
 958                        ir_mode *mode, long proj) {
 959   return new_rd_Proj(NULL, irg, block, arg, mode, proj);
 960 }
 961 INLINE ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
 962                             long max_proj) {
 963   return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
 964 }
 965 INLINE ir_node *new_r_Tuple  (ir_graph *irg, ir_node *block,
 966                        int arity, ir_node **in) {
 967   return new_rd_Tuple(NULL, irg, block, arity, in );
 968 }
 969 INLINE ir_node *new_r_Id     (ir_graph *irg, ir_node *block,
 970                        ir_node *val, ir_mode *mode) {
 971   return new_rd_Id(NULL, irg, block, val, mode);
 972 }
 973 INLINE ir_node *new_r_Bad    (ir_graph *irg) {
 974   return new_rd_Bad(irg);
 975 }
 976 INLINE ir_node *new_r_Confirm (ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
 977   return new_rd_Confirm (NULL, irg, block, val, bound, cmp);
 978 }
 979 INLINE ir_node *new_r_Unknown (ir_graph *irg) {
 980   return new_rd_Unknown(irg);
 981 }
 982 INLINE ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
 983   return new_rd_CallBegin(NULL, irg, block, callee);
 984 }
 985 INLINE ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
 986   return new_rd_EndReg(NULL, irg, block);
 987 }
 988 INLINE ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
 989   return new_rd_EndExcept(NULL, irg, block);
 990 }
 991 INLINE ir_node *new_r_Break  (ir_graph *irg, ir_node *block) {
 992   return new_rd_Break(NULL, irg, block);
 993 }
 994 INLINE ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
 995                        ir_mode *mode, long proj) {
 996   return new_rd_Filter(NULL, irg, block, arg, mode, proj);
 997 }
 998
 999
1000 /** ********************/
1001 /** public interfaces  */
1002 /** construction tools */
1003
1004 /**
1005  *
1006  *   - create a new Start node in the current block
1007  *
1008  *   @return s - pointer to the created Start node
1009  *
1010  *
1011  */
1012 ir_node *
1013 new_d_Start (dbg_info* db)
1014 {
1015   ir_node *res;
1016
1017   res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
1018                      op_Start, mode_T, 0, NULL);
1019   res->attr.start.irg = current_ir_graph;
1020
1021   res = optimize_node (res);
1022   irn_vrfy_irg (res, current_ir_graph);
1023   return res;
1024 }
1025
1026 ir_node *
1027 new_d_End (dbg_info* db)
1028 {
1029   ir_node *res;
1030   res = new_ir_node (db, current_ir_graph,  current_ir_graph->current_block,
1031                      op_End, mode_X, -1, NULL);
1032   res = optimize_node (res);
1033   irn_vrfy_irg (res, current_ir_graph);
1034
1035   return res;
1036 }
1037
1038 /* Constructs a Block with a fixed number of predecessors.
1039    Does set current_block.  Can be used with automatic Phi
1040    node construction. */
1041 ir_node *
1042 new_d_Block (dbg_info* db, int arity, ir_node **in)
1043 {
1044   ir_node *res;
1045   int i;
1046   bool has_unknown = false;
1047
1048   res = new_rd_Block (db, current_ir_graph, arity, in);
1049
1050   /* Create and initialize array for Phi-node construction. */
1051   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
1052                                          current_ir_graph->n_loc);
1053   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1054
1055   for (i = arity-1; i >= 0; i--) if (get_irn_op(in[i]) == op_Unknown) has_unknown = true;
1056
1057   if (!has_unknown) res = optimize_node (res);
1058   current_ir_graph->current_block = res;
1059
1060   irn_vrfy_irg (res, current_ir_graph);
1061
1062   return res;
1063 }
1064
1065 /* ***********************************************************************/
1066 /* Methods necessary for automatic Phi node creation                     */
1067 /*
1068   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1069   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1070   ir_node *new_rd_Phi0           (ir_graph *irg, ir_node *block, ir_mode *mode)
1071   ir_node *new_rd_Phi_in         (ir_graph *irg, ir_node *block, ir_mode *mode,  ir_node **in, int ins)
1072
1073   Call Graph:   ( A ---> B == A "calls" B)
1074
1075        get_value         mature_block
1076           |                   |
1077           |                   |
1078           |                   |
1079           |          ---> phi_merge
1080           |         /       /   \
1081           |        /       /     \
1082          \|/      /      |/_      \
1083        get_r_value_internal        |
1084                 |                  |
1085                 |                  |
1086                \|/                \|/
1087             new_rd_Phi0          new_rd_Phi_in
1088
1089 * *************************************************************************** */
1090
1091 /* Creates a Phi node with 0 predecessors */
1092 static INLINE ir_node *
1093 new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
1094 {
1095   ir_node *res;
1096   res = new_ir_node (NULL, irg, block, op_Phi, mode, 0, NULL);
1097   irn_vrfy_irg (res, irg);
1098   return res;
1099 }
1100
1101 /* There are two implementations of the Phi node construction.  The first
1102    is faster, but does not work for blocks with more than 2 predecessors.
1103    The second works always but is slower and causes more unnecessary Phi
1104    nodes.
1105    Select the implementations by the following preprocessor flag set in
1106    common/common.h: */
1107 #if USE_FAST_PHI_CONSTRUCTION
1108
1109 /* This is a stack used for allocating and deallocating nodes in
1110    new_rd_Phi_in.  The original implementation used the obstack
1111    to model this stack, now it is explicit.  This reduces side effects.
1112 */
1113 #if USE_EXPLICIT_PHI_IN_STACK
1114 INLINE Phi_in_stack *
1115 new_Phi_in_stack() {
1116   Phi_in_stack *res;
1117
1118   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
1119
1120   res->stack = NEW_ARR_F (ir_node *, 1);
1121   res->pos = 0;
1122
1123   return res;
1124 }
1125
1126 INLINE void
1127 free_Phi_in_stack(Phi_in_stack *s) {
1128   DEL_ARR_F(s->stack);
1129   free(s);
1130 }
1131 static INLINE void
1132 free_to_Phi_in_stack(ir_node *phi) {
1133   assert(get_irn_opcode(phi) == iro_Phi);
1134
1135   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
1136       current_ir_graph->Phi_in_stack->pos)
1137     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
1138   else
1139     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
1140
1141   (current_ir_graph->Phi_in_stack->pos)++;
1142 }
1143
1144 static INLINE ir_node *
1145 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
1146              int arity, ir_node **in) {
1147   ir_node *res;
1148   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
1149   int pos = current_ir_graph->Phi_in_stack->pos;
1150
1151
1152   if (pos == 0) {
1153     /* We need to allocate a new node */
1154     res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
1155     res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
1156   } else {
1157     /* reuse the old node and initialize it again. */
1158     res = stack[pos-1];
1159
1160     assert (res->kind == k_ir_node);
1161     assert (res->op == op_Phi);
1162     res->mode = mode;
1163     res->visited = 0;
1164     res->link = NULL;
1165     assert (arity >= 0);
1166     /* ???!!! How to free the old in array??  Not at all: on obstack ?!! */
1167     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
1168     res->in[0] = block;
1169     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
1170
1171     (current_ir_graph->Phi_in_stack->pos)--;
1172   }
1173   return res;
1174 }
1175 #endif /* USE_EXPLICIT_PHI_IN_STACK */
1176
1177 /* Creates a Phi node with a given, fixed array **in of predecessors.
1178    If the Phi node is unnecessary, as the same value reaches the block
1179    through all control flow paths, it is eliminated and the value
1180    returned directly.  This constructor is only intended for use in
1181    the automatic Phi node generation triggered by get_value or mature.
1182    The implementation is quite tricky and depends on the fact, that
1183    the nodes are allocated on a stack:
1184    The in array contains predecessors and NULLs.  The NULLs appear,
1185    if get_r_value_internal, that computed the predecessors, reached
1186    the same block on two paths.  In this case the same value reaches
1187    this block on both paths, there is no definition in between.  We need
1188    not allocate a Phi where these path's merge, but we have to communicate
1189    this fact to the caller.  This happens by returning a pointer to the
1190    node the caller _will_ allocate.  (Yes, we predict the address. We can
1191    do so because the nodes are allocated on the obstack.)  The caller then
1192    finds a pointer to itself and, when this routine is called again,
1193    eliminates itself.
1194    */
1195 static INLINE ir_node *
1196 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
1197               ir_node **in, int ins)
1198 {
1199   int i;
1200   ir_node *res, *known;
1201
1202   /* allocate a new node on the obstack.
1203      This can return a node to which some of the pointers in the in-array
1204      already point.
1205      Attention: the constructor copies the in array, i.e., the later changes
1206      to the array in this routine do not affect the constructed node!  If
1207      the in array contains NULLs, there will be missing predecessors in the
1208      returned node.
1209      Is this a possible internal state of the Phi node generation? */
1210 #if USE_EXPLICIT_PHI_IN_STACK
1211   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
1212 #else
1213   res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
1214   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
1215 #endif
1216   /* The in-array can contain NULLs.  These were returned by
1217      get_r_value_internal if it reached the same block/definition on a
1218      second path.
1219      The NULLs are replaced by the node itself to simplify the test in the
1220      next loop. */
1221   for (i=0;  i < ins;  ++i)
1222     if (in[i] == NULL) in[i] = res;
1223
1224   /* This loop checks whether the Phi has more than one predecessor.
1225      If so, it is a real Phi node and we break the loop.  Else the
1226      Phi node merges the same definition on several paths and therefore
1227      is not needed. */
1228   for (i=0;  i < ins;  ++i)
1229   {
1230     if (in[i]==res || in[i]==known) continue;
1231
1232     if (known==res)
1233       known = in[i];
1234     else
1235       break;
1236   }
1237
1238   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1239   if (i==ins) {
1240 #if USE_EXPLICIT_PHI_IN_STACK
1241     free_to_Phi_in_stack(res);
1242 #else
1243     obstack_free (current_ir_graph->obst, res);
1244 #endif
1245     res = known;
1246   } else {
1247     res = optimize_node (res);
1248     irn_vrfy_irg (res, irg);
1249   }
1250
1251   /* return the pointer to the Phi node.  This node might be deallocated! */
1252   return res;
1253 }
1254
1255 static ir_node *
1256 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1257
1258 /**
1259     allocates and returns this node.  The routine called to allocate the
1260     node might optimize it away and return a real value, or even a pointer
1261     to a deallocated Phi node on top of the obstack!
1262     This function is called with an in-array of proper size. **/
1263 static ir_node *
1264 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1265 {
1266   ir_node *prevBlock, *res;
1267   int i;
1268
1269   /* This loop goes to all predecessor blocks of the block the Phi node is in
1270      and there finds the operands of the Phi node by calling
1271      get_r_value_internal. */
1272   for (i = 1;  i <= ins;  ++i) {
1273     assert (block->in[i]);
1274     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1275     assert (prevBlock);
1276     nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1277   }
1278
1279   /* After collecting all predecessors into the array nin a new Phi node
1280      with these predecessors is created.  This constructor contains an
1281      optimization: If all predecessors of the Phi node are identical it
1282      returns the only operand instead of a new Phi node.  If the value
1283      passes two different control flow edges without being defined, and
1284      this is the second path treated, a pointer to the node that will be
1285      allocated for the first path (recursion) is returned.  We already
1286      know the address of this node, as it is the next node to be allocated
1287      and will be placed on top of the obstack. (The obstack is a _stack_!) */
1288   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
1289
1290   /* Now we now the value for "pos" and can enter it in the array with
1291      all known local variables.  Attention: this might be a pointer to
1292      a node, that later will be allocated!!! See new_rd_Phi_in.
1293      If this is called in mature, after some set_value in the same block,
1294      the proper value must not be overwritten:
1295      The call order
1296        get_value    (makes Phi0, put's it into graph_arr)
1297        set_value    (overwrites Phi0 in graph_arr)
1298        mature_block (upgrades Phi0, puts it again into graph_arr, overwriting
1299                      the proper value.)
1300      fails. */
1301   if (!block->attr.block.graph_arr[pos]) {
1302     block->attr.block.graph_arr[pos] = res;
1303   } else {
1304     /*  printf(" value already computed by %s\n",
1305         get_id_str(block->attr.block.graph_arr[pos]->op->name));  */
1306   }
1307
1308   return res;
1309 }
1310
1311 /* This function returns the last definition of a variable.  In case
1312    this variable was last defined in a previous block, Phi nodes are
1313    inserted.  If the part of the firm graph containing the definition
1314    is not yet constructed, a dummy Phi node is returned. */
1315 static ir_node *
1316 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
1317 {
1318   ir_node *res;
1319   /* There are 4 cases to treat.
1320
1321      1. The block is not mature and we visit it the first time.  We can not
1322         create a proper Phi node, therefore a Phi0, i.e., a Phi without
1323         predecessors is returned.  This node is added to the linked list (field
1324         "link") of the containing block to be completed when this block is
1325         matured. (Completion will add a new Phi and turn the Phi0 into an Id
1326         node.)
1327
1328      2. The value is already known in this block, graph_arr[pos] is set and we
1329         visit the block the first time.  We can return the value without
1330         creating any new nodes.
1331
1332      3. The block is mature and we visit it the first time.  A Phi node needs
1333         to be created (phi_merge).  If the Phi is not needed, as all it's
1334         operands are the same value reaching the block through different
1335         paths, it's optimized away and the value itself is returned.
1336
1337      4. The block is mature, and we visit it the second time.  Now two
1338         subcases are possible:
1339         * The value was computed completely the last time we were here. This
1340           is the case if there is no loop.  We can return the proper value.
1341         * The recursion that visited this node and set the flag did not
1342           return yet.  We are computing a value in a loop and need to
1343           break the recursion without knowing the result yet.
1344           @@@ strange case.  Straight forward we would create a Phi before
1345           starting the computation of it's predecessors.  In this case we will
1346           find a Phi here in any case.  The problem is that this implementation
1347           only creates a Phi after computing the predecessors, so that it is
1348           hard to compute self references of this Phi.  @@@
1349         There is no simple check for the second subcase.  Therefore we check
1350         for a second visit and treat all such cases as the second subcase.
1351         Anyways, the basic situation is the same:  we reached a block
1352         on two paths without finding a definition of the value:  No Phi
1353         nodes are needed on both paths.
1354         We return this information "Two paths, no Phi needed" by a very tricky
1355         implementation that relies on the fact that an obstack is a stack and
1356         will return a node with the same address on different allocations.
1357         Look also at phi_merge and new_rd_phi_in to understand this.
1358         @@@ Unfortunately this does not work, see testprogram
1359         three_cfpred_example.
1360
1361   */
1362
1363   /* case 4 -- already visited. */
1364   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
1365
1366   /* visited the first time */
1367   set_irn_visited(block, get_irg_visited(current_ir_graph));
1368
1369   /* Get the local valid value */
1370   res = block->attr.block.graph_arr[pos];
1371
1372   /* case 2 -- If the value is actually computed, return it. */
1373   if (res) { return res;};
1374
1375   if (block->attr.block.matured) { /* case 3 */
1376
1377     /* The Phi has the same amount of ins as the corresponding block. */
1378     int ins = get_irn_arity(block);
1379     ir_node **nin;
1380     NEW_ARR_A (ir_node *, nin, ins);
1381
1382     /* Phi merge collects the predecessors and then creates a node. */
1383     res = phi_merge (block, pos, mode, nin, ins);
1384
1385   } else {  /* case 1 */
1386     /* The block is not mature, we don't know how many in's are needed.  A Phi
1387        with zero predecessors is created.  Such a Phi node is called Phi0
1388        node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
1389        to the list of Phi0 nodes in this block to be matured by mature_block
1390        later.
1391        The Phi0 has to remember the pos of it's internal value.  If the real
1392        Phi is computed, pos is used to update the array with the local
1393        values. */
1394
1395     res = new_rd_Phi0 (current_ir_graph, block, mode);
1396     res->attr.phi0_pos = pos;
1397     res->link = block->link;
1398     block->link = res;
1399   }
1400
1401   /* If we get here, the frontend missed a use-before-definition error */
1402   if (!res) {
1403     /* Error Message */
1404     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
1405     assert (mode->code >= irm_F && mode->code <= irm_P);
1406     res = new_rd_Const (NULL, current_ir_graph, block, mode,
1407                        tarval_mode_null[mode->code]);
1408   }
1409
1410   /* The local valid value is available now. */
1411   block->attr.block.graph_arr[pos] = res;
1412
1413   return res;
1414 }
1415
1416 #else /* if 0 */
1417
1418 /**
1419     it starts the recursion.  This causes an Id at the entry of
1420     every block that has no definition of the value! **/
1421
1422 #if USE_EXPLICIT_PHI_IN_STACK
1423 /* Just dummies */
1424 INLINE Phi_in_stack * new_Phi_in_stack() {  return NULL; }
1425 INLINE void free_Phi_in_stack(Phi_in_stack *s) { }
1426 #endif
1427
1428 static INLINE ir_node *
1429 new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
1430               ir_node **in, int ins)
1431 {
1432   int i;
1433   ir_node *res, *known;
1434
1435   /* Allocate a new node on the obstack.  The allocation copies the in
1436      array. */
1437   res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
1438   res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
1439
1440   /* This loop checks whether the Phi has more than one predecessor.
1441      If so, it is a real Phi node and we break the loop.  Else the
1442      Phi node merges the same definition on several paths and therefore
1443      is not needed. Don't consider Bad nodes! */
1444   known = res;
1445   for (i=0;  i < ins;  ++i)
1446   {
1447         assert(in[i]);
1448
1449     if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
1450
1451     if (known==res)
1452       known = in[i];
1453     else
1454       break;
1455   }
1456
1457   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1458   if (i==ins) {
1459     if (res != known) {
1460       obstack_free (current_ir_graph->obst, res);
1461       res = known;
1462     } else {
1463       /* A undefined value, e.g., in unreachable code. */
1464       res = new_Bad();
1465     }
1466   } else {
1467     res = optimize_node (res);
1468     irn_vrfy_irg (res, irg);
1469     /* Memory Phis in endless loops must be kept alive.
1470        As we can't distinguish these easily we keep all of the alive. */
1471     if ((res->op == op_Phi) && (mode == mode_M))
1472       add_End_keepalive(irg->end, res);
1473   }
1474
1475   return res;
1476 }
1477
1478 static ir_node *
1479 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1480
1481 #if PRECISE_EXC_CONTEXT
1482 static ir_node *
1483 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
1484
1485 static INLINE ir_node **
1486 new_frag_arr (ir_node *n) {
1487   ir_node **arr;
1488   int opt;
1489   arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
1490   memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
1491          sizeof(ir_node *)*current_ir_graph->n_loc);
1492   /* turn off optimization before allocating Proj nodes, as res isn't
1493      finished yet. */
1494   opt = get_optimize(); set_optimize(0);
1495   /* Here we rely on the fact that all frag ops have Memory as first result! */
1496   if (get_irn_op(n) == op_Call)
1497     arr[0] = new_Proj(n, mode_M, 3);
1498   else
1499     arr[0] = new_Proj(n, mode_M, 0);
1500   set_optimize(opt);
1501   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
1502   return arr;
1503 }
1504
1505 static INLINE ir_node **
1506 get_frag_arr (ir_node *n) {
1507   if (get_irn_op(n) == op_Call) {
1508     return n->attr.call.frag_arr;
1509   } else if (get_irn_op(n) == op_Alloc) {
1510     return n->attr.a.frag_arr;
1511   } else {
1512     return n->attr.frag_arr;
1513   }
1514 }
1515
1516 static void
1517 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
1518   if (!frag_arr[pos]) frag_arr[pos] = val;
1519   if (frag_arr[current_ir_graph->n_loc - 1])
1520     set_frag_value (get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]), pos, val);
1521 }
1522
1523 static ir_node *
1524 get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
1525   ir_node *res;
1526   ir_node **frag_arr;
1527
1528   assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
1529
1530   frag_arr = get_frag_arr(cfOp);
1531   res = frag_arr[pos];
1532   if (!res) {
1533     if (block->attr.block.graph_arr[pos]) {
1534       /* There was a set_value after the cfOp and no get_value before that
1535                  set_value.  We must build a Phi node now. */
1536       if (block->attr.block.matured) {
1537                 int ins = get_irn_arity(block);
1538                 ir_node **nin;
1539                 NEW_ARR_A (ir_node *, nin, ins);
1540                 res = phi_merge(block, pos, mode, nin, ins);
1541       } else {
1542                 res = new_rd_Phi0 (current_ir_graph, block, mode);
1543                 res->attr.phi0_pos = pos;
1544                 res->link = block->link;
1545                 block->link = res;
1546       }
1547       assert(res);
1548       /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
1549                  but this should be better: (remove comment if this works) */
1550       /* It's a Phi, we can write this into all graph_arrs with NULL */
1551       set_frag_value(block->attr.block.graph_arr, pos, res);
1552     } else {
1553       res = get_r_value_internal(block, pos, mode);
1554       set_frag_value(block->attr.block.graph_arr, pos, res);
1555     }
1556   }
1557   return res;
1558 }
1559 #endif
1560
1561 /**
1562     computes the predecessors for the real phi node, and then
1563     allocates and returns this node.  The routine called to allocate the
1564     node might optimize it away and return a real value.
1565     This function must be called with an in-array of proper size. **/
1566 static ir_node *
1567 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1568 {
1569   ir_node *prevBlock, *prevCfOp, *res, *phi0;
1570   int i;
1571
1572   /* If this block has no value at pos create a Phi0 and remember it
1573      in graph_arr to break recursions.
1574      Else we may not set graph_arr as there a later value is remembered. */
1575   phi0 = NULL;
1576   if (!block->attr.block.graph_arr[pos]) {
1577     if (block == get_irg_start_block(current_ir_graph)) {
1578       /* Collapsing to Bad tarvals is no good idea.
1579          So we call a user-supplied routine here that deals with this case as
1580          appropriate for the given language. Sorryly the only help we can give
1581          here is the position.
1582
1583          Even if all variables are defined before use, it can happen that
1584          we get to the start block, if a cond has been replaced by a tuple
1585          (bad, jmp).  In this case we call the function needlessly, eventually
1586          generating an non existant error.
1587          However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
1588          before recuring.
1589       */
1590       if (default_initialize_local_variable)
1591         block->attr.block.graph_arr[pos] = default_initialize_local_variable(mode, pos);
1592       else
1593         block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
1594       /* We don't need to care about exception ops in the start block.
1595          There are none by definition. */
1596       return block->attr.block.graph_arr[pos];
1597     } else {
1598       phi0 = new_rd_Phi0(current_ir_graph, block, mode);
1599       block->attr.block.graph_arr[pos] = phi0;
1600 #if PRECISE_EXC_CONTEXT
1601       /* Set graph_arr for fragile ops.  Also here we should break recursion.
1602          We could choose a cyclic path through an cfop.  But the recursion would
1603          break at some point. */
1604       set_frag_value(block->attr.block.graph_arr, pos, phi0);
1605 #endif
1606     }
1607   }
1608
1609   /* This loop goes to all predecessor blocks of the block the Phi node
1610      is in and there finds the operands of the Phi node by calling
1611      get_r_value_internal.  */
1612   for (i = 1;  i <= ins;  ++i) {
1613     prevCfOp = skip_Proj(block->in[i]);
1614     assert (prevCfOp);
1615     if (is_Bad(prevCfOp)) {
1616       /* In case a Cond has been optimized we would get right to the start block
1617          with an invalid definition. */
1618       nin[i-1] = new_Bad();
1619       continue;
1620     }
1621     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1622     assert (prevBlock);
1623     if (!is_Bad(prevBlock)) {
1624 #if PRECISE_EXC_CONTEXT
1625       if (is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
1626         assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
1627         nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
1628       } else
1629 #endif
1630         nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1631     } else {
1632       nin[i-1] = new_Bad();
1633     }
1634   }
1635
1636   /* After collecting all predecessors into the array nin a new Phi node
1637      with these predecessors is created.  This constructor contains an
1638      optimization: If all predecessors of the Phi node are identical it
1639      returns the only operand instead of a new Phi node.  */
1640   res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
1641
1642   /* In case we allocated a Phi0 node at the beginning of this procedure,
1643      we need to exchange this Phi0 with the real Phi. */
1644   if (phi0) {
1645     exchange(phi0, res);
1646     block->attr.block.graph_arr[pos] = res;
1647     /* Don't set_frag_value as it does not overwrite.  Doesn't matter, is
1648        only an optimization. */
1649   }
1650
1651   return res;
1652 }
1653
1654 /* This function returns the last definition of a variable.  In case
1655    this variable was last defined in a previous block, Phi nodes are
1656    inserted.  If the part of the firm graph containing the definition
1657    is not yet constructed, a dummy Phi node is returned. */
1658 static ir_node *
1659 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
1660 {
1661   ir_node *res;
1662   /* There are 4 cases to treat.
1663
1664      1. The block is not mature and we visit it the first time.  We can not
1665         create a proper Phi node, therefore a Phi0, i.e., a Phi without
1666         predecessors is returned.  This node is added to the linked list (field
1667         "link") of the containing block to be completed when this block is
1668         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
1669         node.)
1670
1671      2. The value is already known in this block, graph_arr[pos] is set and we
1672         visit the block the first time.  We can return the value without
1673         creating any new nodes.
1674
1675      3. The block is mature and we visit it the first time.  A Phi node needs
1676         to be created (phi_merge).  If the Phi is not needed, as all it's
1677         operands are the same value reaching the block through different
1678         paths, it's optimized away and the value itself is returned.
1679
1680      4. The block is mature, and we visit it the second time.  Now two
1681         subcases are possible:
1682         * The value was computed completely the last time we were here. This
1683           is the case if there is no loop.  We can return the proper value.
1684         * The recursion that visited this node and set the flag did not
1685           return yet.  We are computing a value in a loop and need to
1686           break the recursion.  This case only happens if we visited
1687           the same block with phi_merge before, which inserted a Phi0.
1688           So we return the Phi0.
1689   */
1690
1691   /* case 4 -- already visited. */
1692   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
1693     /* As phi_merge allocates a Phi0 this value is always defined. Here
1694      is the critical difference of the two algorithms. */
1695     assert(block->attr.block.graph_arr[pos]);
1696     return block->attr.block.graph_arr[pos];
1697   }
1698
1699   /* visited the first time */
1700   set_irn_visited(block, get_irg_visited(current_ir_graph));
1701
1702   /* Get the local valid value */
1703   res = block->attr.block.graph_arr[pos];
1704
1705   /* case 2 -- If the value is actually computed, return it. */
1706   if (res) { return res; };
1707
1708   if (block->attr.block.matured) { /* case 3 */
1709
1710     /* The Phi has the same amount of ins as the corresponding block. */
1711     int ins = get_irn_arity(block);
1712     ir_node **nin;
1713     NEW_ARR_A (ir_node *, nin, ins);
1714
1715     /* Phi merge collects the predecessors and then creates a node. */
1716     res = phi_merge (block, pos, mode, nin, ins);
1717
1718   } else {  /* case 1 */
1719     /* The block is not mature, we don't know how many in's are needed.  A Phi
1720        with zero predecessors is created.  Such a Phi node is called Phi0
1721        node.  The Phi0 is then added to the list of Phi0 nodes in this block
1722        to be matured by mature_block later.
1723        The Phi0 has to remember the pos of it's internal value.  If the real
1724        Phi is computed, pos is used to update the array with the local
1725        values. */
1726     res = new_rd_Phi0 (current_ir_graph, block, mode);
1727     res->attr.phi0_pos = pos;
1728     res->link = block->link;
1729     block->link = res;
1730   }
1731
1732   /* If we get here, the frontend missed a use-before-definition error */
1733   if (!res) {
1734     /* Error Message */
1735     printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
1736     assert (mode->code >= irm_F && mode->code <= irm_P);
1737     res = new_rd_Const (NULL, current_ir_graph, block, mode,
1738                        get_mode_null(mode));
1739   }
1740
1741   /* The local valid value is available now. */
1742   block->attr.block.graph_arr[pos] = res;
1743
1744   return res;
1745 }
1746
1747 #endif /* USE_FAST_PHI_CONSTRUCTION */
1748
1749 /* ************************************************************************** */
1750
1751 /** Finalize a Block node, when all control flows are known.  */
1752 /** Acceptable parameters are only Block nodes.               */
1753 void
1754 mature_block (ir_node *block)
1755 {
1756
1757   int ins;
1758   ir_node *n, **nin;
1759   ir_node *next;
1760
1761   assert (get_irn_opcode(block) == iro_Block);
1762   /* @@@ should be commented in
1763      assert (!get_Block_matured(block) && "Block already matured"); */
1764
1765   if (!get_Block_matured(block)) {
1766     ins = ARR_LEN (block->in)-1;
1767     /* Fix block parameters */
1768     block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
1769
1770     /* An array for building the Phi nodes. */
1771     NEW_ARR_A (ir_node *, nin, ins);
1772
1773     /* Traverse a chain of Phi nodes attached to this block and mature
1774        these, too. **/
1775     for (n = block->link;  n;  n=next) {
1776       inc_irg_visited(current_ir_graph);
1777       next = n->link;
1778       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
1779     }
1780
1781     block->attr.block.matured = 1;
1782
1783     /* Now, as the block is a finished firm node, we can optimize it.
1784        Since other nodes have been allocated since the block was created
1785        we can not free the node on the obstack.  Therefore we have to call
1786        optimize_in_place.
1787        Unfortunately the optimization does not change a lot, as all allocated
1788        nodes refer to the unoptimized node.
1789        We can call _2, as global cse has no effect on blocks. */
1790     block = optimize_in_place_2(block);
1791     irn_vrfy_irg(block, current_ir_graph);
1792   }
1793 }
1794
1795 ir_node *
1796 new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
1797 {
1798   return new_rd_Phi (db, current_ir_graph, current_ir_graph->current_block,
1799                     arity, in, mode);
1800 }
1801
1802 ir_node *
1803 new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
1804 {
1805   return new_rd_Const (db, current_ir_graph, current_ir_graph->start_block,
1806                       mode, con);
1807 }
1808
1809 ir_node *
1810 new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
1811 {
1812   return new_rd_Const_type (db, current_ir_graph, current_ir_graph->start_block,
1813                             mode, con, tp);
1814 }
1815
1816
1817 ir_node *
1818 new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
1819 {
1820   return new_rd_Id (db, current_ir_graph, current_ir_graph->current_block,
1821                    val, mode);
1822 }
1823
1824 ir_node *
1825 new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj)
1826 {
1827   return new_rd_Proj (db, current_ir_graph, current_ir_graph->current_block,
1828                      arg, mode, proj);
1829 }
1830
1831 ir_node *
1832 new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
1833 {
1834   ir_node *res;
1835   assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu));
1836   arg->attr.c.kind = fragmentary;
1837   arg->attr.c.default_proj = max_proj;
1838   res = new_Proj (arg, mode_X, max_proj);
1839   return res;
1840 }
1841
1842 ir_node *
1843 new_d_Conv (dbg_info* db, ir_node *op, ir_mode *mode)
1844 {
1845   return new_rd_Conv (db, current_ir_graph, current_ir_graph->current_block,
1846                      op, mode);
1847 }
1848
1849 ir_node *
1850 new_d_Cast (dbg_info* db, ir_node *op, type *to_tp)
1851 {
1852   return new_rd_Cast (db, current_ir_graph, current_ir_graph->current_block, op, to_tp);
1853 }
1854
1855 ir_node *
1856 new_d_Tuple (dbg_info* db, int arity, ir_node **in)
1857 {
1858   return new_rd_Tuple (db, current_ir_graph, current_ir_graph->current_block,
1859                       arity, in);
1860 }
1861
1862 ir_node *
1863 new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1864 {
1865   return new_rd_Add (db, current_ir_graph, current_ir_graph->current_block,
1866                     op1, op2, mode);
1867 }
1868
1869 ir_node *
1870 new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1871 {
1872   return new_rd_Sub (db, current_ir_graph, current_ir_graph->current_block,
1873                     op1, op2, mode);
1874 }
1875
1876
1877 ir_node *
1878 new_d_Minus  (dbg_info* db, ir_node *op,  ir_mode *mode)
1879 {
1880   return new_rd_Minus (db, current_ir_graph, current_ir_graph->current_block,
1881                       op, mode);
1882 }
1883
1884 ir_node *
1885 new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1886 {
1887   return new_rd_Mul (db, current_ir_graph, current_ir_graph->current_block,
1888                     op1, op2, mode);
1889 }
1890
1891 ir_node *
1892 new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
1893 {
1894   ir_node *res;
1895   res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
1896                      memop, op1, op2);
1897 #if PRECISE_EXC_CONTEXT
1898   if ((current_ir_graph->phase_state == phase_building) &&
1899       (get_irn_op(res) == op_Quot))  /* Could be optimized away. */
1900     res->attr.frag_arr = new_frag_arr(res);
1901 #endif
1902
1903   return res;
1904 }
1905
1906 ir_node *
1907 new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
1908 {
1909   ir_node *res;
1910   res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
1911                        memop, op1, op2);
1912 #if PRECISE_EXC_CONTEXT
1913   if ((current_ir_graph->phase_state == phase_building) &&
1914       (get_irn_op(res) == op_DivMod))   /* Could be optimized away. */
1915     res->attr.frag_arr = new_frag_arr(res);
1916 #endif
1917
1918   return res;
1919 }
1920
1921 ir_node *
1922 new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
1923 {
1924   ir_node *res;
1925   res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
1926                     memop, op1, op2);
1927 #if PRECISE_EXC_CONTEXT
1928   if ((current_ir_graph->phase_state == phase_building) &&
1929       (get_irn_op(res) == op_Div))  /* Could be optimized away. */
1930     res->attr.frag_arr = new_frag_arr(res);
1931 #endif
1932
1933   return res;
1934 }
1935
1936 ir_node *
1937 new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
1938 {
1939   ir_node *res;
1940   res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
1941                     memop, op1, op2);
1942 #if PRECISE_EXC_CONTEXT
1943   if ((current_ir_graph->phase_state == phase_building) &&
1944       (get_irn_op(res) == op_Mod))  /* Could be optimized away. */
1945     res->attr.frag_arr = new_frag_arr(res);
1946 #endif
1947
1948   return res;
1949 }
1950
1951 ir_node *
1952 new_d_And (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1953 {
1954   return new_rd_And (db, current_ir_graph, current_ir_graph->current_block,
1955                     op1, op2, mode);
1956 }
1957
1958 ir_node *
1959 new_d_Or (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1960 {
1961   return new_rd_Or (db, current_ir_graph, current_ir_graph->current_block,
1962                    op1, op2, mode);
1963 }
1964
1965 ir_node *
1966 new_d_Eor (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
1967 {
1968   return new_rd_Eor (db, current_ir_graph, current_ir_graph->current_block,
1969                     op1, op2, mode);
1970 }
1971
1972 ir_node *
1973 new_d_Not (dbg_info* db, ir_node *op, ir_mode *mode)
1974 {
1975   return new_rd_Not (db, current_ir_graph, current_ir_graph->current_block,
1976                     op, mode);
1977 }
1978
1979 ir_node *
1980 new_d_Shl (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
1981 {
1982   return new_rd_Shl (db, current_ir_graph, current_ir_graph->current_block,
1983                     op, k, mode);
1984 }
1985
1986 ir_node *
1987 new_d_Shr (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
1988 {
1989   return new_rd_Shr (db, current_ir_graph, current_ir_graph->current_block,
1990                     op, k, mode);
1991 }
1992
1993 ir_node *
1994 new_d_Shrs (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
1995 {
1996   return new_rd_Shrs (db, current_ir_graph, current_ir_graph->current_block,
1997                      op, k, mode);
1998 }
1999
2000 ir_node *
2001 new_d_Rot (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
2002 {
2003   return new_rd_Rot (db, current_ir_graph, current_ir_graph->current_block,
2004                      op, k, mode);
2005 }
2006
2007 ir_node *
2008 new_d_Abs (dbg_info* db, ir_node *op, ir_mode *mode)
2009 {
2010   return new_rd_Abs (db, current_ir_graph, current_ir_graph->current_block,
2011                     op, mode);
2012 }
2013
2014 ir_node *
2015 new_d_Cmp (dbg_info* db, ir_node *op1, ir_node *op2)
2016 {
2017   return new_rd_Cmp (db, current_ir_graph, current_ir_graph->current_block,
2018                     op1, op2);
2019 }
2020
2021 ir_node *
2022 new_d_Jmp (dbg_info* db)
2023 {
2024   return new_rd_Jmp (db, current_ir_graph, current_ir_graph->current_block);
2025 }
2026
2027 ir_node *
2028 new_d_Cond (dbg_info* db, ir_node *c)
2029 {
2030   return new_rd_Cond (db, current_ir_graph, current_ir_graph->current_block, c);
2031 }
2032
2033 ir_node *
2034 new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
2035           type *tp)
2036 {
2037   ir_node *res;
2038   res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
2039                      store, callee, arity, in, tp);
2040 #if PRECISE_EXC_CONTEXT
2041   if ((current_ir_graph->phase_state == phase_building) &&
2042       (get_irn_op(res) == op_Call))  /* Could be optimized away. */
2043     res->attr.call.frag_arr = new_frag_arr(res);
2044 #endif
2045
2046   return res;
2047 }
2048
2049 ir_node *
2050 new_d_Return (dbg_info* db, ir_node* store, int arity, ir_node **in)
2051 {
2052   return new_rd_Return (db, current_ir_graph, current_ir_graph->current_block,
2053                        store, arity, in);
2054 }
2055
2056 ir_node *
2057 new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj)
2058 {
2059   return new_rd_Raise (db, current_ir_graph, current_ir_graph->current_block,
2060                       store, obj);
2061 }
2062
2063 ir_node *
2064 new_d_Load (dbg_info* db, ir_node *store, ir_node *addr)
2065 {
2066   ir_node *res;
2067   res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block,
2068                      store, addr);
2069 #if PRECISE_EXC_CONTEXT
2070   if ((current_ir_graph->phase_state == phase_building) &&
2071       (get_irn_op(res) == op_Load))  /* Could be optimized away. */
2072     res->attr.frag_arr = new_frag_arr(res);
2073 #endif
2074
2075   return res;
2076 }
2077
2078 ir_node *
2079 new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val)
2080 {
2081   ir_node *res;
2082   res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block,
2083                       store, addr, val);
2084 #if PRECISE_EXC_CONTEXT
2085   if ((current_ir_graph->phase_state == phase_building) &&
2086       (get_irn_op(res) == op_Store))  /* Could be optimized away. */
2087     res->attr.frag_arr = new_frag_arr(res);
2088 #endif
2089
2090   return res;
2091 }
2092
2093 ir_node *
2094 new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type,
2095            where_alloc where)
2096 {
2097   ir_node *res;
2098   res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
2099                       store, size, alloc_type, where);
2100 #if PRECISE_EXC_CONTEXT
2101   if ((current_ir_graph->phase_state == phase_building) &&
2102       (get_irn_op(res) == op_Alloc))  /* Could be optimized away. */
2103     res->attr.a.frag_arr = new_frag_arr(res);
2104 #endif
2105
2106   return res;
2107 }
2108
2109 ir_node *
2110 new_d_Free (dbg_info* db, ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
2111 {
2112   return new_rd_Free (db, current_ir_graph, current_ir_graph->current_block,
2113                      store, ptr, size, free_type);
2114 }
2115
2116 ir_node *
2117 new_d_simpleSel (dbg_info* db, ir_node *store, ir_node *objptr, entity *ent)
2118 /* GL: objptr was called frame before.  Frame was a bad choice for the name
2119    as the operand could as well be a pointer to a dynamic object. */
2120 {
2121   return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
2122                     store, objptr, 0, NULL, ent);
2123 }
2124
2125 ir_node *
2126 new_d_Sel (dbg_info* db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
2127 {
2128   return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
2129                     store, objptr, n_index, index, sel);
2130 }
2131
2132 ir_node *
2133 new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
2134 {
2135   return (new_rd_InstOf (db, current_ir_graph, current_ir_graph->current_block,
2136                                                  store, objptr, ent));
2137 }
2138
2139 ir_node *
2140 new_d_SymConst (dbg_info* db, type_or_id_p value, symconst_kind kind)
2141 {
2142   return new_rd_SymConst (db, current_ir_graph, current_ir_graph->start_block,
2143                          value, kind);
2144 }
2145
2146 ir_node *
2147 new_d_Sync (dbg_info* db, int arity, ir_node** in)
2148 {
2149   return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block,
2150                       arity, in);
2151 }
2152
2153
2154 ir_node *
2155 new_d_Bad (void)
2156 {
2157   return current_ir_graph->bad;
2158 }
2159
2160 ir_node *
2161 new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
2162 {
2163   return new_rd_Confirm (db, current_ir_graph, current_ir_graph->current_block,
2164                          val, bound, cmp);
2165 }
2166
2167 ir_node *
2168 new_d_Unknown (void)
2169 {
2170   return current_ir_graph->unknown;
2171 }
2172
2173 ir_node *
2174 new_d_CallBegin (dbg_info *db, ir_node *call)
2175 {
2176   ir_node *res;
2177   res = new_rd_CallBegin (db, current_ir_graph, current_ir_graph->current_block, call);
2178   return res;
2179 }
2180
2181 ir_node *
2182 new_d_EndReg (dbg_info *db)
2183 {
2184   ir_node *res;
2185   res = new_rd_EndReg(db, current_ir_graph, current_ir_graph->current_block);
2186   return res;
2187 }
2188
2189 ir_node *
2190 new_d_EndExcept (dbg_info *db)
2191 {
2192   ir_node *res;
2193   res = new_rd_EndExcept(db, current_ir_graph, current_ir_graph->current_block);
2194   return res;
2195 }
2196
2197 ir_node *
2198 new_d_Break (dbg_info *db)
2199 {
2200   return new_rd_Break (db, current_ir_graph, current_ir_graph->current_block);
2201 }
2202
2203 ir_node *
2204 new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
2205 {
2206   return new_rd_Filter (db, current_ir_graph, current_ir_graph->current_block,
2207                         arg, mode, proj);
2208 }
2209
2210 /* ********************************************************************* */
2211 /* Comfortable interface with automatic Phi node construction.           */
2212 /* (Uses also constructors of ?? interface, except new_Block.            */
2213 /* ********************************************************************* */
2214
2215 /** Block construction **/
2216 /* immature Block without predecessors */
2217 ir_node *new_d_immBlock (dbg_info* db) {
2218   ir_node *res;
2219
2220   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2221   /* creates a new dynamic in-array as length of in is -1 */
2222   res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
2223   current_ir_graph->current_block = res;
2224   res->attr.block.matured = 0;
2225   res->attr.block.exc = exc_normal;
2226   res->attr.block.handler_entry = 0;
2227   res->attr.block.backedge = NULL;
2228   res->attr.block.in_cg = NULL;
2229   res->attr.block.cg_backedge = NULL;
2230   set_Block_block_visited(res, 0);
2231
2232   /* Create and initialize array for Phi-node construction. */
2233   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
2234                                          current_ir_graph->n_loc);
2235   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
2236
2237   /* Immature block may not be optimized! */
2238   irn_vrfy_irg (res, current_ir_graph);
2239
2240   return res;
2241 }
2242
2243 INLINE ir_node *
2244 new_immBlock () {
2245   return new_d_immBlock(NULL);
2246 }
2247
2248 /* add an adge to a jmp/control flow node */
2249 void
2250 add_in_edge (ir_node *block, ir_node *jmp)
2251 {
2252   if (block->attr.block.matured) {
2253     assert(0 && "Error: Block already matured!\n");
2254   }
2255   else {
2256     assert (jmp != NULL);
2257     ARR_APP1 (ir_node *, block->in, jmp);
2258   }
2259 }
2260
2261 /* changing the current block */
2262 void
2263 switch_block (ir_node *target)
2264 {
2265   current_ir_graph->current_block = target;
2266 }
2267
2268 /* ************************ */
2269 /* parameter administration */
2270
2271 /* get a value from the parameter array from the current block by its index */
2272 ir_node *
2273 get_d_value (dbg_info* db, int pos, ir_mode *mode)
2274 {
2275   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2276   inc_irg_visited(current_ir_graph);
2277
2278   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
2279 }
2280 /* get a value from the parameter array from the current block by its index */
2281 INLINE ir_node *
2282 get_value (int pos, ir_mode *mode)
2283 {
2284   return get_d_value(NULL, pos, mode);
2285 }
2286
2287 /* set a value at position pos in the parameter array from the current block */
2288 INLINE void
2289 set_value (int pos, ir_node *value)
2290 {
2291   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2292   assert(pos+1 < current_ir_graph->n_loc);
2293   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
2294 }
2295
2296 /* get the current store */
2297 INLINE ir_node *
2298 get_store (void)
2299 {
2300   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2301   /* GL: one could call get_value instead */
2302   inc_irg_visited(current_ir_graph);
2303   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
2304 }
2305
2306 /* set the current store */
2307 INLINE void
2308 set_store (ir_node *store)
2309 {
2310   /* GL: one could call set_value instead */
2311   assert(get_irg_phase_state (current_ir_graph) == phase_building);
2312   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
2313 }
2314
2315 void
2316 keep_alive (ir_node *ka)
2317 {
2318   add_End_keepalive(current_ir_graph->end, ka);
2319 }
2320
2321 /** Useful access routines **/
2322 /* Returns the current block of the current graph.  To set the current
2323    block use switch_block(). */
2324 ir_node *get_cur_block() {
2325   return get_irg_current_block(current_ir_graph);
2326 }
2327
2328 /* Returns the frame type of the current graph */
2329 type *get_cur_frame_type() {
2330   return get_irg_frame_type(current_ir_graph);
2331 }
2332
2333
2334 /* ********************************************************************* */
2335 /* initialize */
2336
2337 /* call once for each run of the library */
2338 void
2339 init_cons (default_initialize_local_variable_func_t *func)
2340 {
2341   default_initialize_local_variable = func;
2342 }
2343
2344 /* call for each graph */
2345 void
2346 finalize_cons (ir_graph *irg) {
2347   irg->phase_state = phase_high;
2348 }
2349
2350
2351 ir_node *new_Block(int arity, ir_node **in) {
2352   return new_d_Block(NULL, arity, in);
2353 }
2354 ir_node *new_Start  (void) {
2355   return new_d_Start(NULL);
2356 }
2357 ir_node *new_End    (void) {
2358   return new_d_End(NULL);
2359 }
2360 ir_node *new_Jmp    (void) {
2361   return new_d_Jmp(NULL);
2362 }
2363 ir_node *new_Cond   (ir_node *c) {
2364   return new_d_Cond(NULL, c);
2365 }
2366 ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
2367   return new_d_Return(NULL, store, arity, in);
2368 }
2369 ir_node *new_Raise  (ir_node *store, ir_node *obj) {
2370   return new_d_Raise(NULL, store, obj);
2371 }
2372 ir_node *new_Const  (ir_mode *mode, tarval *con) {
2373   return new_d_Const(NULL, mode, con);
2374 }
2375 ir_node *new_SymConst (type_or_id_p value, symconst_kind kind) {
2376   return new_d_SymConst(NULL, value, kind);
2377 }
2378 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, entity *ent) {
2379   return new_d_simpleSel(NULL, store, objptr, ent);
2380 }
2381 ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
2382                      entity *ent) {
2383   return new_d_Sel(NULL, store, objptr, arity, in, ent);
2384 }
2385 ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
2386   return (new_d_InstOf (NULL, store, objptr, ent));
2387 }
2388 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
2389                      type *tp) {
2390   return new_d_Call(NULL, store, callee, arity, in, tp);
2391 }
2392 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
2393   return new_d_Add(NULL, op1, op2, mode);
2394 }
2395 ir_node *new_Sub    (ir_node *op1, ir_node *op2, ir_mode *mode) {
2396   return new_d_Sub(NULL, op1, op2, mode);
2397 }
2398 ir_node *new_Minus  (ir_node *op,  ir_mode *mode) {
2399   return new_d_Minus(NULL, op, mode);
2400 }
2401 ir_node *new_Mul    (ir_node *op1, ir_node *op2, ir_mode *mode) {
2402   return new_d_Mul(NULL, op1, op2, mode);
2403 }
2404 ir_node *new_Quot   (ir_node *memop, ir_node *op1, ir_node *op2) {
2405   return new_d_Quot(NULL, memop, op1, op2);
2406 }
2407 ir_node *new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2) {
2408   return new_d_DivMod(NULL, memop, op1, op2);
2409 }
2410 ir_node *new_Div    (ir_node *memop, ir_node *op1, ir_node *op2) {
2411   return new_d_Div(NULL, memop, op1, op2);
2412 }
2413 ir_node *new_Mod    (ir_node *memop, ir_node *op1, ir_node *op2) {
2414   return new_d_Mod(NULL, memop, op1, op2);
2415 }
2416 ir_node *new_Abs    (ir_node *op, ir_mode *mode) {
2417   return new_d_Abs(NULL, op, mode);
2418 }
2419 ir_node *new_And    (ir_node *op1, ir_node *op2, ir_mode *mode) {
2420   return new_d_And(NULL, op1, op2, mode);
2421 }
2422 ir_node *new_Or     (ir_node *op1, ir_node *op2, ir_mode *mode) {
2423   return new_d_Or(NULL, op1, op2, mode);
2424 }
2425 ir_node *new_Eor    (ir_node *op1, ir_node *op2, ir_mode *mode) {
2426   return new_d_Eor(NULL, op1, op2, mode);
2427 }
2428 ir_node *new_Not    (ir_node *op,                ir_mode *mode) {
2429   return new_d_Not(NULL, op, mode);
2430 }
2431 ir_node *new_Shl    (ir_node *op,  ir_node *k,   ir_mode *mode) {
2432   return new_d_Shl(NULL, op, k, mode);
2433 }
2434 ir_node *new_Shr    (ir_node *op,  ir_node *k,   ir_mode *mode) {
2435   return new_d_Shr(NULL, op, k, mode);
2436 }
2437 ir_node *new_Shrs   (ir_node *op,  ir_node *k,   ir_mode *mode) {
2438   return new_d_Shrs(NULL, op, k, mode);
2439 }
2440 #define new_Rotate new_Rot
2441 ir_node *new_Rot    (ir_node *op,  ir_node *k,   ir_mode *mode) {
2442   return new_d_Rot(NULL, op, k, mode);
2443 }
2444 ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
2445   return new_d_Cmp(NULL, op1, op2);
2446 }
2447 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
2448   return new_d_Conv(NULL, op, mode);
2449 }
2450 ir_node *new_Cast   (ir_node *op, type *to_tp) {
2451   return new_d_Cast(NULL, op, to_tp);
2452 }
2453 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
2454   return new_d_Phi(NULL, arity, in, mode);
2455 }
2456 ir_node *new_Load   (ir_node *store, ir_node *addr) {
2457   return new_d_Load(NULL, store, addr);
2458 }
2459 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
2460   return new_d_Store(NULL, store, addr, val);
2461 }
2462 ir_node *new_Alloc  (ir_node *store, ir_node *size, type *alloc_type,
2463                      where_alloc where) {
2464   return new_d_Alloc(NULL, store, size, alloc_type, where);
2465 }
2466 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,
2467                      type *free_type) {
2468   return new_d_Free(NULL, store, ptr, size, free_type);
2469 }
2470 ir_node *new_Sync   (int arity, ir_node **in) {
2471   return new_d_Sync(NULL, arity, in);
2472 }
2473 ir_node *new_Proj   (ir_node *arg, ir_mode *mode, long proj) {
2474   return new_d_Proj(NULL, arg, mode, proj);
2475 }
2476 ir_node *new_defaultProj (ir_node *arg, long max_proj) {
2477   return new_d_defaultProj(NULL, arg, max_proj);
2478 }
2479 ir_node *new_Tuple  (int arity, ir_node **in) {
2480   return new_d_Tuple(NULL, arity, in);
2481 }
2482 ir_node *new_Id     (ir_node *val, ir_mode *mode) {
2483   return new_d_Id(NULL, val, mode);
2484 }
2485 ir_node *new_Bad    (void) {
2486   return new_d_Bad();
2487 }
2488 ir_node *new_Confirm (ir_node *val, ir_node *bound, pn_Cmp cmp) {
2489   return new_d_Confirm (NULL, val, bound, cmp);
2490 }
2491 ir_node *new_Unknown(void) {
2492   return new_d_Unknown();
2493 }
2494 ir_node *new_CallBegin (ir_node *callee) {
2495   return new_d_CallBegin(NULL, callee);
2496 }
2497 ir_node *new_EndReg (void) {
2498   return new_d_EndReg(NULL);
2499 }
2500 ir_node *new_EndExcept (void) {
2501   return new_d_EndExcept(NULL);
2502 }
2503 ir_node *new_Break  (void) {
2504   return new_d_Break(NULL);
2505 }
2506 ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
2507   return new_d_Filter(NULL, arg, mode, proj);
2508 }