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