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

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