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