nsz Git - libfirm/blob - ir/ir/ircons.c

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