#include "iredges_t.h"
#include "irflag_t.h"
+/* Uncomment to use original code instead of generated one */
+// #define USE_ORIGINAL
+
/* when we need verifying */
#ifdef NDEBUG
# define IRN_VRFY_IRG(res, irg)
return new_bd_##instr(db, current_ir_graph->current_block, op, mode); \
}
+#ifndef USE_ORIGINAL
+#include "gen_ir_cons.c.inl"
+#else
/**
* Constructs a Block with a fixed number of predecessors.
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_End */
+#endif
/**
* Creates a Phi node with all predecessors. Calling this constructor
return res;
} /* new_bd_Phi */
+#ifdef USE_ORIGINAL
static ir_node *
new_bd_Const_type(dbg_info *db, tarval *con, ir_type *tp) {
ir_node *res;
return res;
} /* new_bd_Const_type */
+#endif
static ir_node *
new_bd_Const(dbg_info *db, tarval *con) {
return new_rd_Const(db, irg, new_tarval_from_long(value, mode));
} /* new_bd_Const_long */
+#ifdef USE_ORIGINAL
static ir_node *
new_bd_Id(dbg_info *db, ir_node *block, ir_node *val, ir_mode *mode) {
ir_node *res;
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_Proj */
+#endif
static ir_node *
new_bd_defaultProj(dbg_info *db, ir_node *block, ir_node *arg,
return res;
} /* new_bd_Conv */
+#ifdef USE_ORIGINAL
static ir_node *
new_bd_Cast(dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp) {
ir_node *res;
} /* new_bd_Tuple */
NEW_BD_BINOP(Add)
+#endif
NEW_BD_BINOP(Sub)
NEW_BD_UNOP(Minus)
NEW_BD_BINOP(Mul)
NEW_BD_BINOP(Mulh)
NEW_BD_DIVOP(Quot)
NEW_BD_DIVOP(DivMod)
+#ifdef USE_ORIGINAL
NEW_BD_DIVOP(Div)
+#endif
NEW_BD_DIVOP(Mod)
NEW_BD_BINOP(And)
NEW_BD_BINOP(Or)
return res;
}
+#ifdef USE_ORIGINAL
static ir_node *
new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) {
ir_node *in[2];
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_Cond */
+#endif
static ir_node *
new_bd_Call(dbg_info *db, ir_node *block, ir_node *store,
int r_arity;
ir_graph *irg = current_ir_graph;
- r_arity = arity+2;
+ r_arity = arity + 2;
NEW_ARR_A(ir_node *, r_in, r_arity);
r_in[0] = store;
r_in[1] = callee;
return res;
} /* new_bd_Call */
+static ir_node *
+new_bd_Builtin(dbg_info *db, ir_node *block, ir_node *store,
+ ir_builtin_kind kind, int arity, ir_node **in, ir_type *tp) {
+ ir_node **r_in;
+ ir_node *res;
+ int r_arity;
+ ir_graph *irg = current_ir_graph;
+
+ r_arity = arity + 1;
+ NEW_ARR_A(ir_node *, r_in, r_arity);
+ r_in[0] = store;
+ memcpy(&r_in[1], in, sizeof(ir_node *) * arity);
+
+ res = new_ir_node(db, irg, block, op_Builtin, mode_T, r_arity, r_in);
+
+ assert((get_unknown_type() == tp) || is_Method_type(tp));
+ res->attr.builtin.exc.pin_state = op_pin_state_pinned;
+ res->attr.builtin.kind = kind;
+ res->attr.builtin.builtin_tp = tp;
+ res = optimize_node(res);
+ IRN_VRFY_IRG(res, irg);
+ return res;
+} /* new_bd_Buildin */
+
static ir_node *
new_bd_Return(dbg_info *db, ir_node *block,
ir_node *store, int arity, ir_node **in) {
static ir_node *
new_bd_Load(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *adr, ir_mode *mode) {
+ ir_node *store, ir_node *adr, ir_mode *mode, ir_cons_flags flags) {
ir_node *in[2];
ir_node *res;
ir_graph *irg = current_ir_graph;
in[0] = store;
in[1] = adr;
res = new_ir_node(db, irg, block, op_Load, mode_T, 2, in);
- res->attr.load.exc.pin_state = op_pin_state_pinned;
+ res->attr.load.exc.pin_state = flags & cons_floats ? op_pin_state_floats : 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->attr.load.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile;
+ res->attr.load.aligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned;
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
static ir_node *
new_bd_Store(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *adr, ir_node *val) {
+ ir_node *store, ir_node *adr, ir_node *val, ir_cons_flags flags) {
ir_node *in[3];
ir_node *res;
ir_graph *irg = current_ir_graph;
in[1] = adr;
in[2] = val;
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->attr.store.exc.pin_state = flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned;
+ res->attr.store.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile;
+ res->attr.store.aligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned;
+
res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
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;
/* private interfaces, for professional use only */
/* --------------------------------------------- */
+#ifdef USE_ORIGINAL
/* Constructs a Block with a fixed number of predecessors.
Does not set current_block. Can not be used with automatic
Phi node construction. */
return res;
} /* new_rd_End */
+#endif
/* Creates a Phi node with all predecessors. Calling this constructor
is only allowed if the corresponding block is mature. */
return res;
} /* new_rd_Phi */
+#ifdef USE_ORIGINAL
ir_node *
new_rd_Const_type(dbg_info *db, ir_graph *irg, tarval *con, ir_type *tp) {
ir_node *res;
return res;
} /* new_rd_Const_type */
+#endif
ir_node *
new_rd_Const(dbg_info *db, ir_graph *irg, tarval *con) {
ir_node *res;
+#ifdef USE_ORIGINAL
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
res = new_bd_Const_type(db, con, firm_unknown_type);
current_ir_graph = rem;
+#else
+ res = new_rd_Const_type(db, irg, con, firm_unknown_type);
+#endif
return res;
} /* new_rd_Const */
return new_rd_Const(db, irg, new_tarval_from_long(value, mode));
} /* new_rd_Const_long */
+#ifdef USE_ORIGINAL
ir_node *
new_rd_Id(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode) {
ir_node *res;
return res;
} /* new_rd_Proj */
+#endif
ir_node *
new_rd_defaultProj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg,
return res;
} /* new_rd_Conv */
+#ifdef USE_ORIGINAL
ir_node *
new_rd_Cast(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
ir_node *res;
} /* new_rd_Tuple */
NEW_RD_BINOP(Add)
+#endif
NEW_RD_BINOP(Sub)
NEW_RD_UNOP(Minus)
NEW_RD_BINOP(Mul)
NEW_RD_BINOP(Mulh)
NEW_RD_DIVOP(Quot)
NEW_RD_DIVOP(DivMod)
+#ifdef USE_ORIGINAL
NEW_RD_DIVOP(Div)
+#endif
NEW_RD_DIVOP(Mod)
NEW_RD_BINOP(And)
NEW_RD_BINOP(Or)
return res;
}
+#ifdef USE_ORIGINAL
ir_node *
new_rd_Cmp(dbg_info *db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2) {
return res;
} /* new_rd_Cond */
+#endif
ir_node *
new_rd_Call(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
return res;
} /* new_rd_Call */
+ir_node *
+new_rd_Builtin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+ ir_builtin_kind kind, int arity, ir_node **in, ir_type *tp) {
+ ir_node *res;
+ ir_graph *rem = current_ir_graph;
+
+ current_ir_graph = irg;
+ res = new_bd_Builtin(db, block, store, kind, arity, in, tp);
+ current_ir_graph = rem;
+
+ return res;
+} /* new_rd_Builtin */
+
ir_node *
new_rd_Return(dbg_info *db, ir_graph *irg, ir_node *block,
ir_node *store, int arity, ir_node **in) {
ir_node *
new_rd_Load(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *adr, ir_mode *mode) {
+ ir_node *store, ir_node *adr, ir_mode *mode, ir_cons_flags flags) {
ir_node *res;
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- res = new_bd_Load(db, block, store, adr, mode);
+ res = new_bd_Load(db, block, store, adr, mode, flags);
current_ir_graph = rem;
return res;
ir_node *
new_rd_Store(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *adr, ir_node *val) {
+ ir_node *store, ir_node *adr, ir_node *val, ir_cons_flags flags) {
ir_node *res;
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- res = new_bd_Store(db, block, store, adr, val);
+ res = new_bd_Store(db, block, store, adr, val, flags);
current_ir_graph = rem;
return res;
} /* new_rd_ASM */
+#ifdef USE_ORIGINAL
ir_node *new_r_Block(ir_graph *irg, int arity, ir_node **in) {
return new_rd_Block(NULL, irg, arity, in);
}
ir_node *new_r_Cond(ir_graph *irg, ir_node *block, ir_node *c) {
return new_rd_Cond(NULL, irg, block, c);
}
+#endif
ir_node *new_r_Return(ir_graph *irg, ir_node *block,
ir_node *store, int arity, ir_node **in) {
return new_rd_Return(NULL, irg, block, store, arity, in);
ir_node *new_r_Const_long(ir_graph *irg, ir_mode *mode, long value) {
return new_rd_Const_long(NULL, irg, mode, value);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Const_type(ir_graph *irg, tarval *con, ir_type *tp) {
return new_rd_Const_type(NULL, irg, con, tp);
}
+#endif
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, mode, value, symkind);
ir_type *tp) {
return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
}
+ir_node *new_r_Builtin(ir_graph *irg, ir_node *block, ir_node *store,
+ ir_builtin_kind kind, int arity, ir_node **in,
+ ir_type *tp) {
+ return new_rd_Builtin(NULL, irg, block, store, kind, arity, in, tp);
+}
+#ifdef USE_ORIGINAL
ir_node *new_r_Add(ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Add(NULL, irg, block, op1, op2, mode);
}
+#endif
ir_node *new_r_Sub(ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Sub(NULL, irg, block, 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);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Div(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_Div(NULL, irg, block, memop, op1, op2, mode, state);
}
+#endif
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 *op, ir_node *k, ir_mode *mode) {
return new_rd_Borrow(NULL, irg, block, op, k, mode);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Cmp(ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2) {
return new_rd_Cmp(NULL, irg, block, op1, op2);
}
+#endif
ir_node *new_r_Conv(ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode) {
return new_rd_Conv(NULL, irg, block, op, mode);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Cast(ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
return new_rd_Cast(NULL, irg, block, op, to_tp);
}
+#endif
ir_node *new_r_Phi(ir_graph *irg, ir_node *block, int arity,
ir_node **in, ir_mode *mode) {
return new_rd_Phi(NULL, irg, block, arity, in, mode);
}
ir_node *new_r_Load(ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *adr, ir_mode *mode) {
- return new_rd_Load(NULL, irg, block, store, adr, mode);
+ ir_node *store, ir_node *adr, ir_mode *mode, ir_cons_flags flags) {
+ return new_rd_Load(NULL, irg, block, store, adr, mode, flags);
}
ir_node *new_r_Store(ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *adr, ir_node *val) {
- return new_rd_Store(NULL, irg, block, store, adr, val);
+ ir_node *store, ir_node *adr, ir_node *val, ir_cons_flags flags) {
+ return new_rd_Store(NULL, irg, block, store, adr, val, flags);
}
ir_node *new_r_Alloc(ir_graph *irg, ir_node *block, ir_node *store,
ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
ir_node *new_r_Sync(ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
return new_rd_Sync(NULL, irg, block, arity, in);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Proj(ir_graph *irg, ir_node *block, ir_node *arg,
ir_mode *mode, long proj) {
return new_rd_Proj(NULL, irg, block, arg, mode, proj);
}
+#endif
ir_node *new_r_defaultProj(ir_graph *irg, ir_node *block, ir_node *arg,
long max_proj) {
return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
}
+#ifdef USE_ORIGINAL
ir_node *new_r_Tuple(ir_graph *irg, ir_node *block,
int arity, ir_node **in) {
return new_rd_Tuple(NULL, irg, block, arity, in );
ir_node *val, ir_mode *mode) {
return new_rd_Id(NULL, irg, block, val, mode);
}
+#endif
ir_node *new_r_Bad(ir_graph *irg) {
return get_irg_bad(irg);
}
/** public interfaces */
/** construction tools */
+#ifdef USE_ORIGINAL
+
/**
*
* - create a new Start node in the current block
}
if (!has_unknown) res = optimize_node(res);
- current_ir_graph->current_block = res;
IRN_VRFY_IRG(res, current_ir_graph);
return res;
} /* new_d_Block */
+#endif
/* ***********************************************************************/
/* Methods necessary for automatic Phi node creation */
/* 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! */
+ is not needed.
+ Note: We MUST consider Bad nodes, else we might get data flow cycles in dead loops! */
known = res;
for (i = ins - 1; i >= 0; --i) {
assert(in[i]);
if (phi0 && in[i] == phi0)
in[i] = res;
- if (in[i] == res || in[i] == known || is_Bad(in[i]))
+ if (in[i] == res || in[i] == known)
continue;
if (known == res)
exchange phi0, as this is done in mature_immBlock(). */
if (phi0 == NULL) {
phi0_all = block->attr.block.graph_arr[pos];
- if (!(is_Phi(phi0_all) &&
- (get_irn_arity(phi0_all) == 0) &&
- (get_nodes_block(phi0_all) == block)))
+ if (! is_Phi0(phi0_all) ||
+ get_irn_arity(phi0_all) != 0 ||
+ get_nodes_block(phi0_all) != block)
phi0_all = NULL;
} else {
phi0_all = phi0;
return new_bd_Const_long(db, mode, value);
} /* new_d_Const_long */
+#ifdef USE_ORIGINAL
ir_node *
new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp) {
return new_bd_Const_type(db, con, tp);
new_d_Proj(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) {
return new_bd_Proj(db, current_ir_graph->current_block, arg, mode, proj);
} /* new_d_Proj */
+#endif
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;
- res = new_Proj(arg, mode_X, max_proj);
+ res = new_d_Proj(db, arg, mode_X, max_proj);
return res;
} /* new_d_defaultProj */
return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 1);
} /* new_d_strictConv */
+#ifdef USE_ORIGINAL
ir_node *
new_d_Cast(dbg_info *db, ir_node *op, ir_type *to_tp) {
return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
} /* new_d_Tuple */
NEW_D_BINOP(Add)
+#endif
NEW_D_BINOP(Sub)
NEW_D_UNOP(Minus)
NEW_D_BINOP(Mul)
return res;
} /* new_d_DivMod */
+#ifdef USE_ORIGINAL
ir_node *
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;
return res;
} /* new_d_Div */
+#endif
ir_node *
new_d_DivRL(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
NEW_D_BINOP(Carry)
NEW_D_BINOP(Borrow)
+#ifdef USE_ORIGINAL
ir_node *
new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2) {
return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
new_d_Cond(dbg_info *db, ir_node *c) {
return new_bd_Cond(db, current_ir_graph->current_block, c);
} /* new_d_Cond */
+#endif
ir_node *
new_d_Call(dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
return res;
} /* new_d_Call */
+ir_node *
+new_d_Builtin(dbg_info *db, ir_node *store, ir_builtin_kind kind, int arity, ir_node **in,
+ ir_type *tp) {
+ return new_bd_Builtin(db, current_ir_graph->current_block, store, kind, arity, in, tp);
+} /* new_d_Builtin */
+
ir_node *
new_d_Return(dbg_info *db, ir_node* store, int arity, ir_node **in) {
return new_bd_Return(db, current_ir_graph->current_block,
} /* new_d_Return */
ir_node *
-new_d_Load(dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode) {
+new_d_Load(dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode, ir_cons_flags flags) {
ir_node *res;
res = new_bd_Load(db, current_ir_graph->current_block,
- store, addr, mode);
+ store, addr, mode, flags);
#if PRECISE_EXC_CONTEXT
firm_alloc_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr);
#endif
} /* new_d_Load */
ir_node *
-new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val) {
+new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val, ir_cons_flags flags) {
ir_node *res;
res = new_bd_Store(db, current_ir_graph->current_block,
- store, addr, val);
+ store, addr, val, flags);
#if PRECISE_EXC_CONTEXT
firm_alloc_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr);
#endif
assert(get_irg_phase_state(current_ir_graph) == phase_building);
/* creates a new dynamic in-array as length of in is -1 */
res = new_ir_node(db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
- current_ir_graph->current_block = res;
/* macroblock head */
res->in[0] = res;
inc_irg_visited(irg);
(void) db;
+ assert(pos >= 0);
+
return get_r_value_internal(irg->current_block, pos + 1, mode);
} /* get_d_value */
set_value(int pos, ir_node *value) {
ir_graph *irg = current_ir_graph;
assert(get_irg_phase_state(irg) == phase_building);
+ assert(pos >= 0);
assert(pos+1 < irg->n_loc);
assert(is_ir_node(value));
irg->current_block->attr.block.graph_arr[pos + 1] = value;
irp->phase_state = phase_high;
} /* irp_finalize_cons */
-
+#ifdef USE_ORIGINAL
ir_node *new_Block(int arity, ir_node **in) {
return new_d_Block(NULL, arity, in);
}
ir_node *new_Cond(ir_node *c) {
return new_d_Cond(NULL, c);
}
+#endif
ir_node *new_Return(ir_node *store, int arity, ir_node *in[]) {
return new_d_Return(NULL, store, arity, in);
}
return new_d_Const_long(NULL, mode, value);
}
+#ifdef USE_ORIGINAL
ir_node *new_Const_type(tarval *con, ir_type *tp) {
return new_d_Const_type(NULL, con, tp);
}
+#endif
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_type *tp) {
return new_d_Call(NULL, store, callee, arity, in, tp);
}
+ir_node *new_Builtin(ir_node *store, ir_builtin_kind kind, int arity, ir_node **in,
+ ir_type *tp) {
+ return new_d_Builtin(NULL, store, kind, arity, in, tp);
+}
+#ifdef USE_ORIGINAL
ir_node *new_Add(ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Add(NULL, op1, op2, mode);
}
+#endif
ir_node *new_Sub(ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Sub(NULL, op1, op2, mode);
}
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);
}
+#ifdef USE_ORIGINAL
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);
}
+#endif
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_Borrow(ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Borrow(NULL, op1, op2, mode);
}
+#ifdef USE_ORIGINAL
ir_node *new_Cmp(ir_node *op1, ir_node *op2) {
return new_d_Cmp(NULL, op1, op2);
}
+#endif
ir_node *new_Conv(ir_node *op, ir_mode *mode) {
return new_d_Conv(NULL, op, mode);
}
ir_node *new_strictConv(ir_node *op, ir_mode *mode) {
return new_d_strictConv(NULL, op, mode);
}
+#ifdef USE_ORIGINAL
ir_node *new_Cast(ir_node *op, ir_type *to_tp) {
return new_d_Cast(NULL, op, to_tp);
}
+#endif
ir_node *new_Phi(int arity, ir_node **in, ir_mode *mode) {
return new_d_Phi(NULL, arity, in, mode);
}
-ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode) {
- return new_d_Load(NULL, store, addr, mode);
+ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode, ir_cons_flags flags) {
+ return new_d_Load(NULL, store, addr, mode, flags);
}
-ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val) {
- return new_d_Store(NULL, store, addr, val);
+ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val, ir_cons_flags flags) {
+ return new_d_Store(NULL, store, addr, val, flags);
}
ir_node *new_Alloc(ir_node *store, ir_node *size, ir_type *alloc_type,
ir_where_alloc where) {
ir_node *new_Sync(int arity, ir_node *in[]) {
return new_d_Sync(NULL, arity, in);
}
+#ifdef USE_ORIGINAL
ir_node *new_Proj(ir_node *arg, ir_mode *mode, long proj) {
return new_d_Proj(NULL, arg, mode, proj);
}
+#endif
ir_node *new_defaultProj(ir_node *arg, long max_proj) {
return new_d_defaultProj(NULL, arg, max_proj);
}
+#ifdef USE_ORIGINAL
ir_node *new_Tuple(int arity, ir_node **in) {
return new_d_Tuple(NULL, arity, in);
}
ir_node *new_Id(ir_node *val, ir_mode *mode) {
return new_d_Id(NULL, val, mode);
}
+#endif
ir_node *new_Bad(void) {
return get_irg_bad(current_ir_graph);
}
projects / libfirm / blobdiff