X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Fircons.c;h=c72760b7f58d57a9f6df928a043a99fb4210ccc7;hb=2dc559c36ea238dcdc6b7d2656c1663b822b2223;hp=5b85701cb4d3f6df885cfc6ad8befa0c20da2127;hpb=222c1d46a0a3f0bddf3df3d84523287a4a960720;p=libfirm diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index 5b85701cb..c72760b7f 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -25,9 +25,7 @@ Michael Beck * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #include "irprog_t.h" #include "irgraph_t.h" @@ -40,22 +38,14 @@ #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 - Phi_in. Redefinition in irgraph.c!! */ -struct Phi_in_stack { - ir_node **stack; - int pos; -}; -typedef struct Phi_in_stack Phi_in_stack; -#endif +/* Uncomment to use original code instead of generated one */ +// #define USE_ORIGINAL /* when we need verifying */ #ifdef NDEBUG @@ -177,6 +167,9 @@ new_d_##instr(dbg_info *db, ir_node *op, ir_mode *mode) { \ 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. @@ -232,6 +225,7 @@ new_bd_End(dbg_info *db, ir_node *block) { IRN_VRFY_IRG(res, irg); return res; } /* new_bd_End */ +#endif /** * Creates a Phi node with all predecessors. Calling this constructor @@ -254,7 +248,7 @@ new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode) 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) { + if (is_Unknown(in[i])) { has_unknown = 1; break; } @@ -270,12 +264,11 @@ new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode) } /* new_bd_Phi */ static ir_node * -new_bd_Const_type(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) { +new_bd_Const_type(dbg_info *db, 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 = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, get_tarval_mode(con), 0, NULL); res->attr.con.tv = con; set_Const_type(res, tp); /* Call method because of complex assertion. */ res = optimize_node (res); @@ -286,19 +279,20 @@ new_bd_Const_type(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_t } /* new_bd_Const_type */ static ir_node * -new_bd_Const(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con) { +new_bd_Const(dbg_info *db, tarval *con) { ir_graph *irg = current_ir_graph; - return new_rd_Const_type (db, irg, block, mode, con, firm_unknown_type); + return new_rd_Const_type (db, irg, con, firm_unknown_type); } /* new_bd_Const */ static ir_node * -new_bd_Const_long(dbg_info *db, ir_node *block, ir_mode *mode, long value) { +new_bd_Const_long(dbg_info *db, ir_mode *mode, long value) { ir_graph *irg = current_ir_graph; - return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode)); + 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; @@ -328,6 +322,7 @@ new_bd_Proj(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode, 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, @@ -354,6 +349,7 @@ new_bd_Conv(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode, int strict 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; @@ -362,7 +358,7 @@ new_bd_Cast(dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp) { assert(is_atomic_type(to_tp)); res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op); - res->attr.cast.totype = to_tp; + res->attr.cast.type = to_tp; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -384,10 +380,12 @@ NEW_BD_BINOP(Sub) NEW_BD_UNOP(Minus) NEW_BD_BINOP(Mul) NEW_BD_BINOP(Mulh) +#endif NEW_BD_DIVOP(Quot) NEW_BD_DIVOP(DivMod) NEW_BD_DIVOP(Div) NEW_BD_DIVOP(Mod) +#ifdef USE_ORIGINAL NEW_BD_BINOP(And) NEW_BD_BINOP(Or) NEW_BD_BINOP(Eor) @@ -395,10 +393,11 @@ NEW_BD_UNOP(Not) 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) +#endif /** Creates a remainderless Div node. */ static ir_node *new_bd_DivRL(dbg_info *db, ir_node *block, @@ -419,6 +418,7 @@ static ir_node *new_bd_DivRL(dbg_info *db, ir_node *block, 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]; @@ -467,6 +467,7 @@ new_bd_Cond(dbg_info *db, ir_node *block, ir_node *c) { 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, @@ -476,7 +477,7 @@ 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; @@ -493,6 +494,31 @@ new_bd_Call(dbg_info *db, ir_node *block, ir_node *store, 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 */ + +#ifdef USE_ORIGINAL static ir_node * new_bd_Return(dbg_info *db, ir_node *block, ir_node *store, int arity, ir_node **in) { @@ -513,7 +539,7 @@ new_bd_Return(dbg_info *db, ir_node *block, 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; @@ -521,10 +547,10 @@ new_bd_Load(dbg_info *db, ir_node *block, 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.load_mode = mode; - res->attr.load.volatility = volatility_non_volatile; - res->attr.load.aligned = align_is_aligned; + res->attr.load.exc.pin_state = flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned; + res->attr.load.mode = mode; + 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; @@ -532,7 +558,7 @@ new_bd_Load(dbg_info *db, ir_node *block, 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; @@ -541,13 +567,15 @@ new_bd_Store(dbg_info *db, ir_node *block, 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; } /* new_bd_Store */ +#endif static ir_node * new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store, @@ -567,6 +595,7 @@ new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store, return res; } /* new_bd_Alloc */ +#ifdef USE_ORIGINAL 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, ir_where_alloc where) { @@ -584,6 +613,7 @@ new_bd_Free(dbg_info *db, ir_node *block, ir_node *store, IRN_VRFY_IRG(res, irg); return res; } /* new_bd_Free */ +#endif static ir_node * new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr, @@ -605,7 +635,7 @@ new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr, * Sel's can select functions which should be of mode mode_P_code. */ res = new_ir_node(db, irg, block, op_Sel, mode, r_arity, r_in); - res->attr.sel.ent = ent; + res->attr.sel.entity = ent; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -617,9 +647,9 @@ new_bd_SymConst_type(dbg_info *db, ir_node *block, ir_mode *mode, ir_graph *irg = current_ir_graph; ir_node *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); @@ -637,6 +667,7 @@ new_bd_Sync(dbg_info *db, ir_node *block) { return res; } /* new_bd_Sync */ +#ifdef USE_ORIGINAL static ir_node * new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) { ir_node *in[2], *res; @@ -660,6 +691,7 @@ new_bd_Unknown(ir_mode *m) { res = optimize_node(res); return res; } /* new_bd_Unknown */ +#endif static ir_node * new_bd_CallBegin(dbg_info *db, ir_node *block, ir_node *call) { @@ -729,6 +761,7 @@ new_bd_Filter(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode, return res; } /* new_bd_Filter */ +#ifdef USE_ORIGINAL static ir_node * new_bd_Mux(dbg_info *db, ir_node *block, ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) { @@ -747,30 +780,7 @@ new_bd_Mux(dbg_info *db, ir_node *block, IRN_VRFY_IRG(res, irg); 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 */ +#endif static ir_node * new_bd_CopyB(dbg_info *db, ir_node *block, @@ -801,8 +811,9 @@ new_bd_InstOf(dbg_info *db, ir_node *block, ir_node *store, in[0] = store; in[1] = objptr; - res = new_ir_node(db, irg, block, op_Sel, mode_T, 2, in); - res->attr.instof.type = type; + res = new_ir_node(db, irg, block, op_InstOf, mode_T, 2, in); + res->attr.instof.exc.pin_state = op_pin_state_floats; + res->attr.instof.type = type; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -840,6 +851,7 @@ new_bd_Bound(dbg_info *db, ir_node *block, return res; } /* new_bd_Bound */ +#ifdef USE_ORIGINAL static ir_node * new_bd_Pin(dbg_info *db, ir_node *block, ir_node *node) { ir_node *res; @@ -850,24 +862,24 @@ new_bd_Pin(dbg_info *db, ir_node *block, ir_node *node) { IRN_VRFY_IRG(res, irg); return res; } /* new_bd_Pin */ +#endif static ir_node * new_bd_ASM(dbg_info *db, ir_node *block, int arity, ir_node *in[], ir_asm_constraint *inputs, 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.clobber, clobber, sizeof(clobber[0]) * n_clobber); + 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); @@ -878,6 +890,7 @@ new_bd_ASM(dbg_info *db, ir_node *block, int arity, ir_node *in[], ir_asm_constr /* 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. */ @@ -916,6 +929,7 @@ new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block) { 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. */ @@ -932,34 +946,39 @@ new_rd_Phi(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in, } /* new_rd_Phi */ ir_node * -new_rd_Const_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) { +new_rd_Const_type(dbg_info *db, ir_graph *irg, tarval *con, ir_type *tp) { ir_node *res; ir_graph *rem = current_ir_graph; current_ir_graph = irg; - res = new_bd_Const_type(db, block, mode, con, tp); + res = new_bd_Const_type(db, con, tp); current_ir_graph = rem; return res; } /* new_rd_Const_type */ ir_node * -new_rd_Const(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con) { +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, block, mode, con, firm_unknown_type); + 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 */ ir_node * -new_rd_Const_long(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, long value) { - return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode)); +new_rd_Const_long(dbg_info *db, ir_graph *irg, ir_mode *mode, long value) { + 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; @@ -984,6 +1003,7 @@ new_rd_Proj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode * return res; } /* new_rd_Proj */ +#endif ir_node * new_rd_defaultProj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, @@ -998,6 +1018,7 @@ new_rd_defaultProj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, return res; } /* new_rd_defaultProj */ +#ifdef USE_ORIGINAL ir_node * new_rd_Conv(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { ir_node *res; @@ -1009,7 +1030,21 @@ new_rd_Conv(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *m return res; } /* new_rd_Conv */ +#endif + +ir_node * +new_rd_strictConv(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { + ir_node *res; + ir_graph *rem = current_ir_graph; + + current_ir_graph = irg; + res = new_bd_Conv(db, block, op, mode, 1); + current_ir_graph = rem; + + return res; +} /* new_rd_strictConv */ +#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; @@ -1039,10 +1074,12 @@ NEW_RD_BINOP(Sub) NEW_RD_UNOP(Minus) NEW_RD_BINOP(Mul) NEW_RD_BINOP(Mulh) +#endif NEW_RD_DIVOP(Quot) NEW_RD_DIVOP(DivMod) NEW_RD_DIVOP(Div) NEW_RD_DIVOP(Mod) +#ifdef USE_ORIGINAL NEW_RD_BINOP(And) NEW_RD_BINOP(Or) NEW_RD_BINOP(Eor) @@ -1050,10 +1087,11 @@ NEW_RD_UNOP(Not) 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) +#endif /* creates a rd constructor for an divRL */ ir_node *new_rd_DivRL(dbg_info *db, ir_graph *irg, ir_node *block, @@ -1067,6 +1105,7 @@ ir_node *new_rd_DivRL(dbg_info *db, ir_graph *irg, ir_node *block, 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) { @@ -1115,6 +1154,7 @@ new_rd_Cond(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c) { return res; } /* new_rd_Cond */ +#endif ir_node * new_rd_Call(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, @@ -1129,6 +1169,20 @@ 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 */ + +#ifdef USE_ORIGINAL ir_node * new_rd_Return(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, int arity, ir_node **in) { @@ -1144,12 +1198,12 @@ new_rd_Return(dbg_info *db, ir_graph *irg, ir_node *block, 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; @@ -1157,16 +1211,17 @@ new_rd_Load(dbg_info *db, ir_graph *irg, ir_node *block, 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_Store */ +#endif ir_node * new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, @@ -1181,6 +1236,7 @@ new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, return res; } /* new_rd_Alloc */ +#ifdef USE_ORIGINAL 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, ir_where_alloc where) { @@ -1193,6 +1249,7 @@ new_rd_Free(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, return res; } /* new_rd_Free */ +#endif ir_node * new_rd_simpleSel(dbg_info *db, ir_graph *irg, ir_node *block, @@ -1207,6 +1264,7 @@ new_rd_simpleSel(dbg_info *db, ir_graph *irg, ir_node *block, return res; } /* new_rd_simpleSel */ +#ifdef USE_ORIGINAL ir_node * new_rd_Sel(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, int arity, ir_node **in, ir_entity *ent) { @@ -1219,6 +1277,7 @@ new_rd_Sel(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node return res; } /* new_rd_Sel */ +#endif ir_node * new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, @@ -1291,11 +1350,7 @@ new_rd_Sync(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node *in[ return res; } /* new_rd_Sync */ -ir_node * -new_rd_Bad(ir_graph *irg) { - return get_irg_bad(irg); -} /* new_rd_Bad */ - +#ifdef USE_ORIGINAL ir_node * new_rd_Confirm(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) { ir_node *res; @@ -1319,6 +1374,7 @@ new_rd_Unknown(ir_graph *irg, ir_mode *m) { return res; } /* new_rd_Unknown */ +#endif ir_node * new_rd_CallBegin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) { @@ -1377,11 +1433,7 @@ new_rd_Filter(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode return res; } /* new_rd_Filter */ -ir_node * -new_rd_NoMem(ir_graph *irg) { - return get_irg_no_mem(irg); -} /* new_rd_NoMem */ - +#ifdef USE_ORIGINAL ir_node * new_rd_Mux(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) { @@ -1394,19 +1446,7 @@ new_rd_Mux(dbg_info *db, ir_graph *irg, ir_node *block, 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 */ +#endif 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) { @@ -1457,6 +1497,7 @@ ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block, return res; } /* new_rd_Bound */ +#ifdef USE_ORIGINAL ir_node *new_rd_Pin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *node) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1467,6 +1508,7 @@ ir_node *new_rd_Pin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *node) return res; } /* new_rd_Pin */ +#endif ir_node *new_rd_ASM(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node *in[], ir_asm_constraint *inputs, @@ -1483,6 +1525,7 @@ ir_node *new_rd_ASM(dbg_info *db, ir_graph *irg, ir_node *block, } /* 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); } @@ -1505,17 +1548,15 @@ 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(ir_graph *irg, ir_node *block, - ir_mode *mode, tarval *con) { - return new_rd_Const(NULL, irg, block, mode, con); +#endif +ir_node *new_r_Const(ir_graph *irg, tarval *con) { + return new_rd_Const(NULL, irg, con); } -ir_node *new_r_Const_long(ir_graph *irg, ir_node *block, - ir_mode *mode, long value) { - return new_rd_Const_long(NULL, irg, block, mode, value); +ir_node *new_r_Const_long(ir_graph *irg, ir_mode *mode, long value) { + return new_rd_Const_long(NULL, irg, mode, value); } -ir_node *new_r_Const_type(ir_graph *irg, ir_node *block, - ir_mode *mode, tarval *con, ir_type *tp) { - return new_rd_Const_type(NULL, irg, block, mode, con, tp); +ir_node *new_r_Const_type(ir_graph *irg, tarval *con, ir_type *tp) { + return new_rd_Const_type(NULL, irg, con, tp); } ir_node *new_r_SymConst(ir_graph *irg, ir_node *block, ir_mode *mode, symconst_symbol value, symconst_kind symkind) { @@ -1525,16 +1566,24 @@ ir_node *new_r_simpleSel(ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, ir_entity *ent) { return new_rd_Sel(NULL, irg, block, store, objptr, 0, NULL, ent); } +#ifdef USE_ORIGINAL ir_node *new_r_Sel(ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, int n_index, ir_node **index, ir_entity *ent) { return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent); } +#endif ir_node *new_r_Call(ir_graph *irg, ir_node *block, ir_node *store, ir_node *callee, int arity, ir_node **in, 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); @@ -1555,6 +1604,7 @@ 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); } +#endif ir_node *new_r_Quot(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_Quot(NULL, irg, block, memop, op1, op2, mode, state); @@ -1575,6 +1625,7 @@ ir_node *new_r_Mod(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_Mod(NULL, irg, block, memop, op1, op2, mode, state); } +#ifdef USE_ORIGINAL ir_node *new_r_Abs(ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { return new_rd_Abs(NULL, irg, block, op, mode); @@ -1607,9 +1658,9 @@ ir_node *new_r_Shrs(ir_graph *irg, ir_node *block, 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) { @@ -1627,40 +1678,52 @@ 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); } -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_strictConv(ir_graph *irg, ir_node *block, + ir_node *op, ir_mode *mode) { + return new_rd_strictConv(NULL, irg, block, op, mode); } 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); } +#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); +} 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); } +#endif 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) { return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where); } +#ifdef USE_ORIGINAL ir_node *new_r_Free(ir_graph *irg, ir_node *block, ir_node *store, 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); } +#endif 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 ); @@ -1669,15 +1732,18 @@ ir_node *new_r_Id(ir_graph *irg, ir_node *block, 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 new_rd_Bad(irg); + return get_irg_bad(irg); } +#ifdef USE_ORIGINAL 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_Unknown(ir_graph *irg, ir_mode *m) { return new_rd_Unknown(irg, m); } +#endif ir_node *new_r_CallBegin(ir_graph *irg, ir_node *block, ir_node *callee) { return new_rd_CallBegin(NULL, irg, block, callee); } @@ -1695,16 +1761,14 @@ ir_node *new_r_Filter(ir_graph *irg, ir_node *block, ir_node *arg, return new_rd_Filter(NULL, irg, block, arg, mode, proj); } ir_node *new_r_NoMem(ir_graph *irg) { - return new_rd_NoMem(irg); + return get_irg_no_mem(irg); } +#ifdef USE_ORIGINAL ir_node *new_r_Mux(ir_graph *irg, ir_node *block, 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); -} +#endif 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); @@ -1721,9 +1785,11 @@ ir_node *new_r_Bound(ir_graph *irg, ir_node *block, ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) { return new_rd_Bound(NULL, irg, block, store, idx, lower, upper); } +#ifdef USE_ORIGINAL ir_node *new_r_Pin(ir_graph *irg, ir_node *block, ir_node *node) { return new_rd_Pin(NULL, irg, block, node); } +#endif ir_node *new_r_ASM(ir_graph *irg, ir_node *block, int arity, ir_node *in[], ir_asm_constraint *inputs, int n_outs, ir_asm_constraint *outputs, @@ -1735,6 +1801,8 @@ ir_node *new_r_ASM(ir_graph *irg, ir_node *block, /** public interfaces */ /** construction tools */ +#ifdef USE_ORIGINAL + /** * * - create a new Start node in the current block @@ -1775,7 +1843,11 @@ new_d_Block(dbg_info *db, int arity, ir_node **in) { int i; int has_unknown = 0; +#ifdef USE_ORIGINAL res = new_bd_Block(db, arity, in); +#else + res = new_rd_Block(db, current_ir_graph, arity, in); +#endif /* Create and initialize array for Phi-node construction. */ if (get_irg_phase_state(current_ir_graph) == phase_building) { @@ -1785,18 +1857,20 @@ new_d_Block(dbg_info *db, int arity, ir_node **in) { } for (i = arity-1; i >= 0; i--) - if (get_irn_op(in[i]) == op_Unknown) { + if (is_Unknown(in[i])) { has_unknown = 1; break; } 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 */ @@ -1825,7 +1899,7 @@ new_d_Block(dbg_info *db, int arity, ir_node **in) { * *************************************************************************** */ /** Creates a Phi node with 0 predecessors. */ -static INLINE ir_node * +static inline ir_node * new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode) { ir_node *res; @@ -1846,7 +1920,7 @@ new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode) { * @param phi0 in non-NULL: the Phi0 node in the same block that represents * the value for which the new Phi is constructed */ -static INLINE ir_node * +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) { int i; @@ -1860,7 +1934,8 @@ new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode, /* 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]); @@ -1872,7 +1947,7 @@ new_rd_Phi_in(ir_graph *irg, ir_node *block, ir_mode *mode, 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) @@ -1926,7 +2001,7 @@ phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins); * Further the last entry in frag_arr of current block points to n. This * constructs a chain block->last_frag_op-> ... first_frag_op of all frag ops in the block. */ -static INLINE ir_node **new_frag_arr(ir_node *n) { +static inline ir_node **new_frag_arr(ir_node *n) { ir_node **arr; int opt; @@ -1938,11 +2013,11 @@ static INLINE ir_node **new_frag_arr(ir_node *n) { 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) && @@ -1961,7 +2036,7 @@ static INLINE ir_node **new_frag_arr(ir_node *n) { /** * Returns the frag_arr from a node. */ -static INLINE ir_node **get_frag_arr(ir_node *n) { +static inline ir_node **get_frag_arr(ir_node *n) { switch (get_irn_opcode(n)) { case iro_Call: return n->attr.call.exc.frag_arr; @@ -2154,9 +2229,9 @@ phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) { 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; @@ -2323,21 +2398,22 @@ new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode) { } /* new_d_Phi */ ir_node * -new_d_Const(dbg_info *db, ir_mode *mode, tarval *con) { - return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con); +new_d_Const(dbg_info *db, tarval *con) { + return new_bd_Const(db, con); } /* new_d_Const */ ir_node * new_d_Const_long(dbg_info *db, ir_mode *mode, long value) { - return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value); + return new_bd_Const_long(db, mode, value); } /* new_d_Const_long */ ir_node * -new_d_Const_type(dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp) { - return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp); +new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp) { + return new_bd_Const_type(db, con, tp); } /* new_d_Const_type */ +#ifdef USE_ORIGINAL ir_node * new_d_Id(dbg_info *db, ir_node *val, ir_mode *mode) { return new_bd_Id(db, current_ir_graph->current_block, val, mode); @@ -2347,28 +2423,31 @@ ir_node * 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 */ +#ifdef USE_ORIGINAL ir_node * new_d_Conv(dbg_info *db, ir_node *op, ir_mode *mode) { return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 0); } /* new_d_Conv */ +#endif ir_node * new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode) { 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); @@ -2384,26 +2463,33 @@ NEW_D_BINOP(Sub) NEW_D_UNOP(Minus) NEW_D_BINOP(Mul) NEW_D_BINOP(Mulh) +#endif /** - * 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, op_pin_state state) { ir_node *res; 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; @@ -2414,7 +2500,7 @@ new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode * ir_node *res; 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; @@ -2425,7 +2511,7 @@ new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mod ir_node *res; 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; @@ -2436,7 +2522,7 @@ new_d_DivRL(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *m ir_node *res; res = new_bd_DivRL(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; @@ -2447,12 +2533,13 @@ new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mod ir_node *res; res = new_bd_Mod(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_Mod, &res->attr.except.frag_arr); #endif return res; } /* new_d_Mod */ +#ifdef USE_ORIGINAL NEW_D_BINOP(And) NEW_D_BINOP(Or) NEW_D_BINOP(Eor) @@ -2460,7 +2547,7 @@ NEW_D_UNOP(Not) 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) @@ -2484,6 +2571,7 @@ ir_node * 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, @@ -2492,12 +2580,19 @@ new_d_Call(dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **i 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; } /* 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 */ + +#ifdef USE_ORIGINAL 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, @@ -2505,28 +2600,29 @@ new_d_Return(dbg_info *db, ir_node* store, int arity, ir_node **in) { } /* 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 - 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; } /* 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 - 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; } /* new_d_Store */ +#endif ir_node * new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type, @@ -2535,18 +2631,20 @@ new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type, 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; } /* new_d_Alloc */ +#ifdef USE_ORIGINAL ir_node * new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr, 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); } +#endif ir_node * new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent) @@ -2557,11 +2655,13 @@ new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent) store, objptr, 0, NULL, ent); } /* new_d_simpleSel */ +#ifdef USE_ORIGINAL ir_node * new_d_Sel(dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, ir_entity *sel) { return new_bd_Sel(db, current_ir_graph->current_block, store, objptr, n_index, index, sel); } /* new_d_Sel */ +#endif ir_node * new_d_SymConst_type(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *tp) { @@ -2580,12 +2680,7 @@ new_d_Sync(dbg_info *db, int arity, ir_node *in[]) { return new_rd_Sync(db, current_ir_graph, current_ir_graph->current_block, arity, in); } /* new_d_Sync */ - -ir_node * -(new_d_Bad)(void) { - return _new_d_Bad(); -} /* new_d_Bad */ - +#ifdef USE_ORIGINAL 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, @@ -2596,6 +2691,7 @@ ir_node * new_d_Unknown(ir_mode *m) { return new_bd_Unknown(m); } /* new_d_Unknown */ +#endif ir_node * new_d_CallBegin(dbg_info *db, ir_node *call) { @@ -2623,23 +2719,14 @@ new_d_Filter(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) { arg, mode, proj); } /* new_d_Filter */ -ir_node * -(new_d_NoMem)(void) { - return _new_d_NoMem(); -} /* new_d_NoMem */ - +#ifdef USE_ORIGINAL ir_node * new_d_Mux(dbg_info *db, ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) { return new_bd_Mux(db, current_ir_graph->current_block, 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 */ +#endif ir_node *new_d_CopyB(dbg_info *db,ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) { @@ -2647,7 +2734,7 @@ ir_node *new_d_CopyB(dbg_info *db,ir_node *store, 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 */ @@ -2669,15 +2756,17 @@ ir_node *new_d_Bound(dbg_info *db,ir_node *store, 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 */ +#ifdef USE_ORIGINAL ir_node * new_d_Pin(dbg_info *db, ir_node *node) { return new_bd_Pin(db, current_ir_graph->current_block, node); } /* new_d_Pin */ +#endif ir_node * new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs, @@ -2700,7 +2789,6 @@ new_d_immBlock(dbg_info *db) { 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; @@ -2788,6 +2876,8 @@ get_d_value(dbg_info *db, int pos, ir_mode *mode) { inc_irg_visited(irg); (void) db; + assert(pos >= 0); + return get_r_value_internal(irg->current_block, pos + 1, mode); } /* get_d_value */ @@ -2802,6 +2892,7 @@ void 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; @@ -2892,9 +2983,9 @@ ir_type *get_cur_frame_type(void) { /* 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) { @@ -2905,7 +2996,7 @@ irp_finalize_cons(void) { 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); } @@ -2927,8 +3018,9 @@ ir_node *new_Cond(ir_node *c) { ir_node *new_Return(ir_node *store, int arity, ir_node *in[]) { return new_d_Return(NULL, store, arity, in); } -ir_node *new_Const(ir_mode *mode, tarval *con) { - return new_d_Const(NULL, mode, con); +#endif +ir_node *new_Const(tarval *con) { + return new_d_Const(NULL, con); } ir_node *new_Const_long(ir_mode *mode, long value) { @@ -2936,7 +3028,7 @@ ir_node *new_Const_long(ir_mode *mode, long value) { } ir_node *new_Const_type(tarval *con, ir_type *tp) { - return new_d_Const_type(NULL, get_type_mode(tp), con, tp); + return new_d_Const_type(NULL, con, tp); } ir_node *new_SymConst_type(ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *type) { @@ -2948,14 +3040,21 @@ ir_node *new_SymConst(ir_mode *mode, symconst_symbol value, symconst_kind kind) ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent) { return new_d_simpleSel(NULL, store, objptr, ent); } +#ifdef USE_ORIGINAL ir_node *new_Sel(ir_node *store, ir_node *objptr, int arity, ir_node **in, ir_entity *ent) { return new_d_Sel(NULL, store, objptr, arity, in, ent); } +#endif ir_node *new_Call(ir_node *store, ir_node *callee, int arity, ir_node **in, 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); } @@ -2971,6 +3070,7 @@ ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *new_Mulh(ir_node *op1, ir_node *op2, ir_mode *mode) { return new_d_Mulh(NULL, op1, op2, mode); } +#endif 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); } @@ -2986,6 +3086,7 @@ ir_node *new_DivRL(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op 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); } +#ifdef USE_ORIGINAL ir_node *new_Abs(ir_node *op, ir_mode *mode) { return new_d_Abs(NULL, op, mode); } @@ -3010,8 +3111,8 @@ ir_node *new_Shr(ir_node *op, ir_node *k, ir_mode *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); @@ -3025,53 +3126,64 @@ ir_node *new_Cmp(ir_node *op1, ir_node *op2) { ir_node *new_Conv(ir_node *op, ir_mode *mode) { return new_d_Conv(NULL, op, mode); } +#endif ir_node *new_strictConv(ir_node *op, ir_mode *mode) { return new_d_strictConv(NULL, op, mode); } -ir_node *new_Cast(ir_node *op, ir_type *to_tp) { - return new_d_Cast(NULL, op, to_tp); -} 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); +#ifdef USE_ORIGINAL +ir_node *new_Cast(ir_node *op, ir_type *to_tp) { + return new_d_Cast(NULL, op, to_tp); +} +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); } +#endif ir_node *new_Alloc(ir_node *store, ir_node *size, ir_type *alloc_type, ir_where_alloc where) { return new_d_Alloc(NULL, store, size, alloc_type, where); } +#ifdef USE_ORIGINAL ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where) { return new_d_Free(NULL, store, ptr, size, free_type, where); } +#endif 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 new_d_Bad(); + return get_irg_bad(current_ir_graph); } +#ifdef USE_ORIGINAL ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp) { return new_d_Confirm(NULL, val, bound, cmp); } ir_node *new_Unknown(ir_mode *m) { return new_d_Unknown(m); } +#endif ir_node *new_CallBegin(ir_node *callee) { return new_d_CallBegin(NULL, callee); } @@ -3088,14 +3200,13 @@ ir_node *new_Filter(ir_node *arg, ir_mode *mode, long proj) { return new_d_Filter(NULL, arg, mode, proj); } ir_node *new_NoMem(void) { - return new_d_NoMem(); + return get_irg_no_mem(current_ir_graph); } +#ifdef USE_ORIGINAL 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); -} +#endif 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); } @@ -3108,9 +3219,15 @@ ir_node *new_Raise(ir_node *store, ir_node *obj) { ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) { return new_d_Bound(NULL, store, idx, lower, upper); } +#ifdef USE_ORIGINAL ir_node *new_Pin(ir_node *node) { return new_d_Pin(NULL, node); } +#endif +ir_node *new_Dummy(ir_mode *m) { + ir_graph *irg = current_ir_graph; + return new_ir_node(NULL, irg, get_irg_start_block(irg), op_Dummy, m, 0, NULL); +} ir_node *new_ASM(int arity, ir_node *in[], ir_asm_constraint *inputs, int n_outs, ir_asm_constraint *outputs, int n_clobber, ident *clobber[], ident *asm_text) {