/*
- * 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 "irnode_t.h"
#include "irmode_t.h"
#include "ircons_t.h"
-#include "firm_common_t.h"
-#include "irvrfy.h"
+#include "irverify.h"
#include "irop_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
+#include "error.h"
/* when we need verifying */
#ifdef NDEBUG
-# define IRN_VRFY_IRG(res, irg)
+# define IRN_VERIFY_IRG(res, irg)
#else
-# define IRN_VRFY_IRG(res, irg) irn_vrfy_irg(res, irg)
+# define IRN_VERIFY_IRG(res, irg) irn_verify_irg(res, irg)
#endif /* NDEBUG */
/**
*/
static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
-/* creates a bd constructor for a binop */
-#define NEW_BD_BINOP(instr) \
-static ir_node * \
-new_bd_##instr(dbg_info *db, ir_node *block, \
- ir_node *op1, ir_node *op2, ir_mode *mode) \
-{ \
- ir_node *in[2]; \
- ir_node *res; \
- ir_graph *irg = current_ir_graph; \
- in[0] = op1; \
- in[1] = op2; \
- res = new_ir_node(db, irg, block, op_##instr, mode, 2, in); \
- res = optimize_node(res); \
- IRN_VRFY_IRG(res, irg); \
- return res; \
-}
-
-/* creates a bd constructor for an unop */
-#define NEW_BD_UNOP(instr) \
-static ir_node * \
-new_bd_##instr(dbg_info *db, ir_node *block, \
- ir_node *op, ir_mode *mode) \
-{ \
- ir_node *res; \
- ir_graph *irg = current_ir_graph; \
- res = new_ir_node(db, irg, block, op_##instr, mode, 1, &op); \
- res = optimize_node(res); \
- IRN_VRFY_IRG(res, irg); \
- return res; \
-}
-
-/* creates a bd constructor for an divop */
-#define NEW_BD_DIVOP(instr) \
-static ir_node * \
-new_bd_##instr(dbg_info *db, ir_node *block, \
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, 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_##instr, mode_T, 3, in); \
- res->attr.divmod.exc.pin_state = state; \
- res->attr.divmod.res_mode = mode; \
- res = optimize_node(res); \
- IRN_VRFY_IRG(res, irg); \
- return res; \
-}
-
-/* creates a rd constructor for a binop */
-#define NEW_RD_BINOP(instr) \
-ir_node * \
-new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block, \
- ir_node *op1, ir_node *op2, ir_mode *mode) \
-{ \
- ir_node *res; \
- ir_graph *rem = current_ir_graph; \
- current_ir_graph = irg; \
- res = new_bd_##instr(db, block, op1, op2, mode); \
- current_ir_graph = rem; \
- return res; \
-}
-
-/* creates a rd constructor for an unop */
-#define NEW_RD_UNOP(instr) \
-ir_node * \
-new_rd_##instr(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_##instr(db, block, op, mode); \
- current_ir_graph = rem; \
- return res; \
-}
-
-/* creates a rd constructor for an divop */
-#define NEW_RD_DIVOP(instr) \
-ir_node * \
-new_rd_##instr(dbg_info *db, ir_graph *irg, ir_node *block, \
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) \
-{ \
- ir_node *res; \
- ir_graph *rem = current_ir_graph; \
- current_ir_graph = irg; \
- res = new_bd_##instr(db, block, memop, op1, op2, mode, state);\
- current_ir_graph = rem; \
- return res; \
-}
-
-/* creates a d constructor for an binop */
-#define NEW_D_BINOP(instr) \
-ir_node * \
-new_d_##instr(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) { \
- return new_bd_##instr(db, current_ir_graph->current_block, op1, op2, mode); \
-}
-
-/* creates a d constructor for an unop */
-#define NEW_D_UNOP(instr) \
-ir_node * \
-new_d_##instr(dbg_info *db, ir_node *op, ir_mode *mode) { \
- return new_bd_##instr(db, current_ir_graph->current_block, op, mode); \
-}
-
-
-/**
- * Constructs a Block with a fixed number of predecessors.
- * Does not set current_block. Cannot be used with automatic
- * Phi node construction.
- */
-static ir_node *
-new_bd_Block(dbg_info *db, int arity, ir_node **in) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, NULL, op_Block, mode_BB, arity, in);
-
- /* macroblock header */
- res->in[0] = res;
-
- res->attr.block.is_dead = 0;
- res->attr.block.is_mb_head = 1;
- res->attr.block.has_label = 0;
- res->attr.block.irg = irg;
- res->attr.block.backedge = new_backedge_arr(irg->obst, arity);
- res->attr.block.in_cg = NULL;
- res->attr.block.cg_backedge = NULL;
- res->attr.block.extblk = NULL;
- res->attr.block.mb_depth = 0;
- res->attr.block.label = 0;
-
- set_Block_matured(res, 1);
- set_Block_block_visited(res, 0);
-
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Block */
+#include "gen_ir_cons.c.inl"
-static ir_node *
-new_bd_Start(dbg_info *db, ir_node *block) {
+static ir_node *new_bd_Start(dbg_info *db, ir_node *block)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
res = new_ir_node(db, irg, block, op_Start, mode_T, 0, NULL);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_Start */
-static ir_node *
-new_bd_End(dbg_info *db, ir_node *block) {
+static ir_node *new_bd_End(dbg_info *db, ir_node *block)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
res = new_ir_node(db, irg, block, op_End, mode_X, -1, NULL);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_End */
* Creates a Phi node with all predecessors. Calling this constructor
* is only allowed if the corresponding block is mature.
*/
-static ir_node *
-new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode) {
+static ir_node *new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
int i;
int has_unknown = 0;
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) {
+ if (is_Unknown(in[i])) {
has_unknown = 1;
break;
}
if (!has_unknown) res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_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);
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) {
+static ir_node *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->attr.con.tv = con;
+ res = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, get_tarval_mode(con), 0, NULL);
+ res->attr.con.tarval = con;
set_Const_type(res, tp); /* Call method because of complex assertion. */
res = optimize_node (res);
assert(get_Const_type(res) == tp);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_Const_type */
-static ir_node *
-new_bd_Const(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con) {
+static ir_node *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) {
+static ir_node *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 */
-static ir_node *
-new_bd_Id(dbg_info *db, ir_node *block, ir_node *val, ir_mode *mode) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Id, mode, 1, &val);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Id */
-
-static ir_node *
-new_bd_Proj(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
- long proj) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node (db, irg, block, op_Proj, mode, 1, &arg);
- res->attr.proj = proj;
-
- assert(res);
- assert(get_Proj_pred(res));
- assert(get_nodes_block(get_Proj_pred(res)));
-
- res = optimize_node(res);
-
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Proj */
-
-static ir_node *
-new_bd_defaultProj(dbg_info *db, ir_node *block, ir_node *arg,
- long max_proj) {
+static ir_node *new_bd_defaultProj(dbg_info *db, ir_node *arg, long max_proj)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
assert(arg->op == op_Cond);
- arg->attr.cond.kind = fragmentary;
arg->attr.cond.default_proj = max_proj;
- res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
+ res = new_rd_Proj(db, arg, mode_X, max_proj);
return res;
} /* new_bd_defaultProj */
-static ir_node *
-new_bd_Conv(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode, int strict_flag) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op);
- res->attr.conv.strict = strict_flag;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Conv */
-
-static ir_node *
-new_bd_Cast(dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- 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 = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Cast */
-
-static ir_node *
-new_bd_Tuple(dbg_info *db, ir_node *block, int arity, ir_node **in) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Tuple, mode_T, arity, in);
- res = optimize_node (res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Tuple */
-
-NEW_BD_BINOP(Add)
-NEW_BD_BINOP(Sub)
-NEW_BD_UNOP(Minus)
-NEW_BD_BINOP(Mul)
-NEW_BD_BINOP(Mulh)
-NEW_BD_DIVOP(Quot)
-NEW_BD_DIVOP(DivMod)
-NEW_BD_DIVOP(Div)
-NEW_BD_DIVOP(Mod)
-NEW_BD_BINOP(And)
-NEW_BD_BINOP(Or)
-NEW_BD_BINOP(Eor)
-NEW_BD_UNOP(Not)
-NEW_BD_BINOP(Shl)
-NEW_BD_BINOP(Shr)
-NEW_BD_BINOP(Shrs)
-NEW_BD_BINOP(Rot)
-NEW_BD_UNOP(Abs)
-NEW_BD_BINOP(Carry)
-NEW_BD_BINOP(Borrow)
-
-static ir_node *
-new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) {
- ir_node *in[2];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
- in[0] = op1;
- in[1] = op2;
- res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Cmp */
-
-static ir_node *
-new_bd_Jmp(dbg_info *db, ir_node *block) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Jmp, mode_X, 0, NULL);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Jmp */
-
-static ir_node *
-new_bd_IJmp(dbg_info *db, ir_node *block, ir_node *tgt) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_IJmp, mode_X, 1, &tgt);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_IJmp */
-
-static ir_node *
-new_bd_Cond(dbg_info *db, ir_node *block, ir_node *c) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Cond, mode_T, 1, &c);
- res->attr.cond.kind = dense;
- res->attr.cond.default_proj = 0;
- res->attr.cond.pred = COND_JMP_PRED_NONE;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Cond */
-
-static ir_node *
-new_bd_Call(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *callee, 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+2;
- NEW_ARR_A(ir_node *, r_in, r_arity);
- r_in[0] = store;
- r_in[1] = callee;
- memcpy(&r_in[2], in, sizeof(ir_node *) * arity);
-
- res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
-
- assert((get_unknown_type() == tp) || is_Method_type(tp));
- set_Call_type(res, tp);
- res->attr.call.exc.pin_state = op_pin_state_pinned;
- res->attr.call.callee_arr = NULL;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Call */
-
-static ir_node *
-new_bd_Return(dbg_info *db, ir_node *block,
- ir_node *store, int arity, ir_node **in) {
- 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_Return, mode_X, r_arity, r_in);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Return */
-
-static ir_node *
-new_bd_Load(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *adr, ir_mode *mode) {
- 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 = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Load */
-
-static ir_node *
-new_bd_Store(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *adr, ir_node *val) {
- ir_node *in[3];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = store;
- 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 = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Store */
-
-static ir_node *
-new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
- ir_node *in[2];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = store;
- in[1] = size;
- res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in);
- res->attr.alloc.exc.pin_state = op_pin_state_pinned;
- res->attr.alloc.where = where;
- res->attr.alloc.type = alloc_type;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Alloc */
-
-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) {
- ir_node *in[3];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = store;
- in[1] = ptr;
- in[2] = size;
- res = new_ir_node (db, irg, block, op_Free, mode_M, 3, in);
- res->attr.free.where = where;
- res->attr.free.type = free_type;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Free */
-
-static ir_node *
-new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
- int arity, ir_node **in, ir_entity *ent) {
+static ir_node *new_bd_Sel(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *objptr, int arity, ir_node **in,
+ ir_entity *ent)
+{
ir_node **r_in;
ir_node *res;
int r_arity;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
ir_mode *mode = is_Method_type(get_entity_type(ent)) ? mode_P_code : mode_P_data;
assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
* 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);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_Sel */
-static ir_node *
-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;
+static ir_node *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 = get_irn_irg(block);
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);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_SymConst_type */
-static ir_node *
-new_bd_Sync(dbg_info *db, ir_node *block) {
+static ir_node *new_bd_Sync(dbg_info *db, ir_node *block)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
res = new_ir_node(db, irg, block, op_Sync, mode_M, -1, NULL);
/* no need to call optimize node here, Sync are always created with no predecessors */
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_bd_Sync */
-static ir_node *
-new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- ir_node *in[2], *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = val;
- in[1] = bound;
- res = new_ir_node(db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
- res->attr.confirm.cmp = cmp;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Confirm */
-
-static ir_node *
-new_bd_Unknown(ir_mode *m) {
+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 *text)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(block);
- res = new_ir_node(NULL, irg, get_irg_start_block(irg), op_Unknown, m, 0, NULL);
- res = optimize_node(res);
- return res;
-} /* new_bd_Unknown */
+ 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.input_constraints
+ = NEW_ARR_D(ir_asm_constraint, irg->obst, arity);
+ res->attr.assem.output_constraints
+ = NEW_ARR_D(ir_asm_constraint, irg->obst, n_outs);
+ res->attr.assem.clobbers = NEW_ARR_D(ident *, irg->obst, n_clobber);
+ res->attr.assem.text = text;
-static ir_node *
-new_bd_CallBegin(dbg_info *db, ir_node *block, ir_node *call) {
- ir_node *in[1];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
+ memcpy(res->attr.assem.input_constraints, inputs, sizeof(inputs[0]) * arity);
+ memcpy(res->attr.assem.output_constraints, outputs, sizeof(outputs[0]) * n_outs);
+ memcpy(res->attr.assem.clobbers, clobber, sizeof(clobber[0]) * n_clobber);
- in[0] = get_Call_ptr(call);
- res = new_ir_node(db, irg, block, op_CallBegin, mode_T, 1, in);
- /* res->attr.callbegin.irg = irg; */
- res->attr.callbegin.call = call;
res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
-} /* new_bd_CallBegin */
-
-static ir_node *
-new_bd_EndReg(dbg_info *db, ir_node *block) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
+} /* new_bd_ASM */
- res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
- set_irg_end_reg(irg, res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_EndReg */
+/* --------------------------------------------- */
+/* private interfaces, for professional use only */
+/* --------------------------------------------- */
-static ir_node *
-new_bd_EndExcept(dbg_info *db, ir_node *block) {
+ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block)
+{
+ ir_graph *rem = current_ir_graph;
ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
- set_irg_end_except(irg, res);
- IRN_VRFY_IRG (res, irg);
- return res;
-} /* new_bd_EndExcept */
-static ir_node *
-new_bd_Break(dbg_info *db, ir_node *block) {
- ir_node *res;
- ir_graph *irg = current_ir_graph;
+ current_ir_graph = irg;
+ res = new_bd_Start(db, block);
+ current_ir_graph = rem;
- res = new_ir_node(db, irg, block, op_Break, mode_X, 0, NULL);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Break */
+} /* new_rd_Start */
-static ir_node *
-new_bd_Filter(dbg_info *db, ir_node *block, ir_node *arg, ir_mode *mode,
- long proj) {
+ir_node *new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- res = new_ir_node(db, irg, block, op_Filter, mode, 1, &arg);
- res->attr.filter.proj = proj;
- res->attr.filter.in_cg = NULL;
- res->attr.filter.backedge = NULL;
+ ir_graph *rem = current_ir_graph;
- assert(res);
- assert(get_Proj_pred(res));
- assert(get_nodes_block(get_Proj_pred(res)));
+ current_ir_graph = irg;
+ res = new_bd_End(db, block);
+ current_ir_graph = rem;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Filter */
+} /* new_rd_End */
-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) {
- ir_node *in[3];
+/* Creates a Phi node with all predecessors. Calling this constructor
+ is only allowed if the corresponding block is mature. */
+ir_node *new_rd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = sel;
- in[1] = ir_false;
- in[2] = ir_true;
+ ir_graph *rem = current_ir_graph;
- res = new_ir_node(db, irg, block, op_Mux, mode, 3, in);
- assert(res);
+ current_ir_graph = get_Block_irg(block);
+ res = new_bd_Phi(db, block,arity, in, mode);
+ current_ir_graph = rem;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Mux */
+} /* new_rd_Phi */
-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 *new_rd_Const_type(dbg_info *db, ir_graph *irg, tarval *con, ir_type *tp)
+{
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];
+ ir_graph *rem = current_ir_graph;
- res = new_ir_node(db, irg, block, op_Psi, mode, 2 * arity + 1, in);
- assert(res);
+ current_ir_graph = irg;
+ res = new_bd_Const_type(db, con, tp);
+ current_ir_graph = rem;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Psi */
+} /* new_rd_Const_type */
-static ir_node *
-new_bd_CopyB(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
- ir_node *in[3];
+ir_node *new_rd_Const(dbg_info *db, ir_graph *irg, tarval *con)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = store;
- in[1] = dst;
- in[2] = src;
+//#ifdef USE_ORIGINAL
+ ir_graph *rem = current_ir_graph;
- res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in);
+ current_ir_graph = irg;
+ res = new_bd_Const_type(db, con, firm_unknown_type);
+ current_ir_graph = rem;
+//#else
+// res = new_rd_Const_type(db, irg, con, firm_unknown_type);
+//#endif
- res->attr.copyb.exc.pin_state = op_pin_state_pinned;
- res->attr.copyb.data_type = data_type;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_CopyB */
+} /* new_rd_Const */
-static ir_node *
-new_bd_InstOf(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *objptr, ir_type *type) {
- ir_node *in[2];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
+ir_node *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 */
- 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 = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_InstOf */
+ir_node *new_rd_defaultProj(dbg_info *db, ir_node *arg, long max_proj)
+{
+ return new_bd_defaultProj(db, arg, max_proj);
+} /* new_rd_defaultProj */
-static ir_node *
-new_bd_Raise(dbg_info *db, ir_node *block, ir_node *store, ir_node *obj) {
- ir_node *in[2];
+ir_node *new_rd_simpleSel(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *objptr, ir_entity *ent)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
-
- in[0] = store;
- in[1] = obj;
- res = new_ir_node(db, irg, block, op_Raise, mode_T, 2, in);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_Raise */
+ ir_graph *rem = current_ir_graph;
-static ir_node *
-new_bd_Bound(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
- ir_node *in[4];
- ir_node *res;
- ir_graph *irg = current_ir_graph;
+ current_ir_graph = get_Block_irg(block);
+ res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
+ current_ir_graph = rem;
- in[0] = store;
- in[1] = idx;
- in[2] = lower;
- in[3] = upper;
- res = new_ir_node(db, irg, block, op_Bound, mode_T, 4, in);
- res->attr.bound.exc.pin_state = op_pin_state_pinned;
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Bound */
+} /* new_rd_simpleSel */
-static ir_node *
-new_bd_Pin(dbg_info *db, ir_node *block, ir_node *node) {
+ir_node *new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_mode *mode,
+ symconst_symbol value, symconst_kind symkind,
+ ir_type *tp)
+{
ir_node *res;
- ir_graph *irg = current_ir_graph;
+ ir_graph *rem = current_ir_graph;
+ ir_node *block = get_irg_start_block(irg);
+
+ current_ir_graph = irg;
+ res = new_bd_SymConst_type(db, block, mode, value, symkind, tp);
+ current_ir_graph = rem;
- res = new_ir_node(db, irg, block, op_Pin, get_irn_mode(node), 1, &node);
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
return res;
-} /* new_bd_Pin */
+} /* new_rd_SymConst_type */
-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.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);
-
- res = optimize_node(res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_bd_ASM */
-
-/* --------------------------------------------- */
-/* private interfaces, for professional use only */
-/* --------------------------------------------- */
-
-/* Constructs a Block with a fixed number of predecessors.
- Does not set current_block. Can not be used with automatic
- Phi node construction. */
-ir_node *
-new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node **in) {
- ir_graph *rem = current_ir_graph;
- ir_node *res;
-
- current_ir_graph = irg;
- res = new_bd_Block(db, arity, in);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Block */
-
-ir_node *
-new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_graph *rem = current_ir_graph;
- ir_node *res;
-
- current_ir_graph = irg;
- res = new_bd_Start(db, block);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Start */
-
-ir_node *
-new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_End(db, block);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_End */
-
-/* Creates a Phi node with all predecessors. Calling this constructor
- is only allowed if the corresponding block is mature. */
-ir_node *
-new_rd_Phi(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Phi(db, block,arity, in, mode);
- current_ir_graph = rem;
-
- return res;
-} /* 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) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Const_type(db, block, mode, 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) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Const_type(db, block, mode, con, firm_unknown_type);
- current_ir_graph = rem;
-
- 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 */
-
-ir_node *
-new_rd_Id(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Id(db, block, val, mode);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Id */
-
-ir_node *
-new_rd_Proj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
- long proj) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Proj(db, block, arg, mode, proj);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Proj */
-
-ir_node *
-new_rd_defaultProj(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg,
- long max_proj) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_defaultProj(db, block, arg, max_proj);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_defaultProj */
-
-ir_node *
-new_rd_Conv(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, 0);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Conv */
-
-ir_node *
-new_rd_Cast(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Cast(db, block, op, to_tp);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Cast */
-
-ir_node *
-new_rd_Tuple(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Tuple(db, block, arity, in);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Tuple */
-
-NEW_RD_BINOP(Add)
-NEW_RD_BINOP(Sub)
-NEW_RD_UNOP(Minus)
-NEW_RD_BINOP(Mul)
-NEW_RD_BINOP(Mulh)
-NEW_RD_DIVOP(Quot)
-NEW_RD_DIVOP(DivMod)
-NEW_RD_DIVOP(Div)
-NEW_RD_DIVOP(Mod)
-NEW_RD_BINOP(And)
-NEW_RD_BINOP(Or)
-NEW_RD_BINOP(Eor)
-NEW_RD_UNOP(Not)
-NEW_RD_BINOP(Shl)
-NEW_RD_BINOP(Shr)
-NEW_RD_BINOP(Shrs)
-NEW_RD_BINOP(Rot)
-NEW_RD_UNOP(Abs)
-NEW_RD_BINOP(Carry)
-NEW_RD_BINOP(Borrow)
-
-ir_node *
-new_rd_Cmp(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Cmp(db, block, op1, op2);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Cmp */
-
-ir_node *
-new_rd_Jmp(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Jmp(db, block);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Jmp */
-
-ir_node *
-new_rd_IJmp(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *tgt) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_IJmp(db, block, tgt);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_IJmp */
-
-ir_node *
-new_rd_Cond(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Cond(db, block, c);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Cond */
-
-ir_node *
-new_rd_Call(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node **in, ir_type *tp) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Call(db, block, store, callee, arity, in, tp);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Call */
-
-ir_node *
-new_rd_Return(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, int arity, ir_node **in) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Return(db, block, store, arity, in);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Return */
-
-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 *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Load(db, block, store, adr, mode);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Load */
-
-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 *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Store(db, block, store, adr, val);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Store */
-
-ir_node *
-new_rd_Alloc(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *size, ir_type *alloc_type, ir_where_alloc where) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Alloc(db, block, store, size, alloc_type, where);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Alloc */
-
-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) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Free(db, block, store, ptr, size, free_type, where);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Free */
-
-ir_node *
-new_rd_simpleSel(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *objptr, ir_entity *ent) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Sel(db, block, store, objptr, 0, NULL, ent);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_simpleSel */
-
-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) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Sel(db, block, store, objptr, arity, in, ent);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Sel */
-
-ir_node *
-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, 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, ir_mode *mode,
- symconst_symbol value, symconst_kind symkind) {
- return new_rd_SymConst_type(db, irg, block, mode, value, symkind, firm_unknown_type);
+ir_node *new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_mode *mode,
+ symconst_symbol value, symconst_kind symkind)
+{
+ return new_rd_SymConst_type(db, irg, mode, value, symkind, firm_unknown_type);
} /* new_rd_SymConst */
- ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_mode *mode, 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), mode, sym, symconst_addr_ent, tp);
+ return new_rd_SymConst_type(db, 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_mode *mode, 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), mode, sym, symconst_ofs_ent, tp);
+ return new_rd_SymConst_type(db, 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, 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), 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_mode *mode, 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), mode, sym, symconst_type_tag, tp);
+ return new_rd_SymConst_type(db, 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_mode *mode, 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), mode, sym, symconst_type_size, tp);
+ return new_rd_SymConst_type(db, irg, mode, sym, symconst_type_size, tp);
} /* new_rd_SymConst_size */
-ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_mode *mode, 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), mode, sym, symconst_type_align, tp);
+ return new_rd_SymConst_type(db, irg, mode, sym, symconst_type_align, tp);
} /* new_rd_SymConst_align */
-ir_node *
-new_rd_Sync(dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
+ir_node *new_rd_Sync(dbg_info *db, ir_node *block, int arity, ir_node *in[])
+{
ir_node *res;
ir_graph *rem = current_ir_graph;
int i;
- current_ir_graph = irg;
+ current_ir_graph = get_Block_irg(block);
res = new_bd_Sync(db, block);
current_ir_graph = rem;
return res;
} /* new_rd_Sync */
-ir_node *
-new_rd_Bad(ir_graph *irg) {
- return get_irg_bad(irg);
-} /* new_rd_Bad */
-
-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;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Confirm(db, block, val, bound, cmp);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Confirm */
-
-ir_node *
-new_rd_Unknown(ir_graph *irg, ir_mode *m) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Unknown(m);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Unknown */
-
-ir_node *
-new_rd_CallBegin(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_CallBegin(db, block, call);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_CallBegin */
-
-ir_node *
-new_rd_EndReg(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_node *res;
-
- res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
- set_irg_end_reg(irg, res);
- IRN_VRFY_IRG(res, irg);
- return res;
-} /* new_rd_EndReg */
-
-ir_node *
-new_rd_EndExcept(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_node *res;
-
- res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
- set_irg_end_except(irg, res);
- IRN_VRFY_IRG (res, irg);
- return res;
-} /* new_rd_EndExcept */
-
-ir_node *
-new_rd_Break(dbg_info *db, ir_graph *irg, ir_node *block) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Break(db, block);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Break */
-
-ir_node *
-new_rd_Filter(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
- long proj) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Filter(db, block, arg, mode, proj);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Filter */
-
-ir_node *
-new_rd_NoMem(ir_graph *irg) {
- return get_irg_no_mem(irg);
-} /* new_rd_NoMem */
-
-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) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Mux(db, block, sel, ir_false, ir_true, mode);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Mux */
-
-ir_node *
-new_rd_Psi(dbg_info *db, ir_graph *irg, ir_node *block,
- int arity, ir_node *cond[], ir_node *vals[], ir_mode *mode) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Psi(db, block, arity, cond, vals, mode);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Psi */
-
-ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_CopyB(db, block, store, dst, src, data_type);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_CopyB */
-
-ir_node *
-new_rd_InstOf(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *objptr, ir_type *type) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_InstOf(db, block, store, objptr, type);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_InstOf */
-
-ir_node *
-new_rd_Raise(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Raise(db, block, store, obj);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Raise */
-
-ir_node *new_rd_Bound(dbg_info *db, ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {
- ir_node *res;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
- res = new_bd_Bound(db, block, store, idx, lower, upper);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Bound */
-
-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;
-
- current_ir_graph = irg;
- res = new_bd_Pin(db, block, node);
- current_ir_graph = rem;
-
- return res;
-} /* new_rd_Pin */
-
-ir_node *new_rd_ASM(dbg_info *db, ir_graph *irg, ir_node *block,
+ir_node *new_rd_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) {
+ int n_clobber, ident *clobber[], ident *text)
+{
ir_node *res;
ir_graph *rem = current_ir_graph;
- current_ir_graph = irg;
- res = new_bd_ASM(db, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+ current_ir_graph = get_Block_irg(block);
+ res = new_bd_ASM(db, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
current_ir_graph = rem;
return res;
} /* new_rd_ASM */
-
-ir_node *new_r_Block(ir_graph *irg, int arity, ir_node **in) {
- return new_rd_Block(NULL, irg, arity, in);
-}
-ir_node *new_r_Start(ir_graph *irg, ir_node *block) {
+ir_node *new_r_Start(ir_graph *irg, ir_node *block)
+{
return new_rd_Start(NULL, irg, block);
}
-ir_node *new_r_End(ir_graph *irg, ir_node *block) {
+ir_node *new_r_End(ir_graph *irg, ir_node *block)
+{
return new_rd_End(NULL, irg, block);
}
-ir_node *new_r_Jmp(ir_graph *irg, ir_node *block) {
- return new_rd_Jmp(NULL, irg, block);
-}
-ir_node *new_r_IJmp(ir_graph *irg, ir_node *block, ir_node *tgt) {
- return new_rd_IJmp(NULL, irg, block, tgt);
-}
-ir_node *new_r_Cond(ir_graph *irg, ir_node *block, ir_node *c) {
- return new_rd_Cond(NULL, irg, block, c);
-}
-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);
-}
-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_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_SymConst(ir_graph *irg, ir_node *block, ir_mode *mode,
- symconst_symbol value, symconst_kind symkind) {
- return new_rd_SymConst(NULL, irg, block, mode, value, symkind);
-}
-ir_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);
-}
-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);
-}
-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_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 *new_r_Sub(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Sub(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Minus(ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
- return new_rd_Minus(NULL, irg, block, op, mode);
-}
-ir_node *new_r_Mul(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Mul(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Mulh(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Mulh(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Quot(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_rd_Quot(NULL, irg, block, memop, op1, op2, mode, state);
-}
-ir_node *new_r_DivMod(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_rd_DivMod(NULL, irg, block, memop, op1, op2, mode, state);
-}
-ir_node *new_r_Div(ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_rd_Div(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);
-}
-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 *new_r_And(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_And(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Or(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Or(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Eor(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_rd_Eor(NULL, irg, block, op1, op2, mode);
-}
-ir_node *new_r_Not(ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
- return new_rd_Not(NULL, irg, block, op, mode);
-}
-ir_node *new_r_Shl(ir_graph *irg, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode) {
- return new_rd_Shl(NULL, irg, block, op, k, mode);
-}
-ir_node *new_r_Shr(ir_graph *irg, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode) {
- return new_rd_Shr(NULL, irg, block, op, k, mode);
-}
-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 *op, ir_node *k, ir_mode *mode) {
- return new_rd_Rot(NULL, irg, block, op, k, mode);
-}
-ir_node *new_r_Carry(ir_graph *irg, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode) {
- return new_rd_Carry(NULL, irg, block, op, k, mode);
-}
-ir_node *new_r_Borrow(ir_graph *irg, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode) {
- return new_rd_Borrow(NULL, irg, block, op, k, mode);
-}
-ir_node *new_r_Cmp(ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2) {
- return new_rd_Cmp(NULL, irg, block, op1, op2);
-}
-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);
-}
-ir_node *new_r_Phi(ir_graph *irg, ir_node *block, int arity,
- ir_node **in, ir_mode *mode) {
- return new_rd_Phi(NULL, irg, block, arity, in, mode);
-}
-ir_node *new_r_Load(ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *adr, ir_mode *mode) {
- return new_rd_Load(NULL, irg, block, store, adr, mode);
-}
-ir_node *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 *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);
-}
-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);
-}
-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);
-}
-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);
-}
-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);
-}
-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 *new_r_Id(ir_graph *irg, ir_node *block,
- ir_node *val, ir_mode *mode) {
- return new_rd_Id(NULL, irg, block, val, mode);
-}
-ir_node *new_r_Bad(ir_graph *irg) {
- return new_rd_Bad(irg);
-}
-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);
-}
-ir_node *new_r_CallBegin(ir_graph *irg, ir_node *block, ir_node *callee) {
- return new_rd_CallBegin(NULL, irg, block, callee);
-}
-ir_node *new_r_EndReg(ir_graph *irg, ir_node *block) {
- return new_rd_EndReg(NULL, irg, block);
-}
-ir_node *new_r_EndExcept(ir_graph *irg, ir_node *block) {
- return new_rd_EndExcept(NULL, irg, block);
-}
-ir_node *new_r_Break(ir_graph *irg, ir_node *block) {
- return new_rd_Break(NULL, irg, block);
+ir_node *new_r_Const(ir_graph *irg, tarval *con)
+{
+ return new_rd_Const(NULL, irg, con);
}
-ir_node *new_r_Filter(ir_graph *irg, ir_node *block, ir_node *arg,
- ir_mode *mode, long proj) {
- return new_rd_Filter(NULL, irg, block, arg, mode, proj);
+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_NoMem(ir_graph *irg) {
- return new_rd_NoMem(irg);
+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_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_SymConst(ir_graph *irg, ir_mode *mode, symconst_symbol value,
+ symconst_kind symkind)
+{
+ return new_rd_SymConst(NULL, irg, mode, value, symkind);
}
-ir_node *new_r_Psi(ir_graph *irg, ir_node *block,
- int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
- return new_rd_Psi(NULL, irg, block, arity, conds, vals, mode);
+ir_node *new_r_simpleSel(ir_node *block, ir_node *store, ir_node *objptr,
+ ir_entity *ent)
+{
+ return new_rd_Sel(NULL, block, store, objptr, 0, NULL, ent);
}
-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 *new_r_Phi(ir_node *block, int arity, ir_node **in, ir_mode *mode)
+{
+ return new_rd_Phi(NULL, block, arity, in, mode);
}
-ir_node *new_r_InstOf(ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
- ir_type *type) {
- return new_rd_InstOf(NULL, irg, block, store, objptr, type);
+ir_node *new_r_Sync(ir_node *block, int arity, ir_node *in[])
+{
+ return new_rd_Sync(NULL, block, arity, in);
}
-ir_node *new_r_Raise(ir_graph *irg, ir_node *block,
- ir_node *store, ir_node *obj) {
- return new_rd_Raise(NULL, irg, block, store, obj);
+ir_node *new_r_defaultProj(ir_node *arg, long max_proj)
+{
+ return new_rd_defaultProj(NULL, arg, max_proj);
}
-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);
+ir_node *new_r_Bad(ir_graph *irg)
+{
+ return get_irg_bad(irg);
}
-ir_node *new_r_Pin(ir_graph *irg, ir_node *block, ir_node *node) {
- return new_rd_Pin(NULL, irg, block, node);
+ir_node *new_r_NoMem(ir_graph *irg)
+{
+ return get_irg_no_mem(irg);
}
-ir_node *new_r_ASM(ir_graph *irg, ir_node *block,
+ir_node *new_r_ASM(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) {
- return new_rd_ASM(NULL, irg, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+ int n_clobber, ident *clobber[], ident *text)
+{
+ return new_rd_ASM(NULL, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
}
/** ********************/
/** public interfaces */
/** construction tools */
-/**
- *
- * - create a new Start node in the current block
- *
- * @return s - pointer to the created Start node
- *
- *
- */
-ir_node *
-new_d_Start(dbg_info *db) {
+ir_node *new_d_Start(dbg_info *db)
+{
ir_node *res;
res = new_ir_node(db, current_ir_graph, current_ir_graph->current_block,
op_Start, mode_T, 0, NULL);
res = optimize_node(res);
- IRN_VRFY_IRG(res, current_ir_graph);
+ IRN_VERIFY_IRG(res, current_ir_graph);
return res;
} /* new_d_Start */
-ir_node *
-new_d_End(dbg_info *db) {
+ir_node *new_d_End(dbg_info *db)
+{
ir_node *res;
res = new_ir_node(db, current_ir_graph, current_ir_graph->current_block,
op_End, mode_X, -1, NULL);
res = optimize_node(res);
- IRN_VRFY_IRG(res, current_ir_graph);
+ IRN_VERIFY_IRG(res, current_ir_graph);
return res;
} /* new_d_End */
-/* Constructs a Block with a fixed number of predecessors.
- Does set current_block. Can be used with automatic Phi
- node construction. */
-ir_node *
-new_d_Block(dbg_info *db, int arity, ir_node **in) {
- ir_node *res;
- int i;
- int has_unknown = 0;
-
- res = new_bd_Block(db, arity, in);
-
- /* Create and initialize array for Phi-node construction. */
- if (get_irg_phase_state(current_ir_graph) == phase_building) {
- res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
- current_ir_graph->n_loc);
- memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
- }
-
- for (i = arity-1; i >= 0; i--)
- if (get_irn_op(in[i]) == op_Unknown) {
- 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 */
-
/* ***********************************************************************/
/* Methods necessary for automatic Phi node creation */
/*
* *************************************************************************** */
/** Creates a Phi node with 0 predecessors. */
-static INLINE ir_node *
-new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode) {
+static inline ir_node *new_rd_Phi0(ir_graph *irg, ir_node *block, ir_mode *mode)
+{
ir_node *res;
res = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
- IRN_VRFY_IRG(res, irg);
+ IRN_VERIFY_IRG(res, irg);
return res;
} /* new_rd_Phi0 */
-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) {
+/**
+ * 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;
ir_node *res, *known;
/* 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. */
- IRN_VRFY_IRG(res, irg);
+ res = optimize_node(res); /* This is necessary to add the node to the hash table for cse. */
+ IRN_VERIFY_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);
}
return res;
} /* new_rd_Phi_in */
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
+static ir_node *get_r_value_internal(ir_node *block, int pos, ir_mode *mode);
-#if PRECISE_EXC_CONTEXT
-static ir_node *
-phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
+static ir_node *phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
/**
* Construct a new frag_array for node n.
* 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)
- arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
- else if (get_irn_op(n) == op_CopyB)
- arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
- else {
+ if (is_Call(n)) {
+ arr[0] = new_Proj(n, mode_M, pn_Call_M);
+ } else if (is_CopyB(n)) {
+ arr[0] = new_Proj(n, mode_M, pn_CopyB_M);
+ } 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;
}
} /* get_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
+static void set_frag_value(ir_node **frag_arr, int pos, ir_node *val)
+{
+#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 *
-get_r_frag_value_internal(ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
+static ir_node *get_r_frag_value_internal(ir_node *block, ir_node *cfOp,
+ int pos, ir_mode *mode)
+{
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 {
}
return res;
} /* get_r_frag_value_internal */
-#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;
+static int is_exception_flow(ir_node *cf_pred, ir_node *prev_cf_op)
+{
+ /*
+ * Note: all projections from a raise are "exceptional control flow" we we handle it
+ * like a normal Jmp, because there is no "regular" one.
+ * That's why Raise is no "fragile_op"!
+ */
if (is_fragile_op(prev_cf_op)) {
if (is_Proj(cf_pred)) {
if (get_Proj_proj(cf_pred) == pn_Generic_X_regular) {
return 1;
}
/* Hmm, exception but not a Proj? */
- assert(!"unexpected condition: fragile op without a proj");
- return 1;
+ panic("unexpected condition: fragile op without a proj");
}
return 0;
} /* is_exception_flow */
* node might optimize it away and return a real value.
* This function must be called with an in-array of proper size.
*/
-static ir_node *
-phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) {
+static ir_node *phi_merge(ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
+{
ir_node *prevBlock, *res, *phi0, *phi0_all;
int i;
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()) {
/* Set graph_arr for fragile ops. Also here we should break recursion.
We could choose a cyclic path through an cfop. But the recursion would
break at some point. */
set_frag_value(block->attr.block.graph_arr, pos, phi0);
}
-#endif
}
}
prevBlock = prevCfOp->in[0]; /* go past control flow op to prev block */
assert(prevBlock);
if (!is_Bad(prevBlock)) {
-#if PRECISE_EXC_CONTEXT
if (get_opt_precise_exc_context() && is_exception_flow(cf_pred, prevCfOp)) {
assert(get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode));
nin[i-1] = get_r_frag_value_internal(prevBlock, prevCfOp, pos, mode);
} else
-#endif
nin[i-1] = get_r_value_internal(prevBlock, pos, mode);
} else {
nin[i-1] = new_Bad();
/* We want to pass the Phi0 node to the constructor: this finds additional
optimization possibilities.
The Phi0 node either is allocated in this function, or it comes from
- a former call to get_r_value_internal. In this case we may not yet
- exchange phi0, as this is done in mature_immBlock. */
- if (!phi0) {
+ a former call to get_r_value_internal(). In this case we may not yet
+ exchange phi0, as this is done in mature_immBlock(). */
+ if (phi0 == NULL) {
phi0_all = block->attr.block.graph_arr[pos];
- if (!((get_irn_op(phi0_all) == op_Phi) &&
- (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
* @param pos the value number of the value searched
* @param mode the mode of this value (needed for Phi construction)
*/
-static ir_node *
-get_r_value_internal(ir_node *block, int pos, ir_mode *mode) {
+static ir_node *get_r_value_internal(ir_node *block, int pos, ir_mode *mode)
+{
ir_node *res;
/* There are 4 cases to treat.
1. The block is not mature and we visit it the first time. We can not
create a proper Phi node, therefore a Phi0, i.e., a Phi without
- predecessors is returned. This node is added to the linked list (field
- "link") of the containing block to be completed when this block is
+ 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;
* Finalize a Block node, when all control flows are known.
* Acceptable parameters are only Block nodes.
*/
-void
-mature_immBlock(ir_node *block) {
+void mature_immBlock(ir_node *block)
+{
int ins;
ir_node *n, **nin;
ir_node *next;
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_VERIFY_IRG(block, irg);
}
} /* mature_immBlock */
-ir_node *
-new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode) {
+ir_node *new_d_Phi(dbg_info *db, int arity, ir_node **in, ir_mode *mode)
+{
return new_bd_Phi(db, current_ir_graph->current_block, arity, in, 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);
+ir_node *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);
+ir_node *new_d_Const_long(dbg_info *db, ir_mode *mode, long 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);
+ir_node *new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp)
+{
+ return new_bd_Const_type(db, con, tp);
} /* new_d_Const_type */
-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_Id */
-
-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 */
-
-ir_node *
-new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj) {
+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 */
-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 */
-
-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 */
-
-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_Cast */
-
-ir_node *
-new_d_Tuple(dbg_info *db, int arity, ir_node **in) {
- return new_bd_Tuple(db, current_ir_graph->current_block, arity, in);
-} /* new_d_Tuple */
-
-NEW_D_BINOP(Add)
-NEW_D_BINOP(Sub)
-NEW_D_UNOP(Minus)
-NEW_D_BINOP(Mul)
-NEW_D_BINOP(Mulh)
-
/**
- * Allocate the frag array.
+ * Allocate a frag array for a node if the current graph state is phase_building.
+ *
+ * @param irn the node for which the frag array should be allocated
+ * @param op the opcode of the (original) node, if does not match opcode of irn,
+ * nothing is done
+ * @param frag_store the address of the frag store in irn attributes, if this
+ * address contains a value != NULL, does nothing
*/
-static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
+void firm_alloc_frag_arr(ir_node *irn, ir_op *op, ir_node ***frag_store)
+{
if (get_opt_precise_exc_context()) {
if ((current_ir_graph->phase_state == phase_building) &&
- (get_irn_op(res) == op) && /* Could be optimized away. */
+ (get_irn_op(irn) == op) && /* Could be optimized away. */
!*frag_store) /* Could be a cse where the arr is already set. */ {
- *frag_store = new_frag_arr(res);
+ *frag_store = new_frag_arr(irn);
}
}
-} /* allocate_frag_arr */
-
-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. */
-#endif
-
- return res;
-} /* new_d_Quot */
-
-ir_node *
-new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- 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. */
-#endif
-
- return res;
-} /* new_d_DivMod */
-
-ir_node *
-new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- 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. */
-#endif
-
- return res;
-}
-
-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. */
-#endif
-
- return res;
-} /* new_d_Mod */
-
-NEW_D_BINOP(And)
-NEW_D_BINOP(Or)
-NEW_D_BINOP(Eor)
-NEW_D_UNOP(Not)
-NEW_D_BINOP(Shl)
-NEW_D_BINOP(Shr)
-NEW_D_BINOP(Shrs)
-NEW_D_BINOP(Rot)
-NEW_D_UNOP(Abs)
-NEW_D_BINOP(Carry)
-NEW_D_BINOP(Borrow)
-
-ir_node *
-new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2) {
- return new_bd_Cmp(db, current_ir_graph->current_block, op1, op2);
-} /* new_d_Cmp */
-
-ir_node *
-new_d_Jmp(dbg_info *db) {
- return new_bd_Jmp(db, current_ir_graph->current_block);
-} /* new_d_Jmp */
-
-ir_node *
-new_d_IJmp(dbg_info *db, ir_node *tgt) {
- return new_bd_IJmp(db, current_ir_graph->current_block, tgt);
-} /* new_d_IJmp */
-
-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 */
-
-ir_node *
-new_d_Call(dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
- ir_type *tp) {
- ir_node *res;
- 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. */
-#endif
-
- return res;
-} /* new_d_Call */
-
-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,
- store, arity, in);
-} /* new_d_Return */
-
-ir_node *
-new_d_Load(dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode) {
- ir_node *res;
- res = new_bd_Load(db, current_ir_graph->current_block,
- store, addr, mode);
-#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr); /* Could be optimized away. */
-#endif
-
- return res;
-} /* new_d_Load */
-
-ir_node *
-new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val) {
- ir_node *res;
- res = new_bd_Store(db, current_ir_graph->current_block,
- store, addr, val);
-#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr); /* Could be optimized away. */
-#endif
-
- return res;
-} /* new_d_Store */
-
-ir_node *
-new_d_Alloc(dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
- 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. */
-#endif
-
- return res;
-} /* new_d_Alloc */
-
-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);
-}
+} /* firm_alloc_frag_arr */
-ir_node *
-new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent)
+ir_node *new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent)
/* GL: objptr was called frame before. Frame was a bad choice for the name
as the operand could as well be a pointer to a dynamic object. */
{
store, objptr, 0, NULL, ent);
} /* new_d_simpleSel */
-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 */
-
-ir_node *
-new_d_SymConst_type(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind, ir_type *tp) {
+ir_node *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, ir_mode *mode, symconst_symbol value, symconst_kind kind) {
+ir_node *new_d_SymConst(dbg_info *db, ir_mode *mode, symconst_symbol value, symconst_kind kind)
+{
return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), mode,
value, kind, firm_unknown_type);
} /* new_d_SymConst */
-ir_node *
-new_d_Sync(dbg_info *db, int arity, ir_node *in[]) {
- return new_rd_Sync(db, current_ir_graph, current_ir_graph->current_block, arity, in);
+ir_node *new_d_Sync(dbg_info *db, int arity, ir_node *in[])
+{
+ return new_rd_Sync(db, current_ir_graph->current_block, arity, in);
} /* new_d_Sync */
-
-ir_node *
-(new_d_Bad)(void) {
- return _new_d_Bad();
-} /* new_d_Bad */
-
-ir_node *
-new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- return new_bd_Confirm(db, current_ir_graph->current_block,
- val, bound, cmp);
-} /* new_d_Confirm */
-
-ir_node *
-new_d_Unknown(ir_mode *m) {
- return new_bd_Unknown(m);
-} /* new_d_Unknown */
-
-ir_node *
-new_d_CallBegin(dbg_info *db, ir_node *call) {
- return new_bd_CallBegin(db, current_ir_graph->current_block, call);
-} /* new_d_CallBegin */
-
-ir_node *
-new_d_EndReg(dbg_info *db) {
- return new_bd_EndReg(db, current_ir_graph->current_block);
-} /* new_d_EndReg */
-
-ir_node *
-new_d_EndExcept(dbg_info *db) {
- return new_bd_EndExcept(db, current_ir_graph->current_block);
-} /* new_d_EndExcept */
-
-ir_node *
-new_d_Break(dbg_info *db) {
- return new_bd_Break(db, current_ir_graph->current_block);
-} /* new_d_Break */
-
-ir_node *
-new_d_Filter(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) {
- return new_bd_Filter(db, current_ir_graph->current_block,
- arg, mode, proj);
-} /* new_d_Filter */
-
-ir_node *
-(new_d_NoMem)(void) {
- return _new_d_NoMem();
-} /* new_d_NoMem */
-
-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 */
-
-ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
- ir_node *dst, ir_node *src, ir_type *data_type) {
- ir_node *res;
- res = new_bd_CopyB(db, current_ir_graph->current_block,
- store, dst, src, data_type);
-#if PRECISE_EXC_CONTEXT
- allocate_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr);
-#endif
- return res;
-} /* new_d_CopyB */
-
-ir_node *
-new_d_InstOf(dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type) {
- return new_bd_InstOf(db, current_ir_graph->current_block,
- store, objptr, type);
-} /* new_d_InstOf */
-
-ir_node *
-new_d_Raise(dbg_info *db, ir_node *store, ir_node *obj) {
- return new_bd_Raise(db, current_ir_graph->current_block, store, obj);
-} /* new_d_Raise */
-
-ir_node *new_d_Bound(dbg_info *db,ir_node *store,
- ir_node *idx, ir_node *lower, ir_node *upper) {
- ir_node *res;
- 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);
-#endif
- return res;
-} /* new_d_Bound */
-
-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 */
-
-ir_node *
-new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs,
- int n_outs, ir_asm_constraint *outputs,
- int n_clobber, ident *clobber[], ident *asm_text) {
- return new_bd_ASM(db, current_ir_graph->current_block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+ir_node *new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs, int n_clobber,
+ ident *clobber[], ident *text)
+{
+ return new_bd_ASM(db, current_ir_graph->current_block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
} /* new_d_ASM */
/* ********************************************************************* */
/* Block construction */
/* immature Block without predecessors */
-ir_node *
-new_d_immBlock(dbg_info *db) {
+ir_node *new_d_immBlock(dbg_info *db)
+{
ir_node *res;
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;
res->attr.block.is_matured = 0;
res->attr.block.is_dead = 0;
res->attr.block.is_mb_head = 1;
- res->attr.block.has_label = 0;
- res->attr.block.irg = current_ir_graph;
+ res->attr.block.irg.irg = current_ir_graph;
res->attr.block.backedge = NULL;
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
res->attr.block.extblk = NULL;
res->attr.block.region = NULL;
res->attr.block.mb_depth = 0;
- res->attr.block.label = 0;
+ res->attr.block.entity = NULL;
set_Block_block_visited(res, 0);
memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
/* Immature block may not be optimized! */
- IRN_VRFY_IRG(res, current_ir_graph);
+ IRN_VERIFY_IRG(res, current_ir_graph);
return res;
} /* new_d_immBlock */
-ir_node *
-new_immBlock(void) {
+ir_node *new_immBlock(void)
+{
return new_d_immBlock(NULL);
} /* new_immBlock */
/* immature PartBlock with its predecessors */
-ir_node *
-new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp) {
+ir_node *new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp)
+{
ir_node *res = new_d_immBlock(db);
ir_node *blk = get_nodes_block(pred_jmp);
return res;
} /* new_d_immPartBlock */
-ir_node *
-new_immPartBlock(ir_node *pred_jmp) {
+ir_node *new_immPartBlock(ir_node *pred_jmp)
+{
return new_d_immPartBlock(NULL, pred_jmp);
} /* new_immPartBlock */
/* add an edge to a jmp/control flow node */
-void
-add_immBlock_pred(ir_node *block, ir_node *jmp) {
+void add_immBlock_pred(ir_node *block, ir_node *jmp)
+{
int n = ARR_LEN(block->in) - 1;
+ assert(is_Block(block) && "Error: Must be a Block");
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 */
} /* add_immBlock_pred */
/* changing the current block */
-void
-set_cur_block(ir_node *target) {
+void set_cur_block(ir_node *target)
+{
current_ir_graph->current_block = target;
} /* set_cur_block */
/* parameter administration */
/* get a value from the parameter array from the current block by its index */
-ir_node *
-get_d_value(dbg_info *db, int pos, ir_mode *mode) {
+ir_node *get_d_value(dbg_info *db, int pos, ir_mode *mode)
+{
ir_graph *irg = current_ir_graph;
assert(get_irg_phase_state(irg) == phase_building);
inc_irg_visited(irg);
(void) db;
+ assert(pos >= 0);
+
return get_r_value_internal(irg->current_block, pos + 1, mode);
} /* get_d_value */
/* get a value from the parameter array from the current block by its index */
-ir_node *
-get_value(int pos, ir_mode *mode) {
+ir_node *get_value(int pos, ir_mode *mode)
+{
return get_d_value(NULL, pos, mode);
} /* get_value */
+/**
+ * helper function for guess_mode: recursively look for a definition for
+ * local variable @p pos, returns its mode if found.
+ */
+static ir_mode *guess_recursively(ir_node *block, int pos)
+{
+ ir_node *value;
+ int n_preds;
+ int i;
+
+ if (irn_visited(block))
+ return NULL;
+ mark_irn_visited(block);
+
+ /* already have a defintion -> we can simply look at its mode */
+ value = block->attr.block.graph_arr[pos];
+ if (value != NULL)
+ return get_irn_mode(value);
+
+ /* now we try to guess, by looking at the predecessor blocks */
+ n_preds = get_irn_arity(block);
+ for (i = 0; i < n_preds; ++i) {
+ ir_node *pred_block = get_Block_cfgpred_block(block, i);
+ ir_mode *mode = guess_recursively(pred_block, pos);
+ if (mode != NULL)
+ return mode;
+ }
+
+ /* no way to guess */
+ return NULL;
+}
+
+ir_mode *ir_guess_mode(int pos)
+{
+ ir_graph *irg = current_ir_graph;
+ ir_node *block = irg->current_block;
+ ir_node *value = block->attr.block.graph_arr[pos+1];
+ ir_mode *mode;
+
+ /* already have a defintion -> we can simply look at its mode */
+ if (value != NULL)
+ return get_irn_mode(value);
+
+ ir_reserve_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
+ inc_irg_visited(current_ir_graph);
+ mode = guess_recursively(block, pos+1);
+ ir_free_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
+
+ return mode;
+}
+
/* set a value at position pos in the parameter array from the current block */
-void
-set_value(int pos, ir_node *value) {
+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;
} /* set_value */
/* Find the value number for a node in the current block.*/
-int
-find_value(ir_node *value) {
+int find_value(ir_node *value)
+{
int i;
ir_node *bl = current_ir_graph->current_block;
} /* find_value */
/* get the current store */
-ir_node *
-get_store(void) {
+ir_node *get_store(void)
+{
ir_graph *irg = current_ir_graph;
assert(get_irg_phase_state(irg) == phase_building);
} /* get_store */
/* set the current store: handles automatic Sync construction for Load nodes */
-void
-set_store(ir_node *store) {
+void set_store(ir_node *store)
+{
ir_node *load, *pload, *pred, *in[2];
assert(get_irg_phase_state(current_ir_graph) == phase_building);
current_ir_graph->current_block->attr.block.graph_arr[0] = store;
} /* set_store */
-void
-keep_alive(ir_node *ka) {
+void keep_alive(ir_node *ka)
+{
add_End_keepalive(get_irg_end(current_ir_graph), ka);
} /* keep_alive */
/* --- Useful access routines --- */
/* Returns the current block of the current graph. To set the current
block use set_cur_block. */
-ir_node *get_cur_block(void) {
+ir_node *get_cur_block(void)
+{
return get_irg_current_block(current_ir_graph);
} /* get_cur_block */
/* Returns the frame type of the current graph */
-ir_type *get_cur_frame_type(void) {
+ir_type *get_cur_frame_type(void)
+{
return get_irg_frame_type(current_ir_graph);
} /* get_cur_frame_type */
/* initialize */
/* call once for each run of the library */
-void
-init_cons(uninitialized_local_variable_func_t *func) {
+void ir_set_uninitialized_local_variable_func(
+ uninitialized_local_variable_func_t *func)
+{
default_initialize_local_variable = func;
-} /* init_cons */
+}
+
+void irg_finalize_cons(ir_graph *irg)
+{
+ set_irg_phase_state(irg, phase_high);
+}
-void
-irp_finalize_cons(void) {
+void irp_finalize_cons(void)
+{
int i;
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
irg_finalize_cons(get_irp_irg(i));
}
irp->phase_state = phase_high;
-} /* irp_finalize_cons */
-
-
-ir_node *new_Block(int arity, ir_node **in) {
- return new_d_Block(NULL, arity, in);
}
-ir_node *new_Start(void) {
+
+ir_node *new_Start(void)
+{
return new_d_Start(NULL);
}
-ir_node *new_End(void) {
+ir_node *new_End(void)
+{
return new_d_End(NULL);
}
-ir_node *new_Jmp(void) {
- return new_d_Jmp(NULL);
-}
-ir_node *new_IJmp(ir_node *tgt) {
- return new_d_IJmp(NULL, tgt);
-}
-ir_node *new_Cond(ir_node *c) {
- return new_d_Cond(NULL, 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);
+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_long(ir_mode *mode, long value)
+{
return new_d_Const_long(NULL, mode, value);
}
-ir_node *new_Const_type(tarval *con, ir_type *tp) {
- return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
+ir_node *new_Const_type(tarval *con, ir_type *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) {
+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(ir_mode *mode, symconst_symbol value, symconst_kind 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) {
+ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent)
+{
return new_d_simpleSel(NULL, store, objptr, ent);
}
-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);
-}
-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_Add(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Add(NULL, op1, op2, mode);
-}
-ir_node *new_Sub(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Sub(NULL, op1, op2, mode);
-}
-ir_node *new_Minus(ir_node *op, ir_mode *mode) {
- return new_d_Minus(NULL, op, mode);
-}
-ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Mul(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);
-}
-ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_d_Quot(NULL, memop, op1, op2, mode, state);
-}
-ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_d_DivMod(NULL, memop, op1, op2, mode, state);
-}
-ir_node *new_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_Mod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state) {
- return new_d_Mod(NULL, memop, op1, op2, mode, state);
-}
-ir_node *new_Abs(ir_node *op, ir_mode *mode) {
- return new_d_Abs(NULL, op, mode);
-}
-ir_node *new_And(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_And(NULL, op1, op2, mode);
-}
-ir_node *new_Or(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Or(NULL, op1, op2, mode);
-}
-ir_node *new_Eor(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Eor(NULL, op1, op2, mode);
-}
-ir_node *new_Not(ir_node *op, ir_mode *mode) {
- return new_d_Not(NULL, op, mode);
-}
-ir_node *new_Shl(ir_node *op, ir_node *k, ir_mode *mode) {
- return new_d_Shl(NULL, op, k, mode);
-}
-ir_node *new_Shr(ir_node *op, ir_node *k, ir_mode *mode) {
- return new_d_Shr(NULL, op, k, 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_Carry(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Carry(NULL, op1, op2, mode);
-}
-ir_node *new_Borrow(ir_node *op1, ir_node *op2, ir_mode *mode) {
- return new_d_Borrow(NULL, op1, op2, mode);
-}
-ir_node *new_Cmp(ir_node *op1, ir_node *op2) {
- return new_d_Cmp(NULL, op1, op2);
-}
-ir_node *new_Conv(ir_node *op, ir_mode *mode) {
- return new_d_Conv(NULL, op, mode);
-}
-ir_node *new_strictConv(ir_node *op, ir_mode *mode) {
- return new_d_strictConv(NULL, op, mode);
-}
-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) {
+ir_node *new_Phi(int arity, ir_node **in, ir_mode *mode)
+{
return new_d_Phi(NULL, arity, in, mode);
}
-ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode) {
- return new_d_Load(NULL, store, addr, mode);
-}
-ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val) {
- return new_d_Store(NULL, store, addr, val);
-}
-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);
-}
-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);
-}
-ir_node *new_Sync(int arity, ir_node *in[]) {
+ir_node *new_Sync(int arity, ir_node *in[])
+{
return new_d_Sync(NULL, arity, in);
}
-ir_node *new_Proj(ir_node *arg, ir_mode *mode, long proj) {
- return new_d_Proj(NULL, arg, mode, proj);
-}
-ir_node *new_defaultProj(ir_node *arg, long max_proj) {
+ir_node *new_defaultProj(ir_node *arg, long max_proj)
+{
return new_d_defaultProj(NULL, arg, max_proj);
}
-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);
-}
-ir_node *new_Bad(void) {
- return new_d_Bad();
-}
-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);
-}
-ir_node *new_CallBegin(ir_node *callee) {
- return new_d_CallBegin(NULL, callee);
-}
-ir_node *new_EndReg(void) {
- return new_d_EndReg(NULL);
-}
-ir_node *new_EndExcept(void) {
- return new_d_EndExcept(NULL);
-}
-ir_node *new_Break(void) {
- return new_d_Break(NULL);
-}
-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();
-}
-ir_node *new_Mux(ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
- return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
-}
-ir_node *new_Psi(int arity, ir_node *conds[], ir_node *vals[], ir_mode *mode) {
- return new_d_Psi(NULL, arity, conds, vals, mode);
-}
-ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
- return new_d_CopyB(NULL, store, dst, src, data_type);
-}
-ir_node *new_InstOf(ir_node *store, ir_node *objptr, ir_type *ent) {
- return new_d_InstOf(NULL, store, objptr, ent);
-}
-ir_node *new_Raise(ir_node *store, ir_node *obj) {
- return new_d_Raise(NULL, store, 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);
+ir_node *new_Bad(void)
+{
+ return get_irg_bad(current_ir_graph);
}
-ir_node *new_Pin(ir_node *node) {
- return new_d_Pin(NULL, node);
+ir_node *new_NoMem(void)
+{
+ return get_irg_no_mem(current_ir_graph);
}
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) {
- return new_d_ASM(NULL, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+ int n_clobber, ident *clobber[], ident *text)
+{
+ return new_d_ASM(NULL, arity, in, inputs, n_outs, outputs, n_clobber, clobber, text);
}
/* create a new anchor node */
-ir_node *new_Anchor(ir_graph *irg) {
+ir_node *new_Anchor(ir_graph *irg)
+{
ir_node *in[anchor_last];
+ ir_node *res;
memset(in, 0, sizeof(in));
- return new_ir_node(NULL, irg, NULL, op_Anchor, mode_ANY, anchor_last, in);
+ res = new_ir_node(NULL, irg, NULL, op_Anchor, mode_ANY, anchor_last, in);
+
+ /* hack to get get_irn_irg working: set block to ourself and allow
+ * get_Block_irg for anchor */
+ res->attr.irg.irg = irg;
+ res->in[0] = res;
+
+ return res;
}
projects / libfirm / blobdiff