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

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