/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
Michael Beck
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
#include "irprog_t.h"
#include "irgraph_t.h"
#include "iropt_t.h"
#include "irgmod.h"
#include "irhooks.h"
-#include "array.h"
+#include "array_t.h"
#include "irbackedge_t.h"
#include "irflag_t.h"
#include "iredges_t.h"
#include "irflag_t.h"
-#include "xmalloc.h"
#if USE_EXPLICIT_PHI_IN_STACK
/* A stack needed for the automatic Phi node construction in constructor
#define NEW_BD_DIVOP(instr) \
static ir_node * \
new_bd_##instr(dbg_info *db, ir_node *block, \
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) \
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) \
{ \
ir_node *in[3]; \
ir_node *res; \
in[1] = op1; \
in[2] = op2; \
res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
- res->attr.divmod.exc.pin_state = op_pin_state_pinned; \
+ res->attr.divmod.exc.pin_state = state; \
res->attr.divmod.res_mode = mode; \
+ res->attr.divmod.no_remainder = 0; \
res = optimize_node(res); \
IRN_VRFY_IRG(res, irg); \
return res; \
#define NEW_RD_DIVOP(instr) \
ir_node * \
new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block, \
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) \
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) \
{ \
ir_node *res; \
ir_graph *rem = current_ir_graph; \
current_ir_graph = irg; \
- res = new_bd_##instr(db, block, memop, op1, op2, mode); \
+ res = new_bd_##instr(db, block, memop, op1, op2, mode, state);\
current_ir_graph = rem; \
return res; \
}
res->attr.block.is_dead = 0;
res->attr.block.is_mb_head = 1;
+ res->attr.block.has_label = 0;
res->attr.block.irg = irg;
res->attr.block.backedge = new_backedge_arr(irg->obst, arity);
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
res->attr.block.extblk = NULL;
res->attr.block.mb_depth = 0;
+ res->attr.block.label = 0;
set_Block_matured(res, 1);
set_Block_block_visited(res, 0);
/* Don't assert that block matured: the use of this constructor is strongly
restricted ... */
- if ( get_Block_matured(block) )
- assert( get_irn_arity(block) == arity );
+ if (get_Block_matured(block))
+ assert(get_irn_arity(block) == arity);
res = new_ir_node(db, irg, block, op_Phi, mode, arity, in);
- res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
+ res->attr.phi.u.backedge = new_backedge_arr(irg->obst, arity);
- for (i = arity-1; i >= 0; i--)
- if (get_irn_op(in[i]) == op_Unknown) {
+ for (i = arity - 1; i >= 0; --i)
+ if (is_Unknown(in[i])) {
has_unknown = 1;
break;
}
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of them alive. */
- if ((res->op == op_Phi) && (mode == mode_M))
+ if (is_Phi(res) && mode == mode_M)
add_End_keepalive(get_irg_end(irg), res);
return res;
} /* new_bd_Phi */
new_bd_Const_type(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) {
ir_node *res;
ir_graph *irg = current_ir_graph;
+ (void) block;
res = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, mode, 0, NULL);
res->attr.con.tv = con;
NEW_BD_BINOP(Sub)
NEW_BD_UNOP(Minus)
NEW_BD_BINOP(Mul)
+NEW_BD_BINOP(Mulh)
NEW_BD_DIVOP(Quot)
NEW_BD_DIVOP(DivMod)
NEW_BD_DIVOP(Div)
NEW_BD_BINOP(Shl)
NEW_BD_BINOP(Shr)
NEW_BD_BINOP(Shrs)
-NEW_BD_BINOP(Rot)
+NEW_BD_BINOP(Rotl)
NEW_BD_UNOP(Abs)
NEW_BD_BINOP(Carry)
NEW_BD_BINOP(Borrow)
+/** Creates a remainderless Div node. */
+static ir_node *new_bd_DivRL(dbg_info *db, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state)
+{
+ ir_node *in[3];
+ ir_node *res;
+ ir_graph *irg = current_ir_graph;
+ in[0] = memop;
+ in[1] = op1;
+ in[2] = op2;
+ res = new_ir_node(db, irg, block, op_Div, mode_T, 3, in);
+ res->attr.divmod.exc.pin_state = state;
+ res->attr.divmod.res_mode = mode;
+ res->attr.divmod.no_remainder = 1;
+ res = optimize_node(res);
+ IRN_VRFY_IRG(res, irg);
+ return res;
+}
+
static ir_node *
new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) {
ir_node *in[2];
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
- res = optimize_node (res);
+ res = new_ir_node(db, irg, block, op_Jmp, mode_X, 0, NULL);
+ res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_Jmp */
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node (db, irg, block, op_IJmp, mode_X, 1, &tgt);
- res = optimize_node (res);
+ res = new_ir_node(db, irg, block, op_IJmp, mode_X, 1, &tgt);
+ res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
-
- if (get_irn_op(res) == op_IJmp) /* still an IJmp */
- keep_alive(res);
return res;
} /* new_bd_IJmp */
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, &c);
+ res = new_ir_node(db, irg, block, op_Cond, mode_T, 1, &c);
res->attr.cond.kind = dense;
res->attr.cond.default_proj = 0;
res->attr.cond.pred = COND_JMP_PRED_NONE;
- res = optimize_node (res);
+ res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_Cond */
res->attr.load.exc.pin_state = op_pin_state_pinned;
res->attr.load.load_mode = mode;
res->attr.load.volatility = volatility_non_volatile;
+ res->attr.load.aligned = align_is_aligned;
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
res = new_ir_node(db, irg, block, op_Store, mode_T, 3, in);
res->attr.store.exc.pin_state = op_pin_state_pinned;
res->attr.store.volatility = volatility_non_volatile;
+ res->attr.store.aligned = align_is_aligned;
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
static ir_node *
new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *size, ir_type *alloc_type, where_alloc where) {
+ ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
ir_node *in[2];
ir_node *res;
ir_graph *irg = current_ir_graph;
static ir_node *
new_bd_Free(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+ ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
ir_node *in[3];
ir_node *res;
ir_graph *irg = current_ir_graph;
} /* new_bd_Sel */
static ir_node *
-new_bd_SymConst_type(dbg_info *db, ir_node *block, symconst_symbol value,
- symconst_kind symkind, ir_type *tp) {
- ir_node *res;
- ir_mode *mode;
+new_bd_SymConst_type(dbg_info *db, ir_node *block, ir_mode *mode,
+ symconst_symbol value,symconst_kind symkind, ir_type *tp) {
ir_graph *irg = current_ir_graph;
+ ir_node *res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
- if ((symkind == symconst_addr_name) || (symkind == symconst_addr_ent))
- mode = mode_P_data; /* FIXME: can be mode_P_code */
- else
- mode = mode_Iu;
-
- res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL);
-
- res->attr.symc.num = symkind;
- res->attr.symc.sym = value;
- res->attr.symc.tp = tp;
+ res->attr.symc.kind = symkind;
+ res->attr.symc.sym = value;
+ res->attr.symc.tp = tp;
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
} /* new_bd_Sync */
static ir_node *
-new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp, ir_exc_region_t exc_region) {
+new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
ir_node *in[2], *res;
ir_graph *irg = current_ir_graph;
in[0] = val;
in[1] = bound;
res = new_ir_node(db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
- res->attr.confirm.cmp = cmp;
- res->attr.confirm.exc_region = exc_region;
+ res->attr.confirm.cmp = cmp;
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
return res;
} /* new_bd_Mux */
-static ir_node *
-new_bd_Psi(dbg_info *db, ir_node *block,
- int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode) {
- ir_node **in;
- ir_node *res;
- ir_graph *irg = current_ir_graph;
- int i;
-
- NEW_ARR_A(ir_node *, in, 2 * arity + 1);
-
- for (i = 0; i < arity; ++i) {
- in[2 * i] = cond[i];
- in[2 * i + 1] = vals[i];
- }
- in[2 * i] = vals[i];
-
- res = new_ir_node(db, irg, block, op_Psi, mode, 2 * arity + 1, in);
- assert(res);
-
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Psi */
-
static ir_node *
new_bd_CopyB(dbg_info *db, ir_node *block,
ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
int n_outs, ir_asm_constraint *outputs, int n_clobber, ident *clobber[], ident *asm_text) {
ir_node *res;
ir_graph *irg = current_ir_graph;
+ (void) clobber;
res = new_ir_node(db, irg, block, op_ASM, mode_T, arity, in);
res->attr.assem.pin_state = op_pin_state_pinned;
res->attr.assem.inputs = NEW_ARR_D(ir_asm_constraint, irg->obst, arity);
res->attr.assem.outputs = NEW_ARR_D(ir_asm_constraint, irg->obst, n_outs);
- res->attr.assem.clobber = NEW_ARR_D(ident *, irg->obst, n_clobber);
+ res->attr.assem.clobber = NEW_ARR_D(ident *, irg->obst, n_clobber);
res->attr.assem.asm_text = asm_text;
- memcpy(res->attr.assem.inputs, inputs, sizeof(inputs[0]) * arity);
- memcpy(res->attr.assem.outputs, outputs, sizeof(outputs[0]) * n_outs);
+ memcpy(res->attr.assem.inputs, inputs, sizeof(inputs[0]) * arity);
+ memcpy(res->attr.assem.outputs, outputs, sizeof(outputs[0]) * n_outs);
+ memcpy(res->attr.assem.clobber, clobber, sizeof(clobber[0]) * n_clobber);
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
ir_node *res;
ir_graph *rem = current_ir_graph;
- current_ir_graph = rem;
+ current_ir_graph = irg;
res = new_bd_End(db, block);
current_ir_graph = rem;
NEW_RD_BINOP(Sub)
NEW_RD_UNOP(Minus)
NEW_RD_BINOP(Mul)
+NEW_RD_BINOP(Mulh)
NEW_RD_DIVOP(Quot)
NEW_RD_DIVOP(DivMod)
NEW_RD_DIVOP(Div)
NEW_RD_BINOP(Shl)
NEW_RD_BINOP(Shr)
NEW_RD_BINOP(Shrs)
-NEW_RD_BINOP(Rot)
+NEW_RD_BINOP(Rotl)
NEW_RD_UNOP(Abs)
NEW_RD_BINOP(Carry)
NEW_RD_BINOP(Borrow)
+/* creates a rd constructor for an divRL */
+ir_node *new_rd_DivRL(dbg_info *db, ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state)
+{
+ ir_node *res;
+ ir_graph *rem = current_ir_graph;
+ current_ir_graph = irg;
+ res = new_bd_DivRL(db, block, memop, op1, op2, mode, state);
+ current_ir_graph = rem;
+ return res;
+}
+
ir_node *
new_rd_Cmp(dbg_info *db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2) {
ir_node *
new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *size, ir_type *alloc_type, where_alloc where) {
+ ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
ir_node *res;
ir_graph *rem = current_ir_graph;
ir_node *
new_rd_Free(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+ ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
ir_node *res;
ir_graph *rem = current_ir_graph;
} /* new_rd_Sel */
ir_node *
-new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
- symconst_kind symkind, ir_type *tp) {
+new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode,
+ symconst_symbol value, symconst_kind symkind, ir_type *tp) {
ir_node *res;
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- res = new_bd_SymConst_type(db, block, value, symkind, tp);
+ res = new_bd_SymConst_type(db, block, mode, value, symkind, tp);
current_ir_graph = rem;
return res;
} /* new_rd_SymConst_type */
ir_node *
-new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
- symconst_kind symkind) {
- ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
- return res;
+new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode,
+ symconst_symbol value, symconst_kind symkind) {
+ return new_rd_SymConst_type(db, irg, block, mode, value, symkind, firm_unknown_type);
} /* new_rd_SymConst */
- ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
+ ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp) {
symconst_symbol sym;
sym.entity_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_addr_ent, tp);
} /* new_rd_SymConst_addr_ent */
-ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_entity *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_entity *symbol, ir_type *tp) {
symconst_symbol sym;
sym.entity_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_ofs_ent, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_ofs_ent, tp);
} /* new_rd_SymConst_ofs_ent */
-ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ir_mode *mode, ident *symbol, ir_type *tp) {
symconst_symbol sym;
sym.ident_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_addr_name, tp);
} /* new_rd_SymConst_addr_name */
-ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
symconst_symbol sym;
sym.type_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_tag, tp);
} /* new_rd_SymConst_type_tag */
-ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
symconst_symbol sym;
sym.type_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_size, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_size, tp);
} /* new_rd_SymConst_size */
-ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_mode *mode, ir_type *symbol, ir_type *tp) {
symconst_symbol sym;
sym.type_p = symbol;
- return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), mode, sym, symconst_type_align, tp);
} /* new_rd_SymConst_align */
ir_node *
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- res = new_bd_Confirm(db, block, val, bound, cmp, 0);
+ res = new_bd_Confirm(db, block, val, bound, cmp);
current_ir_graph = rem;
return res;
} /* new_rd_Confirm */
-ir_node *
-new_rd_bounded_Confirm(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Confirm(db, block, val, bound, cmp, get_Block_exc_region(block));
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_bounded_Confirm */
-
ir_node *
new_rd_Unknown(ir_graph *irg, ir_mode *m) {
ir_node *res;
return res;
} /* new_rd_Mux */
-ir_node *
-new_rd_Psi(dbg_info *db, ir_graph *irg, ir_node *block,
- int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Psi(db, block, arity, cond, vals, mode);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Psi */
-
ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
ir_node *res;
ir_mode *mode, tarval *con, ir_type *tp) {
return new_rd_Const_type(NULL, irg, block, mode, con, tp);
}
-ir_node *new_r_SymConst(ir_graph *irg, ir_node *block,
+ir_node *new_r_SymConst(ir_graph *irg, ir_node *block, ir_mode *mode,
symconst_symbol value, symconst_kind symkind) {
- return new_rd_SymConst(NULL, irg, block, value, symkind);
+ return new_rd_SymConst(NULL, irg, block, mode, value, symkind);
}
ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store,
ir_node *objptr, ir_entity *ent) {
ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Mul(NULL, irg, block, op1, op2, mode);
}
+ir_node *new_r_Mulh(ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
+ return new_rd_Mulh(NULL, irg, block, op1, op2, mode);
+}
ir_node *new_r_Quot(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Quot(NULL, irg, block, memop, op1, op2, mode);
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_rd_Quot(NULL, irg, block, memop, op1, op2, mode, state);
}
ir_node *new_r_DivMod(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_DivMod(NULL, irg, block, memop, op1, op2, mode);
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_rd_DivMod(NULL, irg, block, memop, op1, op2, mode, state);
}
ir_node *new_r_Div(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Div(NULL, irg, block, memop, op1, op2, mode);
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_rd_Div(NULL, irg, block, memop, op1, op2, mode, state);
+}
+ir_node *new_r_DivRL(ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_rd_DivRL(NULL, irg, block, memop, op1, op2, mode, state);
}
ir_node *new_r_Mod(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Mod(NULL, irg, block, memop, op1, op2, mode);
+ ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_rd_Mod(NULL, irg, block, memop, op1, op2, mode, state);
}
ir_node *new_r_Abs(ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode) {
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Shrs(NULL, irg, block, op, k, mode);
}
-ir_node *new_r_Rot(ir_graph *irg, ir_node *block,
+ir_node *new_r_Rotl(ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
- return new_rd_Rot(NULL, irg, block, op, k, mode);
+ return new_rd_Rotl(NULL, irg, block, op, k, mode);
}
ir_node *new_r_Carry(ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Store(NULL, irg, block, store, adr, val);
}
ir_node *new_r_Alloc(ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *size, ir_type *alloc_type, where_alloc where) {
+ ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
}
ir_node *new_r_Free(ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
+ ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) {
return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
}
ir_node *new_r_Sync(ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
ir_node *new_r_Confirm(ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
return new_rd_Confirm(NULL, irg, block, val, bound, cmp);
}
-ir_node *new_r_bounded_Confirm(ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- return new_rd_bounded_Confirm(NULL, irg, block, val, bound, cmp);
-}
ir_node *new_r_Unknown(ir_graph *irg, ir_mode *m) {
return new_rd_Unknown(irg, m);
}
ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
}
-ir_node *new_r_Psi(ir_graph *irg, ir_node *block,
- int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
- return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
-}
ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
}
for (i = arity-1; i >= 0; i--)
- if (get_irn_op(in[i]) == op_Unknown) {
+ if (is_Unknown(in[i])) {
has_unknown = 1;
break;
}
return res;
} /* new_rd_Phi0 */
-/* There are two implementations of the Phi node construction. The first
- is faster, but does not work for blocks with more than 2 predecessors.
- The second works always but is slower and causes more unnecessary Phi
- nodes.
- Select the implementations by the following preprocessor flag set in
- common/common.h: */
-#if USE_FAST_PHI_CONSTRUCTION
-
-/* This is a stack used for allocating and deallocating nodes in
- new_rd_Phi_in. The original implementation used the obstack
- to model this stack, now it is explicit. This reduces side effects.
-*/
-#if USE_EXPLICIT_PHI_IN_STACK
-Phi_in_stack *
-new_Phi_in_stack(void) {
- Phi_in_stack *res;
-
- res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
-
- res->stack = NEW_ARR_F (ir_node *, 0);
- res->pos = 0;
-
- return res;
-} /* new_Phi_in_stack */
-
-void
-free_Phi_in_stack(Phi_in_stack *s) {
- DEL_ARR_F(s->stack);
- free(s);
-} /* free_Phi_in_stack */
-
-static INLINE void
-free_to_Phi_in_stack(ir_node *phi) {
- if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
- current_ir_graph->Phi_in_stack->pos)
- ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
- else
- current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
-
- (current_ir_graph->Phi_in_stack->pos)++;
-} /* free_to_Phi_in_stack */
-
-static INLINE ir_node *
-alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
- int arity, ir_node **in) {
- ir_node *res;
- ir_node **stack = current_ir_graph->Phi_in_stack->stack;
- int pos = current_ir_graph->Phi_in_stack->pos;
-
-
- if (pos == 0) {
- /* We need to allocate a new node */
- res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
- res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
- } else {
- /* reuse the old node and initialize it again. */
- res = stack[pos-1];
-
- assert(res->kind == k_ir_node);
- assert(res->op == op_Phi);
- res->mode = mode;
- res->visited = 0;
- res->link = NULL;
- assert(arity >= 0);
- /* ???!!! How to free the old in array?? Not at all: on obstack ?!! */
- res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
- res->in[0] = block;
- memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
-
- (current_ir_graph->Phi_in_stack->pos)--;
- }
- return res;
-} /* alloc_or_pop_from_Phi_in_stack */
-#endif /* USE_EXPLICIT_PHI_IN_STACK */
-
-/**
- * Creates a Phi node with a given, fixed array **in of predecessors.
- * If the Phi node is unnecessary, as the same value reaches the block
- * through all control flow paths, it is eliminated and the value
- * returned directly. This constructor is only intended for use in
- * the automatic Phi node generation triggered by get_value or mature.
- * The implementation is quite tricky and depends on the fact, that
- * the nodes are allocated on a stack:
- * The in array contains predecessors and NULLs. The NULLs appear,
- * if get_r_value_internal, that computed the predecessors, reached
- * the same block on two paths. In this case the same value reaches
- * this block on both paths, there is no definition in between. We need
- * not allocate a Phi where these path's merge, but we have to communicate
- * this fact to the caller. This happens by returning a pointer to the
- * node the caller _will_ allocate. (Yes, we predict the address. We can
- * do so because the nodes are allocated on the obstack.) The caller then
- * finds a pointer to itself and, when this routine is called again,
- * eliminates itself.
- */
-static INLINE ir_node *
-new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins) {
- int i;
- ir_node *res, *known;
-
- /* Allocate a new node on the obstack. This can return a node to
- which some of the pointers in the in-array already point.
- Attention: the constructor copies the in array, i.e., the later
- changes to the array in this routine do not affect the
- constructed node! If the in array contains NULLs, there will be
- missing predecessors in the returned node. Is this a possible
- internal state of the Phi node generation? */
-#if USE_EXPLICIT_PHI_IN_STACK
- res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
-#else
- res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
- res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
-#endif
-
- /* The in-array can contain NULLs. These were returned by
- get_r_value_internal if it reached the same block/definition on a
- second path. The NULLs are replaced by the node itself to
- simplify the test in the next loop. */
- for (i = 0; i < ins; ++i) {
- if (in[i] == NULL)
- in[i] = res;
- }
-
- /* This loop checks whether the Phi has more than one predecessor.
- If so, it is a real Phi node and we break the loop. Else the Phi
- node merges the same definition on several paths and therefore is
- not needed. */
- for (i = 0; i < ins; ++i) {
- if (in[i] == res || in[i] == known)
- continue;
-
- if (known == res)
- known = in[i];
- else
- break;
- }
-
- /* i==ins: there is at most one predecessor, we don't need a phi node. */
- if (i==ins) {
-#if USE_EXPLICIT_PHI_IN_STACK
- free_to_Phi_in_stack(res);
-#else
- edges_node_deleted(res, current_ir_graph);
- obstack_free(current_ir_graph->obst, res);
-#endif
- res = known;
- } else {
- res = optimize_node (res);
- IRN_VRFY_IRG(res, irg);
- }
-
- /* return the pointer to the Phi node. This node might be deallocated! */
- return res;
-} /* new_rd_Phi_in */
-
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
-
-/**
- * Allocates and returns this node. The routine called to allocate the
- * node might optimize it away and return a real value, or even a pointer
- * to a deallocated Phi node on top of the obstack!
- * This function is called with an in-array of proper size.
- */
-static ir_node *
-phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
- ir_node *prevBlock, *res;
- int i;
-
- /* This loop goes to all predecessor blocks of the block the Phi node is in
- and there finds the operands of the Phi node by calling
- get_r_value_internal. */
- for (i = 1; i <= ins; ++i) {
- assert (block->in[i]);
- prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
- assert (prevBlock);
- nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
- }
-
- /* After collecting all predecessors into the array nin a new Phi node
- with these predecessors is created. This constructor contains an
- optimization: If all predecessors of the Phi node are identical it
- returns the only operand instead of a new Phi node. If the value
- passes two different control flow edges without being defined, and
- this is the second path treated, a pointer to the node that will be
- allocated for the first path (recursion) is returned. We already
- know the address of this node, as it is the next node to be allocated
- and will be placed on top of the obstack. (The obstack is a _stack_!) */
- res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
-
- /* Now we now the value for "pos" and can enter it in the array with
- all known local variables. Attention: this might be a pointer to
- a node, that later will be allocated!!! See new_rd_Phi_in().
- If this is called in mature, after some set_value() in the same block,
- the proper value must not be overwritten:
- The call order
- get_value (makes Phi0, put's it into graph_arr)
- set_value (overwrites Phi0 in graph_arr)
- mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting
- the proper value.)
- fails. */
- if (!block->attr.block.graph_arr[pos]) {
- block->attr.block.graph_arr[pos] = res;
- } else {
- /* printf(" value already computed by %s\n",
- get_id_str(block->attr.block.graph_arr[pos]->op->name)); */
- }
-
- return res;
-}
/**
- * This function returns the last definition of a variable. In case
- * this variable was last defined in a previous block, Phi nodes are
- * inserted. If the part of the firm graph containing the definition
- * is not yet constructed, a dummy Phi node is returned.
+ * Internal constructor of a Phi node by a phi_merge operation.
+ *
+ * @param irg the graph on which the Phi will be constructed
+ * @param block the block in which the Phi will be constructed
+ * @param mode the mod eof the Phi node
+ * @param in the input array of the phi node
+ * @param ins number of elements in the input array
+ * @param phi0 in non-NULL: the Phi0 node in the same block that represents
+ * the value for which the new Phi is constructed
*/
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode)
-{
- ir_node *res;
- /* There are 4 cases to treat.
-
- 1. The block is not mature and we visit it the first time. We can not
- create a proper Phi node, therefore a Phi0, i.e., a Phi without
- predecessors is returned. This node is added to the linked list (field
- "link") of the containing block to be completed when this block is
- matured. (Completion will add a new Phi and turn the Phi0 into an Id
- node.)
-
- 2. The value is already known in this block, graph_arr[pos] is set and we
- visit the block the first time. We can return the value without
- creating any new nodes.
-
- 3. The block is mature and we visit it the first time. A Phi node needs
- to be created (phi_merge). If the Phi is not needed, as all it's
- operands are the same value reaching the block through different
- paths, it's optimized away and the value itself is returned.
-
- 4. The block is mature, and we visit it the second time. Now two
- subcases are possible:
- * The value was computed completely the last time we were here. This
- is the case if there is no loop. We can return the proper value.
- * The recursion that visited this node and set the flag did not
- return yet. We are computing a value in a loop and need to
- break the recursion without knowing the result yet.
- @@@ strange case. Straight forward we would create a Phi before
- starting the computation of it's predecessors. In this case we will
- find a Phi here in any case. The problem is that this implementation
- only creates a Phi after computing the predecessors, so that it is
- hard to compute self references of this Phi. @@@
- There is no simple check for the second subcase. Therefore we check
- for a second visit and treat all such cases as the second subcase.
- Anyways, the basic situation is the same: we reached a block
- on two paths without finding a definition of the value: No Phi
- nodes are needed on both paths.
- We return this information "Two paths, no Phi needed" by a very tricky
- implementation that relies on the fact that an obstack is a stack and
- will return a node with the same address on different allocations.
- Look also at phi_merge and new_rd_phi_in to understand this.
- @@@ Unfortunately this does not work, see testprogram
- three_cfpred_example.
-
- */
-
- /* case 4 -- already visited. */
- if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
-
- /* visited the first time */
- set_irn_visited(block, get_irg_visited(current_ir_graph));
-
- /* Get the local valid value */
- res = block->attr.block.graph_arr[pos];
-
- /* case 2 -- If the value is actually computed, return it. */
- if (res) return res;
-
- if (block->attr.block.is_matured) { /* case 3 */
-
- /* The Phi has the same amount of ins as the corresponding block. */
- int ins = get_irn_arity(block);
- ir_node **nin;
- NEW_ARR_A(ir_node *, nin, ins);
-
- /* Phi merge collects the predecessors and then creates a node. */
- res = phi_merge(block, pos, mode, nin, ins);
-
- } else { /* case 1 */
- /* The block is not mature, we don't know how many in's are needed. A Phi
- with zero predecessors is created. Such a Phi node is called Phi0
- node. (There is also an obsolete Phi0 opcode.) The Phi0 is then added
- to the list of Phi0 nodes in this block to be matured by mature_immBlock
- later.
- The Phi0 has to remember the pos of it's internal value. If the real
- Phi is computed, pos is used to update the array with the local
- values. */
-
- res = new_rd_Phi0(current_ir_graph, block, mode);
- res->attr.phi0_pos = pos;
- res->link = block->link;
- block->link = res;
- }
-
- /* If we get here, the frontend missed a use-before-definition error */
- if (!res) {
- /* Error Message */
- printf("Error: no value set. Use of undefined variable. Initializing to zero.\n");
- assert(mode->code >= irm_F && mode->code <= irm_P);
- res = new_rd_Const(NULL, current_ir_graph, block, mode, tarval_mode_null[mode->code]);
- }
-
- /* The local valid value is available now. */
- block->attr.block.graph_arr[pos] = res;
-
- return res;
-} /* get_r_value_internal */
-
-#else /* if 0 */
-
-/**
- it starts the recursion. This causes an Id at the entry of
- every block that has no definition of the value! **/
-
-#if USE_EXPLICIT_PHI_IN_STACK
-/* Just dummies */
-Phi_in_stack * new_Phi_in_stack() { return NULL; }
-void free_Phi_in_stack(Phi_in_stack *s) {}
-#endif
-
static INLINE ir_node *
new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode,
ir_node **in, int ins, ir_node *phi0) {
/* Allocate a new node on the obstack. The allocation copies the in
array. */
- res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
- res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
+ res = new_ir_node(NULL, irg, block, op_Phi, mode, ins, in);
+ res->attr.phi.u.backedge = new_backedge_arr(irg->obst, ins);
/* This loop checks whether the Phi has more than one predecessor.
If so, it is a real Phi node and we break the loop. Else the
Phi node merges the same definition on several paths and therefore
is not needed. Don't consider Bad nodes! */
known = res;
- for (i=0; i < ins; ++i)
- {
+ for (i = ins - 1; i >= 0; --i) {
assert(in[i]);
in[i] = skip_Id(in[i]); /* increases the number of freed Phis. */
/* Optimize self referencing Phis: We can't detect them yet properly, as
they still refer to the Phi0 they will replace. So replace right now. */
- if (phi0 && in[i] == phi0) in[i] = res;
+ if (phi0 && in[i] == phi0)
+ in[i] = res;
- if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
+ if (in[i] == res || in[i] == known || is_Bad(in[i]))
+ continue;
- if (known==res)
+ if (known == res)
known = in[i];
else
break;
}
- /* i==ins: there is at most one predecessor, we don't need a phi node. */
- if (i == ins) {
+ /* i < 0: there is at most one predecessor, we don't need a phi node. */
+ if (i < 0) {
if (res != known) {
edges_node_deleted(res, current_ir_graph);
- obstack_free (current_ir_graph->obst, res);
+ obstack_free(current_ir_graph->obst, res);
if (is_Phi(known)) {
/* If pred is a phi node we want to optimize it: If loops are matured in a bad
order, an enclosing Phi know may get superfluous. */
res = optimize_in_place_2(known);
if (res != known)
exchange(known, res);
-
}
else
res = known;
res = new_Bad();
}
} else {
- res = optimize_node (res); /* This is necessary to add the node to the hash table for cse. */
+ res = optimize_node(res); /* This is necessary to add the node to the hash table for cse. */
IRN_VRFY_IRG(res, irg);
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of them alive. */
- if ((res->op == op_Phi) && (mode == mode_M))
+ if (is_Phi(res) && mode == mode_M)
add_End_keepalive(get_irg_end(irg), res);
}
finished yet. */
opt = get_opt_optimize(); set_optimize(0);
/* Here we rely on the fact that all frag ops have Memory as first result! */
- if (get_irn_op(n) == op_Call)
+ if (is_Call(n)) {
arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
- else if (get_irn_op(n) == op_CopyB)
+ } else if (is_CopyB(n)) {
arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
- else {
+ } else {
assert((pn_Quot_M == pn_DivMod_M) &&
(pn_Quot_M == pn_Div_M) &&
(pn_Quot_M == pn_Mod_M) &&
static void
set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
-#if 0
- if (!frag_arr[pos]) frag_arr[pos] = val;
- if (frag_arr[current_ir_graph->n_loc - 1]) {
- ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
- assert(arr != frag_arr && "Endless recursion detected");
- set_frag_value(arr, pos, val);
- }
-#else
+#ifdef DEBUG_libfirm
int i;
- for (i = 0; i < 1000; ++i) {
- if (!frag_arr[pos]) {
+ for (i = 1024; i >= 0; --i)
+#else
+ for (;;)
+#endif
+ {
+ if (frag_arr[pos] == NULL)
frag_arr[pos] = val;
- }
- if (frag_arr[current_ir_graph->n_loc - 1]) {
+ if (frag_arr[current_ir_graph->n_loc - 1] != NULL) {
ir_node **arr = get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]);
+ assert(arr != frag_arr && "Endless recursion detected");
frag_arr = arr;
- }
- else
+ } else
return;
}
- assert(0 && "potential endless recursion");
-#endif
+ assert(!"potential endless recursion in set_frag_value");
} /* set_frag_value */
static ir_node *
ir_node *res;
ir_node **frag_arr;
- assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
+ assert(is_fragile_op(cfOp) && !is_Bad(cfOp));
frag_arr = get_frag_arr(cfOp);
res = frag_arr[pos];
- if (!res) {
- if (block->attr.block.graph_arr[pos]) {
- /* There was a set_value() after the cfOp and no get_value before that
+ if (res == NULL) {
+ if (block->attr.block.graph_arr[pos] != NULL) {
+ /* There was a set_value() after the cfOp and no get_value() before that
set_value(). We must build a Phi node now. */
if (block->attr.block.is_matured) {
int ins = get_irn_arity(block);
res = phi_merge(block, pos, mode, nin, ins);
} else {
res = new_rd_Phi0(current_ir_graph, block, mode);
- res->attr.phi0.pos = pos;
- res->link = block->link;
- block->link = res;
+ res->attr.phi.u.pos = pos;
+ res->attr.phi.next = block->attr.block.phis;
+ block->attr.block.phis = res;
}
- assert(res);
- /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
- but this should be better: (remove comment if this works) */
+ assert(res != NULL);
/* It's a Phi, we can write this into all graph_arrs with NULL */
set_frag_value(block->attr.block.graph_arr, pos, res);
} else {
} /* get_r_frag_value_internal */
#endif /* PRECISE_EXC_CONTEXT */
+/**
+ * Check whether a control flownode cf_pred represents an exception flow.
+ *
+ * @param cf_pred the control flow node
+ * @param prev_cf_op if cf_pred is a Proj, the predecessor node, else equal to cf_pred
+ */
+static int is_exception_flow(ir_node *cf_pred, ir_node *prev_cf_op) {
+ /*
+ * Note: all projections from a raise are "exceptional control flow" we we handle it
+ * like a normal Jmp, because there is no "regular" one.
+ * That's why Raise is no "fragile_op"!
+ */
+ if (is_fragile_op(prev_cf_op)) {
+ if (is_Proj(cf_pred)) {
+ if (get_Proj_proj(cf_pred) == pn_Generic_X_regular) {
+ /* the regular control flow, NO exception */
+ return 0;
+ }
+ assert(get_Proj_proj(cf_pred) == pn_Generic_X_except);
+ return 1;
+ }
+ /* Hmm, exception but not a Proj? */
+ assert(!"unexpected condition: fragile op without a proj");
+ return 1;
+ }
+ return 0;
+} /* is_exception_flow */
+
/**
* Computes the predecessors for the real phi node, and then
* allocates and returns this node. The routine called to allocate the
*/
static ir_node *
phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
- ir_node *prevBlock, *prevCfOp, *res, *phi0, *phi0_all;
+ ir_node *prevBlock, *res, *phi0, *phi0_all;
int i;
/* If this block has no value at pos create a Phi0 and remember it
in graph_arr to break recursions.
Else we may not set graph_arr as there a later value is remembered. */
phi0 = NULL;
- if (!block->attr.block.graph_arr[pos]) {
- if (block == get_irg_start_block(current_ir_graph)) {
+ if (block->attr.block.graph_arr[pos] == NULL) {
+ ir_graph *irg = current_ir_graph;
+
+ if (block == get_irg_start_block(irg)) {
/* Collapsing to Bad tarvals is no good idea.
So we call a user-supplied routine here that deals with this case as
appropriate for the given language. Sorrily the only help we can give
However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
before recurring.
*/
- if (default_initialize_local_variable) {
+ if (default_initialize_local_variable != NULL) {
ir_node *rem = get_cur_block();
set_cur_block(block);
- block->attr.block.graph_arr[pos] = default_initialize_local_variable(current_ir_graph, mode, pos - 1);
+ block->attr.block.graph_arr[pos] = default_initialize_local_variable(irg, mode, pos - 1);
set_cur_block(rem);
}
else
- block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
+ block->attr.block.graph_arr[pos] = new_Unknown(mode);
/* We don't need to care about exception ops in the start block.
There are none by definition. */
return block->attr.block.graph_arr[pos];
} else {
- phi0 = new_rd_Phi0(current_ir_graph, block, mode);
+ phi0 = new_rd_Phi0(irg, block, mode);
block->attr.block.graph_arr[pos] = phi0;
#if PRECISE_EXC_CONTEXT
if (get_opt_precise_exc_context()) {
/* This loop goes to all predecessor blocks of the block the Phi node
is in and there finds the operands of the Phi node by calling
get_r_value_internal. */
- for (i = 1; i <= ins; ++i) {
- prevCfOp = skip_Proj(block->in[i]);
- assert (prevCfOp);
+ for (i = 1; i <= ins; ++i) {
+ ir_node *cf_pred = block->in[i];
+ ir_node *prevCfOp = skip_Proj(cf_pred);
+ assert(prevCfOp);
if (is_Bad(prevCfOp)) {
/* In case a Cond has been optimized we would get right to the start block
with an invalid definition. */
nin[i-1] = new_Bad();
continue;
}
- prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
- assert (prevBlock);
+ prevBlock = prevCfOp->in[0]; /* go past control flow op to prev block */
+ assert(prevBlock);
if (!is_Bad(prevBlock)) {
#if PRECISE_EXC_CONTEXT
- if (get_opt_precise_exc_context() &&
- is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
- assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
- nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
+ if (get_opt_precise_exc_context() && is_exception_flow(cf_pred, prevCfOp)) {
+ assert(get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode));
+ nin[i-1] = get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode);
} else
#endif
- nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
+ nin[i-1] = get_r_value_internal(prevBlock, pos, mode);
} else {
nin[i-1] = new_Bad();
}
/* We want to pass the Phi0 node to the constructor: this finds additional
optimization possibilities.
The Phi0 node either is allocated in this function, or it comes from
- a former call to get_r_value_internal. In this case we may not yet
- exchange phi0, as this is done in mature_immBlock. */
- if (!phi0) {
+ a former call to get_r_value_internal(). In this case we may not yet
+ exchange phi0, as this is done in mature_immBlock(). */
+ if (phi0 == NULL) {
phi0_all = block->attr.block.graph_arr[pos];
- if (!((get_irn_op(phi0_all) == op_Phi) &&
+ if (!(is_Phi(phi0_all) &&
(get_irn_arity(phi0_all) == 0) &&
(get_nodes_block(phi0_all) == block)))
phi0_all = NULL;
with these predecessors is created. This constructor contains an
optimization: If all predecessors of the Phi node are identical it
returns the only operand instead of a new Phi node. */
- res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins, phi0_all);
+ res = new_rd_Phi_in(current_ir_graph, block, mode, nin, ins, phi0_all);
/* In case we allocated a Phi0 node at the beginning of this procedure,
we need to exchange this Phi0 with the real Phi. */
- if (phi0) {
+ if (phi0 != NULL) {
exchange(phi0, res);
block->attr.block.graph_arr[pos] = res;
/* Don't set_frag_value as it does not overwrite. Doesn't matter, is
} /* phi_merge */
/**
- * This function returns the last definition of a variable. In case
- * this variable was last defined in a previous block, Phi nodes are
+ * This function returns the last definition of a value. In case
+ * this value was last defined in a previous block, Phi nodes are
* inserted. If the part of the firm graph containing the definition
* is not yet constructed, a dummy Phi node is returned.
+ *
+ * @param block the current block
+ * @param pos the value number of the value searched
+ * @param mode the mode of this value (needed for Phi construction)
*/
static ir_node *
get_r_value_internal(ir_node *block, int pos, ir_mode *mode) {
1. The block is not mature and we visit it the first time. We can not
create a proper Phi node, therefore a Phi0, i.e., a Phi without
- predecessors is returned. This node is added to the linked list (field
- "link") of the containing block to be completed when this block is
+ predecessors is returned. This node is added to the linked list (block
+ attribute "phis") of the containing block to be completed when this block is
matured. (Completion will add a new Phi and turn the Phi0 into an Id
node.)
res = block->attr.block.graph_arr[pos];
/* case 2 -- If the value is actually computed, return it. */
- if (res) { return res; };
+ if (res != NULL)
+ return res;
if (block->attr.block.is_matured) { /* case 3 */
/* The Phi has the same amount of ins as the corresponding block. */
int ins = get_irn_arity(block);
ir_node **nin;
- NEW_ARR_A (ir_node *, nin, ins);
+ NEW_ARR_A(ir_node *, nin, ins);
/* Phi merge collects the predecessors and then creates a node. */
- res = phi_merge (block, pos, mode, nin, ins);
+ res = phi_merge(block, pos, mode, nin, ins);
} else { /* case 1 */
/* The block is not mature, we don't know how many in's are needed. A Phi
Phi is computed, pos is used to update the array with the local
values. */
res = new_rd_Phi0(current_ir_graph, block, mode);
- res->attr.phi0.pos = pos;
- res->link = block->link;
- block->link = res;
+ res->attr.phi.u.pos = pos;
+ res->attr.phi.next = block->attr.block.phis;
+ block->attr.block.phis = res;
}
- /* If we get here, the frontend missed a use-before-definition error */
- if (!res) {
- /* Error Message */
- printf("Error: no value set. Use of undefined variable. Initializing to zero.\n");
- assert(mode->code >= irm_F && mode->code <= irm_P);
- res = new_rd_Const(NULL, current_ir_graph, block, mode,
- get_mode_null(mode));
- }
+ assert(is_ir_node(res) && "phi_merge() failed to construct a definition");
/* The local valid value is available now. */
block->attr.block.graph_arr[pos] = res;
return res;
} /* get_r_value_internal */
-#endif /* USE_FAST_PHI_CONSTRUCTION */
-
/* ************************************************************************** */
/*
ir_node *n, **nin;
ir_node *next;
- assert(get_irn_opcode(block) == iro_Block);
- /* @@@ should be commented in
- assert (!get_Block_matured(block) && "Block already matured"); */
-
+ assert(is_Block(block));
if (!get_Block_matured(block)) {
- ins = ARR_LEN(block->in)-1;
+ ir_graph *irg = current_ir_graph;
+
+ ins = ARR_LEN(block->in) - 1;
/* Fix block parameters */
- block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
+ block->attr.block.backedge = new_backedge_arr(irg->obst, ins);
/* An array for building the Phi nodes. */
NEW_ARR_A(ir_node *, nin, ins);
/* Traverse a chain of Phi nodes attached to this block and mature
these, too. **/
- for (n = block->link; n; n = next) {
- inc_irg_visited(current_ir_graph);
- next = n->link;
- exchange(n, phi_merge(block, n->attr.phi0.pos, n->mode, nin, ins));
+ for (n = block->attr.block.phis; n; n = next) {
+ inc_irg_visited(irg);
+ next = n->attr.phi.next;
+ exchange(n, phi_merge(block, n->attr.phi.u.pos, n->mode, nin, ins));
}
block->attr.block.is_matured = 1;
- /* Now, as the block is a finished firm node, we can optimize it.
+ /* Now, as the block is a finished Firm node, we can optimize it.
Since other nodes have been allocated since the block was created
we can not free the node on the obstack. Therefore we have to call
- optimize_in_place.
+ optimize_in_place().
Unfortunately the optimization does not change a lot, as all allocated
nodes refer to the unoptimized node.
- We can call _2, as global cse has no effect on blocks. */
+ We can call optimize_in_place_2(), as global cse has no effect on blocks. */
block = optimize_in_place_2(block);
- IRN_VRFY_IRG(block, current_ir_graph);
+ IRN_VRFY_IRG(block, irg);
}
} /* mature_immBlock */
ir_node *
new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj) {
ir_node *res;
+ (void) db;
assert(arg->op == op_Cond);
arg->attr.cond.kind = fragmentary;
arg->attr.cond.default_proj = max_proj;
NEW_D_BINOP(Sub)
NEW_D_UNOP(Minus)
NEW_D_BINOP(Mul)
+NEW_D_BINOP(Mulh)
/**
- * Allocate the frag array.
+ * Allocate a frag array for a node if the current graph state is phase_building.
+ *
+ * @param irn the node for which the frag array should be allocated
+ * @param op the opcode of the (original) node, if does not match opcode of irn,
+ * nothing is done
+ * @param frag_store the address of the frag store in irn attributes, if this
+ * address contains a value != NULL, does nothing
*/
-static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
+void firm_alloc_frag_arr(ir_node *irn, ir_op *op, ir_node ***frag_store) {
if (get_opt_precise_exc_context()) {
if ((current_ir_graph->phase_state == phase_building) &&
- (get_irn_op(res) == op) && /* Could be optimized away. */
+ (get_irn_op(irn) == op) && /* Could be optimized away. */
!*frag_store) /* Could be a cse where the arr is already set. */ {
- *frag_store = new_frag_arr(res);
+ *frag_store = new_frag_arr(irn);
}
}
-} /* allocate_frag_arr */
+} /* firm_alloc_frag_arr */
ir_node *
-new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
+new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
ir_node *res;
- res = new_bd_Quot(db, current_ir_graph->current_block, memop, op1, op2, mode);
+ res = new_bd_Quot(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Quot, &res->attr.except.frag_arr);
#endif
return res;
} /* new_d_Quot */
ir_node *
-new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
+new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
ir_node *res;
- res = new_bd_DivMod(db, current_ir_graph->current_block, memop, op1, op2, mode);
+ res = new_bd_DivMod(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_DivMod, &res->attr.except.frag_arr);
#endif
return res;
} /* new_d_DivMod */
ir_node *
-new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
+new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
ir_node *res;
- res = new_bd_Div(db, current_ir_graph->current_block, memop, op1, op2, mode);
+ res = new_bd_Div(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Div, &res->attr.except.frag_arr);
#endif
return res;
-}
+} /* new_d_Div */
ir_node *
-new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
+new_d_DivRL(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
ir_node *res;
- res = new_bd_Mod(db, current_ir_graph->current_block, memop, op1, op2, mode);
+ res = new_bd_DivRL(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Div, &res->attr.except.frag_arr);
+#endif
+
+ return res;
+} /* new_d_DivRL */
+
+ir_node *
+new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ ir_node *res;
+ res = new_bd_Mod(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
+#if PRECISE_EXC_CONTEXT
+ firm_alloc_frag_arr(res, op_Mod, &res->attr.except.frag_arr);
#endif
return res;
NEW_D_BINOP(Shl)
NEW_D_BINOP(Shr)
NEW_D_BINOP(Shrs)
-NEW_D_BINOP(Rot)
+NEW_D_BINOP(Rotl)
NEW_D_UNOP(Abs)
NEW_D_BINOP(Carry)
NEW_D_BINOP(Borrow)
res = new_bd_Call(db, current_ir_graph->current_block,
store, callee, arity, in, tp);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr);
#endif
return res;
res = new_bd_Load(db, current_ir_graph->current_block,
store, addr, mode);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);
#endif
return res;
res = new_bd_Store(db, current_ir_graph->current_block,
store, addr, val);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);
#endif
return res;
ir_node *
new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
- where_alloc where) {
+ ir_where_alloc where) {
ir_node *res;
res = new_bd_Alloc(db, current_ir_graph->current_block,
store, size, alloc_type, where);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Alloc, &res->attr.alloc.exc.frag_arr); /* Could be optimized away. */
+ firm_alloc_frag_arr(res, op_Alloc, &res->attr.alloc.exc.frag_arr);
#endif
return res;
ir_node *
new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr,
- ir_node *size, ir_type *free_type, where_alloc where) {
+ ir_node *size, ir_type *free_type, ir_where_alloc where) {
return new_bd_Free(db, current_ir_graph->current_block,
store, ptr, size, free_type, where);
}
} /* new_d_Sel */
ir_node *
-new_d_SymConst_type(dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp) {
- return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
+new_d_SymConst_type(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *tp) {
+ return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
value, kind, tp);
} /* new_d_SymConst_type */
ir_node *
-new_d_SymConst(dbg_info *db, symconst_symbol value, symconst_kind kind) {
- return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph),
+new_d_SymConst(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind) {
+ return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
value, kind, firm_unknown_type);
} /* new_d_SymConst */
ir_node *
new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) {
return new_bd_Confirm(db, current_ir_graph->current_block,
- val, bound, cmp, 0);
+ val, bound, cmp);
} /* new_d_Confirm */
-ir_node *
-new_d_bounded_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- ir_exc_region_t exc_region = get_Block_exc_region(current_ir_graph->current_block);
- return new_bd_Confirm(db, current_ir_graph->current_block,
- val, bound, cmp, exc_region);
-} /* new_d_bounded_Confirm */
-
ir_node *
new_d_Unknown(ir_mode *m) {
return new_bd_Unknown(m);
sel, ir_false, ir_true, mode);
} /* new_d_Mux */
-ir_node *
-new_d_Psi(dbg_info *db,int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
- return new_bd_Psi(db, current_ir_graph->current_block,
- arity, conds, vals, mode);
-} /* new_d_Psi */
-
ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
ir_node *dst, ir_node *src, ir_type *data_type) {
ir_node *res;
res = new_bd_CopyB(db, current_ir_graph->current_block,
store, dst, src, data_type);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
+ firm_alloc_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
#endif
return res;
} /* new_d_CopyB */
res = new_bd_Bound(db, current_ir_graph->current_block,
store, idx, lower, upper);
#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
+ firm_alloc_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr);
#endif
return res;
} /* new_d_Bound */
res->attr.block.is_matured = 0;
res->attr.block.is_dead = 0;
res->attr.block.is_mb_head = 1;
+ res->attr.block.has_label = 0;
res->attr.block.irg = current_ir_graph;
res->attr.block.backedge = NULL;
res->attr.block.in_cg = NULL;
res->attr.block.extblk = NULL;
res->attr.block.region = NULL;
res->attr.block.mb_depth = 0;
+ res->attr.block.label = 0;
set_Block_block_visited(res, 0);
ir_node *blk = get_nodes_block(pred_jmp);
res->in[0] = blk->in[0];
+ assert(res->in[0] != NULL);
add_immBlock_pred(res, pred_jmp);
res->attr.block.is_mb_head = 0;
assert(!block->attr.block.is_matured && "Error: Block already matured!\n");
assert(block->attr.block.is_mb_head && "Error: Cannot add a predecessor to a PartBlock");
- assert(jmp != NULL);
+ assert(is_ir_node(jmp));
ARR_APP1(ir_node *, block->in, jmp);
/* Call the hook */
ir_graph *irg = current_ir_graph;
assert(get_irg_phase_state(irg) == phase_building);
inc_irg_visited(irg);
+ (void) db;
return get_r_value_internal(irg->current_block, pos + 1, mode);
} /* get_d_value */
ir_graph *irg = current_ir_graph;
assert(get_irg_phase_state(irg) == phase_building);
assert(pos+1 < irg->n_loc);
+ assert(is_ir_node(value));
irg->current_block->attr.block.graph_arr[pos + 1] = value;
} /* set_value */
/* call once for each run of the library */
void
-init_cons(uninitialized_local_variable_func_t *func) {
+firm_init_cons(uninitialized_local_variable_func_t *func) {
default_initialize_local_variable = func;
-} /* init_cons */
+} /* firm_init_cons */
void
irp_finalize_cons(void) {
return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
}
-ir_node *new_SymConst_type(symconst_symbol value, symconst_kind kind, ir_type *type) {
- return new_d_SymConst_type(NULL, value, kind, type);
+ir_node *new_SymConst_type(ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *type) {
+ return new_d_SymConst_type(NULL, mode, value, kind, type);
}
-ir_node *new_SymConst(symconst_symbol value, symconst_kind kind) {
- return new_d_SymConst(NULL, value, kind);
+ir_node *new_SymConst(ir_mode *mode, symconst_symbol value, symconst_kind kind) {
+ return new_d_SymConst(NULL, mode, value, kind);
}
ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent) {
return new_d_simpleSel(NULL, store, objptr, ent);
ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Mul(NULL, op1, op2, mode);
}
-ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Quot(NULL, memop, op1, op2, mode);
+ir_node *new_Mulh(ir_node *op1, ir_node *op2, ir_mode *mode) {
+ return new_d_Mulh(NULL, op1, op2, mode);
+}
+ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_d_Quot(NULL, memop, op1, op2, mode, state);
+}
+ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_d_DivMod(NULL, memop, op1, op2, mode, state);
}
-ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_DivMod(NULL, memop, op1, op2, mode);
+ir_node *new_Div(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_d_Div(NULL, memop, op1, op2, mode, state);
}
-ir_node *new_Div(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Div(NULL, memop, op1, op2, mode);
+ir_node *new_DivRL(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_d_DivRL(NULL, memop, op1, op2, mode, state);
}
-ir_node *new_Mod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Mod(NULL, memop, op1, op2, mode);
+ir_node *new_Mod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
+ return new_d_Mod(NULL, memop, op1, op2, mode, state);
}
ir_node *new_Abs(ir_node *op, ir_mode *mode) {
return new_d_Abs(NULL, op, mode);
ir_node *new_Shrs(ir_node *op, ir_node *k, ir_mode *mode) {
return new_d_Shrs(NULL, op, k, mode);
}
-ir_node *new_Rot(ir_node *op, ir_node *k, ir_mode *mode) {
- return new_d_Rot(NULL, op, k, mode);
+ir_node *new_Rotl(ir_node *op, ir_node *k, ir_mode *mode) {
+ return new_d_Rotl(NULL, op, k, mode);
}
ir_node *new_Carry(ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Carry(NULL, op1, op2, mode);
return new_d_Store(NULL, store, addr, val);
}
ir_node *new_Alloc(ir_node *store, ir_node *size, ir_type *alloc_type,
- where_alloc where) {
+ ir_where_alloc where) {
return new_d_Alloc(NULL, store, size, alloc_type, where);
}
ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size,
- ir_type *free_type, where_alloc where) {
+ ir_type *free_type, ir_where_alloc where) {
return new_d_Free(NULL, store, ptr, size, free_type, where);
}
ir_node *new_Sync(int arity, ir_node *in[]) {
ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp) {
return new_d_Confirm(NULL, val, bound, cmp);
}
-ir_node *new_bounded_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp) {
- return new_d_bounded_Confirm(NULL, val, bound, cmp);
-}
ir_node *new_Unknown(ir_mode *m) {
return new_d_Unknown(m);
}
ir_node *new_Mux(ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
}
-ir_node *new_Psi(int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
- return new_d_Psi(NULL, arity, conds, vals, mode);
-}
ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
return new_d_CopyB(NULL, store, dst, src, data_type);
}
int n_clobber, ident *clobber[], ident *asm_text) {
return new_d_ASM(NULL, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
}
+
+/* create a new anchor node */
+ir_node *new_Anchor(ir_graph *irg) {
+ ir_node *in[anchor_last];
+ memset(in, 0, sizeof(in));
+ return new_ir_node(NULL, irg, NULL, op_Anchor, mode_ANY, anchor_last, in);
+}
projects / libfirm / blobdiff