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