* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
-
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
/* memset belongs to string.h */
# include "string.h"
# include "irbackedge_t.h"
+# include "irflag_t.h"
#if USE_EXPLICIT_PHI_IN_STACK
/* A stack needed for the automatic Phi node construction in constructor
set_Block_matured(res, 1);
set_Block_block_visited(res, 0);
- res->attr.block.exc = exc_normal;
- res->attr.block.handler_entry = 0;
+ //res->attr.block.exc = exc_normal;
+ //res->attr.block.handler_entry = 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;
ir_node *res;
res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
- res->attr.start.irg = irg;
+ //res->attr.start.irg = irg;
irn_vrfy_irg (res, irg);
return res;
int i;
bool has_unknown = false;
- assert( get_Block_matured(block) );
- assert( get_irn_arity(block) == arity );
+ /* Don't assert that block matured: the use of this constructor is strongly
+ restricted ... */
+ if ( get_Block_matured(block) )
+ assert( get_irn_arity(block) == arity );
res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
ir_node *res;
int r_arity;
+ assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
+
r_arity = arity + 2;
NEW_ARR_A (ir_node *, r_in, r_arity); /* uses alloca */
r_in[0] = store;
}
INLINE ir_node *
-new_rd_Unknown (ir_graph *irg)
+new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
{
- return irg->unknown;
+ ir_node *in[2], *res;
+ 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;
+}
+
+INLINE ir_node *
+new_rd_Unknown (ir_graph *irg, ir_mode *m)
+{
+ return new_ir_node (NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
}
INLINE ir_node *
ir_node *res;
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.irg = irg;
res->attr.callbegin.call = call;
res = optimize_node (res);
irn_vrfy_irg (res, irg);
ir_node *res;
res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL);
- res->attr.end.irg = irg;
+ //res->attr.end.irg = irg;
irn_vrfy_irg (res, irg);
return res;
ir_node *res;
res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL);
- res->attr.end.irg = irg;
+ //res->attr.end.irg = irg;
irn_vrfy_irg (res, irg);
return res;
}
+ir_node *
+new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block,
+ ir_node *callee, int arity, ir_node **in, type *tp)
+{
+ ir_node **r_in;
+ ir_node *res;
+ int r_arity;
+
+ r_arity = arity+1;
+ NEW_ARR_A (ir_node *, r_in, r_arity);
+ r_in[0] = callee;
+ memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
+
+ res = new_ir_node (db, irg, block, op_FuncCall, mode_T, r_arity, r_in);
+
+ assert(is_method_type(tp));
+ set_FuncCall_type(res, tp);
+ res->attr.call.callee_arr = NULL;
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
+ return res;
+}
+
+
INLINE ir_node *new_r_Block (ir_graph *irg, int arity, ir_node **in) {
return new_rd_Block(NULL, irg, arity, in);
}
return new_rd_SymConst(NULL, irg, block, value, symkind);
}
INLINE ir_node *new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *objptr, int n_index, ir_node **index,
- entity *ent) {
+ ir_node *objptr, int n_index, ir_node **index,
+ entity *ent) {
return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
}
INLINE ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
- type *ent) {
+ type *ent) {
return (new_rd_InstOf (NULL, irg, block, store, objptr, ent));
}
INLINE ir_node *new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node **in,
- type *tp) {
+ ir_node *callee, int arity, ir_node **in,
+ type *tp) {
return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
}
INLINE ir_node *new_r_Add (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Add(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Sub (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Sub(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Minus (ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
+ ir_node *op, ir_mode *mode) {
return new_rd_Minus(NULL, irg, block, op, mode);
}
INLINE ir_node *new_r_Mul (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Mul(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Quot (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Quot(NULL, irg, block, memop, op1, op2);
}
INLINE ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_DivMod(NULL, irg, block, memop, op1, op2);
}
INLINE ir_node *new_r_Div (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Div(NULL, irg, block, memop, op1, op2);
}
INLINE ir_node *new_r_Mod (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Mod(NULL, irg, block, memop, op1, op2);
}
INLINE ir_node *new_r_Abs (ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
+ ir_node *op, ir_mode *mode) {
return new_rd_Abs(NULL, irg, block, op, mode);
}
INLINE ir_node *new_r_And (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_And(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Or (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Or(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Eor (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Eor(NULL, irg, block, op1, op2, mode);
}
INLINE ir_node *new_r_Not (ir_graph *irg, ir_node *block,
INLINE ir_node *new_r_Bad (ir_graph *irg) {
return new_rd_Bad(irg);
}
-INLINE ir_node *new_r_Unknown (ir_graph *irg) {
- return new_rd_Unknown(irg);
+INLINE 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);
+}
+INLINE ir_node *new_r_Unknown (ir_graph *irg, ir_mode *m) {
+ return new_rd_Unknown(irg, m);
}
INLINE ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
return new_rd_CallBegin(NULL, irg, block, callee);
ir_mode *mode, long proj) {
return new_rd_Filter(NULL, irg, block, arg, mode, proj);
}
+INLINE ir_node *new_r_FuncCall (ir_graph *irg, ir_node *block,
+ ir_node *callee, int arity, ir_node **in,
+ type *tp) {
+ return new_rd_FuncCall(NULL, irg, block, callee, arity, in, tp);
+}
/** ********************/
res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
op_Start, mode_T, 0, NULL);
- res->attr.start.irg = current_ir_graph;
+ //res->attr.start.irg = current_ir_graph;
res = optimize_node (res);
irn_vrfy_irg (res, current_ir_graph);
*/
#if USE_EXPLICIT_PHI_IN_STACK
INLINE Phi_in_stack *
-new_Phi_in_stack() {
+new_Phi_in_stack(void) {
Phi_in_stack *res;
res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
-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;
arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
sizeof(ir_node *)*current_ir_graph->n_loc);
/* turn off optimization before allocating Proj nodes, as res isn't
finished yet. */
- opt = get_optimize(); set_optimize(0);
+ 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, 3);
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);
+ arity, in);
}
}
ir_node *
-new_d_Unknown (void)
+new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
{
- return current_ir_graph->unknown;
+ return new_rd_Confirm (db, current_ir_graph, current_ir_graph->current_block,
+ val, bound, cmp);
+}
+
+ir_node *
+new_d_Unknown (ir_mode *m)
+{
+ return new_rd_Unknown(current_ir_graph, m);
}
ir_node *
arg, mode, proj);
}
+ir_node *
+new_d_FuncCall (dbg_info* db, ir_node *callee, int arity, ir_node **in,
+ type *tp)
+{
+ ir_node *res;
+ res = new_rd_FuncCall (db, current_ir_graph, current_ir_graph->current_block,
+ callee, arity, in, tp);
+
+ return res;
+}
+
/* ********************************************************************* */
/* Comfortable interface with automatic Phi node construction. */
/* (Uses also constructors of ?? interface, except new_Block. */
res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
current_ir_graph->current_block = res;
res->attr.block.matured = 0;
- res->attr.block.exc = exc_normal;
- res->attr.block.handler_entry = 0;
+ //res->attr.block.exc = exc_normal;
+ //res->attr.block.handler_entry = 0;
+ res->attr.block.irg = current_ir_graph;
res->attr.block.backedge = NULL;
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
return new_d_Sel(NULL, store, objptr, arity, in, ent);
}
ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
- return (new_d_InstOf (NULL, store, objptr, ent));
+ return new_d_InstOf (NULL, store, objptr, ent);
}
ir_node *new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
type *tp) {
ir_node *new_Bad (void) {
return new_d_Bad();
}
-ir_node *new_Unknown(void) {
- return new_d_Unknown();
+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_Filter (ir_node *arg, ir_mode *mode, long proj) {
return new_d_Filter(NULL, arg, mode, proj);
}
+ir_node *new_FuncCall (ir_node *callee, int arity, ir_node **in, type *tp) {
+ return new_d_FuncCall(NULL, callee, arity, in, tp);
+}