/*
- * 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
- 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
res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \
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; \
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
/* 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 */
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);
} /* 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;
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;
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;
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)
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,
+ 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;
+}
+#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 */
+
+#ifdef USE_ORIGINAL
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.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;
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;
} /* new_bd_Store */
+#endif
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;
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, 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;
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,
* 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;
} /* 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);
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;
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) {
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) {
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,
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;
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;
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.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);
/* 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. */
} /* 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;
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_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;
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;
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)
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,
+ 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;
+}
+
+#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 */
+
+#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) {
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_Store */
+#endif
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;
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, 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;
return res;
} /* new_rd_Free */
+#endif
ir_node *
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) {
return res;
} /* new_rd_Sel */
+#endif
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 *
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;
return res;
} /* new_rd_Unknown */
+#endif
ir_node *
new_rd_CallBegin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) {
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) {
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) {
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;
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,
} /* 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 *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_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) {
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);
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);
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, 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);
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) {
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, 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);
}
+#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, 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);
}
+#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 );
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);
}
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);
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,
/** public interfaces */
/** construction tools */
+#ifdef USE_ORIGINAL
+
/**
*
* - create a new Start node in the current block
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) {
}
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 */
* *************************************************************************** */
/** 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;
} /* new_rd_Phi0 */
-static INLINE ir_node *
+/**
+ * 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 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;
/* 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! */
+ is not needed.
+ Note: We MUST consider Bad nodes, else we might get data flow cycles in dead loops! */
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)
+ 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);
}
* 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;
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) &&
/**
* 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;
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 {
#endif /* PRECISE_EXC_CONTEXT */
/**
- * check whether a control flow cf_pred is a exception flow.
+ * 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) {
- /* all projections from a raise are exceptional control flow */
- if (is_Raise(prev_cf_op))
- return 1;
+ /*
+ * 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) && get_Proj_proj(cf_pred) == pn_Generic_X_regular) {
- /* the regular control flow, NO exception */
- return 0;
+ 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");
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()) {
/* 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) &&
- (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;
/* 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
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;
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 */
} /* 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);
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);
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;
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;
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;
-}
+} /* new_d_Div */
+
+ir_node *
+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_DivRL(db, current_ir_graph->current_block, memop, op1, op2, mode, state);
+#if PRECISE_EXC_CONTEXT
+ 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
- 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)
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)
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,
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,
} /* 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,
- 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;
} /* 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, 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);
}
+#endif
ir_node *
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, 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 */
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,
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) {
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) {
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 */
+#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,
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;
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 */
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;
} /* 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) {
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_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) {
}
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(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);
}
+#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);
}
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);
}
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_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, 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);
}
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);
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_Store(ir_node *store, ir_node *addr, ir_node *val) {
- return new_d_Store(NULL, store, addr, val);
+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, 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,
- where_alloc where) {
+ 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, where_alloc where) {
+ 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);
}
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);
}
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) {
projects / libfirm / blobdiff