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

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