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