/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Martin Trapp, Christian Schaefer
-**
-** ircons.c: basic and more detailed irnode constructors
-** store, block and parameter administration.
-** Adapted to extended FIRM nodes (exceptions...) and commented
-** by Goetz Lindenmaier
+* All rights reserved.
+*
+* Authors: Martin Trapp, Christian Schaefer
+*
+* ircons.c: basic and more detailed irnode constructors
+* store, block and parameter administration.
+* Adapted to extended FIRM nodes (exceptions...) and commented
+* by Goetz Lindenmaier
*/
/* $Id$ */
# include "irnode_t.h"
# include "irmode_t.h"
# include "ircons.h"
-# include "common_t.h"
+# include "firm_common_t.h"
# include "irvrfy.h"
# include "irop.h"
# include "iropt_t.h"
# include "array.h"
/* memset belongs to string.h */
# include "string.h"
+# include "irbackedge_t.h"
#if USE_EXPLICIT_PHI_IN_STACK
/* A stack needed for the automatic Phi node construction in constructor
/* Constructs a Block with a fixed number of predecessors.
Does not set current_block. Can not be used with automatic
Phi node construction. */
-inline ir_node *
-new_r_Block (ir_graph *irg, int arity, ir_node **in)
+INLINE ir_node *
+new_rd_Block (dbg_info* db, ir_graph *irg, int arity, ir_node **in)
{
ir_node *res;
- res = new_ir_node (irg, NULL, op_Block, mode_R, arity, in);
+ res = new_ir_node (db, irg, NULL, op_Block, mode_BB, arity, in);
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.backedge = new_backedge_arr(irg->obst, arity);
+ res->attr.block.in_cg = NULL;
+ res->attr.block.cg_backedge = NULL;
+
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_Start (ir_graph *irg, ir_node *block)
+INLINE ir_node *
+new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
- res = new_ir_node (irg, block, op_Start, mode_T, 0, NULL);
+ res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_End (ir_graph *irg, ir_node *block)
+INLINE ir_node *
+new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
- res = new_ir_node (irg, block, op_End, mode_X, -1, NULL);
+ res = new_ir_node (db, irg, block, op_End, mode_X, -1, NULL);
irn_vrfy (res);
return res;
/* Creates a Phi node with all predecessors. Calling this constructor
is only allowed if the corresponding block is mature. */
-ir_node *
-new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
+INLINE 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;
assert( get_Block_matured(block) );
assert( get_irn_arity(block) == arity );
- res = new_ir_node (irg, block, op_Phi, mode, arity, in);
+ res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
- res = optimize (res);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
+
+ res = optimize_node (res);
irn_vrfy (res);
/* Memory Phis in endless loops must be kept alive.
return res;
}
-ir_node *
-new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+INLINE ir_node *
+new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
{
ir_node *res;
- res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
+ res = new_ir_node (db, irg, block, op_Const, mode, 0, NULL);
res->attr.con = con;
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
#if 0
return res;
}
-ir_node *
-new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
+INLINE ir_node *
+new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
{
ir_node *in[1] = {val};
ir_node *res;
- res = new_ir_node (irg, block, op_Id, mode, 1, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Id, mode, 1, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
+INLINE ir_node *
+new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
long proj)
{
ir_node *in[1] = {arg};
ir_node *res;
- res = new_ir_node (irg, block, op_Proj, mode, 1, in);
+ res = new_ir_node (db, irg, block, op_Proj, mode, 1, in);
res->attr.proj = proj;
assert(res);
assert(get_Proj_pred(res));
assert(get_nodes_Block(get_Proj_pred(res)));
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
+INLINE ir_node *
+new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
long max_proj)
{
ir_node *res;
- assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_I));
+ assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu));
arg->attr.c.kind = fragmentary;
arg->attr.c.default_proj = max_proj;
- res = new_r_Proj (irg, block, arg, mode_X, max_proj);
+ res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
return res;
}
-ir_node *
-new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
+INLINE ir_node *
+new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
{
ir_node *in[1] = {op};
ir_node *res;
- res = new_ir_node (irg, block, op_Conv, mode, 1, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Conv, mode, 1, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
+INLINE ir_node *
+new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
ir_node *res;
- res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Tuple, mode_T, arity, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Add (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Add, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Add, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Sub (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Sub, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Sub, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Minus (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
ir_node *in[1] = {op};
ir_node *res;
- res = new_ir_node (irg, block, op_Minus, mode, 1, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Minus, mode, 1, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Mul (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Mul, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Mul, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Quot (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *in[3] = {memop, op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Quot, mode_T, 3, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Quot, mode_T, 3, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_DivMod (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *in[3] = {memop, op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_DivMod, mode_T, 3, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_DivMod, mode_T, 3, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Div (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *in[3] = {memop, op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Div, mode_T, 3, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Div, mode_T, 3, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Mod (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *in[3] = {memop, op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Mod, mode_T, 3, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Mod, mode_T, 3, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_And (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_And, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_And, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Or (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Or, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Or, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Eor (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Eor, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Eor, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Not (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
ir_node *in[1] = {op};
ir_node *res;
- res = new_ir_node (irg, block, op_Not, mode, 1, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Not, mode, 1, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Shl (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
ir_node *in[2] = {op, k};
ir_node *res;
- res = new_ir_node (irg, block, op_Shl, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Shl, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Shr (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
ir_node *in[2] = {op, k};
ir_node *res;
- res = new_ir_node (irg, block, op_Shr, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Shr, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Shrs (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
ir_node *in[2] = {op, k};
ir_node *res;
- res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Shrs, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Rot (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
ir_node *in[2] = {op, k};
ir_node *res;
- res = new_ir_node (irg, block, op_Rot, mode, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Rot, mode, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Abs (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
ir_node *in[1] = {op};
ir_node *res;
- res = new_ir_node (irg, block, op_Abs, mode, 1, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Abs, mode, 1, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Cmp (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2)
{
ir_node *in[2] = {op1, op2};
ir_node *res;
- res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Cmp, mode_T, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Jmp (ir_graph *irg, ir_node *block)
+INLINE ir_node *
+new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
{
- ir_node *in[0] = {};
ir_node *res;
- res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
+INLINE ir_node *
+new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
{
ir_node *in[1] = {c};
ir_node *res;
- res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
+ res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, in);
res->attr.c.kind = dense;
res->attr.c.default_proj = 0;
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
ir_node *
-new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node **in, type *type)
+new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *callee, int arity, ir_node **in, type *tp)
{
ir_node **r_in;
ir_node *res;
r_in[1] = callee;
memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
- res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
+ res = new_ir_node (db, irg, block, op_Call, mode_T, r_arity, r_in);
- assert(is_method_type(type));
- set_Call_type(res, type);
- res = optimize (res);
+ assert(is_method_type(tp));
+ set_Call_type(res, tp);
+ res->attr.call.callee_arr = NULL;
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
ir_node *
-new_r_Return (ir_graph *irg, ir_node *block,
+new_rd_Return (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, int arity, ir_node **in)
{
ir_node **r_in;
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 (irg, block, op_Return, mode_X, r_arity, r_in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Return, mode_X, r_arity, r_in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
+INLINE ir_node *
+new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
{
ir_node *in[2] = {store, obj};
ir_node *res;
- res = new_ir_node (irg, block, op_Raise, mode_T, 2, in);
- res = optimize (res);
+ res = new_ir_node (db, irg, block, op_Raise, mode_T, 2, in);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Load (ir_graph *irg, ir_node *block,
+INLINE ir_node *
+new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr)
{
ir_node *in[2] = {store, adr};
ir_node *res;
- res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
+ res = new_ir_node (db, irg, block, op_Load, mode_T, 2, in);
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Store (ir_graph *irg, ir_node *block,
+INLINE 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 *in[3] = {store, adr, val};
ir_node *res;
- res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
+ res = new_ir_node (db, irg, block, op_Store, mode_T, 3, in);
+
+ res = optimize_node (res);
- res = optimize (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
+INLINE ir_node *
+new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
ir_node *size, type *alloc_type, where_alloc where)
{
ir_node *in[2] = {store, size};
ir_node *res;
- res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
+ res = new_ir_node (db, irg, block, op_Alloc, mode_T, 2, in);
res->attr.a.where = where;
res->attr.a.type = alloc_type;
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
+INLINE ir_node *
+new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
ir_node *ptr, ir_node *size, type *free_type)
{
ir_node *in[3] = {store, ptr, size};
ir_node *res;
- res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
+ res = new_ir_node (db, irg, block, op_Free, mode_T, 3, in);
res->attr.f = free_type;
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
+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, entity *ent)
{
ir_node **r_in;
int r_arity;
r_arity = arity + 2;
- NEW_ARR_A (ir_node *, r_in, r_arity);
+ NEW_ARR_A (ir_node *, r_in, r_arity); /* uses alloca */
r_in[0] = store;
r_in[1] = objptr;
memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
- res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
+ res = new_ir_node (db, irg, block, op_Sel, mode_P, r_arity, r_in);
- res->attr.s.ltyp = static_linkage;
res->attr.s.ent = ent;
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-inline ir_node *
-new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id_p value,
+ir_node *
+new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *objptr, type *ent)
+{
+ ir_node **r_in;
+ ir_node *res;
+ int r_arity;
+
+ r_arity = 2;
+ NEW_ARR_A (ir_node *, r_in, r_arity);
+ r_in [0] = store;
+ r_in [1] = objptr;
+
+ res = new_ir_node (db, irg, block, op_Sel, mode_T, r_arity, r_in);
+
+ res->attr.io.ent = ent;
+
+ /* res = optimize (res);
+ * irn_vrfy (res); */
+ return (res);
+}
+
+INLINE ir_node *
+new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, type_or_id_p value,
symconst_kind symkind)
{
- ir_node *in[0] = {};
ir_node *res;
ir_mode *mode;
if (symkind == linkage_ptr_info)
- mode = mode_p;
+ mode = mode_P;
else
- mode = mode_I;
- res = new_ir_node (irg, block, op_SymConst, mode, 0, in);
+ mode = mode_Iu;
+ res = new_ir_node (db, irg, block, op_SymConst, mode, 0, NULL);
res->attr.i.num = symkind;
if (symkind == linkage_ptr_info) {
&& (is_type(value)));
res->attr.i.tori.typ = (type *)value;
}
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
+INLINE ir_node *
+new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
ir_node *res;
- res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
+ res = new_ir_node (db, irg, block, op_Sync, mode_M, arity, in);
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
-ir_node *
-new_r_Bad ()
+INLINE ir_node *
+new_rd_Bad ()
{
return current_ir_graph->bad;
}
+INLINE ir_node *
+new_rd_Unknown ()
+{
+ return current_ir_graph->unknown;
+}
+
+INLINE ir_node *
+new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
+{
+ ir_node *in[1] = { get_Call_ptr(call) };
+ ir_node *res;
+ 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 (res);
+ return res;
+}
+
+INLINE 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);
+ res->attr.end.irg = irg;
+
+ irn_vrfy (res);
+ return res;
+}
+
+INLINE 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);
+ res->attr.end.irg = irg;
+
+ irn_vrfy (res);
+ return res;
+}
+
+INLINE ir_node *
+new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
+{
+ ir_node *res;
+ res = new_ir_node (db, irg, block, op_Break, mode_X, 0, NULL);
+ res = optimize_node (res);
+ irn_vrfy (res);
+ return res;
+}
+
+INLINE ir_node *
+new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
+ long proj)
+{
+ ir_node *in[1] = {arg};
+ ir_node *res;
+ res = new_ir_node (db, irg, block, op_Filter, mode, 1, in);
+ res->attr.filter.proj = proj;
+ res->attr.filter.in_cg = NULL;
+ res->attr.filter.backedge = NULL;
+
+ assert(res);
+ assert(get_Proj_pred(res));
+ assert(get_nodes_Block(get_Proj_pred(res)));
+
+ res = optimize_node (res);
+
+ irn_vrfy (res);
+ return res;
+
+}
+
+INLINE ir_node *new_r_Block (ir_graph *irg, int arity, ir_node **in) {
+ return new_rd_Block(NULL, irg, arity, in);
+}
+INLINE ir_node *new_r_Start (ir_graph *irg, ir_node *block) {
+ return new_rd_Start(NULL, irg, block);
+}
+INLINE ir_node *new_r_End (ir_graph *irg, ir_node *block) {
+ return new_rd_End(NULL, irg, block);
+}
+INLINE ir_node *new_r_Jmp (ir_graph *irg, ir_node *block) {
+ return new_rd_Jmp(NULL, irg, block);
+}
+INLINE ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c) {
+ return new_rd_Cond(NULL, irg, block, c);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
+ type_or_id_p value, symconst_kind symkind) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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) {
+ return new_rd_Eor(NULL, irg, block, op1, op2, mode);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE ir_node *new_r_Load (ir_graph *irg, ir_node *block,
+ ir_node *store, ir_node *adr) {
+ return new_rd_Load(NULL, irg, block, store, adr);
+}
+INLINE 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);
+}
+INLINE ir_node *new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *size, type *alloc_type, where_alloc where) {
+ return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
+}
+INLINE ir_node *new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *ptr, ir_node *size, type *free_type) {
+ return new_rd_Free(NULL, irg, block, store, ptr, size, free_type);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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);
+}
+INLINE 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 );
+}
+INLINE 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);
+}
+INLINE ir_node *new_r_Bad () {
+ return new_rd_Bad();
+}
+INLINE ir_node *new_r_Unknown () {
+ return new_rd_Unknown();
+}
+INLINE ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
+ return new_rd_CallBegin(NULL, irg, block, callee);
+}
+INLINE ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
+ return new_rd_EndReg(NULL, irg, block);
+}
+INLINE ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
+ return new_rd_EndExcept(NULL, irg, block);
+}
+INLINE ir_node *new_r_Break (ir_graph *irg, ir_node *block) {
+ return new_rd_Break(NULL, irg, block);
+}
+INLINE 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);
+}
+
+
/** ********************/
/** public interfaces */
/** construction tools */
-/****f* ircons/new_Start
+/**
*
- * NAME
- * new_Start -- create a new Start node in the current block
+ * - create a new Start node in the current block
*
- * SYNOPSIS
- * s = new_Start(void);
- * ir_node* new_Start(void);
+ * @return s - pointer to the created Start node
*
- * RESULT
- * s - pointer to the created Start node
*
- ****
*/
ir_node *
-new_Start (void)
+new_d_Start (dbg_info* db)
{
ir_node *res;
- res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
+ res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
op_Start, mode_T, 0, NULL);
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
}
ir_node *
-new_End (void)
+new_d_End (dbg_info* db)
{
ir_node *res;
- res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
+ res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
op_End, mode_X, -1, NULL);
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
return res;
Does set current_block. Can be used with automatic Phi
node construction. */
ir_node *
-new_Block (int arity, ir_node **in)
+new_d_Block (dbg_info* db, int arity, ir_node **in)
{
ir_node *res;
- res = new_r_Block (current_ir_graph, arity, in);
+ res = new_rd_Block (db, current_ir_graph, arity, in);
/* Create and initialize array for Phi-node construction. */
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);
- res = optimize (res);
+ res = optimize_node (res);
current_ir_graph->current_block = res;
irn_vrfy (res);
/*
ir_node *phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
- ir_node *new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
- ir_node *new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
+ ir_node *new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
+ ir_node *new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, ir_node **in, int ins)
Call Graph: ( A ---> B == A "calls" B)
| |
| |
\|/ \|/
- new_r_Phi0 new_r_Phi_in
+ new_rd_Phi0 new_rd_Phi_in
* *************************************************************************** */
/* Creates a Phi node with 0 predecessors */
-inline ir_node *
-new_r_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 (irg, block, op_Phi, mode, 0, NULL);
+ res = new_ir_node (NULL, irg, block, op_Phi, mode, 0, NULL);
irn_vrfy (res);
return res;
}
#if USE_FAST_PHI_CONSTRUCTION
/* This is a stack used for allocating and deallocating nodes in
- new_r_Phi_in. The original implementation used the obstack
+ new_rd_Phi_in. The original implementation used the obstack
to model this stack, now it is explicit. This reduces side effects.
*/
#if USE_EXPLICIT_PHI_IN_STACK
-Phi_in_stack *
+INLINE Phi_in_stack *
new_Phi_in_stack() {
Phi_in_stack *res;
return res;
}
-void
+INLINE void
free_Phi_in_stack(Phi_in_stack *s) {
DEL_ARR_F(s->stack);
free(s);
}
-
-void free_to_Phi_in_stack(ir_node *phi) {
+static INLINE void
+free_to_Phi_in_stack(ir_node *phi) {
assert(get_irn_opcode(phi) == iro_Phi);
if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
(current_ir_graph->Phi_in_stack->pos)++;
}
-ir_node *
+static INLINE ir_node *
alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
int arity, ir_node **in) {
ir_node *res;
if (pos == 0) {
/* We need to allocate a new node */
- res = new_ir_node (irg, block, op_Phi, mode, arity, in);
+ res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
} else {
/* reuse the old node and initialize it again. */
res = stack[pos-1];
res->visited = 0;
res->link = NULL;
assert (arity >= 0);
- /* ???!!! How to free the old in array?? */
+ /* ???!!! How to free the old in array?? Not at all: on obstack ?!! */
res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
res->in[0] = block;
memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
finds a pointer to itself and, when this routine is called again,
eliminates itself.
*/
-inline ir_node *
-new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
+static INLINE ir_node *
+new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
ir_node **in, int ins)
{
int i;
#if USE_EXPLICIT_PHI_IN_STACK
res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
#else
- res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
+ res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
#endif
/* The in-array can contain NULLs. These were returned by
get_r_value_internal if it reached the same block/definition on a
#endif
res = known;
} else {
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
}
return res;
}
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
-/** This function computes the predecessors for a real Phi node, and then
+/**
allocates and returns this node. The routine called to allocate the
node might optimize it away and return a real value, or even a pointer
to a deallocated Phi node on top of the obstack!
This function is called with an in-array of proper size. **/
-static inline ir_node *
+static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
{
ir_node *prevBlock, *res;
allocated for the first path (recursion) is returned. We already
know the address of this node, as it is the next node to be allocated
and will be placed on top of the obstack. (The obstack is a _stack_!) */
- res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
+ res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
/* Now we now the value for "pos" and can enter it in the array with
all known local variables. Attention: this might be a pointer to
- a node, that later will be allocated!!! See new_r_Phi_in.
+ a node, that later will be allocated!!! See new_rd_Phi_in.
If this is called in mature, after some set_value in the same block,
the proper value must not be overwritten:
The call order
this variable was last defined in a previous block, Phi nodes are
inserted. If the part of the firm graph containing the definition
is not yet constructed, a dummy Phi node is returned. */
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
{
ir_node *res;
We return this information "Two paths, no Phi needed" by a very tricky
implementation that relies on the fact that an obstack is a stack and
will return a node with the same address on different allocations.
- Look also at phi_merge and new_r_phi_in to understand this.
+ Look also at phi_merge and new_rd_phi_in to understand this.
@@@ Unfortunately this does not work, see testprogram
three_cfpred_example.
Phi is computed, pos is used to update the array with the local
values. */
- res = new_r_Phi0 (current_ir_graph, block, mode);
+ res = new_rd_Phi0 (current_ir_graph, block, mode);
res->attr.phi0_pos = pos;
res->link = block->link;
block->link = 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_r_Const (current_ir_graph, block, mode,
+ assert (mode->code >= irm_F && mode->code <= irm_P);
+ res = new_rd_Const (NULL, current_ir_graph, block, mode,
tarval_mode_null[mode->code]);
}
#else /* if 0 */
-/** This is the simple algorithm. If first generates a Phi0, then
+/**
it starts the recursion. This causes an Id at the entry of
every block that has no definition of the value! **/
#if USE_EXPLICIT_PHI_IN_STACK
/* Just dummies */
-Phi_in_stack * new_Phi_in_stack() { return NULL; }
-void free_Phi_in_stack(Phi_in_stack *s) { }
+INLINE Phi_in_stack * new_Phi_in_stack() { return NULL; }
+INLINE void free_Phi_in_stack(Phi_in_stack *s) { }
#endif
-inline ir_node *
-new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
+static INLINE ir_node *
+new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
ir_node **in, int ins)
{
int i;
/* Allocate a new node on the obstack. The allocation copies the in
array. */
- res = new_ir_node (irg, block, op_Phi, mode, ins, in);
+ res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
+ res->attr.phi_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
res = new_Bad();
}
} else {
- res = optimize (res);
+ res = optimize_node (res);
irn_vrfy (res);
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of the alive. */
return res;
}
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
#if PRECISE_EXC_CONTEXT
-static inline ir_node *
+static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
-ir_node **
+static INLINE ir_node **
new_frag_arr (ir_node *n) {
ir_node **arr;
int opt;
return arr;
}
-inline ir_node **
+static INLINE ir_node **
get_frag_arr (ir_node *n) {
if (get_irn_op(n) == op_Call) {
return n->attr.call.frag_arr;
}
}
-inline ir_node *
+static void
set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
if (!frag_arr[pos]) frag_arr[pos] = val;
if (frag_arr[current_ir_graph->n_loc - 1])
set_frag_value (get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]), pos, val);
}
-inline ir_node *
+static ir_node *
get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
ir_node *res;
- ir_node **rem;
ir_node **frag_arr;
assert(is_fragile_op(cfOp) && (get_irn_op(cfOp) != op_Bad));
if (!res) {
if (block->attr.block.graph_arr[pos]) {
/* There was a set_value after the cfOp and no get_value before that
- set_value. We must build a Phi node now. */
+ set_value. We must build a Phi node now. */
if (block->attr.block.matured) {
- int ins = get_irn_arity(block);
- ir_node **nin;
- NEW_ARR_A (ir_node *, nin, ins);
- res = phi_merge(block, pos, mode, nin, ins);
+ int ins = get_irn_arity(block);
+ ir_node **nin;
+ NEW_ARR_A (ir_node *, nin, ins);
+ res = phi_merge(block, pos, mode, nin, ins);
} else {
- res = new_r_Phi0 (current_ir_graph, block, mode);
- res->attr.phi0_pos = pos;
- res->link = block->link;
- block->link = res;
+ res = new_rd_Phi0 (current_ir_graph, block, mode);
+ res->attr.phi0_pos = pos;
+ res->link = block->link;
+ block->link = res;
}
assert(res);
/* @@@ tested by Flo: set_frag_value(frag_arr, pos, res);
- but this should be better: (remove comment if this works) */
+ but this should be better: (remove comment if this works) */
/* It's a Phi, we can write this into all graph_arrs with NULL */
set_frag_value(block->attr.block.graph_arr, pos, res);
} else {
}
#endif
-/** This function allocates a dummy Phi node to break recursions,
+/**
computes the predecessors for the real phi node, and then
allocates and returns this node. The routine called to allocate the
node might optimize it away and return a real value.
- This function is called with an in-array of proper size. **/
-static inline ir_node *
+ 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)
{
ir_node *prevBlock, *prevCfOp, *res, *phi0;
There are none by definition. */
return block->attr.block.graph_arr[pos];
} else {
- phi0 = new_r_Phi0(current_ir_graph, block, mode);
+ phi0 = new_rd_Phi0(current_ir_graph, block, mode);
block->attr.block.graph_arr[pos] = phi0;
#if PRECISE_EXC_CONTEXT
/* Set graph_arr for fragile ops. Also here we should break recursion.
with these predecessors is created. This constructor contains an
optimization: If all predecessors of the Phi node are identical it
returns the only operand instead of a new Phi node. */
- res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
+ res = new_rd_Phi_in (current_ir_graph, block, mode, nin, ins);
/* In case we allocated a Phi0 node at the beginning of this procedure,
we need to exchange this Phi0 with the real Phi. */
this variable was last defined in a previous block, Phi nodes are
inserted. If the part of the firm graph containing the definition
is not yet constructed, a dummy Phi node is returned. */
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
{
ir_node *res;
The Phi0 has to remember the pos of it's internal value. If the real
Phi is computed, pos is used to update the array with the local
values. */
- res = new_r_Phi0 (current_ir_graph, block, mode);
+ res = new_rd_Phi0 (current_ir_graph, block, mode);
res->attr.phi0_pos = pos;
res->link = block->link;
block->link = 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_r_Const (current_ir_graph, block, mode,
+ 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,
tarval_mode_null[mode->code]);
}
ir_node *next;
assert (get_irn_opcode(block) == iro_Block);
- // assert (!get_Block_matured(block) && "Block already matured");
+ /* @@@ should be commented in
+ assert (!get_Block_matured(block) && "Block already matured"); */
if (!get_Block_matured(block)) {
+ ins = ARR_LEN (block->in)-1;
+ /* Fix block parameters */
+ block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
/* An array for building the Phi nodes. */
- ins = ARR_LEN (block->in)-1;
NEW_ARR_A (ir_node *, nin, ins);
- /* shouldn't we delete this array at the end of the procedure? @@@ memory leak? */
/* Traverse a chain of Phi nodes attached to this block and mature
these, too. **/
}
ir_node *
-new_Phi (int arity, ir_node **in, ir_mode *mode)
+new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode)
{
- return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Phi (db, current_ir_graph, current_ir_graph->current_block,
arity, in, mode);
}
ir_node *
-new_Const (ir_mode *mode, tarval *con)
+new_d_Const (dbg_info* db, ir_mode *mode, tarval *con)
{
- return new_r_Const (current_ir_graph, current_ir_graph->start_block,
+ return new_rd_Const (db, current_ir_graph, current_ir_graph->start_block,
mode, con);
}
ir_node *
-new_Id (ir_node *val, ir_mode *mode)
+new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
{
- return new_r_Id (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Id (db, current_ir_graph, current_ir_graph->current_block,
val, mode);
}
ir_node *
-new_Proj (ir_node *arg, ir_mode *mode, long proj)
+new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj)
{
- return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Proj (db, current_ir_graph, current_ir_graph->current_block,
arg, mode, proj);
}
ir_node *
-new_defaultProj (ir_node *arg, long max_proj)
+new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
{
ir_node *res;
- assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_I));
+ assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu));
arg->attr.c.kind = fragmentary;
arg->attr.c.default_proj = max_proj;
res = new_Proj (arg, mode_X, max_proj);
}
ir_node *
-new_Conv (ir_node *op, ir_mode *mode)
+new_d_Conv (dbg_info* db, ir_node *op, ir_mode *mode)
{
- return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Conv (db, current_ir_graph, current_ir_graph->current_block,
op, mode);
}
ir_node *
-new_Tuple (int arity, ir_node **in)
+new_d_Tuple (dbg_info* db, int arity, ir_node **in)
{
- return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Tuple (db, current_ir_graph, current_ir_graph->current_block,
arity, in);
}
ir_node *
-new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_Add (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Add (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Sub (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Minus (ir_node *op, ir_mode *mode)
+new_d_Minus (dbg_info* db, ir_node *op, ir_mode *mode)
{
- return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Minus (db, current_ir_graph, current_ir_graph->current_block,
op, mode);
}
ir_node *
-new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Mul (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *res;
- res = new_r_Quot (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block,
memop, op1, op2);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *res;
- res = new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block,
memop, op1, op2);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *res;
- res = new_r_Div (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block,
memop, op1, op2);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
+new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2)
{
ir_node *res;
- res = new_r_Mod (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block,
memop, op1, op2);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_And (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_And (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_And (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Or (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_Or (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Or (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
+new_d_Eor (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode)
{
- return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Eor (db, current_ir_graph, current_ir_graph->current_block,
op1, op2, mode);
}
ir_node *
-new_Not (ir_node *op, ir_mode *mode)
+new_d_Not (dbg_info* db, ir_node *op, ir_mode *mode)
{
- return new_r_Not (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Not (db, current_ir_graph, current_ir_graph->current_block,
op, mode);
}
ir_node *
-new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
+new_d_Shl (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
{
- return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Shl (db, current_ir_graph, current_ir_graph->current_block,
op, k, mode);
}
ir_node *
-new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
+new_d_Shr (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
{
- return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Shr (db, current_ir_graph, current_ir_graph->current_block,
op, k, mode);
}
ir_node *
-new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
+new_d_Shrs (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
{
- return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Shrs (db, current_ir_graph, current_ir_graph->current_block,
op, k, mode);
}
ir_node *
-new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
+new_d_Rot (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode)
{
- return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Rot (db, current_ir_graph, current_ir_graph->current_block,
op, k, mode);
}
ir_node *
-new_Abs (ir_node *op, ir_mode *mode)
+new_d_Abs (dbg_info* db, ir_node *op, ir_mode *mode)
{
- return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Abs (db, current_ir_graph, current_ir_graph->current_block,
op, mode);
}
ir_node *
-new_Cmp (ir_node *op1, ir_node *op2)
+new_d_Cmp (dbg_info* db, ir_node *op1, ir_node *op2)
{
- return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Cmp (db, current_ir_graph, current_ir_graph->current_block,
op1, op2);
}
ir_node *
-new_Jmp (void)
+new_d_Jmp (dbg_info* db)
{
- return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
+ return new_rd_Jmp (db, current_ir_graph, current_ir_graph->current_block);
}
ir_node *
-new_Cond (ir_node *c)
+new_d_Cond (dbg_info* db, ir_node *c)
{
- return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
+ return new_rd_Cond (db, current_ir_graph, current_ir_graph->current_block, c);
}
ir_node *
-new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
- type *type)
+new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
+ type *tp)
{
ir_node *res;
- res = new_r_Call (current_ir_graph, current_ir_graph->current_block,
- store, callee, arity, in, type);
+ res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
+ store, callee, arity, in, tp);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
(get_irn_op(res) == op_Call)) /* Could be optimized away. */
}
ir_node *
-new_Return (ir_node* store, int arity, ir_node **in)
+new_d_Return (dbg_info* db, ir_node* store, int arity, ir_node **in)
{
- return new_r_Return (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Return (db, current_ir_graph, current_ir_graph->current_block,
store, arity, in);
}
ir_node *
-new_Raise (ir_node *store, ir_node *obj)
+new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj)
{
- return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Raise (db, current_ir_graph, current_ir_graph->current_block,
store, obj);
}
ir_node *
-new_Load (ir_node *store, ir_node *addr)
+new_d_Load (dbg_info* db, ir_node *store, ir_node *addr)
{
ir_node *res;
- res = new_r_Load (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block,
store, addr);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_Store (ir_node *store, ir_node *addr, ir_node *val)
+new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val)
{
ir_node *res;
- res = new_r_Store (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block,
store, addr, val);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
+new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type,
where_alloc where)
{
ir_node *res;
- res = new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
+ res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block,
store, size, alloc_type, where);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
}
ir_node *
-new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
+new_d_Free (dbg_info* db, ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
{
- return new_r_Free (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Free (db, current_ir_graph, current_ir_graph->current_block,
store, ptr, size, free_type);
}
ir_node *
-new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
+new_d_simpleSel (dbg_info* db, ir_node *store, ir_node *objptr, 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. */
{
- return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
store, objptr, 0, NULL, ent);
}
ir_node *
-new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
+new_d_Sel (dbg_info* db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
{
- return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block,
store, objptr, n_index, index, sel);
}
ir_node *
-new_SymConst (type_or_id_p value, symconst_kind kind)
+new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
{
- return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
+ return (new_rd_InstOf (db, current_ir_graph, current_ir_graph->current_block,
+ store, objptr, ent));
+}
+
+ir_node *
+new_d_SymConst (dbg_info* db, type_or_id_p value, symconst_kind kind)
+{
+ return new_rd_SymConst (db, current_ir_graph, current_ir_graph->current_block,
value, kind);
}
ir_node *
-new_Sync (int arity, ir_node** in)
+new_d_Sync (dbg_info* db, int arity, ir_node** in)
{
- return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
+ return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block,
arity, in);
}
ir_node *
-new_Bad (void)
+new_d_Bad (void)
{
return current_ir_graph->bad;
}
+ir_node *
+new_d_Unknown (void)
+{
+ return current_ir_graph->unknown;
+}
+
+ir_node *
+new_d_CallBegin (dbg_info *db, ir_node *call)
+{
+ ir_node *res;
+ res = new_rd_CallBegin (db, current_ir_graph, current_ir_graph->current_block, call);
+ return res;
+}
+
+ir_node *
+new_d_EndReg (dbg_info *db)
+{
+ ir_node *res;
+ res = new_rd_EndReg(db, current_ir_graph, current_ir_graph->current_block);
+ return res;
+}
+
+ir_node *
+new_d_EndExcept (dbg_info *db)
+{
+ ir_node *res;
+ res = new_rd_EndExcept(db, current_ir_graph, current_ir_graph->current_block);
+ return res;
+}
+
+ir_node *
+new_d_Break (dbg_info *db)
+{
+ return new_rd_Break (db, current_ir_graph, current_ir_graph->current_block);
+}
+
+ir_node *
+new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj)
+{
+ return new_rd_Filter (db, current_ir_graph, current_ir_graph->current_block,
+ arg, mode, proj);
+}
+
/* ********************************************************************* */
/* Comfortable interface with automatic Phi node construction. */
/* (Uses also constructors of ?? interface, except new_Block. */
/** Block construction **/
/* immature Block without predecessors */
-ir_node *new_immBlock (void) {
+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 (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
+ 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.backedge = NULL;
+ res->attr.block.in_cg = NULL;
+ res->attr.block.cg_backedge = NULL;
set_Block_block_visited(res, 0);
/* Create and initialize array for Phi-node construction. */
return res;
}
+INLINE ir_node *
+new_immBlock () {
+ return new_d_immBlock(NULL);
+}
+
/* add an adge to a jmp/control flow node */
void
add_in_edge (ir_node *block, ir_node *jmp)
/* get a value from the parameter array from the current block by its index */
ir_node *
-get_value (int pos, ir_mode *mode)
+get_d_value (dbg_info* db, int pos, ir_mode *mode)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
inc_irg_visited(current_ir_graph);
+
return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
}
-
+/* get a value from the parameter array from the current block by its index */
+INLINE ir_node *
+get_value (int pos, ir_mode *mode)
+{
+ return get_d_value(NULL, pos, mode);
+}
/* set a value at position pos in the parameter array from the current block */
-inline void
+INLINE void
set_value (int pos, ir_node *value)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
+ assert(pos+1 < current_ir_graph->n_loc);
current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
}
/* get the current store */
-inline ir_node *
+INLINE ir_node *
get_store (void)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
}
/* set the current store */
-inline void
+INLINE void
set_store (ir_node *store)
{
- assert(get_irg_phase_state (current_ir_graph) == phase_building);
/* GL: one could call set_value instead */
+ assert(get_irg_phase_state (current_ir_graph) == phase_building);
current_ir_graph->current_block->attr.block.graph_arr[0] = store;
}
-inline void
+void
keep_alive (ir_node *ka)
{
add_End_keepalive(current_ir_graph->end, ka);
finalize_cons (ir_graph *irg) {
irg->phase_state = phase_high;
}
+
+
+ir_node *new_Block(int arity, ir_node **in) {
+ return new_d_Block(NULL, arity, in);
+}
+ir_node *new_Start (void) {
+ return new_d_Start(NULL);
+}
+ir_node *new_End (void) {
+ return new_d_End(NULL);
+}
+ir_node *new_Jmp (void) {
+ return new_d_Jmp(NULL);
+}
+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_Raise (ir_node *store, ir_node *obj) {
+ return new_d_Raise(NULL, store, obj);
+}
+ir_node *new_Const (ir_mode *mode, tarval *con) {
+ return new_d_Const(NULL, mode, con);
+}
+ir_node *new_SymConst (type_or_id_p value, symconst_kind kind) {
+ return new_d_SymConst(NULL, value, kind);
+}
+ir_node *new_simpleSel(ir_node *store, ir_node *objptr, 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,
+ entity *ent) {
+ 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));
+}
+ir_node *new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
+ 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_Quot (ir_node *memop, ir_node *op1, ir_node *op2) {
+ return new_d_Quot(NULL, memop, op1, op2);
+}
+ir_node *new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2) {
+ return new_d_DivMod(NULL, memop, op1, op2);
+}
+ir_node *new_Div (ir_node *memop, ir_node *op1, ir_node *op2) {
+ return new_d_Div(NULL, memop, op1, op2);
+}
+ir_node *new_Mod (ir_node *memop, ir_node *op1, ir_node *op2) {
+ return new_d_Mod(NULL, memop, op1, op2);
+}
+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);
+}
+#define new_Rotate new_Rot
+ir_node *new_Rot (ir_node *op, ir_node *k, ir_mode *mode) {
+ return new_d_Rot(NULL, op, k, 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_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) {
+ return new_d_Load(NULL, store, addr);
+}
+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, type *alloc_type,
+ 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,
+ type *free_type) {
+ return new_d_Free(NULL, store, ptr, size, free_type);
+}
+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) {
+ 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_Unknown(void) {
+ return new_d_Unknown();
+}
+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);
+}
projects / libfirm / blobdiff