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 #include "config.h"
  29
  30 #include "irprog_t.h"
  31 #include "irgraph_t.h"
  32 #include "irnode_t.h"
  33 #include "irmode_t.h"
  34 #include "ircons_t.h"
  35 #include "irverify.h"
  36 #include "irop_t.h"
  37 #include "iropt_t.h"
  38 #include "irgmod.h"
  39 #include "irhooks.h"
  40 #include "array_t.h"
  41 #include "irbackedge_t.h"
  42 #include "irflag_t.h"
  43 #include "iredges_t.h"
  44 #include "irflag_t.h"
  45 #include "error.h"
  46
  47 /* when we need verifying */
  48 #ifdef NDEBUG
  49 # define IRN_VERIFY_IRG(res, irg)
  50 #else
  51 # define IRN_VERIFY_IRG(res, irg)  irn_verify_irg(res, irg)
  52 #endif /* NDEBUG */
  53
  54 /**
  55  * Language dependent variable initialization callback.
  56  */
  57 static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
  58
  59 #include "gen_ir_cons.c.inl"
  60
  61 static ir_node *new_bd_Start(dbg_info *db, ir_node *block)
  62 {
  63         ir_node  *res;
  64         ir_graph *irg = get_irn_irg(block);
  65
  66         res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
  67
  68         IRN_VERIFY_IRG(res, irg);
  69         return res;
  70 }  /* new_bd_Start */
  71
  72 static ir_node *new_bd_End(dbg_info *db, ir_node *block)
  73 {
  74         ir_node  *res;
  75         ir_graph *irg = get_irn_irg(block);
  76
  77         res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
  78
  79         IRN_VERIFY_IRG(res, irg);
  80         return res;
  81 }  /* new_bd_End */
  82
  83 /**
  84  * Creates a Phi node with all predecessors.  Calling this constructor
  85  * is only allowed if the corresponding block is mature.
  86  */
  87 static ir_node *new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
  88 {
  89         ir_node  *res;
  90         ir_graph *irg = get_irn_irg(block);
  91         int i;
  92         int has_unknown = 0;
  93
  94         /* Don't assert that block matured: the use of this constructor is strongly
  95            restricted ... */
  96         if (get_Block_matured(block))
  97                 assert(get_irn_arity(block) == arity);
  98
  99         res = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
 100
 101         res->attr.phi.u.backedge = new_backedge_arr(irg->obst, arity);
 102
 103         for (i = arity - 1; i >= 0; --i)
 104                 if (is_Unknown(in[i])) {
 105                         has_unknown = 1;
 106                         break;
 107                 }
 108
 109         if (!has_unknown) res = optimize_node(res);
 110         IRN_VERIFY_IRG(res, irg);
 111
 112         /* Memory Phis in endless loops must be kept alive.
 113            As we can't distinguish these easily we keep all of them alive. */
 114         if (is_Phi(res) && mode == mode_M)
 115                 add_End_keepalive(get_irg_end(irg), res);
 116         return res;
 117 }  /* new_bd_Phi */
 118
 119 static ir_node *new_bd_Const_type(dbg_info *db, tarval *con, ir_type *tp)
 120 {
 121         ir_node  *res;
 122         ir_graph *irg = current_ir_graph;
 123
 124         res = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, get_tarval_mode(con), 0, NULL);
 125         res->attr.con.tarval = con;
 126         set_Const_type(res, tp);  /* Call method because of complex assertion. */
 127         res = optimize_node (res);
 128         assert(get_Const_type(res) == tp);
 129         IRN_VERIFY_IRG(res, irg);
 130
 131         return res;
 132 }  /* new_bd_Const_type */
 133
 134 static ir_node *new_bd_Const(dbg_info *db, tarval *con)
 135 {
 136         ir_graph *irg = current_ir_graph;
 137
 138         return new_rd_Const_type(db, irg, con, firm_unknown_type);
 139 }  /* new_bd_Const */
 140
 141 static ir_node *new_bd_Const_long(dbg_info *db, ir_mode *mode, long value)
 142 {
 143         ir_graph *irg = current_ir_graph;
 144
 145         return new_rd_Const(db, irg, new_tarval_from_long(value, mode));
 146 }  /* new_bd_Const_long */
 147
 148 static ir_node *new_bd_defaultProj(dbg_info *db, ir_node *arg, long max_proj)
 149 {
 150         ir_node  *res;
 151
 152         assert(is_Cond(arg));
 153         arg->attr.cond.default_proj = max_proj;
 154         res = new_rd_Proj(db, arg, mode_X, max_proj);
 155         return res;
 156 }  /* new_bd_defaultProj */
 157
 158 static ir_node *new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store,
 159                            ir_node *objptr, int arity, ir_node **in,
 160                            ir_entity *ent)
 161 {
 162         ir_node  **r_in;
 163         ir_node  *res;
 164         int      r_arity;
 165         ir_graph *irg  = get_irn_irg(block);
 166         ir_mode  *mode = is_Method_type(get_entity_type(ent)) ? mode_P_code : mode_P_data;
 167
 168         assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
 169
 170         r_arity = arity + 2;
 171         NEW_ARR_A(ir_node *, r_in, r_arity);  /* uses alloca */
 172         r_in[0] = store;
 173         r_in[1] = objptr;
 174         memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
 175         /*
 176          * Sel's can select functions which should be of mode mode_P_code.
 177          */
 178         res = new_ir_node(db, irg, block, op_Sel, mode, r_arity, r_in);
 179         res->attr.sel.entity = ent;
 180         res = optimize_node(res);
 181         IRN_VERIFY_IRG(res, irg);
 182         return res;
 183 }  /* new_bd_Sel */
 184
 185 static ir_node *new_bd_SymConst_type(dbg_info *db, ir_node *block,
 186                                      ir_mode *mode, symconst_symbol value,
 187                                      symconst_kind symkind, ir_type *tp)
 188 {
 189         ir_graph *irg = get_irn_irg(block);
 190         ir_node  *res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
 191
 192         res->attr.symc.kind = symkind;
 193         res->attr.symc.sym  = value;
 194         res->attr.symc.tp   = tp;
 195
 196         res = optimize_node(res);
 197         IRN_VERIFY_IRG(res, irg);
 198         return res;
 199 }  /* new_bd_SymConst_type */
 200
 201 static ir_node *new_bd_Sync(dbg_info *db, ir_node *block)
 202 {
 203         ir_node  *res;
 204         ir_graph *irg = get_irn_irg(block);
 205
 206         res = new_ir_node(db, irg, block, op_Sync, mode_M, -1, NULL);
 207         /* no need to call optimize node here, Sync are always created with no predecessors */
 208         IRN_VERIFY_IRG(res, irg);
 209         return res;
 210 }  /* new_bd_Sync */
 211
 212 static ir_node *new_bd_ASM(dbg_info *db, ir_node *block, int arity,
 213                            ir_node *in[], ir_asm_constraint *inputs, int n_outs,
 214                                  ir_asm_constraint *outputs, int n_clobber,
 215                                  ident *clobber[], ident *text)
 216 {
 217         ir_node  *res;
 218         ir_graph *irg = get_irn_irg(block);
 219
 220         res = new_ir_node(db, irg, block, op_ASM, mode_T, arity, in);
 221         res->attr.assem.pin_state = op_pin_state_pinned;
 222         res->attr.assem.input_constraints
 223                 = NEW_ARR_D(ir_asm_constraint, irg->obst, arity);
 224         res->attr.assem.output_constraints
 225                 = NEW_ARR_D(ir_asm_constraint, irg->obst, n_outs);
 226         res->attr.assem.clobbers = NEW_ARR_D(ident *, irg->obst, n_clobber);
 227         res->attr.assem.text     = text;
 228
 229         memcpy(res->attr.assem.input_constraints,  inputs,  sizeof(inputs[0]) * arity);
 230         memcpy(res->attr.assem.output_constraints, outputs, sizeof(outputs[0]) * n_outs);
 231         memcpy(res->attr.assem.clobbers, clobber, sizeof(clobber[0]) * n_clobber);
 232
 233         res = optimize_node(res);
 234         IRN_VERIFY_IRG(res, irg);
 235         return res;
 236 }  /* new_bd_ASM */
 237
 238 /* --------------------------------------------- */
 239 /* private interfaces, for professional use only */
 240 /* --------------------------------------------- */
 241
 242 ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block)
 243 {
 244         ir_graph *rem = current_ir_graph;
 245         ir_node  *res;
 246
 247         current_ir_graph = irg;
 248         res = new_bd_Start(db, block);
 249         current_ir_graph = rem;
 250
 251         return res;
 252 }  /* new_rd_Start */
 253
 254 ir_node *new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block)
 255 {
 256         ir_node  *res;
 257         ir_graph *rem = current_ir_graph;
 258
 259         current_ir_graph = irg;
 260         res = new_bd_End(db, block);
 261         current_ir_graph = rem;
 262
 263         return res;
 264 }  /* new_rd_End */
 265
 266 /* Creates a Phi node with all predecessors.  Calling this constructor
 267    is only allowed if the corresponding block is mature.  */
 268 ir_node *new_rd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
 269 {
 270         ir_node  *res;
 271         ir_graph *rem = current_ir_graph;
 272
 273         current_ir_graph = get_Block_irg(block);
 274         res = new_bd_Phi(db, block,arity, in, mode);
 275         current_ir_graph = rem;
 276
 277         return res;
 278 }  /* new_rd_Phi */
 279
 280 ir_node *new_rd_Const_type(dbg_info *db, ir_graph *irg, tarval *con, ir_type *tp)
 281 {
 282         ir_node  *res;
 283         ir_graph *rem = current_ir_graph;
 284
 285         current_ir_graph = irg;
 286         res = new_bd_Const_type(db, con, tp);
 287         current_ir_graph = rem;
 288
 289         return res;
 290 }  /* new_rd_Const_type */
 291
 292 ir_node *new_rd_Const(dbg_info *db, ir_graph *irg, tarval *con)
 293 {
 294         ir_node  *res;
 295 //#ifdef USE_ORIGINAL
 296         ir_graph *rem = current_ir_graph;
 297
 298         current_ir_graph = irg;
 299         res = new_bd_Const_type(db, con, firm_unknown_type);
 300         current_ir_graph = rem;
 301 //#else
 302 //      res = new_rd_Const_type(db, irg, con, firm_unknown_type);
 303 //#endif
 304
 305         return res;
 306 }  /* new_rd_Const */
 307
 308 ir_node *new_rd_Const_long(dbg_info *db, ir_graph *irg, ir_mode *mode, long value)
 309 {
 310         return new_rd_Const(db, irg, new_tarval_from_long(value, mode));
 311 }  /* new_rd_Const_long */
 312
 313 ir_node *new_rd_defaultProj(dbg_info *db, ir_node *arg, long max_proj)
 314 {
 315         return new_bd_defaultProj(db, arg, max_proj);
 316 }  /* new_rd_defaultProj */
 317
 318 ir_node *new_rd_simpleSel(dbg_info *db, ir_node *block, ir_node *store,
 319                           ir_node *objptr, ir_entity *ent)
 320 {
 321         ir_node  *res;
 322         ir_graph *rem = current_ir_graph;
 323
 324         current_ir_graph = get_Block_irg(block);
 325         res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
 326         current_ir_graph = rem;
 327
 328         return res;
 329 }  /* new_rd_simpleSel */
 330
 331 ir_node *new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_mode *mode,
 332                               symconst_symbol value, symconst_kind symkind,
 333                               ir_type *tp)
 334 {
 335         ir_node  *res;
 336         ir_graph *rem = current_ir_graph;
 337         ir_node  *block = get_irg_start_block(irg);
 338
 339         current_ir_graph = irg;
 340         res = new_bd_SymConst_type(db, block, mode, value, symkind, tp);
 341         current_ir_graph = rem;
 342
 343         return res;
 344 }  /* new_rd_SymConst_type */
 345
 346 ir_node *new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_mode *mode,
 347                          symconst_symbol value, symconst_kind symkind)
 348 {
 349         return new_rd_SymConst_type(db, irg, mode, value, symkind, firm_unknown_type);
 350 }  /* new_rd_SymConst */
 351
 352 ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp)
 353 {
 354         symconst_symbol sym;
 355         sym.entity_p = symbol;
 356         return new_rd_SymConst_type(db, irg, mode, sym, symconst_addr_ent, tp);
 357 }  /* new_rd_SymConst_addr_ent */
 358
 359 ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp)
 360 {
 361         symconst_symbol sym;
 362         sym.entity_p = symbol;
 363         return new_rd_SymConst_type(db, irg, mode, sym, symconst_ofs_ent, tp);
 364 }  /* new_rd_SymConst_ofs_ent */
 365
 366 ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp)
 367 {
 368         symconst_symbol sym;
 369         sym.type_p = symbol;
 370         return new_rd_SymConst_type(db, irg, mode, sym, symconst_type_tag, tp);
 371 }  /* new_rd_SymConst_type_tag */
 372
 373 ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp)
 374 {
 375         symconst_symbol sym;
 376         sym.type_p = symbol;
 377         return new_rd_SymConst_type(db, irg, mode, sym, symconst_type_size, tp);
 378 }  /* new_rd_SymConst_size */
 379
 380 ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp)
 381 {
 382         symconst_symbol sym;
 383         sym.type_p = symbol;
 384         return new_rd_SymConst_type(db, irg, mode, sym, symconst_type_align, tp);
 385 }  /* new_rd_SymConst_align */
 386
 387 ir_node *new_rd_Sync(dbg_info *db, ir_node *block, int arity, ir_node *in[])
 388 {
 389         ir_node  *res;
 390         ir_graph *rem = current_ir_graph;
 391         int      i;
 392
 393         current_ir_graph = get_Block_irg(block);
 394         res = new_bd_Sync(db, block);
 395         current_ir_graph = rem;
 396
 397         for (i = 0; i < arity; ++i)
 398                 add_Sync_pred(res, in[i]);
 399
 400         return res;
 401 }  /* new_rd_Sync */
 402
 403 ir_node *new_rd_ASM(dbg_info *db, ir_node *block,
 404                     int arity, ir_node *in[], ir_asm_constraint *inputs,
 405                     int n_outs, ir_asm_constraint *outputs,
 406                     int n_clobber, ident *clobber[], ident *text)
 407 {
 408         ir_node  *res;
 409         ir_graph *rem = current_ir_graph;
 410
 411         current_ir_graph = get_Block_irg(block);
 412         res = new_bd_ASM(db, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
 413         current_ir_graph = rem;
 414
 415         return res;
 416 }  /* new_rd_ASM */
 417
 418 ir_node *new_r_Start(ir_graph *irg, ir_node *block)
 419 {
 420         return new_rd_Start(NULL, irg, block);
 421 }
 422 ir_node *new_r_End(ir_graph *irg, ir_node *block)
 423 {
 424         return new_rd_End(NULL, irg, block);
 425 }
 426 ir_node *new_r_Const(ir_graph *irg, tarval *con)
 427 {
 428         return new_rd_Const(NULL, irg, con);
 429 }
 430 ir_node *new_r_Const_long(ir_graph *irg, ir_mode *mode, long value)
 431 {
 432         return new_rd_Const_long(NULL, irg, mode, value);
 433 }
 434 ir_node *new_r_Const_type(ir_graph *irg, tarval *con, ir_type *tp)
 435 {
 436         return new_rd_Const_type(NULL, irg, con, tp);
 437 }
 438 ir_node *new_r_SymConst(ir_graph *irg, ir_mode *mode, symconst_symbol value,
 439                         symconst_kind symkind)
 440 {
 441         return new_rd_SymConst(NULL, irg, mode, value, symkind);
 442 }
 443 ir_node *new_r_simpleSel(ir_node *block, ir_node *store, ir_node *objptr,
 444                          ir_entity *ent)
 445 {
 446         return new_rd_Sel(NULL, block, store, objptr, 0, NULL, ent);
 447 }
 448 ir_node *new_r_Phi(ir_node *block, int arity, ir_node **in, ir_mode *mode)
 449 {
 450         return new_rd_Phi(NULL, block, arity, in, mode);
 451 }
 452 ir_node *new_r_Sync(ir_node *block, int arity, ir_node *in[])
 453 {
 454         return new_rd_Sync(NULL, block, arity, in);
 455 }
 456 ir_node *new_r_defaultProj(ir_node *arg, long max_proj)
 457 {
 458         return new_rd_defaultProj(NULL, arg, max_proj);
 459 }
 460 ir_node *new_r_Bad(ir_graph *irg)
 461 {
 462         return get_irg_bad(irg);
 463 }
 464 ir_node *new_r_NoMem(ir_graph *irg)
 465 {
 466         return get_irg_no_mem(irg);
 467 }
 468 ir_node *new_r_ASM(ir_node *block,
 469                    int arity, ir_node *in[], ir_asm_constraint *inputs,
 470                    int n_outs, ir_asm_constraint *outputs,
 471                    int n_clobber, ident *clobber[], ident *text)
 472 {
 473         return new_rd_ASM(NULL, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
 474 }
 475
 476 /** ********************/
 477 /** public interfaces  */
 478 /** construction tools */
 479
 480 ir_node *new_d_Start(dbg_info *db)
 481 {
 482         ir_node *res;
 483
 484         res = new_ir_node(db, current_ir_graph, current_ir_graph->current_block,
 485                           op_Start, mode_T, 0, NULL);
 486
 487         res = optimize_node(res);
 488         IRN_VERIFY_IRG(res, current_ir_graph);
 489         return res;
 490 }  /* new_d_Start */
 491
 492 ir_node *new_d_End(dbg_info *db)
 493 {
 494         ir_node *res;
 495         res = new_ir_node(db, current_ir_graph,  current_ir_graph->current_block,
 496                           op_End, mode_X, -1, NULL);
 497         res = optimize_node(res);
 498         IRN_VERIFY_IRG(res, current_ir_graph);
 499
 500         return res;
 501 }  /* new_d_End */
 502
 503 /* ***********************************************************************/
 504 /* Methods necessary for automatic Phi node creation                     */
 505 /*
 506   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 507   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 508   ir_node *new_rd_Phi0          (ir_graph *irg, ir_node *block, ir_mode *mode)
 509   ir_node *new_rd_Phi_in        (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
 510
 511   Call Graph:   ( A ---> B == A "calls" B)
 512
 513        get_value         mature_immBlock
 514           |                   |
 515           |                   |
 516           |                   |
 517           |          ---> phi_merge
 518           |         /       /   \
 519           |        /       /     \
 520          \|/      /      |/_      \
 521        get_r_value_internal        |
 522                 |                  |
 523                 |                  |
 524                \|/                \|/
 525            new_rd_Phi0          new_rd_Phi_in
 526
 527 * *************************************************************************** */
 528
 529 /** Creates a Phi node with 0 predecessors. */
 530 static inline ir_node *new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode)
 531 {
 532         ir_node *res;
 533
 534         res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
 535         IRN_VERIFY_IRG(res, irg);
 536         return res;
 537 }  /* new_rd_Phi0 */
 538
 539
 540 /**
 541  * Internal constructor of a Phi node by a phi_merge operation.
 542  *
 543  * @param irg    the graph on which the Phi will be constructed
 544  * @param block  the block in which the Phi will be constructed
 545  * @param mode   the mod eof the Phi node
 546  * @param in     the input array of the phi node
 547  * @param ins    number of elements in the input array
 548  * @param phi0   in non-NULL: the Phi0 node in the same block that represents
 549  *               the value for which the new Phi is constructed
 550  */
 551 static inline ir_node *new_rd_Phi_in(ir_graph *irg, ir_node *block,
 552                                      ir_mode *mode, ir_node **in, int ins,
 553                                      ir_node *phi0)
 554 {
 555         int i;
 556         ir_node *res, *known;
 557
 558         /* Allocate a new node on the obstack.  The allocation copies the in
 559            array. */
 560         res = new_ir_node(NULL, irg, block, op_Phi, mode, ins, in);
 561         res->attr.phi.u.backedge = new_backedge_arr(irg->obst, ins);
 562
 563         /* This loop checks whether the Phi has more than one predecessor.
 564            If so, it is a real Phi node and we break the loop.  Else the
 565            Phi node merges the same definition on several paths and therefore
 566            is not needed.
 567            Note: We MUST consider Bad nodes, else we might get data flow cycles in dead loops! */
 568         known = res;
 569         for (i = ins - 1; i >= 0; --i)  {
 570                 assert(in[i]);
 571
 572                 in[i] = skip_Id(in[i]);  /* increases the number of freed Phis. */
 573
 574                 /* Optimize self referencing Phis:  We can't detect them yet properly, as
 575                 they still refer to the Phi0 they will replace.  So replace right now. */
 576                 if (phi0 && in[i] == phi0)
 577                         in[i] = res;
 578
 579                 if (in[i] == res || in[i] == known)
 580                         continue;
 581
 582                 if (known == res)
 583                         known = in[i];
 584                 else
 585                         break;
 586         }
 587
 588         /* i < 0: there is at most one predecessor, we don't need a phi node. */
 589         if (i < 0) {
 590                 if (res != known) {
 591                         edges_node_deleted(res, current_ir_graph);
 592                         obstack_free(current_ir_graph->obst, res);
 593                         if (is_Phi(known)) {
 594                                 /* If pred is a phi node we want to optimize it: If loops are matured in a bad
 595                                    order, an enclosing Phi know may get superfluous. */
 596                                 res = optimize_in_place_2(known);
 597                                 if (res != known)
 598                                         exchange(known, res);
 599                         }
 600                         else
 601                                 res = known;
 602                 } else {
 603                         /* A undefined value, e.g., in unreachable code. */
 604                         res = new_Bad();
 605                 }
 606         } else {
 607                 res = optimize_node(res);  /* This is necessary to add the node to the hash table for cse. */
 608                 IRN_VERIFY_IRG(res, irg);
 609                 /* Memory Phis in endless loops must be kept alive.
 610                    As we can't distinguish these easily we keep all of them alive. */
 611                 if (is_Phi(res) && mode == mode_M)
 612                         add_End_keepalive(get_irg_end(irg), res);
 613         }
 614
 615         return res;
 616 }  /* new_rd_Phi_in */
 617
 618 static ir_node *get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
 619
 620 static ir_node *phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
 621
 622 /**
 623  * Computes the predecessors for the real phi node, and then
 624  * allocates and returns this node.  The routine called to allocate the
 625  * node might optimize it away and return a real value.
 626  * This function must be called with an in-array of proper size.
 627  */
 628 static ir_node *phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 629 {
 630         ir_node *prevBlock, *res, *phi0, *phi0_all;
 631         int i;
 632
 633         /* If this block has no value at pos create a Phi0 and remember it
 634            in graph_arr to break recursions.
 635            Else we may not set graph_arr as there a later value is remembered. */
 636         phi0 = NULL;
 637         if (block->attr.block.graph_arr[pos] == NULL) {
 638                 ir_graph *irg = current_ir_graph;
 639
 640                 if (block == get_irg_start_block(irg)) {
 641                         /* Collapsing to Bad tarvals is no good idea.
 642                            So we call a user-supplied routine here that deals with this
 643                            case as appropriate for the given language. Sorrily the only
 644                            help we can give here is the position.
 645
 646                            Even if all variables are defined before use, it can happen that
 647                            we get to the start block, if a Cond has been replaced by a tuple
 648                            (bad, jmp).  In this case we call the function needlessly,
 649                            eventually generating an non existent error.
 650                            However, this SHOULD NOT HAPPEN, as bad control flow nodes are
 651                            intercepted before recurring.
 652                          */
 653                         if (default_initialize_local_variable != NULL) {
 654                                 ir_node *rem = get_cur_block();
 655
 656                                 set_cur_block(block);
 657                                 block->attr.block.graph_arr[pos] = default_initialize_local_variable(irg, mode, pos - 1);
 658                                 set_cur_block(rem);
 659                         } else {
 660                                 block->attr.block.graph_arr[pos] = new_Unknown(mode);
 661                         }
 662                         return block->attr.block.graph_arr[pos];
 663                 } else {
 664                         phi0 = new_rd_Phi0(irg, block, mode);
 665                         block->attr.block.graph_arr[pos] = phi0;
 666                 }
 667         }
 668
 669         /* This loop goes to all predecessor blocks of the block the Phi node
 670            is in and there finds the operands of the Phi node by calling
 671            get_r_value_internal.  */
 672         for (i = 1; i <= ins; ++i) {
 673                 ir_node *cf_pred = block->in[i];
 674                 ir_node *prevCfOp = skip_Proj(cf_pred);
 675                 assert(prevCfOp);
 676                 if (is_Bad(prevCfOp)) {
 677                         /* In case a Cond has been optimized we would get right to the start block
 678                         with an invalid definition. */
 679                         nin[i-1] = new_Bad();
 680                         continue;
 681                 }
 682                 prevBlock = prevCfOp->in[0]; /* go past control flow op to prev block */
 683                 assert(prevBlock);
 684                 if (!is_Bad(prevBlock)) {
 685                         nin[i-1] = get_r_value_internal(prevBlock, pos, mode);
 686                 } else {
 687                         nin[i-1] = new_Bad();
 688                 }
 689         }
 690
 691         /* We want to pass the Phi0 node to the constructor: this finds additional
 692            optimization possibilities.
 693            The Phi0 node either is allocated in this function, or it comes from
 694            a former call to get_r_value_internal(). In this case we may not yet
 695            exchange phi0, as this is done in mature_immBlock(). */
 696         if (phi0 == NULL) {
 697                 phi0_all = block->attr.block.graph_arr[pos];
 698                 if (! is_Phi0(phi0_all)            ||
 699                     get_irn_arity(phi0_all) != 0   ||
 700                     get_nodes_block(phi0_all) != block)
 701                         phi0_all = NULL;
 702         } else {
 703                 phi0_all = phi0;
 704         }
 705
 706         /* After collecting all predecessors into the array nin a new Phi node
 707            with these predecessors is created.  This constructor contains an
 708            optimization: If all predecessors of the Phi node are identical it
 709            returns the only operand instead of a new Phi node.  */
 710         res = new_rd_Phi_in(current_ir_graph, block, mode, nin, ins, phi0_all);
 711
 712         /* In case we allocated a Phi0 node at the beginning of this procedure,
 713            we need to exchange this Phi0 with the real Phi. */
 714         if (phi0 != NULL) {
 715                 exchange(phi0, res);
 716                 block->attr.block.graph_arr[pos] = res;
 717         }
 718
 719         return res;
 720 }  /* phi_merge */
 721
 722 /**
 723  * This function returns the last definition of a value.  In case
 724  * this value was last defined in a previous block, Phi nodes are
 725  * inserted.  If the part of the firm graph containing the definition
 726  * is not yet constructed, a dummy Phi node is returned.
 727  *
 728  * @param block   the current block
 729  * @param pos     the value number of the value searched
 730  * @param mode    the mode of this value (needed for Phi construction)
 731  */
 732 static ir_node *get_r_value_internal(ir_node *block, int pos, ir_mode *mode)
 733 {
 734         ir_node *res;
 735         /* There are 4 cases to treat.
 736
 737            1. The block is not mature and we visit it the first time.  We can not
 738               create a proper Phi node, therefore a Phi0, i.e., a Phi without
 739               predecessors is returned.  This node is added to the linked list (block
 740               attribute "phis") of the containing block to be completed when this block is
 741               matured. (Completion will add a new Phi and turn the Phi0 into an Id
 742               node.)
 743
 744            2. The value is already known in this block, graph_arr[pos] is set and we
 745               visit the block the first time.  We can return the value without
 746               creating any new nodes.
 747
 748            3. The block is mature and we visit it the first time.  A Phi node needs
 749               to be created (phi_merge).  If the Phi is not needed, as all it's
 750               operands are the same value reaching the block through different
 751               paths, it's optimized away and the value itself is returned.
 752
 753            4. The block is mature, and we visit it the second time.  Now two
 754               subcases are possible:
 755               * The value was computed completely the last time we were here. This
 756                 is the case if there is no loop.  We can return the proper value.
 757               * The recursion that visited this node and set the flag did not
 758                 return yet.  We are computing a value in a loop and need to
 759                 break the recursion.  This case only happens if we visited
 760             the same block with phi_merge before, which inserted a Phi0.
 761             So we return the Phi0.
 762         */
 763
 764         /* case 4 -- already visited. */
 765         if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
 766                 /* As phi_merge allocates a Phi0 this value is always defined. Here
 767                 is the critical difference of the two algorithms. */
 768                 assert(block->attr.block.graph_arr[pos]);
 769                 return block->attr.block.graph_arr[pos];
 770         }
 771
 772         /* visited the first time */
 773         set_irn_visited(block, get_irg_visited(current_ir_graph));
 774
 775         /* Get the local valid value */
 776         res = block->attr.block.graph_arr[pos];
 777
 778         /* case 2 -- If the value is actually computed, return it. */
 779         if (res != NULL)
 780                 return res;
 781
 782         if (block->attr.block.is_matured) { /* case 3 */
 783
 784                 /* The Phi has the same amount of ins as the corresponding block. */
 785                 int ins = get_irn_arity(block);
 786                 ir_node **nin;
 787                 NEW_ARR_A(ir_node *, nin, ins);
 788
 789                 /* Phi merge collects the predecessors and then creates a node. */
 790                 res = phi_merge(block, pos, mode, nin, ins);
 791
 792         } else {  /* case 1 */
 793                 /* The block is not mature, we don't know how many in's are needed.  A Phi
 794                    with zero predecessors is created.  Such a Phi node is called Phi0
 795                    node.  The Phi0 is then added to the list of Phi0 nodes in this block
 796                    to be matured by mature_immBlock later.
 797                    The Phi0 has to remember the pos of it's internal value.  If the real
 798                    Phi is computed, pos is used to update the array with the local
 799                    values. */
 800                 res = new_rd_Phi0(current_ir_graph, block, mode);
 801                 res->attr.phi.u.pos    = pos;
 802                 res->attr.phi.next     = block->attr.block.phis;
 803                 block->attr.block.phis = res;
 804         }
 805
 806         assert(is_ir_node(res) && "phi_merge() failed to construct a definition");
 807
 808         /* The local valid value is available now. */
 809         block->attr.block.graph_arr[pos] = res;
 810
 811         return res;
 812 }  /* get_r_value_internal */
 813
 814 /* ************************************************************************** */
 815
 816 /*
 817  * Finalize a Block node, when all control flows are known.
 818  * Acceptable parameters are only Block nodes.
 819  */
 820 void mature_immBlock(ir_node *block)
 821 {
 822         int ins;
 823         ir_node *n, **nin;
 824         ir_node *next;
 825
 826         assert(is_Block(block));
 827         if (!get_Block_matured(block)) {
 828                 ir_graph *irg = current_ir_graph;
 829
 830                 ins = ARR_LEN(block->in) - 1;
 831                 /* Fix block parameters */
 832                 block->attr.block.backedge = new_backedge_arr(irg->obst, ins);
 833
 834                 /* An array for building the Phi nodes. */
 835                 NEW_ARR_A(ir_node *, nin, ins);
 836
 837                 /* Traverse a chain of Phi nodes attached to this block and mature
 838                 these, too. **/
 839                 for (n = block->attr.block.phis; n; n = next) {
 840                         inc_irg_visited(irg);
 841                         next = n->attr.phi.next;
 842                         exchange(n, phi_merge(block, n->attr.phi.u.pos, n->mode, nin, ins));
 843                 }
 844
 845                 block->attr.block.is_matured = 1;
 846
 847                 /* Now, as the block is a finished Firm node, we can optimize it.
 848                    Since other nodes have been allocated since the block was created
 849                    we can not free the node on the obstack.  Therefore we have to call
 850                    optimize_in_place().
 851                    Unfortunately the optimization does not change a lot, as all allocated
 852                    nodes refer to the unoptimized node.
 853                    We can call optimize_in_place_2(), as global cse has no effect on blocks. */
 854                 block = optimize_in_place_2(block);
 855                 IRN_VERIFY_IRG(block, irg);
 856         }
 857 }  /* mature_immBlock */
 858
 859 ir_node *new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode)
 860 {
 861         return new_bd_Phi(db, current_ir_graph->current_block, arity, in, mode);
 862 }  /* new_d_Phi */
 863
 864 ir_node *new_d_Const(dbg_info *db, tarval *con)
 865 {
 866         return new_bd_Const(db, con);
 867 }  /* new_d_Const */
 868
 869 ir_node *new_d_Const_long(dbg_info *db, ir_mode *mode, long value)
 870 {
 871         return new_bd_Const_long(db, mode, value);
 872 }  /* new_d_Const_long */
 873
 874 ir_node *new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp)
 875 {
 876         return new_bd_Const_type(db, con, tp);
 877 }  /* new_d_Const_type */
 878
 879
 880 ir_node *new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj)
 881 {
 882         ir_node *res;
 883         assert(is_Cond(arg));
 884         arg->attr.cond.default_proj = max_proj;
 885         res = new_d_Proj(db, arg, mode_X, max_proj);
 886         return res;
 887 }  /* new_d_defaultProj */
 888
 889 ir_node *new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent)
 890 /* GL: objptr was called frame before.  Frame was a bad choice for the name
 891    as the operand could as well be a pointer to a dynamic object. */
 892 {
 893         return new_bd_Sel(db, current_ir_graph->current_block,
 894                           store, objptr, 0, NULL, ent);
 895 }  /* new_d_simpleSel */
 896
 897 ir_node *new_d_SymConst_type(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *tp)
 898 {
 899         return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
 900                                     value, kind, tp);
 901 }  /* new_d_SymConst_type */
 902
 903 ir_node *new_d_SymConst(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind)
 904 {
 905         return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
 906                                     value, kind, firm_unknown_type);
 907 }  /* new_d_SymConst */
 908
 909 ir_node *new_d_Sync(dbg_info *db, int arity, ir_node *in[])
 910 {
 911         return new_rd_Sync(db, current_ir_graph->current_block, arity, in);
 912 }  /* new_d_Sync */
 913
 914 ir_node *new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs,
 915                    int n_outs, ir_asm_constraint *outputs, int n_clobber,
 916                    ident *clobber[], ident *text)
 917 {
 918         return new_bd_ASM(db, current_ir_graph->current_block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
 919 }  /* new_d_ASM */
 920
 921 /* ********************************************************************* */
 922 /* Comfortable interface with automatic Phi node construction.           */
 923 /* (Uses also constructors of ?? interface, except new_Block.            */
 924 /* ********************************************************************* */
 925
 926 /*  Block construction */
 927 /* immature Block without predecessors */
 928 ir_node *new_d_immBlock(dbg_info *db)
 929 {
 930         ir_node *res;
 931
 932         assert(get_irg_phase_state(current_ir_graph) == phase_building);
 933         /* creates a new dynamic in-array as length of in is -1 */
 934         res = new_ir_node(db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
 935
 936         res->attr.block.is_matured  = 0;
 937         res->attr.block.is_dead     = 0;
 938         res->attr.block.irg.irg     = current_ir_graph;
 939         res->attr.block.backedge    = NULL;
 940         res->attr.block.in_cg       = NULL;
 941         res->attr.block.cg_backedge = NULL;
 942         res->attr.block.extblk      = NULL;
 943         res->attr.block.region      = NULL;
 944         res->attr.block.entity      = NULL;
 945
 946         set_Block_block_visited(res, 0);
 947
 948         /* Create and initialize array for Phi-node construction. */
 949         res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
 950                                               current_ir_graph->n_loc);
 951         memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
 952
 953         /* Immature block may not be optimized! */
 954         IRN_VERIFY_IRG(res, current_ir_graph);
 955
 956         return res;
 957 }  /* new_d_immBlock */
 958
 959 ir_node *new_immBlock(void)
 960 {
 961         return new_d_immBlock(NULL);
 962 }  /* new_immBlock */
 963
 964 /* add an edge to a jmp/control flow node */
 965 void add_immBlock_pred(ir_node *block, ir_node *jmp)
 966 {
 967         int n = ARR_LEN(block->in) - 1;
 968
 969         assert(is_Block(block) && "Error: Must be a Block");
 970         assert(!block->attr.block.is_matured && "Error: Block already matured!\n");
 971         assert(is_ir_node(jmp));
 972
 973         ARR_APP1(ir_node *, block->in, jmp);
 974         /* Call the hook */
 975         hook_set_irn_n(block, n, jmp, NULL);
 976 }  /* add_immBlock_pred */
 977
 978 /* changing the current block */
 979 void set_cur_block(ir_node *target)
 980 {
 981         current_ir_graph->current_block = target;
 982 }  /* set_cur_block */
 983
 984 /* ************************ */
 985 /* parameter administration */
 986
 987 /* get a value from the parameter array from the current block by its index */
 988 ir_node *get_d_value(dbg_info *db, int pos, ir_mode *mode)
 989 {
 990         ir_graph *irg = current_ir_graph;
 991         assert(get_irg_phase_state(irg) == phase_building);
 992         inc_irg_visited(irg);
 993         (void) db;
 994
 995         assert(pos >= 0);
 996
 997         return get_r_value_internal(irg->current_block, pos + 1, mode);
 998 }  /* get_d_value */
 999
1000 /* get a value from the parameter array from the current block by its index */
1001 ir_node *get_value(int pos, ir_mode *mode)
1002 {
1003         return get_d_value(NULL, pos, mode);
1004 }  /* get_value */
1005
1006 /**
1007  * helper function for guess_mode: recursively look for a definition for
1008  * local variable @p pos, returns its mode if found.
1009  */
1010 static ir_mode *guess_recursively(ir_node *block, int pos)
1011 {
1012         ir_node *value;
1013         int      n_preds;
1014         int      i;
1015
1016         if (irn_visited(block))
1017                 return NULL;
1018         mark_irn_visited(block);
1019
1020         /* already have a defintion -> we can simply look at its mode */
1021         value = block->attr.block.graph_arr[pos];
1022         if (value != NULL)
1023                 return get_irn_mode(value);
1024
1025         /* now we try to guess, by looking at the predecessor blocks */
1026         n_preds = get_irn_arity(block);
1027         for (i = 0; i < n_preds; ++i) {
1028                 ir_node *pred_block = get_Block_cfgpred_block(block, i);
1029                 ir_mode *mode       = guess_recursively(pred_block, pos);
1030                 if (mode != NULL)
1031                         return mode;
1032         }
1033
1034         /* no way to guess */
1035         return NULL;
1036 }
1037
1038 ir_mode *ir_guess_mode(int pos)
1039 {
1040         ir_graph *irg   = current_ir_graph;
1041         ir_node  *block = irg->current_block;
1042         ir_node  *value = block->attr.block.graph_arr[pos+1];
1043         ir_mode  *mode;
1044
1045         /* already have a defintion -> we can simply look at its mode */
1046         if (value != NULL)
1047                 return get_irn_mode(value);
1048
1049         ir_reserve_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
1050         inc_irg_visited(current_ir_graph);
1051         mode = guess_recursively(block, pos+1);
1052         ir_free_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
1053
1054         return mode;
1055 }
1056
1057 /* set a value at position pos in the parameter array from the current block */
1058 void set_value(int pos, ir_node *value)
1059 {
1060         ir_graph *irg = current_ir_graph;
1061         assert(get_irg_phase_state(irg) == phase_building);
1062         assert(pos >= 0);
1063         assert(pos+1 < irg->n_loc);
1064         assert(is_ir_node(value));
1065         irg->current_block->attr.block.graph_arr[pos + 1] = value;
1066 }  /* set_value */
1067
1068 /* Find the value number for a node in the current block.*/
1069 int find_value(ir_node *value)
1070 {
1071         int i;
1072         ir_node *bl = current_ir_graph->current_block;
1073
1074         for (i = ARR_LEN(bl->attr.block.graph_arr) - 1; i >= 1; --i)
1075                 if (bl->attr.block.graph_arr[i] == value)
1076                         return i - 1;
1077         return -1;
1078 }  /* find_value */
1079
1080 /* get the current store */
1081 ir_node *get_store(void)
1082 {
1083         ir_graph *irg = current_ir_graph;
1084
1085         assert(get_irg_phase_state(irg) == phase_building);
1086         /* GL: one could call get_value instead */
1087         inc_irg_visited(irg);
1088         return get_r_value_internal(irg->current_block, 0, mode_M);
1089 }  /* get_store */
1090
1091 /* set the current store: handles automatic Sync construction for Load nodes */
1092 void set_store(ir_node *store)
1093 {
1094         ir_node *load, *pload, *pred, *in[2];
1095
1096         assert(get_irg_phase_state(current_ir_graph) == phase_building);
1097         /* Beware: due to dead code elimination, a store might become a Bad node even in
1098            the construction phase. */
1099         assert((get_irn_mode(store) == mode_M || is_Bad(store)) && "storing non-memory node");
1100
1101         if (get_opt_auto_create_sync()) {
1102                 /* handle non-volatile Load nodes by automatically creating Sync's */
1103                 load = skip_Proj(store);
1104                 if (is_Load(load) && get_Load_volatility(load) == volatility_non_volatile) {
1105                         pred = get_Load_mem(load);
1106
1107                         if (is_Sync(pred)) {
1108                                 /* a Load after a Sync: move it up */
1109                                 ir_node *mem = skip_Proj(get_Sync_pred(pred, 0));
1110
1111                                 set_Load_mem(load, get_memop_mem(mem));
1112                                 add_Sync_pred(pred, store);
1113                                 store = pred;
1114                         } else {
1115                                 pload = skip_Proj(pred);
1116                                 if (is_Load(pload) && get_Load_volatility(pload) == volatility_non_volatile) {
1117                                         /* a Load after a Load: create a new Sync */
1118                                         set_Load_mem(load, get_Load_mem(pload));
1119
1120                                         in[0] = pred;
1121                                         in[1] = store;
1122                                         store = new_Sync(2, in);
1123                                 }
1124                         }
1125                 }
1126         }
1127         current_ir_graph->current_block->attr.block.graph_arr[0] = store;
1128 }  /* set_store */
1129
1130 void keep_alive(ir_node *ka)
1131 {
1132         add_End_keepalive(get_irg_end(current_ir_graph), ka);
1133 }  /* keep_alive */
1134
1135 /* --- Useful access routines --- */
1136 /* Returns the current block of the current graph.  To set the current
1137    block use set_cur_block. */
1138 ir_node *get_cur_block(void)
1139 {
1140         return get_irg_current_block(current_ir_graph);
1141 }  /* get_cur_block */
1142
1143 /* Returns the frame type of the current graph */
1144 ir_type *get_cur_frame_type(void)
1145 {
1146         return get_irg_frame_type(current_ir_graph);
1147 }  /* get_cur_frame_type */
1148
1149
1150 /* ********************************************************************* */
1151 /* initialize */
1152
1153 /* call once for each run of the library */
1154 void ir_set_uninitialized_local_variable_func(
1155                 uninitialized_local_variable_func_t *func)
1156 {
1157         default_initialize_local_variable = func;
1158 }
1159
1160 void irg_finalize_cons(ir_graph *irg)
1161 {
1162         set_irg_phase_state(irg, phase_high);
1163 }
1164
1165 void irp_finalize_cons(void)
1166 {
1167         int i;
1168         for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
1169                 irg_finalize_cons(get_irp_irg(i));
1170         }
1171         irp->phase_state = phase_high;
1172 }
1173
1174 ir_node *new_Start(void)
1175 {
1176         return new_d_Start(NULL);
1177 }
1178 ir_node *new_End(void)
1179 {
1180         return new_d_End(NULL);
1181 }
1182 ir_node *new_Const(tarval *con)
1183 {
1184         return new_d_Const(NULL, con);
1185 }
1186
1187 ir_node *new_Const_long(ir_mode *mode, long value)
1188 {
1189         return new_d_Const_long(NULL, mode, value);
1190 }
1191
1192 ir_node *new_Const_type(tarval *con, ir_type *tp)
1193 {
1194         return new_d_Const_type(NULL, con, tp);
1195 }
1196
1197 ir_node *new_SymConst_type(ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *type)
1198 {
1199         return new_d_SymConst_type(NULL, mode, value, kind, type);
1200 }
1201 ir_node *new_SymConst(ir_mode *mode, symconst_symbol value, symconst_kind kind)
1202 {
1203         return new_d_SymConst(NULL, mode, value, kind);
1204 }
1205 ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent)
1206 {
1207         return new_d_simpleSel(NULL, store, objptr, ent);
1208 }
1209 ir_node *new_Phi(int arity, ir_node **in, ir_mode *mode)
1210 {
1211         return new_d_Phi(NULL, arity, in, mode);
1212 }
1213 ir_node *new_Sync(int arity, ir_node *in[])
1214 {
1215         return new_d_Sync(NULL, arity, in);
1216 }
1217 ir_node *new_defaultProj(ir_node *arg, long max_proj)
1218 {
1219         return new_d_defaultProj(NULL, arg, max_proj);
1220 }
1221 ir_node *new_Bad(void)
1222 {
1223         return get_irg_bad(current_ir_graph);
1224 }
1225 ir_node *new_NoMem(void)
1226 {
1227         return get_irg_no_mem(current_ir_graph);
1228 }
1229 ir_node *new_ASM(int arity, ir_node *in[], ir_asm_constraint *inputs,
1230                  int n_outs, ir_asm_constraint *outputs,
1231                  int n_clobber, ident *clobber[], ident *text)
1232 {
1233         return new_d_ASM(NULL, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
1234 }
1235
1236 /* create a new anchor node */
1237 ir_node *new_Anchor(ir_graph *irg)
1238 {
1239         ir_node *in[anchor_last];
1240         ir_node *res;
1241         memset(in, 0, sizeof(in));
1242         res = new_ir_node(NULL, irg, NULL, op_Anchor, mode_ANY, anchor_last, in);
1243
1244         /* hack to get get_irn_irg working: set block to ourself and allow
1245          * get_Block_irg for anchor */
1246         res->attr.irg.irg = irg;
1247         res->in[0] = res;
1248
1249         return res;
1250 }