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

   1 /*
   2  * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Various irnode constructors. Automatic construction of SSA
  23  *          representation.
  24  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Boris Boesler
  25             Michael Beck
  26  * @version $Id$
  27  */
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include "irprog_t.h"
  33 #include "irgraph_t.h"
  34 #include "irnode_t.h"
  35 #include "irmode_t.h"
  36 #include "ircons_t.h"
  37 #include "firm_common_t.h"
  38 #include "irvrfy.h"
  39 #include "irop_t.h"
  40 #include "iropt_t.h"
  41 #include "irgmod.h"
  42 #include "irhooks.h"
  43 #include "array.h"
  44 #include "irbackedge_t.h"
  45 #include "irflag_t.h"
  46 #include "iredges_t.h"
  47 #include "irflag_t.h"
  48 #include "xmalloc.h"
  49
  50 #if USE_EXPLICIT_PHI_IN_STACK
  51 /* A stack needed for the automatic Phi node construction in constructor
  52    Phi_in. Redefinition in irgraph.c!! */
  53 struct Phi_in_stack {
  54         ir_node **stack;
  55         int       pos;
  56 };
  57 typedef struct Phi_in_stack Phi_in_stack;
  58 #endif
  59
  60 /* when we need verifying */
  61 #ifdef NDEBUG
  62 # define IRN_VRFY_IRG(res, irg)
  63 #else
  64 # define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)
  65 #endif /* NDEBUG */
  66
  67 /**
  68  * Language dependent variable initialization callback.
  69  */
  70 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
  71
  72 /* creates a bd constructor for a binop */
  73 #define NEW_BD_BINOP(instr)                                     \
  74 static ir_node *                                                \
  75 new_bd_##instr(dbg_info *db, ir_node *block,                    \
  76        ir_node *op1, ir_node *op2, ir_mode *mode)               \
  77 {                                                               \
  78   ir_node  *in[2];                                              \
  79   ir_node  *res;                                                \
  80   ir_graph *irg = current_ir_graph;                             \
  81   in[0] = op1;                                                  \
  82   in[1] = op2;                                                  \
  83   res = new_ir_node(db, irg, block, op_##instr, mode, 2, in);   \
  84   res = optimize_node(res);                                     \
  85   IRN_VRFY_IRG(res, irg);                                       \
  86   return res;                                                   \
  87 }
  88
  89 /* creates a bd constructor for an unop */
  90 #define NEW_BD_UNOP(instr)                                      \
  91 static ir_node *                                                \
  92 new_bd_##instr(dbg_info *db, ir_node *block,                    \
  93               ir_node *op, ir_mode *mode)                       \
  94 {                                                               \
  95   ir_node  *res;                                                \
  96   ir_graph *irg = current_ir_graph;                             \
  97   res = new_ir_node(db, irg, block, op_##instr, mode, 1, &op);  \
  98   res = optimize_node(res);                                     \
  99   IRN_VRFY_IRG(res, irg);                                       \
 100   return res;                                                   \
 101 }
 102
 103 /* creates a bd constructor for an divop */
 104 #define NEW_BD_DIVOP(instr)                                     \
 105 static ir_node *                                                \
 106 new_bd_##instr(dbg_info *db, ir_node *block,                    \
 107             ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) \
 108 {                                                               \
 109   ir_node  *in[3];                                              \
 110   ir_node  *res;                                                \
 111   ir_graph *irg = current_ir_graph;                             \
 112   in[0] = memop;                                                \
 113   in[1] = op1;                                                  \
 114   in[2] = op2;                                                  \
 115   res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
 116   res->attr.divmod.exc.pin_state = op_pin_state_pinned;         \
 117   res->attr.divmod.res_mode = mode;                             \
 118   res = optimize_node(res);                                     \
 119   IRN_VRFY_IRG(res, irg);                                       \
 120   return res;                                                   \
 121 }
 122
 123 /* creates a rd constructor for a binop */
 124 #define NEW_RD_BINOP(instr)                                     \
 125 ir_node *                                                       \
 126 new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block,     \
 127        ir_node *op1, ir_node *op2, ir_mode *mode)               \
 128 {                                                               \
 129   ir_node  *res;                                                \
 130   ir_graph *rem = current_ir_graph;                             \
 131   current_ir_graph = irg;                                       \
 132   res = new_bd_##instr(db, block, op1, op2, mode);              \
 133   current_ir_graph = rem;                                       \
 134   return res;                                                   \
 135 }
 136
 137 /* creates a rd constructor for an unop */
 138 #define NEW_RD_UNOP(instr)                                      \
 139 ir_node *                                                       \
 140 new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block,     \
 141               ir_node *op, ir_mode *mode)                       \
 142 {                                                               \
 143   ir_node  *res;                                                \
 144   ir_graph *rem = current_ir_graph;                             \
 145   current_ir_graph = irg;                                       \
 146   res = new_bd_##instr(db, block, op, mode);                    \
 147   current_ir_graph = rem;                                       \
 148   return res;                                                   \
 149 }
 150
 151 /* creates a rd constructor for an divop */
 152 #define NEW_RD_DIVOP(instr)                                     \
 153 ir_node *                                                       \
 154 new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block,     \
 155             ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) \
 156 {                                                               \
 157   ir_node  *res;                                                \
 158   ir_graph *rem = current_ir_graph;                             \
 159   current_ir_graph = irg;                                       \
 160   res = new_bd_##instr(db, block, memop, op1, op2, mode);       \
 161   current_ir_graph = rem;                                       \
 162   return res;                                                   \
 163 }
 164
 165 /* creates a d constructor for an binop */
 166 #define NEW_D_BINOP(instr)                                                    \
 167 ir_node *                                                                     \
 168 new_d_##instr(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {      \
 169   return new_bd_##instr(db, current_ir_graph->current_block, op1, op2, mode); \
 170 }
 171
 172 /* creates a d constructor for an unop */
 173 #define NEW_D_UNOP(instr)                                                     \
 174 ir_node *                                                                     \
 175 new_d_##instr(dbg_info *db, ir_node *op, ir_mode *mode) {                     \
 176   return new_bd_##instr(db, current_ir_graph->current_block, op, mode);       \
 177 }
 178
 179
 180 /**
 181  * Constructs a Block with a fixed number of predecessors.
 182  * Does not set current_block.  Cannot be used with automatic
 183  * Phi node construction.
 184  */
 185 static ir_node *
 186 new_bd_Block(dbg_info *db, int arity, ir_node **in) {
 187         ir_node  *res;
 188         ir_graph *irg = current_ir_graph;
 189
 190         res = new_ir_node(db, irg, NULL, op_Block, mode_BB, arity, in);
 191
 192         /* macroblock header */
 193         res->in[0] = res;
 194
 195         res->attr.block.is_dead     = 0;
 196     res->attr.block.is_mb_head  = 1;
 197         res->attr.block.irg         = irg;
 198         res->attr.block.backedge    = new_backedge_arr(irg->obst, arity);
 199         res->attr.block.in_cg       = NULL;
 200         res->attr.block.cg_backedge = NULL;
 201         res->attr.block.extblk      = NULL;
 202     res->attr.block.mb_depth    = 0;
 203
 204         set_Block_matured(res, 1);
 205         set_Block_block_visited(res, 0);
 206
 207     IRN_VRFY_IRG(res, irg);
 208         return res;
 209 }  /* new_bd_Block */
 210
 211 static ir_node *
 212 new_bd_Start(dbg_info *db, ir_node *block) {
 213         ir_node  *res;
 214         ir_graph *irg = current_ir_graph;
 215
 216         res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
 217
 218         IRN_VRFY_IRG(res, irg);
 219         return res;
 220 }  /* new_bd_Start */
 221
 222 static ir_node *
 223 new_bd_End(dbg_info *db, ir_node *block) {
 224         ir_node  *res;
 225         ir_graph *irg = current_ir_graph;
 226
 227         res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
 228
 229         IRN_VRFY_IRG(res, irg);
 230         return res;
 231 }  /* new_bd_End */
 232
 233 /**
 234  * Creates a Phi node with all predecessors.  Calling this constructor
 235  * is only allowed if the corresponding block is mature.
 236  */
 237 static ir_node *
 238 new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode) {
 239         ir_node  *res;
 240         ir_graph *irg = current_ir_graph;
 241         int i;
 242         int has_unknown = 0;
 243
 244         /* Don't assert that block matured: the use of this constructor is strongly
 245            restricted ... */
 246         if ( get_Block_matured(block) )
 247                 assert( get_irn_arity(block) == arity );
 248
 249         res = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
 250
 251         res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
 252
 253         for (i = arity-1; i >= 0; i--)
 254                 if (get_irn_op(in[i]) == op_Unknown) {
 255                         has_unknown = 1;
 256                         break;
 257                 }
 258
 259         if (!has_unknown) res = optimize_node(res);
 260         IRN_VRFY_IRG(res, irg);
 261
 262         /* Memory Phis in endless loops must be kept alive.
 263            As we can't distinguish these easily we keep all of them alive. */
 264         if ((res->op == op_Phi) && (mode == mode_M))
 265                 add_End_keepalive(get_irg_end(irg), res);
 266         return res;
 267 }  /* new_bd_Phi */
 268
 269 static ir_node *
 270 new_bd_Const_type(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) {
 271         ir_node  *res;
 272         ir_graph *irg = current_ir_graph;
 273
 274         res = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, mode, 0, NULL);
 275         res->attr.con.tv = con;
 276         set_Const_type(res, tp);  /* Call method because of complex assertion. */
 277         res = optimize_node (res);
 278         assert(get_Const_type(res) == tp);
 279         IRN_VRFY_IRG(res, irg);
 280
 281         return res;
 282 }  /* new_bd_Const_type */
 283
 284 static ir_node *
 285 new_bd_Const(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con) {
 286         ir_graph *irg = current_ir_graph;
 287
 288         return new_rd_Const_type (db, irg, block, mode, con, firm_unknown_type);
 289 }  /* new_bd_Const */
 290
 291 static ir_node *
 292 new_bd_Const_long(dbg_info *db, ir_node *block, ir_mode *mode, long value) {
 293         ir_graph *irg = current_ir_graph;
 294
 295         return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
 296 }  /* new_bd_Const_long */
 297
 298 static ir_node *
 299 new_bd_Id(dbg_info *db, ir_node *block, ir_node *val, ir_mode *mode) {
 300         ir_node  *res;
 301         ir_graph *irg = current_ir_graph;
 302
 303         res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
 304         res = optimize_node(res);
 305         IRN_VRFY_IRG(res, irg);
 306         return res;
 307 }  /* new_bd_Id */
 308
 309 static ir_node *
 310 new_bd_Proj(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
 311         long proj) {
 312         ir_node  *res;
 313         ir_graph *irg = current_ir_graph;
 314
 315         res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
 316         res->attr.proj = proj;
 317
 318         assert(res);
 319         assert(get_Proj_pred(res));
 320         assert(get_nodes_block(get_Proj_pred(res)));
 321
 322         res = optimize_node(res);
 323
 324         IRN_VRFY_IRG(res, irg);
 325         return res;
 326 }  /* new_bd_Proj */
 327
 328 static ir_node *
 329 new_bd_defaultProj(dbg_info *db, ir_node *block, ir_node *arg,
 330            long max_proj) {
 331         ir_node  *res;
 332         ir_graph *irg = current_ir_graph;
 333
 334         assert(arg->op == op_Cond);
 335         arg->attr.cond.kind = fragmentary;
 336         arg->attr.cond.default_proj = max_proj;
 337         res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
 338         return res;
 339 }  /* new_bd_defaultProj */
 340
 341 static ir_node *
 342 new_bd_Conv(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode, int strict_flag) {
 343         ir_node  *res;
 344         ir_graph *irg = current_ir_graph;
 345
 346         res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
 347         res->attr.conv.strict = strict_flag;
 348         res = optimize_node(res);
 349         IRN_VRFY_IRG(res, irg);
 350         return res;
 351 }  /* new_bd_Conv */
 352
 353 static ir_node *
 354 new_bd_Cast(dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp) {
 355         ir_node  *res;
 356         ir_graph *irg = current_ir_graph;
 357
 358         assert(is_atomic_type(to_tp));
 359
 360         res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
 361         res->attr.cast.totype = to_tp;
 362         res = optimize_node(res);
 363         IRN_VRFY_IRG(res, irg);
 364         return res;
 365 }  /* new_bd_Cast */
 366
 367 static ir_node *
 368 new_bd_Tuple(dbg_info *db, ir_node *block, int arity, ir_node **in) {
 369         ir_node  *res;
 370         ir_graph *irg = current_ir_graph;
 371
 372         res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
 373         res = optimize_node (res);
 374         IRN_VRFY_IRG(res, irg);
 375         return res;
 376 }  /* new_bd_Tuple */
 377
 378 NEW_BD_BINOP(Add)
 379 NEW_BD_BINOP(Sub)
 380 NEW_BD_UNOP(Minus)
 381 NEW_BD_BINOP(Mul)
 382 NEW_BD_DIVOP(Quot)
 383 NEW_BD_DIVOP(DivMod)
 384 NEW_BD_DIVOP(Div)
 385 NEW_BD_DIVOP(Mod)
 386 NEW_BD_BINOP(And)
 387 NEW_BD_BINOP(Or)
 388 NEW_BD_BINOP(Eor)
 389 NEW_BD_UNOP(Not)
 390 NEW_BD_BINOP(Shl)
 391 NEW_BD_BINOP(Shr)
 392 NEW_BD_BINOP(Shrs)
 393 NEW_BD_BINOP(Rot)
 394 NEW_BD_UNOP(Abs)
 395 NEW_BD_BINOP(Carry)
 396 NEW_BD_BINOP(Borrow)
 397
 398 static ir_node *
 399 new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) {
 400         ir_node  *in[2];
 401         ir_node  *res;
 402         ir_graph *irg = current_ir_graph;
 403         in[0] = op1;
 404         in[1] = op2;
 405         res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);
 406         res = optimize_node(res);
 407         IRN_VRFY_IRG(res, irg);
 408         return res;
 409 }  /* new_bd_Cmp */
 410
 411 static ir_node *
 412 new_bd_Jmp(dbg_info *db, ir_node *block) {
 413         ir_node  *res;
 414         ir_graph *irg = current_ir_graph;
 415
 416         res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
 417         res = optimize_node (res);
 418         IRN_VRFY_IRG(res, irg);
 419         return res;
 420 }  /* new_bd_Jmp */
 421
 422 static ir_node *
 423 new_bd_IJmp(dbg_info *db, ir_node *block, ir_node *tgt) {
 424         ir_node  *res;
 425         ir_graph *irg = current_ir_graph;
 426
 427         res = new_ir_node (db, irg, block, op_IJmp, mode_X, 1, &tgt);
 428         res = optimize_node (res);
 429         IRN_VRFY_IRG(res, irg);
 430
 431         if (get_irn_op(res) == op_IJmp) /* still an IJmp */
 432                 keep_alive(res);
 433         return res;
 434 }  /* new_bd_IJmp */
 435
 436 static ir_node *
 437 new_bd_Cond(dbg_info *db, ir_node *block, ir_node *c) {
 438         ir_node  *res;
 439         ir_graph *irg = current_ir_graph;
 440
 441         res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, &c);
 442         res->attr.cond.kind         = dense;
 443         res->attr.cond.default_proj = 0;
 444         res->attr.cond.pred         = COND_JMP_PRED_NONE;
 445         res = optimize_node (res);
 446         IRN_VRFY_IRG(res, irg);
 447         return res;
 448 }  /* new_bd_Cond */
 449
 450 static ir_node *
 451 new_bd_Call(dbg_info *db, ir_node *block, ir_node *store,
 452         ir_node *callee, int arity, ir_node **in, ir_type *tp) {
 453         ir_node  **r_in;
 454         ir_node  *res;
 455         int      r_arity;
 456         ir_graph *irg = current_ir_graph;
 457
 458         r_arity = arity+2;
 459         NEW_ARR_A(ir_node *, r_in, r_arity);
 460         r_in[0] = store;
 461         r_in[1] = callee;
 462         memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 463
 464         res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
 465
 466         assert((get_unknown_type() == tp) || is_Method_type(tp));
 467         set_Call_type(res, tp);
 468         res->attr.call.exc.pin_state = op_pin_state_pinned;
 469         res->attr.call.callee_arr    = NULL;
 470         res = optimize_node(res);
 471         IRN_VRFY_IRG(res, irg);
 472         return res;
 473 }  /* new_bd_Call */
 474
 475 static ir_node *
 476 new_bd_Return(dbg_info *db, ir_node *block,
 477               ir_node *store, int arity, ir_node **in) {
 478         ir_node  **r_in;
 479         ir_node  *res;
 480         int      r_arity;
 481         ir_graph *irg = current_ir_graph;
 482
 483         r_arity = arity+1;
 484         NEW_ARR_A (ir_node *, r_in, r_arity);
 485         r_in[0] = store;
 486         memcpy(&r_in[1], in, sizeof(ir_node *) * arity);
 487         res = new_ir_node(db, irg, block, op_Return, mode_X, r_arity, r_in);
 488         res = optimize_node(res);
 489         IRN_VRFY_IRG(res, irg);
 490         return res;
 491 }  /* new_bd_Return */
 492
 493 static ir_node *
 494 new_bd_Load(dbg_info *db, ir_node *block,
 495         ir_node *store, ir_node *adr, ir_mode *mode) {
 496         ir_node  *in[2];
 497         ir_node  *res;
 498         ir_graph *irg = current_ir_graph;
 499
 500         in[0] = store;
 501         in[1] = adr;
 502         res = new_ir_node(db, irg, block, op_Load, mode_T, 2, in);
 503         res->attr.load.exc.pin_state = op_pin_state_pinned;
 504         res->attr.load.load_mode     = mode;
 505         res->attr.load.volatility    = volatility_non_volatile;
 506         res = optimize_node(res);
 507         IRN_VRFY_IRG(res, irg);
 508         return res;
 509 }  /* new_bd_Load */
 510
 511 static ir_node *
 512 new_bd_Store(dbg_info *db, ir_node *block,
 513          ir_node *store, ir_node *adr, ir_node *val) {
 514         ir_node  *in[3];
 515         ir_node  *res;
 516         ir_graph *irg = current_ir_graph;
 517
 518         in[0] = store;
 519         in[1] = adr;
 520         in[2] = val;
 521         res = new_ir_node(db, irg, block, op_Store, mode_T, 3, in);
 522         res->attr.store.exc.pin_state = op_pin_state_pinned;
 523         res->attr.store.volatility    = volatility_non_volatile;
 524         res = optimize_node(res);
 525         IRN_VRFY_IRG(res, irg);
 526         return res;
 527 }  /* new_bd_Store */
 528
 529 static ir_node *
 530 new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
 531         ir_node *size, ir_type *alloc_type, where_alloc where) {
 532         ir_node  *in[2];
 533         ir_node  *res;
 534         ir_graph *irg = current_ir_graph;
 535
 536         in[0] = store;
 537         in[1] = size;
 538         res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in);
 539         res->attr.alloc.exc.pin_state = op_pin_state_pinned;
 540         res->attr.alloc.where         = where;
 541         res->attr.alloc.type          = alloc_type;
 542         res = optimize_node(res);
 543         IRN_VRFY_IRG(res, irg);
 544         return res;
 545 }  /* new_bd_Alloc */
 546
 547 static ir_node *
 548 new_bd_Free(dbg_info *db, ir_node *block, ir_node *store,
 549         ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
 550         ir_node  *in[3];
 551         ir_node  *res;
 552         ir_graph *irg = current_ir_graph;
 553
 554         in[0] = store;
 555         in[1] = ptr;
 556         in[2] = size;
 557         res = new_ir_node (db, irg, block, op_Free, mode_M, 3, in);
 558         res->attr.free.where = where;
 559         res->attr.free.type  = free_type;
 560         res = optimize_node(res);
 561         IRN_VRFY_IRG(res, irg);
 562         return res;
 563 }  /* new_bd_Free */
 564
 565 static ir_node *
 566 new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
 567            int arity, ir_node **in, ir_entity *ent) {
 568         ir_node  **r_in;
 569         ir_node  *res;
 570         int      r_arity;
 571         ir_graph *irg = current_ir_graph;
 572         ir_mode  *mode = is_Method_type(get_entity_type(ent)) ? mode_P_code : mode_P_data;
 573
 574         assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
 575
 576         r_arity = arity + 2;
 577         NEW_ARR_A(ir_node *, r_in, r_arity);  /* uses alloca */
 578         r_in[0] = store;
 579         r_in[1] = objptr;
 580         memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 581         /*
 582          * Sel's can select functions which should be of mode mode_P_code.
 583          */
 584         res = new_ir_node(db, irg, block, op_Sel, mode, r_arity, r_in);
 585         res->attr.sel.ent = ent;
 586         res = optimize_node(res);
 587         IRN_VRFY_IRG(res, irg);
 588         return res;
 589 }  /* new_bd_Sel */
 590
 591 static ir_node *
 592 new_bd_SymConst_type(dbg_info *db, ir_node *block, symconst_symbol value,
 593                      symconst_kind symkind, ir_type *tp) {
 594         ir_node  *res;
 595         ir_mode  *mode;
 596         ir_graph *irg = current_ir_graph;
 597
 598         if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
 599                 mode = mode_P_data;   /* FIXME: can be mode_P_code */
 600         else
 601                 mode = mode_Iu;
 602
 603         res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
 604
 605         res->attr.symc.num = symkind;
 606         res->attr.symc.sym = value;
 607         res->attr.symc.tp  = tp;
 608
 609         res = optimize_node(res);
 610         IRN_VRFY_IRG(res, irg);
 611         return res;
 612 }  /* new_bd_SymConst_type */
 613
 614 static ir_node *
 615 new_bd_Sync(dbg_info *db, ir_node *block) {
 616         ir_node  *res;
 617         ir_graph *irg = current_ir_graph;
 618
 619         res = new_ir_node(db, irg, block, op_Sync, mode_M, -1, NULL);
 620         /* no need to call optimize node here, Sync are always created with no predecessors */
 621         IRN_VRFY_IRG(res, irg);
 622         return res;
 623 }  /* new_bd_Sync */
 624
 625 static ir_node *
 626 new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
 627         ir_node  *in[2], *res;
 628         ir_graph *irg = current_ir_graph;
 629
 630         in[0] = val;
 631         in[1] = bound;
 632         res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
 633         res->attr.confirm_cmp = cmp;
 634         res = optimize_node (res);
 635         IRN_VRFY_IRG(res, irg);
 636         return res;
 637 }  /* new_bd_Confirm */
 638
 639 static ir_node *
 640 new_bd_Unknown(ir_mode *m) {
 641         ir_node  *res;
 642         ir_graph *irg = current_ir_graph;
 643
 644         res = new_ir_node(NULL, irg, get_irg_start_block(irg), op_Unknown, m, 0, NULL);
 645         res = optimize_node(res);
 646         return res;
 647 }  /* new_bd_Unknown */
 648
 649 static ir_node *
 650 new_bd_CallBegin(dbg_info *db, ir_node *block, ir_node *call) {
 651         ir_node  *in[1];
 652         ir_node  *res;
 653         ir_graph *irg = current_ir_graph;
 654
 655         in[0] = get_Call_ptr(call);
 656         res = new_ir_node(db, irg, block, op_CallBegin, mode_T, 1, in);
 657         /* res->attr.callbegin.irg = irg; */
 658         res->attr.callbegin.call = call;
 659         res = optimize_node(res);
 660         IRN_VRFY_IRG(res, irg);
 661         return res;
 662 }  /* new_bd_CallBegin */
 663
 664 static ir_node *
 665 new_bd_EndReg(dbg_info *db, ir_node *block) {
 666         ir_node  *res;
 667         ir_graph *irg = current_ir_graph;
 668
 669         res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
 670         set_irg_end_reg(irg, res);
 671         IRN_VRFY_IRG(res, irg);
 672         return res;
 673 }  /* new_bd_EndReg */
 674
 675 static ir_node *
 676 new_bd_EndExcept(dbg_info *db, ir_node *block) {
 677         ir_node  *res;
 678         ir_graph *irg = current_ir_graph;
 679
 680         res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
 681         set_irg_end_except(irg, res);
 682         IRN_VRFY_IRG (res, irg);
 683         return res;
 684 }  /* new_bd_EndExcept */
 685
 686 static ir_node *
 687 new_bd_Break(dbg_info *db, ir_node *block) {
 688         ir_node  *res;
 689         ir_graph *irg = current_ir_graph;
 690
 691         res = new_ir_node(db, irg, block, op_Break, mode_X, 0, NULL);
 692         res = optimize_node(res);
 693         IRN_VRFY_IRG(res, irg);
 694         return res;
 695 }  /* new_bd_Break */
 696
 697 static ir_node *
 698 new_bd_Filter(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
 699               long proj) {
 700         ir_node  *res;
 701         ir_graph *irg = current_ir_graph;
 702
 703         res = new_ir_node(db, irg, block, op_Filter, mode, 1, &arg);
 704         res->attr.filter.proj = proj;
 705         res->attr.filter.in_cg = NULL;
 706         res->attr.filter.backedge = NULL;
 707
 708         assert(res);
 709         assert(get_Proj_pred(res));
 710         assert(get_nodes_block(get_Proj_pred(res)));
 711
 712         res = optimize_node(res);
 713         IRN_VRFY_IRG(res, irg);
 714         return res;
 715 }  /* new_bd_Filter */
 716
 717 static ir_node *
 718 new_bd_Mux(dbg_info *db, ir_node *block,
 719            ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
 720         ir_node  *in[3];
 721         ir_node  *res;
 722         ir_graph *irg = current_ir_graph;
 723
 724         in[0] = sel;
 725         in[1] = ir_false;
 726         in[2] = ir_true;
 727
 728         res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
 729         assert(res);
 730
 731         res = optimize_node(res);
 732         IRN_VRFY_IRG(res, irg);
 733         return res;
 734 }  /* new_bd_Mux */
 735
 736 static ir_node *
 737 new_bd_Psi(dbg_info *db, ir_node *block,
 738            int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode) {
 739         ir_node  **in;
 740         ir_node  *res;
 741         ir_graph *irg = current_ir_graph;
 742         int i;
 743
 744         NEW_ARR_A(ir_node *, in, 2 * arity + 1);
 745
 746         for (i = 0; i < arity; ++i) {
 747                 in[2 * i]     = cond[i];
 748                 in[2 * i + 1] = vals[i];
 749         }
 750         in[2 * i] = vals[i];
 751
 752         res = new_ir_node(db, irg, block, op_Psi, mode, 2 * arity + 1, in);
 753         assert(res);
 754
 755         res = optimize_node(res);
 756         IRN_VRFY_IRG(res, irg);
 757         return res;
 758 }  /* new_bd_Psi */
 759
 760 static ir_node *
 761 new_bd_CopyB(dbg_info *db, ir_node *block,
 762     ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
 763         ir_node  *in[3];
 764         ir_node  *res;
 765         ir_graph *irg = current_ir_graph;
 766
 767         in[0] = store;
 768         in[1] = dst;
 769         in[2] = src;
 770
 771         res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in);
 772
 773         res->attr.copyb.exc.pin_state = op_pin_state_pinned;
 774         res->attr.copyb.data_type     = data_type;
 775         res = optimize_node(res);
 776         IRN_VRFY_IRG(res, irg);
 777         return res;
 778 }  /* new_bd_CopyB */
 779
 780 static ir_node *
 781 new_bd_InstOf(dbg_info *db, ir_node *block, ir_node *store,
 782               ir_node *objptr, ir_type *type) {
 783         ir_node  *in[2];
 784         ir_node  *res;
 785         ir_graph *irg = current_ir_graph;
 786
 787         in[0] = store;
 788         in[1] = objptr;
 789         res = new_ir_node(db, irg, block, op_Sel, mode_T, 2, in);
 790         res->attr.instof.type = type;
 791         res = optimize_node(res);
 792         IRN_VRFY_IRG(res, irg);
 793         return res;
 794 }  /* new_bd_InstOf */
 795
 796 static ir_node *
 797 new_bd_Raise(dbg_info *db, ir_node *block, ir_node *store, ir_node *obj) {
 798         ir_node  *in[2];
 799         ir_node  *res;
 800         ir_graph *irg = current_ir_graph;
 801
 802         in[0] = store;
 803         in[1] = obj;
 804         res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);
 805         res = optimize_node(res);
 806         IRN_VRFY_IRG(res, irg);
 807         return res;
 808 }  /* new_bd_Raise */
 809
 810 static ir_node *
 811 new_bd_Bound(dbg_info *db, ir_node *block,
 812              ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
 813         ir_node  *in[4];
 814         ir_node  *res;
 815         ir_graph *irg = current_ir_graph;
 816
 817         in[0] = store;
 818         in[1] = idx;
 819         in[2] = lower;
 820         in[3] = upper;
 821         res = new_ir_node(db, irg, block, op_Bound, mode_T, 4, in);
 822         res->attr.bound.exc.pin_state = op_pin_state_pinned;
 823         res = optimize_node(res);
 824         IRN_VRFY_IRG(res, irg);
 825         return res;
 826 }  /* new_bd_Bound */
 827
 828 static ir_node *
 829 new_bd_Pin(dbg_info *db, ir_node *block, ir_node *node) {
 830         ir_node  *res;
 831         ir_graph *irg = current_ir_graph;
 832
 833         res = new_ir_node(db, irg, block, op_Pin, get_irn_mode(node), 1, &node);
 834         res = optimize_node(res);
 835         IRN_VRFY_IRG(res, irg);
 836         return res;
 837 }  /* new_bd_Pin */
 838
 839 /* --------------------------------------------- */
 840 /* private interfaces, for professional use only */
 841 /* --------------------------------------------- */
 842
 843 /* Constructs a Block with a fixed number of predecessors.
 844    Does not set current_block.  Can not be used with automatic
 845    Phi node construction. */
 846 ir_node *
 847 new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node **in) {
 848         ir_graph *rem = current_ir_graph;
 849         ir_node  *res;
 850
 851         current_ir_graph = irg;
 852         res = new_bd_Block(db, arity, in);
 853         current_ir_graph = rem;
 854
 855         return res;
 856 }  /* new_rd_Block */
 857
 858 ir_node *
 859 new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block) {
 860         ir_graph *rem = current_ir_graph;
 861         ir_node  *res;
 862
 863         current_ir_graph = irg;
 864         res = new_bd_Start(db, block);
 865         current_ir_graph = rem;
 866
 867         return res;
 868 }  /* new_rd_Start */
 869
 870 ir_node *
 871 new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block) {
 872         ir_node  *res;
 873         ir_graph *rem = current_ir_graph;
 874
 875         current_ir_graph = rem;
 876         res = new_bd_End(db, block);
 877         current_ir_graph = rem;
 878
 879         return res;
 880 }  /* new_rd_End */
 881
 882 /* Creates a Phi node with all predecessors.  Calling this constructor
 883    is only allowed if the corresponding block is mature.  */
 884 ir_node *
 885 new_rd_Phi(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode) {
 886         ir_node  *res;
 887         ir_graph *rem = current_ir_graph;
 888
 889         current_ir_graph = irg;
 890         res = new_bd_Phi(db, block,arity, in, mode);
 891         current_ir_graph = rem;
 892
 893         return res;
 894 }  /* new_rd_Phi */
 895
 896 ir_node *
 897 new_rd_Const_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) {
 898         ir_node  *res;
 899         ir_graph *rem = current_ir_graph;
 900
 901         current_ir_graph = irg;
 902         res = new_bd_Const_type(db, block, mode, con, tp);
 903         current_ir_graph = rem;
 904
 905         return res;
 906 }  /* new_rd_Const_type */
 907
 908 ir_node *
 909 new_rd_Const(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con) {
 910         ir_node  *res;
 911         ir_graph *rem = current_ir_graph;
 912
 913         current_ir_graph = irg;
 914         res = new_bd_Const_type(db, block, mode, con, firm_unknown_type);
 915         current_ir_graph = rem;
 916
 917         return res;
 918 }  /* new_rd_Const */
 919
 920 ir_node *
 921 new_rd_Const_long(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, long value) {
 922         return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
 923 }  /* new_rd_Const_long */
 924
 925 ir_node *
 926 new_rd_Id(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode) {
 927         ir_node  *res;
 928         ir_graph *rem = current_ir_graph;
 929
 930         current_ir_graph = irg;
 931         res = new_bd_Id(db, block, val, mode);
 932         current_ir_graph = rem;
 933
 934         return res;
 935 }  /* new_rd_Id */
 936
 937 ir_node *
 938 new_rd_Proj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
 939             long proj) {
 940         ir_node  *res;
 941         ir_graph *rem = current_ir_graph;
 942
 943         current_ir_graph = irg;
 944         res = new_bd_Proj(db, block, arg, mode, proj);
 945         current_ir_graph = rem;
 946
 947         return res;
 948 }  /* new_rd_Proj */
 949
 950 ir_node *
 951 new_rd_defaultProj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg,
 952                    long max_proj) {
 953         ir_node  *res;
 954         ir_graph *rem = current_ir_graph;
 955
 956         current_ir_graph = irg;
 957         res = new_bd_defaultProj(db, block, arg, max_proj);
 958         current_ir_graph = rem;
 959
 960         return res;
 961 }  /* new_rd_defaultProj */
 962
 963 ir_node *
 964 new_rd_Conv(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) {
 965         ir_node  *res;
 966         ir_graph *rem = current_ir_graph;
 967
 968         current_ir_graph = irg;
 969         res = new_bd_Conv(db, block, op, mode, 0);
 970         current_ir_graph = rem;
 971
 972         return res;
 973 }  /* new_rd_Conv */
 974
 975 ir_node *
 976 new_rd_Cast(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
 977         ir_node  *res;
 978         ir_graph *rem = current_ir_graph;
 979
 980         current_ir_graph = irg;
 981         res = new_bd_Cast(db, block, op, to_tp);
 982         current_ir_graph = rem;
 983
 984         return res;
 985 }  /* new_rd_Cast */
 986
 987 ir_node *
 988 new_rd_Tuple(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in) {
 989         ir_node  *res;
 990         ir_graph *rem = current_ir_graph;
 991
 992         current_ir_graph = irg;
 993         res = new_bd_Tuple(db, block, arity, in);
 994         current_ir_graph = rem;
 995
 996         return res;
 997 }  /* new_rd_Tuple */
 998
 999 NEW_RD_BINOP(Add)
1000 NEW_RD_BINOP(Sub)
1001 NEW_RD_UNOP(Minus)
1002 NEW_RD_BINOP(Mul)
1003 NEW_RD_DIVOP(Quot)
1004 NEW_RD_DIVOP(DivMod)
1005 NEW_RD_DIVOP(Div)
1006 NEW_RD_DIVOP(Mod)
1007 NEW_RD_BINOP(And)
1008 NEW_RD_BINOP(Or)
1009 NEW_RD_BINOP(Eor)
1010 NEW_RD_UNOP(Not)
1011 NEW_RD_BINOP(Shl)
1012 NEW_RD_BINOP(Shr)
1013 NEW_RD_BINOP(Shrs)
1014 NEW_RD_BINOP(Rot)
1015 NEW_RD_UNOP(Abs)
1016 NEW_RD_BINOP(Carry)
1017 NEW_RD_BINOP(Borrow)
1018
1019 ir_node *
1020 new_rd_Cmp(dbg_info *db, ir_graph *irg, ir_node *block,
1021            ir_node *op1, ir_node *op2) {
1022         ir_node  *res;
1023         ir_graph *rem = current_ir_graph;
1024
1025         current_ir_graph = irg;
1026         res = new_bd_Cmp(db, block, op1, op2);
1027         current_ir_graph = rem;
1028
1029         return res;
1030 }  /* new_rd_Cmp */
1031
1032 ir_node *
1033 new_rd_Jmp(dbg_info *db, ir_graph *irg, ir_node *block) {
1034         ir_node  *res;
1035         ir_graph *rem = current_ir_graph;
1036
1037         current_ir_graph = irg;
1038         res = new_bd_Jmp(db, block);
1039         current_ir_graph = rem;
1040
1041         return res;
1042 }  /* new_rd_Jmp */
1043
1044 ir_node *
1045 new_rd_IJmp(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *tgt) {
1046         ir_node  *res;
1047         ir_graph *rem = current_ir_graph;
1048
1049         current_ir_graph = irg;
1050         res = new_bd_IJmp(db, block, tgt);
1051         current_ir_graph = rem;
1052
1053         return res;
1054 }  /* new_rd_IJmp */
1055
1056 ir_node *
1057 new_rd_Cond(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c) {
1058         ir_node  *res;
1059         ir_graph *rem = current_ir_graph;
1060
1061         current_ir_graph = irg;
1062         res = new_bd_Cond(db, block, c);
1063         current_ir_graph = rem;
1064
1065         return res;
1066 }  /* new_rd_Cond */
1067
1068 ir_node *
1069 new_rd_Call(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1070             ir_node *callee, int arity, ir_node **in, ir_type *tp) {
1071         ir_node  *res;
1072         ir_graph *rem = current_ir_graph;
1073
1074         current_ir_graph = irg;
1075         res = new_bd_Call(db, block, store, callee, arity, in, tp);
1076         current_ir_graph = rem;
1077
1078         return res;
1079 }  /* new_rd_Call */
1080
1081 ir_node *
1082 new_rd_Return(dbg_info *db, ir_graph *irg, ir_node *block,
1083               ir_node *store, int arity, ir_node **in) {
1084         ir_node  *res;
1085         ir_graph *rem = current_ir_graph;
1086
1087         current_ir_graph = irg;
1088         res = new_bd_Return(db, block, store, arity, in);
1089         current_ir_graph = rem;
1090
1091         return res;
1092 }  /* new_rd_Return */
1093
1094 ir_node *
1095 new_rd_Load(dbg_info *db, ir_graph *irg, ir_node *block,
1096             ir_node *store, ir_node *adr, ir_mode *mode) {
1097         ir_node  *res;
1098         ir_graph *rem = current_ir_graph;
1099
1100         current_ir_graph = irg;
1101         res = new_bd_Load(db, block, store, adr, mode);
1102         current_ir_graph = rem;
1103
1104         return res;
1105 }  /* new_rd_Load */
1106
1107 ir_node *
1108 new_rd_Store(dbg_info *db, ir_graph *irg, ir_node *block,
1109              ir_node *store, ir_node *adr, ir_node *val) {
1110         ir_node  *res;
1111         ir_graph *rem = current_ir_graph;
1112
1113         current_ir_graph = irg;
1114         res = new_bd_Store(db, block, store, adr, val);
1115         current_ir_graph = rem;
1116
1117         return res;
1118 }  /* new_rd_Store */
1119
1120 ir_node *
1121 new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1122              ir_node *size, ir_type *alloc_type, where_alloc where) {
1123         ir_node  *res;
1124         ir_graph *rem = current_ir_graph;
1125
1126         current_ir_graph = irg;
1127         res = new_bd_Alloc(db, block, store, size, alloc_type, where);
1128         current_ir_graph = rem;
1129
1130         return res;
1131 }  /* new_rd_Alloc */
1132
1133 ir_node *
1134 new_rd_Free(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1135             ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
1136         ir_node  *res;
1137         ir_graph *rem = current_ir_graph;
1138
1139         current_ir_graph = irg;
1140         res = new_bd_Free(db, block, store, ptr, size, free_type, where);
1141         current_ir_graph = rem;
1142
1143         return res;
1144 }  /* new_rd_Free */
1145
1146 ir_node *
1147 new_rd_simpleSel(dbg_info *db, ir_graph *irg, ir_node *block,
1148                  ir_node *store, ir_node *objptr, ir_entity *ent) {
1149         ir_node  *res;
1150         ir_graph *rem = current_ir_graph;
1151
1152         current_ir_graph = irg;
1153         res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
1154         current_ir_graph = rem;
1155
1156         return res;
1157 }  /* new_rd_simpleSel */
1158
1159 ir_node *
1160 new_rd_Sel(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
1161            int arity, ir_node **in, ir_entity *ent) {
1162         ir_node  *res;
1163         ir_graph *rem = current_ir_graph;
1164
1165         current_ir_graph = irg;
1166         res = new_bd_Sel(db, block, store, objptr, arity, in, ent);
1167         current_ir_graph = rem;
1168
1169         return res;
1170 }  /* new_rd_Sel */
1171
1172 ir_node *
1173 new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
1174                      symconst_kind symkind, ir_type *tp) {
1175         ir_node  *res;
1176         ir_graph *rem = current_ir_graph;
1177
1178         current_ir_graph = irg;
1179         res = new_bd_SymConst_type(db, block, value, symkind, tp);
1180         current_ir_graph = rem;
1181
1182         return res;
1183 }  /* new_rd_SymConst_type */
1184
1185 ir_node *
1186 new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
1187                 symconst_kind symkind) {
1188         ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
1189         return res;
1190 }  /* new_rd_SymConst */
1191
1192  ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
1193         symconst_symbol sym;
1194         sym.entity_p = symbol;
1195         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp);
1196 }  /* new_rd_SymConst_addr_ent */
1197
1198 ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
1199         symconst_symbol sym;
1200         sym.entity_p = symbol;
1201         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_ofs_ent, tp);
1202 }  /* new_rd_SymConst_ofs_ent */
1203
1204 ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
1205         symconst_symbol sym;
1206         sym.ident_p = symbol;
1207         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);
1208 }  /* new_rd_SymConst_addr_name */
1209
1210 ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
1211         symconst_symbol sym;
1212         sym.type_p = symbol;
1213         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);
1214 }  /* new_rd_SymConst_type_tag */
1215
1216 ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
1217         symconst_symbol sym;
1218         sym.type_p = symbol;
1219         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_size, tp);
1220 }  /* new_rd_SymConst_size */
1221
1222 ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
1223         symconst_symbol sym;
1224         sym.type_p = symbol;
1225         return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp);
1226 }  /* new_rd_SymConst_align */
1227
1228 ir_node *
1229 new_rd_Sync(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
1230         ir_node  *res;
1231         ir_graph *rem = current_ir_graph;
1232         int      i;
1233
1234         current_ir_graph = irg;
1235         res = new_bd_Sync(db, block);
1236         current_ir_graph = rem;
1237
1238         for (i = 0; i < arity; ++i)
1239                 add_Sync_pred(res, in[i]);
1240
1241         return res;
1242 }  /* new_rd_Sync */
1243
1244 ir_node *
1245 new_rd_Bad(ir_graph *irg) {
1246         return get_irg_bad(irg);
1247 }  /* new_rd_Bad */
1248
1249 ir_node *
1250 new_rd_Confirm(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
1251         ir_node  *res;
1252         ir_graph *rem = current_ir_graph;
1253
1254         current_ir_graph = irg;
1255         res = new_bd_Confirm(db, block, val, bound, cmp);
1256         current_ir_graph = rem;
1257
1258         return res;
1259 }  /* new_rd_Confirm */
1260
1261 ir_node *
1262 new_rd_Unknown(ir_graph *irg, ir_mode *m) {
1263         ir_node  *res;
1264         ir_graph *rem = current_ir_graph;
1265
1266         current_ir_graph = irg;
1267         res = new_bd_Unknown(m);
1268         current_ir_graph = rem;
1269
1270         return res;
1271 }  /* new_rd_Unknown */
1272
1273 ir_node *
1274 new_rd_CallBegin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) {
1275         ir_node  *res;
1276         ir_graph *rem = current_ir_graph;
1277
1278         current_ir_graph = irg;
1279         res = new_bd_CallBegin(db, block, call);
1280         current_ir_graph = rem;
1281
1282         return res;
1283 }  /* new_rd_CallBegin */
1284
1285 ir_node *
1286 new_rd_EndReg(dbg_info *db, ir_graph *irg, ir_node *block) {
1287         ir_node *res;
1288
1289         res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
1290         set_irg_end_reg(irg, res);
1291         IRN_VRFY_IRG(res, irg);
1292         return res;
1293 }  /* new_rd_EndReg */
1294
1295 ir_node *
1296 new_rd_EndExcept(dbg_info *db, ir_graph *irg, ir_node *block) {
1297         ir_node *res;
1298
1299         res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
1300         set_irg_end_except(irg, res);
1301         IRN_VRFY_IRG (res, irg);
1302         return res;
1303 }  /* new_rd_EndExcept */
1304
1305 ir_node *
1306 new_rd_Break(dbg_info *db, ir_graph *irg, ir_node *block) {
1307         ir_node  *res;
1308         ir_graph *rem = current_ir_graph;
1309
1310         current_ir_graph = irg;
1311         res = new_bd_Break(db, block);
1312         current_ir_graph = rem;
1313
1314         return res;
1315 }  /* new_rd_Break */
1316
1317 ir_node *
1318 new_rd_Filter(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
1319               long proj) {
1320         ir_node  *res;
1321         ir_graph *rem = current_ir_graph;
1322
1323         current_ir_graph = irg;
1324         res = new_bd_Filter(db, block, arg, mode, proj);
1325         current_ir_graph = rem;
1326
1327         return res;
1328 }  /* new_rd_Filter */
1329
1330 ir_node *
1331 new_rd_NoMem(ir_graph *irg) {
1332         return get_irg_no_mem(irg);
1333 }  /* new_rd_NoMem */
1334
1335 ir_node *
1336 new_rd_Mux(dbg_info *db, ir_graph *irg, ir_node *block,
1337            ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
1338         ir_node  *res;
1339         ir_graph *rem = current_ir_graph;
1340
1341         current_ir_graph = irg;
1342         res = new_bd_Mux(db, block, sel, ir_false, ir_true, mode);
1343         current_ir_graph = rem;
1344
1345         return res;
1346 }  /* new_rd_Mux */
1347
1348 ir_node *
1349 new_rd_Psi(dbg_info *db, ir_graph *irg, ir_node *block,
1350            int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode) {
1351         ir_node  *res;
1352         ir_graph *rem = current_ir_graph;
1353
1354         current_ir_graph = irg;
1355         res = new_bd_Psi(db, block, arity, cond, vals, mode);
1356         current_ir_graph = rem;
1357
1358         return res;
1359 }  /* new_rd_Psi */
1360
1361 ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
1362                       ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
1363         ir_node  *res;
1364         ir_graph *rem = current_ir_graph;
1365
1366         current_ir_graph = irg;
1367         res = new_bd_CopyB(db, block, store, dst, src, data_type);
1368         current_ir_graph = rem;
1369
1370         return res;
1371 }  /* new_rd_CopyB */
1372
1373 ir_node *
1374 new_rd_InstOf(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
1375               ir_node *objptr, ir_type *type) {
1376         ir_node  *res;
1377         ir_graph *rem = current_ir_graph;
1378
1379         current_ir_graph = irg;
1380         res = new_bd_InstOf(db, block, store, objptr, type);
1381         current_ir_graph = rem;
1382
1383         return res;
1384 }  /* new_rd_InstOf */
1385
1386 ir_node *
1387 new_rd_Raise(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj) {
1388         ir_node  *res;
1389         ir_graph *rem = current_ir_graph;
1390
1391         current_ir_graph = irg;
1392         res = new_bd_Raise(db, block, store, obj);
1393         current_ir_graph = rem;
1394
1395         return res;
1396 }  /* new_rd_Raise */
1397
1398 ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block,
1399                       ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
1400         ir_node  *res;
1401         ir_graph *rem = current_ir_graph;
1402
1403         current_ir_graph = irg;
1404         res = new_bd_Bound(db, block, store, idx, lower, upper);
1405         current_ir_graph = rem;
1406
1407         return res;
1408 }  /* new_rd_Bound */
1409
1410 ir_node *new_rd_Pin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *node) {
1411         ir_node  *res;
1412         ir_graph *rem = current_ir_graph;
1413
1414         current_ir_graph = irg;
1415         res = new_bd_Pin(db, block, node);
1416         current_ir_graph = rem;
1417
1418         return res;
1419 }  /* new_rd_Pin */
1420
1421 ir_node *new_r_Block(ir_graph *irg,  int arity, ir_node **in) {
1422         return new_rd_Block(NULL, irg, arity, in);
1423 }
1424 ir_node *new_r_Start(ir_graph *irg, ir_node *block) {
1425         return new_rd_Start(NULL, irg, block);
1426 }
1427 ir_node *new_r_End(ir_graph *irg, ir_node *block) {
1428         return new_rd_End(NULL, irg, block);
1429 }
1430 ir_node *new_r_Jmp(ir_graph *irg, ir_node *block) {
1431         return new_rd_Jmp(NULL, irg, block);
1432 }
1433 ir_node *new_r_IJmp(ir_graph *irg, ir_node *block, ir_node *tgt) {
1434         return new_rd_IJmp(NULL, irg, block, tgt);
1435 }
1436 ir_node *new_r_Cond(ir_graph *irg, ir_node *block, ir_node *c) {
1437         return new_rd_Cond(NULL, irg, block, c);
1438 }
1439 ir_node *new_r_Return(ir_graph *irg, ir_node *block,
1440                       ir_node *store, int arity, ir_node **in) {
1441         return new_rd_Return(NULL, irg, block, store, arity, in);
1442 }
1443 ir_node *new_r_Const(ir_graph *irg, ir_node *block,
1444                      ir_mode *mode, tarval *con) {
1445         return new_rd_Const(NULL, irg, block, mode, con);
1446 }
1447 ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
1448                           ir_mode *mode, long value) {
1449         return new_rd_Const_long(NULL, irg, block, mode, value);
1450 }
1451 ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
1452                           ir_mode *mode, tarval *con, ir_type *tp) {
1453         return new_rd_Const_type(NULL, irg, block, mode, con, tp);
1454 }
1455 ir_node *new_r_SymConst(ir_graph *irg, ir_node *block,
1456                         symconst_symbol value, symconst_kind symkind) {
1457         return new_rd_SymConst(NULL, irg, block, value, symkind);
1458 }
1459 ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
1460                          ir_node *objptr, ir_entity *ent) {
1461         return new_rd_Sel(NULL, irg, block, store, objptr, 0, NULL, ent);
1462 }
1463 ir_node *new_r_Sel(ir_graph *irg, ir_node *block, ir_node *store,
1464                    ir_node *objptr, int n_index, ir_node **index,
1465                    ir_entity *ent) {
1466         return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
1467 }
1468 ir_node *new_r_Call(ir_graph *irg, ir_node *block, ir_node *store,
1469                     ir_node *callee, int arity, ir_node **in,
1470                     ir_type *tp) {
1471         return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
1472 }
1473 ir_node *new_r_Add(ir_graph *irg, ir_node *block,
1474                    ir_node *op1, ir_node *op2, ir_mode *mode) {
1475         return new_rd_Add(NULL, irg, block, op1, op2, mode);
1476 }
1477 ir_node *new_r_Sub(ir_graph *irg, ir_node *block,
1478                    ir_node *op1, ir_node *op2, ir_mode *mode) {
1479         return new_rd_Sub(NULL, irg, block, op1, op2, mode);
1480 }
1481 ir_node *new_r_Minus(ir_graph *irg, ir_node *block,
1482                      ir_node *op,  ir_mode *mode) {
1483         return new_rd_Minus(NULL, irg, block,  op, mode);
1484 }
1485 ir_node *new_r_Mul(ir_graph *irg, ir_node *block,
1486                    ir_node *op1, ir_node *op2, ir_mode *mode) {
1487         return new_rd_Mul(NULL, irg, block, op1, op2, mode);
1488 }
1489 ir_node *new_r_Quot(ir_graph *irg, ir_node *block,
1490                     ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
1491         return new_rd_Quot(NULL, irg, block, memop, op1, op2, mode);
1492 }
1493 ir_node *new_r_DivMod(ir_graph *irg, ir_node *block,
1494                       ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
1495         return new_rd_DivMod(NULL, irg, block, memop, op1, op2, mode);
1496 }
1497 ir_node *new_r_Div(ir_graph *irg, ir_node *block,
1498                    ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
1499         return new_rd_Div(NULL, irg, block, memop, op1, op2, mode);
1500 }
1501 ir_node *new_r_Mod(ir_graph *irg, ir_node *block,
1502                    ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
1503         return new_rd_Mod(NULL, irg, block, memop, op1, op2, mode);
1504 }
1505 ir_node *new_r_Abs(ir_graph *irg, ir_node *block,
1506                    ir_node *op, ir_mode *mode) {
1507         return new_rd_Abs(NULL, irg, block, op, mode);
1508 }
1509 ir_node *new_r_And(ir_graph *irg, ir_node *block,
1510                    ir_node *op1, ir_node *op2, ir_mode *mode) {
1511         return new_rd_And(NULL, irg, block,  op1, op2, mode);
1512 }
1513 ir_node *new_r_Or(ir_graph *irg, ir_node *block,
1514                   ir_node *op1, ir_node *op2, ir_mode *mode) {
1515         return new_rd_Or(NULL, irg, block,  op1, op2, mode);
1516 }
1517 ir_node *new_r_Eor(ir_graph *irg, ir_node *block,
1518                    ir_node *op1, ir_node *op2, ir_mode *mode) {
1519         return new_rd_Eor(NULL, irg, block,  op1, op2, mode);
1520 }
1521 ir_node *new_r_Not(ir_graph *irg, ir_node *block,
1522                    ir_node *op, ir_mode *mode) {
1523         return new_rd_Not(NULL, irg, block, op, mode);
1524 }
1525 ir_node *new_r_Shl(ir_graph *irg, ir_node *block,
1526                    ir_node *op, ir_node *k, ir_mode *mode) {
1527         return new_rd_Shl(NULL, irg, block, op, k, mode);
1528 }
1529 ir_node *new_r_Shr(ir_graph *irg, ir_node *block,
1530                    ir_node *op, ir_node *k, ir_mode *mode) {
1531         return new_rd_Shr(NULL, irg, block, op, k, mode);
1532 }
1533 ir_node *new_r_Shrs(ir_graph *irg, ir_node *block,
1534                     ir_node *op, ir_node *k, ir_mode *mode) {
1535         return new_rd_Shrs(NULL, irg, block, op, k, mode);
1536 }
1537 ir_node *new_r_Rot(ir_graph *irg, ir_node *block,
1538                    ir_node *op, ir_node *k, ir_mode *mode) {
1539         return new_rd_Rot(NULL, irg, block, op, k, mode);
1540 }
1541 ir_node *new_r_Carry(ir_graph *irg, ir_node *block,
1542                      ir_node *op, ir_node *k, ir_mode *mode) {
1543         return new_rd_Carry(NULL, irg, block, op, k, mode);
1544 }
1545 ir_node *new_r_Borrow(ir_graph *irg, ir_node *block,
1546                       ir_node *op, ir_node *k, ir_mode *mode) {
1547         return new_rd_Borrow(NULL, irg, block, op, k, mode);
1548 }
1549 ir_node *new_r_Cmp(ir_graph *irg, ir_node *block,
1550                    ir_node *op1, ir_node *op2) {
1551         return new_rd_Cmp(NULL, irg, block, op1, op2);
1552 }
1553 ir_node *new_r_Conv(ir_graph *irg, ir_node *block,
1554                     ir_node *op, ir_mode *mode) {
1555         return new_rd_Conv(NULL, irg, block, op, mode);
1556 }
1557 ir_node *new_r_Cast(ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
1558         return new_rd_Cast(NULL, irg, block, op, to_tp);
1559 }
1560 ir_node *new_r_Phi(ir_graph *irg, ir_node *block, int arity,
1561                    ir_node **in, ir_mode *mode) {
1562         return new_rd_Phi(NULL, irg, block, arity, in, mode);
1563 }
1564 ir_node *new_r_Load(ir_graph *irg, ir_node *block,
1565                     ir_node *store, ir_node *adr, ir_mode *mode) {
1566         return new_rd_Load(NULL, irg, block, store, adr, mode);
1567 }
1568 ir_node *new_r_Store(ir_graph *irg, ir_node *block,
1569                      ir_node *store, ir_node *adr, ir_node *val) {
1570         return new_rd_Store(NULL, irg, block, store, adr, val);
1571 }
1572 ir_node *new_r_Alloc(ir_graph *irg, ir_node *block, ir_node *store,
1573                      ir_node *size, ir_type *alloc_type, where_alloc where) {
1574         return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
1575 }
1576 ir_node *new_r_Free(ir_graph *irg, ir_node *block, ir_node *store,
1577                     ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
1578         return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
1579 }
1580 ir_node *new_r_Sync(ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
1581         return new_rd_Sync(NULL, irg, block, arity, in);
1582 }
1583 ir_node *new_r_Proj(ir_graph *irg, ir_node *block, ir_node *arg,
1584                     ir_mode *mode, long proj) {
1585         return new_rd_Proj(NULL, irg, block, arg, mode, proj);
1586 }
1587 ir_node *new_r_defaultProj(ir_graph *irg, ir_node *block, ir_node *arg,
1588                            long max_proj) {
1589         return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
1590 }
1591 ir_node *new_r_Tuple(ir_graph *irg, ir_node *block,
1592                      int arity, ir_node **in) {
1593         return new_rd_Tuple(NULL, irg, block, arity, in );
1594 }
1595 ir_node *new_r_Id(ir_graph *irg, ir_node *block,
1596                   ir_node *val, ir_mode *mode) {
1597         return new_rd_Id(NULL, irg, block, val, mode);
1598 }
1599 ir_node *new_r_Bad(ir_graph *irg) {
1600         return new_rd_Bad(irg);
1601 }
1602 ir_node *new_r_Confirm(ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
1603         return new_rd_Confirm (NULL, irg, block, val, bound, cmp);
1604 }
1605 ir_node *new_r_Unknown(ir_graph *irg, ir_mode *m) {
1606         return new_rd_Unknown(irg, m);
1607 }
1608 ir_node *new_r_CallBegin(ir_graph *irg, ir_node *block, ir_node *callee) {
1609         return new_rd_CallBegin(NULL, irg, block, callee);
1610 }
1611 ir_node *new_r_EndReg(ir_graph *irg, ir_node *block) {
1612         return new_rd_EndReg(NULL, irg, block);
1613 }
1614 ir_node *new_r_EndExcept(ir_graph *irg, ir_node *block) {
1615         return new_rd_EndExcept(NULL, irg, block);
1616 }
1617 ir_node *new_r_Break(ir_graph *irg, ir_node *block) {
1618         return new_rd_Break(NULL, irg, block);
1619 }
1620 ir_node *new_r_Filter(ir_graph *irg, ir_node *block, ir_node *arg,
1621                       ir_mode *mode, long proj) {
1622         return new_rd_Filter(NULL, irg, block, arg, mode, proj);
1623 }
1624 ir_node *new_r_NoMem(ir_graph *irg) {
1625         return new_rd_NoMem(irg);
1626 }
1627 ir_node *new_r_Mux(ir_graph *irg, ir_node *block,
1628                    ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
1629         return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
1630 }
1631 ir_node *new_r_Psi(ir_graph *irg, ir_node *block,
1632                    int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
1633         return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
1634 }
1635 ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
1636                      ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
1637         return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
1638 }
1639 ir_node *new_r_InstOf(ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
1640                       ir_type *type) {
1641         return new_rd_InstOf(NULL, irg, block, store, objptr, type);
1642 }
1643 ir_node *new_r_Raise(ir_graph *irg, ir_node *block,
1644                      ir_node *store, ir_node *obj) {
1645         return new_rd_Raise(NULL, irg, block, store, obj);
1646 }
1647 ir_node *new_r_Bound(ir_graph *irg, ir_node *block,
1648                      ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
1649         return new_rd_Bound(NULL, irg, block, store, idx, lower, upper);
1650 }
1651 ir_node *new_r_Pin(ir_graph *irg, ir_node *block, ir_node *node) {
1652         return new_rd_Pin(NULL, irg, block, node);
1653 }
1654
1655 /** ********************/
1656 /** public interfaces  */
1657 /** construction tools */
1658
1659 /**
1660  *
1661  *   - create a new Start node in the current block
1662  *
1663  *   @return s - pointer to the created Start node
1664  *
1665  *
1666  */
1667 ir_node *
1668 new_d_Start(dbg_info *db) {
1669         ir_node *res;
1670
1671         res = new_ir_node(db, current_ir_graph, current_ir_graph->current_block,
1672                           op_Start, mode_T, 0, NULL);
1673
1674         res = optimize_node(res);
1675         IRN_VRFY_IRG(res, current_ir_graph);
1676         return res;
1677 }  /* new_d_Start */
1678
1679 ir_node *
1680 new_d_End(dbg_info *db) {
1681         ir_node *res;
1682         res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
1683                           op_End, mode_X, -1, NULL);
1684         res = optimize_node(res);
1685         IRN_VRFY_IRG(res, current_ir_graph);
1686
1687         return res;
1688 }  /* new_d_End */
1689
1690 /* Constructs a Block with a fixed number of predecessors.
1691    Does set current_block.  Can be used with automatic Phi
1692    node construction. */
1693 ir_node *
1694 new_d_Block(dbg_info *db, int arity, ir_node **in) {
1695         ir_node *res;
1696         int i;
1697         int has_unknown = 0;
1698
1699         res = new_bd_Block(db, arity, in);
1700
1701         /* Create and initialize array for Phi-node construction. */
1702         if (get_irg_phase_state(current_ir_graph) == phase_building) {
1703                 res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
1704                                                       current_ir_graph->n_loc);
1705                 memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1706         }
1707
1708         for (i = arity-1; i >= 0; i--)
1709                 if (get_irn_op(in[i]) == op_Unknown) {
1710                         has_unknown = 1;
1711                         break;
1712                 }
1713
1714         if (!has_unknown) res = optimize_node(res);
1715         current_ir_graph->current_block = res;
1716
1717         IRN_VRFY_IRG(res, current_ir_graph);
1718
1719         return res;
1720 }  /* new_d_Block */
1721
1722 /* ***********************************************************************/
1723 /* Methods necessary for automatic Phi node creation                     */
1724 /*
1725   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1726   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1727   ir_node *new_rd_Phi0          (ir_graph *irg, ir_node *block, ir_mode *mode)
1728   ir_node *new_rd_Phi_in        (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
1729
1730   Call Graph:   ( A ---> B == A "calls" B)
1731
1732        get_value         mature_immBlock
1733           |                   |
1734           |                   |
1735           |                   |
1736           |          ---> phi_merge
1737           |         /       /   \
1738           |        /       /     \
1739          \|/      /      |/_      \
1740        get_r_value_internal        |
1741                 |                  |
1742                 |                  |
1743                \|/                \|/
1744            new_rd_Phi0          new_rd_Phi_in
1745
1746 * *************************************************************************** */
1747
1748 /** Creates a Phi node with 0 predecessors. */
1749 static INLINE ir_node *
1750 new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode) {
1751         ir_node *res;
1752
1753         res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
1754         IRN_VRFY_IRG(res, irg);
1755         return res;
1756 }  /* new_rd_Phi0 */
1757
1758 /* There are two implementations of the Phi node construction.  The first
1759    is faster, but does not work for blocks with more than 2 predecessors.
1760    The second works always but is slower and causes more unnecessary Phi
1761    nodes.
1762    Select the implementations by the following preprocessor flag set in
1763    common/common.h: */
1764 #if USE_FAST_PHI_CONSTRUCTION
1765
1766 /* This is a stack used for allocating and deallocating nodes in
1767    new_rd_Phi_in.  The original implementation used the obstack
1768    to model this stack, now it is explicit.  This reduces side effects.
1769 */
1770 #if USE_EXPLICIT_PHI_IN_STACK
1771 Phi_in_stack *
1772 new_Phi_in_stack(void) {
1773         Phi_in_stack *res;
1774
1775         res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
1776
1777         res->stack = NEW_ARR_F (ir_node *, 0);
1778         res->pos = 0;
1779
1780         return res;
1781 }  /* new_Phi_in_stack */
1782
1783 void
1784 free_Phi_in_stack(Phi_in_stack *s) {
1785         DEL_ARR_F(s->stack);
1786         free(s);
1787 }  /* free_Phi_in_stack */
1788
1789 static INLINE void
1790 free_to_Phi_in_stack(ir_node *phi) {
1791         if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
1792             current_ir_graph->Phi_in_stack->pos)
1793                 ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
1794         else
1795                 current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
1796
1797         (current_ir_graph->Phi_in_stack->pos)++;
1798 }  /* free_to_Phi_in_stack */
1799
1800 static INLINE ir_node *
1801 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
1802                                int arity, ir_node **in) {
1803         ir_node *res;
1804         ir_node **stack = current_ir_graph->Phi_in_stack->stack;
1805         int pos = current_ir_graph->Phi_in_stack->pos;
1806
1807
1808         if (pos == 0) {
1809                 /* We need to allocate a new node */
1810                 res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
1811                 res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
1812         } else {
1813                 /* reuse the old node and initialize it again. */
1814                 res = stack[pos-1];
1815
1816                 assert(res->kind == k_ir_node);
1817                 assert(res->op == op_Phi);
1818                 res->mode = mode;
1819                 res->visited = 0;
1820                 res->link = NULL;
1821                 assert(arity >= 0);
1822                 /* ???!!! How to free the old in array??  Not at all: on obstack ?!! */
1823                 res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
1824                 res->in[0] = block;
1825                 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
1826
1827                 (current_ir_graph->Phi_in_stack->pos)--;
1828         }
1829         return res;
1830 }  /* alloc_or_pop_from_Phi_in_stack */
1831 #endif /* USE_EXPLICIT_PHI_IN_STACK */
1832
1833 /**
1834  * Creates a Phi node with a given, fixed array **in of predecessors.
1835  * If the Phi node is unnecessary, as the same value reaches the block
1836  * through all control flow paths, it is eliminated and the value
1837  * returned directly.  This constructor is only intended for use in
1838  * the automatic Phi node generation triggered by get_value or mature.
1839  * The implementation is quite tricky and depends on the fact, that
1840  * the nodes are allocated on a stack:
1841  * The in array contains predecessors and NULLs.  The NULLs appear,
1842  * if get_r_value_internal, that computed the predecessors, reached
1843  * the same block on two paths.  In this case the same value reaches
1844  * this block on both paths, there is no definition in between.  We need
1845  * not allocate a Phi where these path's merge, but we have to communicate
1846  * this fact to the caller.  This happens by returning a pointer to the
1847  * node the caller _will_ allocate.  (Yes, we predict the address. We can
1848  * do so because the nodes are allocated on the obstack.)  The caller then
1849  * finds a pointer to itself and, when this routine is called again,
1850  * eliminates itself.
1851  */
1852 static INLINE ir_node *
1853 new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins) {
1854         int i;
1855         ir_node *res, *known;
1856
1857         /* Allocate a new node on the obstack.  This can return a node to
1858            which some of the pointers in the in-array already point.
1859            Attention: the constructor copies the in array, i.e., the later
1860            changes to the array in this routine do not affect the
1861            constructed node!  If the in array contains NULLs, there will be
1862            missing predecessors in the returned node.  Is this a possible
1863            internal state of the Phi node generation? */
1864 #if USE_EXPLICIT_PHI_IN_STACK
1865         res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
1866 #else
1867         res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
1868         res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
1869 #endif
1870
1871         /* The in-array can contain NULLs.  These were returned by
1872            get_r_value_internal if it reached the same block/definition on a
1873            second path.  The NULLs are replaced by the node itself to
1874            simplify the test in the next loop. */
1875         for (i = 0;  i < ins;  ++i) {
1876                 if (in[i] == NULL)
1877                         in[i] = res;
1878         }
1879
1880         /* This loop checks whether the Phi has more than one predecessor.
1881            If so, it is a real Phi node and we break the loop.  Else the Phi
1882            node merges the same definition on several paths and therefore is
1883            not needed. */
1884         for (i = 0;  i < ins;  ++i) {
1885                 if (in[i] == res || in[i] == known)
1886                         continue;
1887
1888                 if (known == res)
1889                         known = in[i];
1890                 else
1891                         break;
1892         }
1893
1894         /* i==ins: there is at most one predecessor, we don't need a phi node. */
1895         if (i==ins) {
1896 #if USE_EXPLICIT_PHI_IN_STACK
1897                 free_to_Phi_in_stack(res);
1898 #else
1899                 edges_node_deleted(res, current_ir_graph);
1900                 obstack_free(current_ir_graph->obst, res);
1901 #endif
1902                 res = known;
1903         } else {
1904                 res = optimize_node (res);
1905                 IRN_VRFY_IRG(res, irg);
1906         }
1907
1908         /* return the pointer to the Phi node.  This node might be deallocated! */
1909         return res;
1910 }  /* new_rd_Phi_in */
1911
1912 static ir_node *
1913 get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
1914
1915 /**
1916  * Allocates and returns this node.  The routine called to allocate the
1917  * node might optimize it away and return a real value, or even a pointer
1918  * to a deallocated Phi node on top of the obstack!
1919  * This function is called with an in-array of proper size.
1920  */
1921 static ir_node *
1922 phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
1923         ir_node *prevBlock, *res;
1924         int i;
1925
1926         /* This loop goes to all predecessor blocks of the block the Phi node is in
1927            and there finds the operands of the Phi node by calling
1928            get_r_value_internal. */
1929         for (i = 1;  i <= ins;  ++i) {
1930                 assert (block->in[i]);
1931                 prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1932                 assert (prevBlock);
1933                 nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1934         }
1935
1936         /* After collecting all predecessors into the array nin a new Phi node
1937            with these predecessors is created.  This constructor contains an
1938            optimization: If all predecessors of the Phi node are identical it
1939            returns the only operand instead of a new Phi node.  If the value
1940            passes two different control flow edges without being defined, and
1941            this is the second path treated, a pointer to the node that will be
1942            allocated for the first path (recursion) is returned.  We already
1943            know the address of this node, as it is the next node to be allocated
1944            and will be placed on top of the obstack. (The obstack is a _stack_!) */
1945         res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
1946
1947         /* Now we now the value for "pos" and can enter it in the array with
1948            all known local variables.  Attention: this might be a pointer to
1949            a node, that later will be allocated!!! See new_rd_Phi_in().
1950            If this is called in mature, after some set_value() in the same block,
1951            the proper value must not be overwritten:
1952            The call order
1953              get_value    (makes Phi0, put's it into graph_arr)
1954              set_value    (overwrites Phi0 in graph_arr)
1955              mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
1956                            the proper value.)
1957            fails. */
1958         if (!block->attr.block.graph_arr[pos]) {
1959                 block->attr.block.graph_arr[pos] = res;
1960         } else {
1961                 /*  printf(" value already computed by %s\n",
1962                 get_id_str(block->attr.block.graph_arr[pos]->op->name));  */
1963         }
1964
1965         return res;
1966 }
1967
1968 /**
1969  * This function returns the last definition of a variable.  In case
1970  * this variable was last defined in a previous block, Phi nodes are
1971  * inserted.  If the part of the firm graph containing the definition
1972  * is not yet constructed, a dummy Phi node is returned.
1973  */
1974 static ir_node *
1975 get_r_value_internal(ir_node *block, int pos, ir_mode *mode)
1976 {
1977         ir_node *res;
1978         /* There are 4 cases to treat.
1979
1980            1. The block is not mature and we visit it the first time.  We can not
1981               create a proper Phi node, therefore a Phi0, i.e., a Phi without
1982               predecessors is returned.  This node is added to the linked list (field
1983               "link") of the containing block to be completed when this block is
1984               matured. (Completion will add a new Phi and turn the Phi0 into an Id
1985               node.)
1986
1987            2. The value is already known in this block, graph_arr[pos] is set and we
1988               visit the block the first time.  We can return the value without
1989               creating any new nodes.
1990
1991            3. The block is mature and we visit it the first time.  A Phi node needs
1992               to be created (phi_merge).  If the Phi is not needed, as all it's
1993               operands are the same value reaching the block through different
1994               paths, it's optimized away and the value itself is returned.
1995
1996            4. The block is mature, and we visit it the second time.  Now two
1997               subcases are possible:
1998               * The value was computed completely the last time we were here. This
1999                 is the case if there is no loop.  We can return the proper value.
2000               * The recursion that visited this node and set the flag did not
2001                 return yet.  We are computing a value in a loop and need to
2002                 break the recursion without knowing the result yet.
2003             @@@ strange case.  Straight forward we would create a Phi before
2004             starting the computation of it's predecessors.  In this case we will
2005             find a Phi here in any case.  The problem is that this implementation
2006             only creates a Phi after computing the predecessors, so that it is
2007             hard to compute self references of this Phi.  @@@
2008               There is no simple check for the second subcase.  Therefore we check
2009               for a second visit and treat all such cases as the second subcase.
2010               Anyways, the basic situation is the same:  we reached a block
2011               on two paths without finding a definition of the value:  No Phi
2012               nodes are needed on both paths.
2013               We return this information "Two paths, no Phi needed" by a very tricky
2014               implementation that relies on the fact that an obstack is a stack and
2015               will return a node with the same address on different allocations.
2016               Look also at phi_merge and new_rd_phi_in to understand this.
2017           @@@ Unfortunately this does not work, see testprogram
2018           three_cfpred_example.
2019
2020         */
2021
2022         /* case 4 -- already visited. */
2023         if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
2024
2025         /* visited the first time */
2026         set_irn_visited(block, get_irg_visited(current_ir_graph));
2027
2028         /* Get the local valid value */
2029         res = block->attr.block.graph_arr[pos];
2030
2031         /* case 2 -- If the value is actually computed, return it. */
2032         if (res) return res;
2033
2034         if (block->attr.block.is_matured) { /* case 3 */
2035
2036                 /* The Phi has the same amount of ins as the corresponding block. */
2037                 int ins = get_irn_arity(block);
2038                 ir_node **nin;
2039                 NEW_ARR_A(ir_node *, nin, ins);
2040
2041                 /* Phi merge collects the predecessors and then creates a node. */
2042                 res = phi_merge(block, pos, mode, nin, ins);
2043
2044         } else {  /* case 1 */
2045                 /* The block is not mature, we don't know how many in's are needed.  A Phi
2046                    with zero predecessors is created.  Such a Phi node is called Phi0
2047                    node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
2048                    to the list of Phi0 nodes in this block to be matured by mature_immBlock
2049                    later.
2050                    The Phi0 has to remember the pos of it's internal value.  If the real
2051                    Phi is computed, pos is used to update the array with the local
2052                    values. */
2053
2054                 res = new_rd_Phi0(current_ir_graph, block, mode);
2055                 res->attr.phi0_pos = pos;
2056                 res->link = block->link;
2057                 block->link = res;
2058         }
2059
2060         /* If we get here, the frontend missed a use-before-definition error */
2061         if (!res) {
2062                 /* Error Message */
2063                 printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2064                 assert(mode->code >= irm_F && mode->code <= irm_P);
2065                 res = new_rd_Const(NULL, current_ir_graph, block, mode, tarval_mode_null[mode->code]);
2066         }
2067
2068         /* The local valid value is available now. */
2069         block->attr.block.graph_arr[pos] = res;
2070
2071         return res;
2072 }  /* get_r_value_internal */
2073
2074 #else /* if 0 */
2075
2076 /**
2077     it starts the recursion.  This causes an Id at the entry of
2078     every block that has no definition of the value! **/
2079
2080 #if USE_EXPLICIT_PHI_IN_STACK
2081 /* Just dummies */
2082 Phi_in_stack * new_Phi_in_stack() { return NULL; }
2083 void free_Phi_in_stack(Phi_in_stack *s) {}
2084 #endif
2085
2086 static INLINE ir_node *
2087 new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode,
2088               ir_node **in, int ins, ir_node *phi0) {
2089         int i;
2090         ir_node *res, *known;
2091
2092         /* Allocate a new node on the obstack.  The allocation copies the in
2093            array. */
2094         res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
2095         res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
2096
2097         /* This loop checks whether the Phi has more than one predecessor.
2098            If so, it is a real Phi node and we break the loop.  Else the
2099            Phi node merges the same definition on several paths and therefore
2100            is not needed. Don't consider Bad nodes! */
2101         known = res;
2102         for (i=0;  i < ins;  ++i)
2103         {
2104                 assert(in[i]);
2105
2106                 in[i] = skip_Id(in[i]);  /* increases the number of freed Phis. */
2107
2108                 /* Optimize self referencing Phis:  We can't detect them yet properly, as
2109                 they still refer to the Phi0 they will replace.  So replace right now. */
2110                 if (phi0 && in[i] == phi0) in[i] = res;
2111
2112                 if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
2113
2114                 if (known==res)
2115                         known = in[i];
2116                 else
2117                         break;
2118         }
2119
2120         /* i==ins: there is at most one predecessor, we don't need a phi node. */
2121         if (i == ins) {
2122                 if (res != known) {
2123                         edges_node_deleted(res, current_ir_graph);
2124                         obstack_free (current_ir_graph->obst, res);
2125                         if (is_Phi(known)) {
2126                                 /* If pred is a phi node we want to optimize it: If loops are matured in a bad
2127                                    order, an enclosing Phi know may get superfluous. */
2128                                 res = optimize_in_place_2(known);
2129                                 if (res != known)
2130                                         exchange(known, res);
2131
2132                         }
2133                         else
2134                                 res = known;
2135                 } else {
2136                         /* A undefined value, e.g., in unreachable code. */
2137                         res = new_Bad();
2138                 }
2139         } else {
2140                 res = optimize_node (res);  /* This is necessary to add the node to the hash table for cse. */
2141                 IRN_VRFY_IRG(res, irg);
2142                 /* Memory Phis in endless loops must be kept alive.
2143                    As we can't distinguish these easily we keep all of them alive. */
2144                 if ((res->op == op_Phi) && (mode == mode_M))
2145                         add_End_keepalive(get_irg_end(irg), res);
2146         }
2147
2148         return res;
2149 }  /* new_rd_Phi_in */
2150
2151 static ir_node *
2152 get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
2153
2154 #if PRECISE_EXC_CONTEXT
2155 static ir_node *
2156 phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
2157
2158 /**
2159  * Construct a new frag_array for node n.
2160  * Copy the content from the current graph_arr of the corresponding block:
2161  * this is the current state.
2162  * Set ProjM(n) as current memory state.
2163  * Further the last entry in frag_arr of current block points to n.  This
2164  * constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block.
2165  */
2166 static INLINE ir_node **new_frag_arr(ir_node *n) {
2167         ir_node **arr;
2168         int opt;
2169
2170         arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
2171         memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
2172                sizeof(ir_node *)*current_ir_graph->n_loc);
2173
2174         /* turn off optimization before allocating Proj nodes, as res isn't
2175            finished yet. */
2176         opt = get_opt_optimize(); set_optimize(0);
2177         /* Here we rely on the fact that all frag ops have Memory as first result! */
2178         if (get_irn_op(n) == op_Call)
2179                 arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
2180         else if (get_irn_op(n) == op_CopyB)
2181                 arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
2182         else {
2183                 assert((pn_Quot_M == pn_DivMod_M) &&
2184                        (pn_Quot_M == pn_Div_M)    &&
2185                        (pn_Quot_M == pn_Mod_M)    &&
2186                        (pn_Quot_M == pn_Load_M)   &&
2187                        (pn_Quot_M == pn_Store_M)  &&
2188                        (pn_Quot_M == pn_Alloc_M)  &&
2189                        (pn_Quot_M == pn_Bound_M));
2190                 arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
2191         }
2192         set_optimize(opt);
2193
2194         current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
2195         return arr;
2196 }  /* new_frag_arr */
2197
2198 /**
2199  * Returns the frag_arr from a node.
2200  */
2201 static INLINE ir_node **get_frag_arr(ir_node *n) {
2202         switch (get_irn_opcode(n)) {
2203         case iro_Call:
2204                 return n->attr.call.exc.frag_arr;
2205         case iro_Alloc:
2206                 return n->attr.alloc.exc.frag_arr;
2207         case iro_Load:
2208                 return n->attr.load.exc.frag_arr;
2209         case iro_Store:
2210                 return n->attr.store.exc.frag_arr;
2211         default:
2212                 return n->attr.except.frag_arr;
2213         }
2214 }  /* get_frag_arr */
2215
2216 static void
2217 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
2218 #if 0
2219         if (!frag_arr[pos]) frag_arr[pos] = val;
2220         if (frag_arr[current_ir_graph->n_loc - 1]) {
2221                 ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2222                 assert(arr != frag_arr && "Endless recursion detected");
2223                 set_frag_value(arr, pos, val);
2224         }
2225 #else
2226         int i;
2227
2228         for (i = 0; i < 1000; ++i) {
2229                 if (!frag_arr[pos]) {
2230                         frag_arr[pos] = val;
2231                 }
2232                 if (frag_arr[current_ir_graph->n_loc - 1]) {
2233                         ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
2234                         frag_arr = arr;
2235                 }
2236                 else
2237                         return;
2238         }
2239         assert(0 && "potential endless recursion");
2240 #endif
2241 }  /* set_frag_value */
2242
2243 static ir_node *
2244 get_r_frag_value_internal(ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
2245         ir_node *res;
2246         ir_node **frag_arr;
2247
2248         assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
2249
2250         frag_arr = get_frag_arr(cfOp);
2251         res = frag_arr[pos];
2252         if (!res) {
2253                 if (block->attr.block.graph_arr[pos]) {
2254                         /* There was a set_value() after the cfOp and no get_value before that
2255                            set_value().  We must build a Phi node now. */
2256                         if (block->attr.block.is_matured) {
2257                                 int ins = get_irn_arity(block);
2258                                 ir_node **nin;
2259                                 NEW_ARR_A(ir_node *, nin, ins);
2260                                 res = phi_merge(block, pos, mode, nin, ins);
2261                         } else {
2262                                 res = new_rd_Phi0(current_ir_graph, block, mode);
2263                                 res->attr.phi0.pos = pos;
2264                                 res->link = block->link;
2265                                 block->link = res;
2266                         }
2267                         assert(res);
2268                         /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
2269                            but this should be better: (remove comment if this works) */
2270                         /* It's a Phi, we can write this into all graph_arrs with NULL */
2271                         set_frag_value(block->attr.block.graph_arr, pos, res);
2272                 } else {
2273                         res = get_r_value_internal(block, pos, mode);
2274                         set_frag_value(block->attr.block.graph_arr, pos, res);
2275                 }
2276         }
2277         return res;
2278 }  /* get_r_frag_value_internal */
2279 #endif /* PRECISE_EXC_CONTEXT */
2280
2281 /**
2282  * Computes the predecessors for the real phi node, and then
2283  * allocates and returns this node.  The routine called to allocate the
2284  * node might optimize it away and return a real value.
2285  * This function must be called with an in-array of proper size.
2286  */
2287 static ir_node *
2288 phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
2289         ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
2290         int i;
2291
2292         /* If this block has no value at pos create a Phi0 and remember it
2293            in graph_arr to break recursions.
2294            Else we may not set graph_arr as there a later value is remembered. */
2295         phi0 = NULL;
2296         if (!block->attr.block.graph_arr[pos]) {
2297                 if (block == get_irg_start_block(current_ir_graph)) {
2298                         /* Collapsing to Bad tarvals is no good idea.
2299                            So we call a user-supplied routine here that deals with this case as
2300                            appropriate for the given language. Sorrily the only help we can give
2301                            here is the position.
2302
2303                            Even if all variables are defined before use, it can happen that
2304                            we get to the start block, if a Cond has been replaced by a tuple
2305                            (bad, jmp).  In this case we call the function needlessly, eventually
2306                            generating an non existent error.
2307                            However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
2308                            before recurring.
2309                          */
2310                         if (default_initialize_local_variable) {
2311                                 ir_node *rem = get_cur_block();
2312
2313                                 set_cur_block(block);
2314                                 block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);
2315                                 set_cur_block(rem);
2316                         }
2317                         else
2318                                 block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
2319                         /* We don't need to care about exception ops in the start block.
2320                            There are none by definition. */
2321                         return block->attr.block.graph_arr[pos];
2322                 } else {
2323                         phi0 = new_rd_Phi0(current_ir_graph, block, mode);
2324                         block->attr.block.graph_arr[pos] = phi0;
2325 #if PRECISE_EXC_CONTEXT
2326                         if (get_opt_precise_exc_context()) {
2327                                 /* Set graph_arr for fragile ops.  Also here we should break recursion.
2328                                    We could choose a cyclic path through an cfop.  But the recursion would
2329                                    break at some point. */
2330                                 set_frag_value(block->attr.block.graph_arr, pos, phi0);
2331                         }
2332 #endif
2333                 }
2334         }
2335
2336         /* This loop goes to all predecessor blocks of the block the Phi node
2337            is in and there finds the operands of the Phi node by calling
2338            get_r_value_internal.  */
2339         for (i = 1;  i <= ins;  ++i) {
2340                 prevCfOp = skip_Proj(block->in[i]);
2341                 assert (prevCfOp);
2342                 if (is_Bad(prevCfOp)) {
2343                         /* In case a Cond has been optimized we would get right to the start block
2344                         with an invalid definition. */
2345                         nin[i-1] = new_Bad();
2346                         continue;
2347                 }
2348                 prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
2349                 assert (prevBlock);
2350                 if (!is_Bad(prevBlock)) {
2351 #if PRECISE_EXC_CONTEXT
2352                         if (get_opt_precise_exc_context() &&
2353                                 is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
2354                                         assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
2355                                         nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
2356                         } else
2357 #endif
2358                                 nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
2359                 } else {
2360                         nin[i-1] = new_Bad();
2361                 }
2362         }
2363
2364         /* We want to pass the Phi0 node to the constructor: this finds additional
2365            optimization possibilities.
2366            The Phi0 node either is allocated in this function, or it comes from
2367            a former call to get_r_value_internal. In this case we may not yet
2368            exchange phi0, as this is done in mature_immBlock. */
2369         if (!phi0) {
2370                 phi0_all = block->attr.block.graph_arr[pos];
2371                 if (!((get_irn_op(phi0_all) == op_Phi) &&
2372                         (get_irn_arity(phi0_all) == 0)   &&
2373                         (get_nodes_block(phi0_all) == block)))
2374                         phi0_all = NULL;
2375         } else {
2376                 phi0_all = phi0;
2377         }
2378
2379         /* After collecting all predecessors into the array nin a new Phi node
2380            with these predecessors is created.  This constructor contains an
2381            optimization: If all predecessors of the Phi node are identical it
2382            returns the only operand instead of a new Phi node.  */
2383         res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins, phi0_all);
2384
2385         /* In case we allocated a Phi0 node at the beginning of this procedure,
2386            we need to exchange this Phi0 with the real Phi. */
2387         if (phi0) {
2388                 exchange(phi0, res);
2389                 block->attr.block.graph_arr[pos] = res;
2390                 /* Don't set_frag_value as it does not overwrite.  Doesn't matter, is
2391                    only an optimization. */
2392         }
2393
2394         return res;
2395 }  /* phi_merge */
2396
2397 /**
2398  * This function returns the last definition of a variable.  In case
2399  * this variable was last defined in a previous block, Phi nodes are
2400  * inserted.  If the part of the firm graph containing the definition
2401  * is not yet constructed, a dummy Phi node is returned.
2402  */
2403 static ir_node *
2404 get_r_value_internal(ir_node *block, int pos, ir_mode *mode) {
2405         ir_node *res;
2406         /* There are 4 cases to treat.
2407
2408            1. The block is not mature and we visit it the first time.  We can not
2409               create a proper Phi node, therefore a Phi0, i.e., a Phi without
2410               predecessors is returned.  This node is added to the linked list (field
2411               "link") of the containing block to be completed when this block is
2412               matured. (Completion will add a new Phi and turn the Phi0 into an Id
2413               node.)
2414
2415            2. The value is already known in this block, graph_arr[pos] is set and we
2416               visit the block the first time.  We can return the value without
2417               creating any new nodes.
2418
2419            3. The block is mature and we visit it the first time.  A Phi node needs
2420               to be created (phi_merge).  If the Phi is not needed, as all it's
2421               operands are the same value reaching the block through different
2422               paths, it's optimized away and the value itself is returned.
2423
2424            4. The block is mature, and we visit it the second time.  Now two
2425               subcases are possible:
2426               * The value was computed completely the last time we were here. This
2427                 is the case if there is no loop.  We can return the proper value.
2428               * The recursion that visited this node and set the flag did not
2429                 return yet.  We are computing a value in a loop and need to
2430                 break the recursion.  This case only happens if we visited
2431             the same block with phi_merge before, which inserted a Phi0.
2432             So we return the Phi0.
2433         */
2434
2435         /* case 4 -- already visited. */
2436         if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
2437                 /* As phi_merge allocates a Phi0 this value is always defined. Here
2438                 is the critical difference of the two algorithms. */
2439                 assert(block->attr.block.graph_arr[pos]);
2440                 return block->attr.block.graph_arr[pos];
2441         }
2442
2443         /* visited the first time */
2444         set_irn_visited(block, get_irg_visited(current_ir_graph));
2445
2446         /* Get the local valid value */
2447         res = block->attr.block.graph_arr[pos];
2448
2449         /* case 2 -- If the value is actually computed, return it. */
2450         if (res) { return res; };
2451
2452         if (block->attr.block.is_matured) { /* case 3 */
2453
2454                 /* The Phi has the same amount of ins as the corresponding block. */
2455                 int ins = get_irn_arity(block);
2456                 ir_node **nin;
2457                 NEW_ARR_A (ir_node *, nin, ins);
2458
2459                 /* Phi merge collects the predecessors and then creates a node. */
2460                 res = phi_merge (block, pos, mode, nin, ins);
2461
2462         } else {  /* case 1 */
2463                 /* The block is not mature, we don't know how many in's are needed.  A Phi
2464                    with zero predecessors is created.  Such a Phi node is called Phi0
2465                    node.  The Phi0 is then added to the list of Phi0 nodes in this block
2466                    to be matured by mature_immBlock later.
2467                    The Phi0 has to remember the pos of it's internal value.  If the real
2468                    Phi is computed, pos is used to update the array with the local
2469                    values. */
2470                 res = new_rd_Phi0(current_ir_graph, block, mode);
2471                 res->attr.phi0.pos = pos;
2472                 res->link = block->link;
2473                 block->link = res;
2474         }
2475
2476         /* If we get here, the frontend missed a use-before-definition error */
2477         if (!res) {
2478                 /* Error Message */
2479                 printf("Error: no value set.  Use of undefined variable.  Initializing to zero.\n");
2480                 assert(mode->code >= irm_F && mode->code <= irm_P);
2481                 res = new_rd_Const(NULL, current_ir_graph, block, mode,
2482                                    get_mode_null(mode));
2483         }
2484
2485         /* The local valid value is available now. */
2486         block->attr.block.graph_arr[pos] = res;
2487
2488         return res;
2489 }  /* get_r_value_internal */
2490
2491 #endif /* USE_FAST_PHI_CONSTRUCTION */
2492
2493 /* ************************************************************************** */
2494
2495 /*
2496  * Finalize a Block node, when all control flows are known.
2497  * Acceptable parameters are only Block nodes.
2498  */
2499 void
2500 mature_immBlock(ir_node *block) {
2501         int ins;
2502         ir_node *n, **nin;
2503         ir_node *next;
2504
2505         assert(get_irn_opcode(block) == iro_Block);
2506         /* @@@ should be commented in
2507            assert (!get_Block_matured(block) && "Block already matured"); */
2508
2509         if (!get_Block_matured(block)) {
2510                 ins = ARR_LEN(block->in)-1;
2511                 /* Fix block parameters */
2512                 block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
2513
2514                 /* An array for building the Phi nodes. */
2515                 NEW_ARR_A(ir_node *, nin, ins);
2516
2517                 /* Traverse a chain of Phi nodes attached to this block and mature
2518                 these, too. **/
2519                 for (n = block->link; n; n = next) {
2520                         inc_irg_visited(current_ir_graph);
2521                         next = n->link;
2522                         exchange(n, phi_merge(block, n->attr.phi0.pos, n->mode, nin, ins));
2523                 }
2524
2525                 block->attr.block.is_matured = 1;
2526
2527                 /* Now, as the block is a finished firm node, we can optimize it.
2528                    Since other nodes have been allocated since the block was created
2529                    we can not free the node on the obstack.  Therefore we have to call
2530                    optimize_in_place.
2531                    Unfortunately the optimization does not change a lot, as all allocated
2532                    nodes refer to the unoptimized node.
2533                    We can call _2, as global cse has no effect on blocks. */
2534                 block = optimize_in_place_2(block);
2535                 IRN_VRFY_IRG(block, current_ir_graph);
2536         }
2537 }  /* mature_immBlock */
2538
2539 ir_node *
2540 new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode) {
2541         return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);
2542 }  /* new_d_Phi */
2543
2544 ir_node *
2545 new_d_Const(dbg_info *db, ir_mode *mode, tarval *con) {
2546         return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con);
2547 }  /* new_d_Const */
2548
2549 ir_node *
2550 new_d_Const_long(dbg_info *db, ir_mode *mode, long value) {
2551         return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value);
2552 }  /* new_d_Const_long */
2553
2554 ir_node *
2555 new_d_Const_type(dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp) {
2556         return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp);
2557 }  /* new_d_Const_type */
2558
2559
2560 ir_node *
2561 new_d_Id(dbg_info *db, ir_node *val, ir_mode *mode) {
2562         return new_bd_Id(db, current_ir_graph->current_block, val, mode);
2563 }  /* new_d_Id */
2564
2565 ir_node *
2566 new_d_Proj(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) {
2567         return new_bd_Proj(db, current_ir_graph->current_block, arg, mode, proj);
2568 }  /* new_d_Proj */
2569
2570 ir_node *
2571 new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj) {
2572         ir_node *res;
2573         assert(arg->op == op_Cond);
2574         arg->attr.cond.kind = fragmentary;
2575         arg->attr.cond.default_proj = max_proj;
2576         res = new_Proj(arg, mode_X, max_proj);
2577         return res;
2578 }  /* new_d_defaultProj */
2579
2580 ir_node *
2581 new_d_Conv(dbg_info *db, ir_node *op, ir_mode *mode) {
2582         return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 0);
2583 }  /* new_d_Conv */
2584
2585 ir_node *
2586 new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode) {
2587         return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 1);
2588 }  /* new_d_strictConv */
2589
2590 ir_node *
2591 new_d_Cast(dbg_info *db, ir_node *op, ir_type *to_tp) {
2592         return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
2593 }  /* new_d_Cast */
2594
2595 ir_node *
2596 new_d_Tuple(dbg_info *db, int arity, ir_node **in) {
2597         return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);
2598 }  /* new_d_Tuple */
2599
2600 NEW_D_BINOP(Add)
2601 NEW_D_BINOP(Sub)
2602 NEW_D_UNOP(Minus)
2603 NEW_D_BINOP(Mul)
2604
2605 /**
2606  * Allocate the frag array.
2607  */
2608 static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
2609         if (get_opt_precise_exc_context()) {
2610                 if ((current_ir_graph->phase_state == phase_building) &&
2611                     (get_irn_op(res) == op) && /* Could be optimized away. */
2612                     !*frag_store)    /* Could be a cse where the arr is already set. */ {
2613                         *frag_store = new_frag_arr(res);
2614                 }
2615         }
2616 }  /* allocate_frag_arr */
2617
2618 ir_node *
2619 new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
2620         ir_node *res;
2621         res = new_bd_Quot(db, current_ir_graph->current_block, memop, op1, op2, mode);
2622 #if PRECISE_EXC_CONTEXT
2623         allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr);  /* Could be optimized away. */
2624 #endif
2625
2626         return res;
2627 }  /* new_d_Quot */
2628
2629 ir_node *
2630 new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
2631         ir_node *res;
2632         res = new_bd_DivMod(db, current_ir_graph->current_block, memop, op1, op2, mode);
2633 #if PRECISE_EXC_CONTEXT
2634         allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2635 #endif
2636
2637         return res;
2638 }  /* new_d_DivMod */
2639
2640 ir_node *
2641 new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
2642         ir_node *res;
2643         res = new_bd_Div(db, current_ir_graph->current_block, memop, op1, op2, mode);
2644 #if PRECISE_EXC_CONTEXT
2645         allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr);  /* Could be optimized away. */
2646 #endif
2647
2648         return res;
2649 }
2650
2651 ir_node *
2652 new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
2653         ir_node *res;
2654         res = new_bd_Mod(db, current_ir_graph->current_block, memop, op1, op2, mode);
2655 #if PRECISE_EXC_CONTEXT
2656         allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr);  /* Could be optimized away. */
2657 #endif
2658
2659         return res;
2660 }  /* new_d_Mod */
2661
2662 NEW_D_BINOP(And)
2663 NEW_D_BINOP(Or)
2664 NEW_D_BINOP(Eor)
2665 NEW_D_UNOP(Not)
2666 NEW_D_BINOP(Shl)
2667 NEW_D_BINOP(Shr)
2668 NEW_D_BINOP(Shrs)
2669 NEW_D_BINOP(Rot)
2670 NEW_D_UNOP(Abs)
2671 NEW_D_BINOP(Carry)
2672 NEW_D_BINOP(Borrow)
2673
2674 ir_node *
2675 new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2) {
2676         return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
2677 }  /* new_d_Cmp */
2678
2679 ir_node *
2680 new_d_Jmp(dbg_info *db) {
2681         return new_bd_Jmp(db, current_ir_graph->current_block);
2682 }  /* new_d_Jmp */
2683
2684 ir_node *
2685 new_d_IJmp(dbg_info *db, ir_node *tgt) {
2686         return new_bd_IJmp(db, current_ir_graph->current_block, tgt);
2687 }  /* new_d_IJmp */
2688
2689 ir_node *
2690 new_d_Cond(dbg_info *db, ir_node *c) {
2691         return new_bd_Cond(db, current_ir_graph->current_block, c);
2692 }  /* new_d_Cond */
2693
2694 ir_node *
2695 new_d_Call(dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
2696            ir_type *tp) {
2697         ir_node *res;
2698         res = new_bd_Call(db, current_ir_graph->current_block,
2699                           store, callee, arity, in, tp);
2700 #if PRECISE_EXC_CONTEXT
2701         allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);  /* Could be optimized away. */
2702 #endif
2703
2704         return res;
2705 }  /* new_d_Call */
2706
2707 ir_node *
2708 new_d_Return(dbg_info *db, ir_node* store, int arity, ir_node **in) {
2709         return new_bd_Return(db, current_ir_graph->current_block,
2710                              store, arity, in);
2711 }  /* new_d_Return */
2712
2713 ir_node *
2714 new_d_Load(dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode) {
2715         ir_node *res;
2716         res = new_bd_Load(db, current_ir_graph->current_block,
2717                           store, addr, mode);
2718 #if PRECISE_EXC_CONTEXT
2719         allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);  /* Could be optimized away. */
2720 #endif
2721
2722         return res;
2723 }  /* new_d_Load */
2724
2725 ir_node *
2726 new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val) {
2727         ir_node *res;
2728         res = new_bd_Store(db, current_ir_graph->current_block,
2729                            store, addr, val);
2730 #if PRECISE_EXC_CONTEXT
2731         allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);  /* Could be optimized away. */
2732 #endif
2733
2734         return res;
2735 }  /* new_d_Store */
2736
2737 ir_node *
2738 new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
2739             where_alloc where) {
2740         ir_node *res;
2741         res = new_bd_Alloc(db, current_ir_graph->current_block,
2742                            store, size, alloc_type, where);
2743 #if PRECISE_EXC_CONTEXT
2744         allocate_frag_arr(res, op_Alloc, &res->attr.alloc.exc.frag_arr);  /* Could be optimized away. */
2745 #endif
2746
2747         return res;
2748 }  /* new_d_Alloc */
2749
2750 ir_node *
2751 new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr,
2752            ir_node *size, ir_type *free_type, where_alloc where) {
2753         return new_bd_Free(db, current_ir_graph->current_block,
2754                            store, ptr, size, free_type, where);
2755 }
2756
2757 ir_node *
2758 new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent)
2759 /* GL: objptr was called frame before.  Frame was a bad choice for the name
2760    as the operand could as well be a pointer to a dynamic object. */
2761 {
2762         return new_bd_Sel(db, current_ir_graph->current_block,
2763                           store, objptr, 0, NULL, ent);
2764 }  /* new_d_simpleSel */
2765
2766 ir_node *
2767 new_d_Sel(dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, ir_entity *sel) {
2768         return new_bd_Sel(db, current_ir_graph->current_block,
2769                           store, objptr, n_index, index, sel);
2770 }  /* new_d_Sel */
2771
2772 ir_node *
2773 new_d_SymConst_type(dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp) {
2774         return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
2775                                     value, kind, tp);
2776 }  /* new_d_SymConst_type */
2777
2778 ir_node *
2779 new_d_SymConst(dbg_info *db, symconst_symbol value, symconst_kind kind) {
2780         return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
2781                                     value, kind, firm_unknown_type);
2782 }  /* new_d_SymConst */
2783
2784 ir_node *
2785 new_d_Sync(dbg_info *db, int arity, ir_node *in[]) {
2786         return new_rd_Sync(db, current_ir_graph, current_ir_graph->current_block, arity, in);
2787 }  /* new_d_Sync */
2788
2789
2790 ir_node *
2791 (new_d_Bad)(void) {
2792         return _new_d_Bad();
2793 }  /* new_d_Bad */
2794
2795 ir_node *
2796 new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) {
2797         return new_bd_Confirm(db, current_ir_graph->current_block,
2798                               val, bound, cmp);
2799 }  /* new_d_Confirm */
2800
2801 ir_node *
2802 new_d_Unknown(ir_mode *m) {
2803         return new_bd_Unknown(m);
2804 }  /* new_d_Unknown */
2805
2806 ir_node *
2807 new_d_CallBegin(dbg_info *db, ir_node *call) {
2808         return new_bd_CallBegin(db, current_ir_graph->current_block, call);
2809 }  /* new_d_CallBegin */
2810
2811 ir_node *
2812 new_d_EndReg(dbg_info *db) {
2813         return new_bd_EndReg(db, current_ir_graph->current_block);
2814 }  /* new_d_EndReg */
2815
2816 ir_node *
2817 new_d_EndExcept(dbg_info *db) {
2818         return new_bd_EndExcept(db, current_ir_graph->current_block);
2819 }  /* new_d_EndExcept */
2820
2821 ir_node *
2822 new_d_Break(dbg_info *db) {
2823         return new_bd_Break(db, current_ir_graph->current_block);
2824 }  /* new_d_Break */
2825
2826 ir_node *
2827 new_d_Filter(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) {
2828         return new_bd_Filter(db, current_ir_graph->current_block,
2829                              arg, mode, proj);
2830 }  /* new_d_Filter */
2831
2832 ir_node *
2833 (new_d_NoMem)(void) {
2834         return _new_d_NoMem();
2835 }  /* new_d_NoMem */
2836
2837 ir_node *
2838 new_d_Mux(dbg_info *db, ir_node *sel, ir_node *ir_false,
2839           ir_node *ir_true, ir_mode *mode) {
2840         return new_bd_Mux(db, current_ir_graph->current_block,
2841                           sel, ir_false, ir_true, mode);
2842 }  /* new_d_Mux */
2843
2844 ir_node *
2845 new_d_Psi(dbg_info *db,int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
2846   return new_bd_Psi(db, current_ir_graph->current_block,
2847                     arity, conds, vals, mode);
2848 }  /* new_d_Psi */
2849
2850 ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
2851     ir_node *dst, ir_node *src, ir_type *data_type) {
2852         ir_node *res;
2853         res = new_bd_CopyB(db, current_ir_graph->current_block,
2854                            store, dst, src, data_type);
2855 #if PRECISE_EXC_CONTEXT
2856         allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
2857 #endif
2858         return res;
2859 }  /* new_d_CopyB */
2860
2861 ir_node *
2862 new_d_InstOf(dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type) {
2863         return new_bd_InstOf(db, current_ir_graph->current_block,
2864                              store, objptr, type);
2865 }  /* new_d_InstOf */
2866
2867 ir_node *
2868 new_d_Raise(dbg_info *db, ir_node *store, ir_node *obj) {
2869         return new_bd_Raise(db, current_ir_graph->current_block, store, obj);
2870 }  /* new_d_Raise */
2871
2872 ir_node *new_d_Bound(dbg_info *db,ir_node *store,
2873     ir_node *idx, ir_node *lower, ir_node *upper) {
2874         ir_node *res;
2875         res = new_bd_Bound(db, current_ir_graph->current_block,
2876                            store, idx, lower, upper);
2877 #if PRECISE_EXC_CONTEXT
2878         allocate_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
2879 #endif
2880         return res;
2881 }  /* new_d_Bound */
2882
2883 ir_node *
2884 new_d_Pin(dbg_info *db, ir_node *node) {
2885         return new_bd_Pin(db, current_ir_graph->current_block, node);
2886 }  /* new_d_Pin */
2887
2888 /* ********************************************************************* */
2889 /* Comfortable interface with automatic Phi node construction.           */
2890 /* (Uses also constructors of ?? interface, except new_Block.            */
2891 /* ********************************************************************* */
2892
2893 /*  Block construction */
2894 /* immature Block without predecessors */
2895 ir_node *
2896 new_d_immBlock(dbg_info *db) {
2897         ir_node *res;
2898
2899         assert(get_irg_phase_state(current_ir_graph) == phase_building);
2900         /* creates a new dynamic in-array as length of in is -1 */
2901         res = new_ir_node(db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
2902         current_ir_graph->current_block = res;
2903
2904     /* macroblock head */
2905     res->in[0] = res;
2906
2907         res->attr.block.is_matured  = 0;
2908         res->attr.block.is_dead     = 0;
2909     res->attr.block.is_mb_head  = 1;
2910         res->attr.block.irg         = current_ir_graph;
2911         res->attr.block.backedge    = NULL;
2912         res->attr.block.in_cg       = NULL;
2913         res->attr.block.cg_backedge = NULL;
2914         res->attr.block.extblk      = NULL;
2915         res->attr.block.region      = NULL;
2916     res->attr.block.mb_depth    = 0;
2917
2918         set_Block_block_visited(res, 0);
2919
2920         /* Create and initialize array for Phi-node construction. */
2921         res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
2922                                               current_ir_graph->n_loc);
2923         memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
2924
2925         /* Immature block may not be optimized! */
2926         IRN_VRFY_IRG(res, current_ir_graph);
2927
2928         return res;
2929 }  /* new_d_immBlock */
2930
2931 ir_node *
2932 new_immBlock(void) {
2933         return new_d_immBlock(NULL);
2934 }  /* new_immBlock */
2935
2936 /* immature PartBlock with its predecessors */
2937 ir_node *
2938 new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp) {
2939         ir_node *res = new_d_immBlock(db);
2940         ir_node *blk = get_nodes_block(pred_jmp);
2941
2942         res->in[0] = blk->in[0];
2943         res->attr.block.is_mb_head = 0;
2944         res->attr.block.mb_depth = blk->attr.block.mb_depth + 1;
2945
2946         add_immBlock_pred(res, pred_jmp);
2947
2948         return res;
2949 }  /* new_d_immPartBlock */
2950
2951 ir_node *
2952 new_immPartBlock(ir_node *pred_jmp) {
2953         return new_d_immPartBlock(NULL, pred_jmp);
2954 }  /* new_immPartBlock */
2955
2956 /* add an edge to a jmp/control flow node */
2957 void
2958 add_immBlock_pred(ir_node *block, ir_node *jmp) {
2959         int n = ARR_LEN(block->in) - 1;
2960
2961         assert(!block->attr.block.is_matured && "Error: Block already matured!\n");
2962         assert(block->attr.block.is_mb_head && "Error: Cannot add a predecessor to a PartBlock");
2963         assert(jmp != NULL);
2964
2965         ARR_APP1(ir_node *, block->in, jmp);
2966         /* Call the hook */
2967         hook_set_irn_n(block, n, jmp, NULL);
2968 }  /* add_immBlock_pred */
2969
2970 /* changing the current block */
2971 void
2972 set_cur_block(ir_node *target) {
2973         current_ir_graph->current_block = target;
2974 }  /* set_cur_block */
2975
2976 /* ************************ */
2977 /* parameter administration */
2978
2979 /* get a value from the parameter array from the current block by its index */
2980 ir_node *
2981 get_d_value(dbg_info *db, int pos, ir_mode *mode) {
2982         ir_graph *irg = current_ir_graph;
2983         assert(get_irg_phase_state(irg) == phase_building);
2984         inc_irg_visited(irg);
2985
2986         return get_r_value_internal(irg->current_block, pos + 1, mode);
2987 }  /* get_d_value */
2988
2989 /* get a value from the parameter array from the current block by its index */
2990 ir_node *
2991 get_value(int pos, ir_mode *mode) {
2992         return get_d_value(NULL, pos, mode);
2993 }  /* get_value */
2994
2995 /* set a value at position pos in the parameter array from the current block */
2996 void
2997 set_value(int pos, ir_node *value) {
2998         ir_graph *irg = current_ir_graph;
2999         assert(get_irg_phase_state(irg) == phase_building);
3000         assert(pos+1 < irg->n_loc);
3001         irg->current_block->attr.block.graph_arr[pos + 1] = value;
3002 }  /* set_value */
3003
3004 /* Find the value number for a node in the current block.*/
3005 int
3006 find_value(ir_node *value) {
3007         int i;
3008         ir_node *bl = current_ir_graph->current_block;
3009
3010         for (i = ARR_LEN(bl->attr.block.graph_arr) - 1; i >= 1; --i)
3011                 if (bl->attr.block.graph_arr[i] == value)
3012                         return i - 1;
3013         return -1;
3014 }  /* find_value */
3015
3016 /* get the current store */
3017 ir_node *
3018 get_store(void) {
3019         ir_graph *irg = current_ir_graph;
3020
3021         assert(get_irg_phase_state(irg) == phase_building);
3022         /* GL: one could call get_value instead */
3023         inc_irg_visited(irg);
3024         return get_r_value_internal(irg->current_block, 0, mode_M);
3025 }  /* get_store */
3026
3027 /* set the current store: handles automatic Sync construction for Load nodes */
3028 void
3029 set_store(ir_node *store) {
3030         ir_node *load, *pload, *pred, *in[2];
3031
3032         assert(get_irg_phase_state(current_ir_graph) == phase_building);
3033         /* Beware: due to dead code elimination, a store might become a Bad node even in
3034            the construction phase. */
3035         assert((get_irn_mode(store) == mode_M || is_Bad(store)) && "storing non-memory node");
3036
3037         if (get_opt_auto_create_sync()) {
3038                 /* handle non-volatile Load nodes by automatically creating Sync's */
3039                 load = skip_Proj(store);
3040                 if (is_Load(load) && get_Load_volatility(load) == volatility_non_volatile) {
3041                         pred = get_Load_mem(load);
3042
3043                         if (is_Sync(pred)) {
3044                                 /* a Load after a Sync: move it up */
3045                                 ir_node *mem = skip_Proj(get_Sync_pred(pred, 0));
3046
3047                                 set_Load_mem(load, get_memop_mem(mem));
3048                                 add_Sync_pred(pred, store);
3049                                 store = pred;
3050                         } else {
3051                                 pload = skip_Proj(pred);
3052                                 if (is_Load(pload) && get_Load_volatility(pload) == volatility_non_volatile) {
3053                                         /* a Load after a Load: create a new Sync */
3054                                         set_Load_mem(load, get_Load_mem(pload));
3055
3056                                         in[0] = pred;
3057                                         in[1] = store;
3058                                         store = new_Sync(2, in);
3059                                 }
3060                         }
3061                 }
3062         }
3063         current_ir_graph->current_block->attr.block.graph_arr[0] = store;
3064 }  /* set_store */
3065
3066 void
3067 keep_alive(ir_node *ka) {
3068         add_End_keepalive(get_irg_end(current_ir_graph), ka);
3069 }  /* keep_alive */
3070
3071 /* --- Useful access routines --- */
3072 /* Returns the current block of the current graph.  To set the current
3073    block use set_cur_block. */
3074 ir_node *get_cur_block(void) {
3075         return get_irg_current_block(current_ir_graph);
3076 }  /* get_cur_block */
3077
3078 /* Returns the frame type of the current graph */
3079 ir_type *get_cur_frame_type(void) {
3080         return get_irg_frame_type(current_ir_graph);
3081 }  /* get_cur_frame_type */
3082
3083
3084 /* ********************************************************************* */
3085 /* initialize */
3086
3087 /* call once for each run of the library */
3088 void
3089 init_cons(uninitialized_local_variable_func_t *func) {
3090         default_initialize_local_variable = func;
3091 }  /* init_cons */
3092
3093 void
3094 irp_finalize_cons(void) {
3095         int i;
3096         for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
3097                 irg_finalize_cons(get_irp_irg(i));
3098         }
3099         irp->phase_state = phase_high;
3100 }  /* irp_finalize_cons */
3101
3102
3103 ir_node *new_Block(int arity, ir_node **in) {
3104         return new_d_Block(NULL, arity, in);
3105 }
3106 ir_node *new_Start(void) {
3107         return new_d_Start(NULL);
3108 }
3109 ir_node *new_End(void) {
3110         return new_d_End(NULL);
3111 }
3112 ir_node *new_Jmp(void) {
3113         return new_d_Jmp(NULL);
3114 }
3115 ir_node *new_IJmp(ir_node *tgt) {
3116         return new_d_IJmp(NULL, tgt);
3117 }
3118 ir_node *new_Cond(ir_node *c) {
3119         return new_d_Cond(NULL, c);
3120 }
3121 ir_node *new_Return(ir_node *store, int arity, ir_node *in[]) {
3122         return new_d_Return(NULL, store, arity, in);
3123 }
3124 ir_node *new_Const(ir_mode *mode, tarval *con) {
3125         return new_d_Const(NULL, mode, con);
3126 }
3127
3128 ir_node *new_Const_long(ir_mode *mode, long value) {
3129         return new_d_Const_long(NULL, mode, value);
3130 }
3131
3132 ir_node *new_Const_type(tarval *con, ir_type *tp) {
3133         return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
3134 }
3135
3136 ir_node *new_SymConst_type(symconst_symbol value, symconst_kind kind, ir_type *type) {
3137         return new_d_SymConst_type(NULL, value, kind, type);
3138 }
3139 ir_node *new_SymConst(symconst_symbol value, symconst_kind kind) {
3140         return new_d_SymConst(NULL, value, kind);
3141 }
3142 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent) {
3143         return new_d_simpleSel(NULL, store, objptr, ent);
3144 }
3145 ir_node *new_Sel(ir_node *store, ir_node *objptr, int arity, ir_node **in,
3146                  ir_entity *ent) {
3147         return new_d_Sel(NULL, store, objptr, arity, in, ent);
3148 }
3149 ir_node *new_Call(ir_node *store, ir_node *callee, int arity, ir_node **in,
3150                   ir_type *tp) {
3151         return new_d_Call(NULL, store, callee, arity, in, tp);
3152 }
3153 ir_node *new_Add(ir_node *op1, ir_node *op2, ir_mode *mode) {
3154         return new_d_Add(NULL, op1, op2, mode);
3155 }
3156 ir_node *new_Sub(ir_node *op1, ir_node *op2, ir_mode *mode) {
3157         return new_d_Sub(NULL, op1, op2, mode);
3158 }
3159 ir_node *new_Minus(ir_node *op,  ir_mode *mode) {
3160         return new_d_Minus(NULL, op, mode);
3161 }
3162 ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode) {
3163         return new_d_Mul(NULL, op1, op2, mode);
3164 }
3165 ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
3166         return new_d_Quot(NULL, memop, op1, op2, mode);
3167 }
3168 ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
3169         return new_d_DivMod(NULL, memop, op1, op2, mode);
3170 }
3171 ir_node *new_Div(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
3172         return new_d_Div(NULL, memop, op1, op2, mode);
3173 }
3174 ir_node *new_Mod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
3175         return new_d_Mod(NULL, memop, op1, op2, mode);
3176 }
3177 ir_node *new_Abs(ir_node *op, ir_mode *mode) {
3178         return new_d_Abs(NULL, op, mode);
3179 }
3180 ir_node *new_And(ir_node *op1, ir_node *op2, ir_mode *mode) {
3181         return new_d_And(NULL, op1, op2, mode);
3182 }
3183 ir_node *new_Or(ir_node *op1, ir_node *op2, ir_mode *mode) {
3184         return new_d_Or(NULL, op1, op2, mode);
3185 }
3186 ir_node *new_Eor(ir_node *op1, ir_node *op2, ir_mode *mode) {
3187         return new_d_Eor(NULL, op1, op2, mode);
3188 }
3189 ir_node *new_Not(ir_node *op,                ir_mode *mode) {
3190         return new_d_Not(NULL, op, mode);
3191 }
3192 ir_node *new_Shl(ir_node *op,  ir_node *k,   ir_mode *mode) {
3193         return new_d_Shl(NULL, op, k, mode);
3194 }
3195 ir_node *new_Shr(ir_node *op,  ir_node *k,   ir_mode *mode) {
3196         return new_d_Shr(NULL, op, k, mode);
3197 }
3198 ir_node *new_Shrs(ir_node *op,  ir_node *k,   ir_mode *mode) {
3199         return new_d_Shrs(NULL, op, k, mode);
3200 }
3201 ir_node *new_Rot(ir_node *op,  ir_node *k,   ir_mode *mode) {
3202         return new_d_Rot(NULL, op, k, mode);
3203 }
3204 ir_node *new_Carry(ir_node *op1, ir_node *op2, ir_mode *mode) {
3205         return new_d_Carry(NULL, op1, op2, mode);
3206 }
3207 ir_node *new_Borrow(ir_node *op1, ir_node *op2, ir_mode *mode) {
3208         return new_d_Borrow(NULL, op1, op2, mode);
3209 }
3210 ir_node *new_Cmp(ir_node *op1, ir_node *op2) {
3211         return new_d_Cmp(NULL, op1, op2);
3212 }
3213 ir_node *new_Conv(ir_node *op, ir_mode *mode) {
3214         return new_d_Conv(NULL, op, mode);
3215 }
3216 ir_node *new_strictConv(ir_node *op, ir_mode *mode) {
3217         return new_d_strictConv(NULL, op, mode);
3218 }
3219 ir_node *new_Cast(ir_node *op, ir_type *to_tp) {
3220         return new_d_Cast(NULL, op, to_tp);
3221 }
3222 ir_node *new_Phi(int arity, ir_node **in, ir_mode *mode) {
3223         return new_d_Phi(NULL, arity, in, mode);
3224 }
3225 ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode) {
3226         return new_d_Load(NULL, store, addr, mode);
3227 }
3228 ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val) {
3229         return new_d_Store(NULL, store, addr, val);
3230 }
3231 ir_node *new_Alloc(ir_node *store, ir_node *size, ir_type *alloc_type,
3232                    where_alloc where) {
3233         return new_d_Alloc(NULL, store, size, alloc_type, where);
3234 }
3235 ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size,
3236                   ir_type *free_type, where_alloc where) {
3237         return new_d_Free(NULL, store, ptr, size, free_type, where);
3238 }
3239 ir_node *new_Sync(int arity, ir_node *in[]) {
3240         return new_d_Sync(NULL, arity, in);
3241 }
3242 ir_node *new_Proj(ir_node *arg, ir_mode *mode, long proj) {
3243         return new_d_Proj(NULL, arg, mode, proj);
3244 }
3245 ir_node *new_defaultProj(ir_node *arg, long max_proj) {
3246         return new_d_defaultProj(NULL, arg, max_proj);
3247 }
3248 ir_node *new_Tuple(int arity, ir_node **in) {
3249         return new_d_Tuple(NULL, arity, in);
3250 }
3251 ir_node *new_Id(ir_node *val, ir_mode *mode) {
3252         return new_d_Id(NULL, val, mode);
3253 }
3254 ir_node *new_Bad(void) {
3255         return new_d_Bad();
3256 }
3257 ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp) {
3258         return new_d_Confirm (NULL, val, bound, cmp);
3259 }
3260 ir_node *new_Unknown(ir_mode *m) {
3261         return new_d_Unknown(m);
3262 }
3263 ir_node *new_CallBegin(ir_node *callee) {
3264         return new_d_CallBegin(NULL, callee);
3265 }
3266 ir_node *new_EndReg(void) {
3267         return new_d_EndReg(NULL);
3268 }
3269 ir_node *new_EndExcept(void) {
3270         return new_d_EndExcept(NULL);
3271 }
3272 ir_node *new_Break(void) {
3273         return new_d_Break(NULL);
3274 }
3275 ir_node *new_Filter(ir_node *arg, ir_mode *mode, long proj) {
3276         return new_d_Filter(NULL, arg, mode, proj);
3277 }
3278 ir_node *new_NoMem(void) {
3279         return new_d_NoMem();
3280 }
3281 ir_node *new_Mux(ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
3282         return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
3283 }
3284 ir_node *new_Psi(int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
3285         return new_d_Psi(NULL, arity, conds, vals, mode);
3286 }
3287 ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
3288         return new_d_CopyB(NULL, store, dst, src, data_type);
3289 }
3290 ir_node *new_InstOf(ir_node *store, ir_node *objptr, ir_type *ent) {
3291         return new_d_InstOf(NULL, store, objptr, ent);
3292 }
3293 ir_node *new_Raise(ir_node *store, ir_node *obj) {
3294         return new_d_Raise(NULL, store, obj);
3295 }
3296 ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
3297         return new_d_Bound(NULL, store, idx, lower, upper);
3298 }
3299 ir_node *new_Pin(ir_node *node) {
3300         return new_d_Pin(NULL, node);
3301 }