if (get_kind(tore) == k_entity) {
entity *ent = (entity *)tore;
- if ((is_method_type(get_entity_type(ent))) &&
- (get_entity_peculiarity(ent) != peculiarity_description) &&
- (get_entity_visibility(ent) != visibility_external_allocated) ) {
+ if ((is_Method_type(get_entity_type(ent))) &&
+ (get_entity_peculiarity(ent) != peculiarity_description) &&
+ (get_entity_visibility(ent) != visibility_external_allocated) ) {
entity *impl = get_SymConst_entity(get_atomic_ent_value(ent));
if (get_entity_link(impl) != env) {
- set_entity_peculiarity(ent, peculiarity_description);
- //set_atomic_ent_value(ent, new_r_Const(get_const_code_irg(), get_irg_start_block(get_const_code_irg()),
- // mode_P, get_tarval_null(mode_P)));
+ set_entity_peculiarity(ent, peculiarity_description);
+ //set_atomic_ent_value(ent, new_r_Const(get_const_code_irg(), get_irg_start_block(get_const_code_irg()),
+ // mode_P, get_tarval_null(mode_P)));
}
}
}
/* 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 *
+ir_node *
new_rd_Block (dbg_info* db, ir_graph *irg, int arity, ir_node **in)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
/* Creates a Phi node with all predecessors. Calling this constructor
is only allowed if the corresponding block is mature. */
-INLINE ir_node *
+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;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
{
type *tp = firm_unknown_type;
return new_rd_Const_type (db, irg, block, mode, con, tp);
}
-INLINE ir_node *
+ir_node *
new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
long proj)
{
}
-INLINE ir_node *
+ir_node *
new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
long max_proj)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
{
ir_node *res;
- assert(is_atomic_type(to_tp));
+ assert(is_Atomic_type(to_tp));
res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
res->attr.cast.totype = to_tp;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
{
ir_node *res;
res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in);
- assert((get_unknown_type() == tp) || is_method_type(tp));
+ 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;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
{
ir_node *in[2];
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr, ir_mode *mode)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr, ir_node *val)
{
return res;
}
-INLINE ir_node *
+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)
{
return res;
}
-INLINE ir_node *
+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)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_SymConst_type (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
symconst_kind symkind, type *tp) {
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
symconst_kind symkind)
{
return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp);
}
-INLINE ir_node *
+ir_node *
new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Bad (ir_graph *irg)
{
return irg->bad;
}
-INLINE ir_node *
+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 *in[2], *res;
return res;
}
-INLINE ir_node *
+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 *
new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
{
ir_node *in[1];
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
{
ir_node *res;
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
long proj)
{
return res;
}
-INLINE ir_node *
+ir_node *
new_rd_NoMem (ir_graph *irg) {
return irg->no_mem;
}
-INLINE ir_node *
+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)
{
}
-INLINE ir_node *new_r_Block (ir_graph *irg, int arity, ir_node **in) {
+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) {
+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) {
+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) {
+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) {
+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 *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 *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_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,
+ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
symconst_symbol 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 *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,
+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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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_Cast (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
+ir_node *new_r_Cast (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
return new_rd_Cast(NULL, irg, block, op, to_tp);
}
-INLINE ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity,
+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 *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);
}
-INLINE ir_node *new_r_Store (ir_graph *irg, ir_node *block,
+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 *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 *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) {
+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_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,
+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,
+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 *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 (ir_graph *irg) {
+ir_node *new_r_Bad (ir_graph *irg) {
return new_rd_Bad(irg);
}
-INLINE ir_node *new_r_Confirm (ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
+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) {
+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) {
+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) {
+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) {
+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) {
+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_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);
}
-INLINE ir_node *new_r_NoMem (ir_graph *irg) {
+ir_node *new_r_NoMem (ir_graph *irg) {
return new_rd_NoMem(irg);
}
-INLINE ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
+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);
}
to model this stack, now it is explicit. This reduces side effects.
*/
#if USE_EXPLICIT_PHI_IN_STACK
-INLINE Phi_in_stack *
+Phi_in_stack *
new_Phi_in_stack(void) {
Phi_in_stack *res;
return res;
}
-INLINE void
+void
free_Phi_in_stack(Phi_in_stack *s) {
DEL_ARR_F(s->stack);
free(s);
#if USE_EXPLICIT_PHI_IN_STACK
/* Just dummies */
-INLINE Phi_in_stack * new_Phi_in_stack() { return NULL; }
-INLINE void free_Phi_in_stack(Phi_in_stack *s) { }
+Phi_in_stack * new_Phi_in_stack() { return NULL; }
+void free_Phi_in_stack(Phi_in_stack *s) { }
#endif
static INLINE ir_node *
return res;
}
-INLINE ir_node *
+ir_node *
new_immBlock (void) {
return new_d_immBlock(NULL);
}
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 *
+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
+void
set_value (int pos, ir_node *value)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
}
/* get the current store */
-INLINE ir_node *
+ir_node *
get_store (void)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
}
/* set the current store */
-INLINE void
+void
set_store (ir_node *store)
{
/* GL: one could call set_value instead */
fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
- if(is_class_type(get_entity_owner(ent))) {
+ if (is_Class_type(get_entity_owner(ent))) {
for(i = 0; i < get_entity_n_overwrites(ent); i++)
print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, ENT_OVERWRITES_EDGE_ATTR);
}
case k_entity: {
entity *ent = (entity *)tore;
if (get_entity_owner(ent) == get_glob_type()) break;
- if (!is_method_type(get_entity_type(ent))) break; /* GL */
- if (env->dump_ent && is_class_type(get_entity_owner(ent))) {
+ if (!is_Method_type(get_entity_type(ent))) break; /* GL */
+ if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
/* The node */
dump_entity_node(F, ent, 0);
/* The edges */
fprintf(F, "%s type: %s (%ld)\n", prefix, get_type_name(type), get_type_nr(type));
fprintf(F, "%s owner: %s (%ld)\n", prefix, get_type_name(owner), get_type_nr(owner));
- if (is_class_type(get_entity_owner(ent))) {
+ if (is_Class_type(get_entity_owner(ent))) {
if (get_entity_n_overwrites(ent) > 0) {
fprintf(F, "%s overwrites:\n", prefix);
for (i = 0; i < get_entity_n_overwrites(ent); ++i) {
} else { /* no entattrs */
fprintf(F, "%s(%3d) %*s: %s", prefix,
get_entity_offset_bits(ent), -40, get_type_name(get_entity_type(ent)), get_entity_name(ent));
- if (is_method_type(get_entity_type(ent))) fprintf(F, "(...)");
+ if (is_Method_type(get_entity_type(ent))) fprintf(F, "(...)");
if (verbosity & dump_verbosity_accessStats) {
if (get_entity_allocation(ent) == allocation_static) fprintf(F, " (stat)");
if (verbosity & dump_verbosity_entconsts) {
if (get_entity_variability(ent) != variability_uninitialized) {
if (is_atomic_entity(ent)) {
- fprintf(F, "%s atomic value: ", prefix);
- dump_node_opcode(F, get_atomic_ent_value(ent));
+ fprintf(F, "%s atomic value: ", prefix);
+ dump_node_opcode(F, get_atomic_ent_value(ent));
} else {
- fprintf(F, "%s compound values:", prefix);
- for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
- compound_graph_path *path = get_compound_ent_value_path(ent, i);
- entity *ent0 = get_compound_graph_path_node(path, 0);
- fprintf(F, "\n%s %3d ", prefix, get_entity_offset_bits(ent0));
- if (get_type_state(type) == layout_fixed)
- fprintf(F, "(%3d) ", get_compound_ent_value_offset_bits(ent, i));
- fprintf(F, "%s", get_entity_name(ent0));
- for (j = 0; j < get_compound_graph_path_length(path); ++j) {
- entity *node = get_compound_graph_path_node(path, j);
- fprintf(F, ".%s", get_entity_name(node));
- if (is_array_type(get_entity_owner(node)))
- fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j));
- }
- fprintf(F, "\t = ");
- dump_node_opcode(F, get_compound_ent_value(ent, i));
- }
+ fprintf(F, "%s compound values:", prefix);
+ for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
+ compound_graph_path *path = get_compound_ent_value_path(ent, i);
+ entity *ent0 = get_compound_graph_path_node(path, 0);
+ fprintf(F, "\n%s %3d ", prefix, get_entity_offset_bits(ent0));
+ if (get_type_state(type) == layout_fixed)
+ fprintf(F, "(%3d) ", get_compound_ent_value_offset_bits(ent, i));
+ fprintf(F, "%s", get_entity_name(ent0));
+ for (j = 0; j < get_compound_graph_path_length(path); ++j) {
+ entity *node = get_compound_graph_path_node(path, j);
+ fprintf(F, ".%s", get_entity_name(node));
+ if (is_Array_type(get_entity_owner(node)))
+ fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j));
+ }
+ fprintf(F, "\t = ");
+ dump_node_opcode(F, get_compound_ent_value(ent, i));
+ }
}
fprintf(F, "\n");
}
fprintf(F, "\n%s peculiarity: %s", prefix, get_peculiarity_string(get_entity_peculiarity(ent)));
fprintf(F, "\n%s ld_name: %s", prefix, ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
fprintf(F, "\n%s offset: %d", prefix, get_entity_offset_bits(ent));
- if (is_method_type(get_entity_type(ent))) {
+ if (is_Method_type(get_entity_type(ent))) {
if (get_entity_irg(ent)) /* can be null */ {
- fprintf(F, "\n%s irg = %ld", prefix, get_irg_graph_nr(get_entity_irg(ent)));
- if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) {
- fprintf(F, "\n%s recursion depth %d", prefix, get_irg_recursion_depth(get_entity_irg(ent)));
- fprintf(F, "\n%s loop depth %d", prefix, get_irg_loop_depth(get_entity_irg(ent)));
- }
+ fprintf(F, "\n%s irg = %ld", prefix, get_irg_graph_nr(get_entity_irg(ent)));
+ if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) {
+ fprintf(F, "\n%s recursion depth %d", prefix, get_irg_recursion_depth(get_entity_irg(ent)));
+ fprintf(F, "\n%s loop depth %d", prefix, get_irg_loop_depth(get_entity_irg(ent)));
+ }
} else {
- fprintf(F, "\n%s irg = NULL", prefix);
+ fprintf(F, "\n%s irg = NULL", prefix);
}
}
fprintf(F, "\n");
int max_disp = -1;
int *freq, *disp; /* Accumulated accesses to static members: dispatch table. */
- if (!is_class_type(tp)) return;
+ if (!is_Class_type(tp)) return;
if (verbosity & dump_verbosity_accessStats) {
int i, n_all = get_type_n_allocations(tp);
for (i = 0; i < get_class_n_members(tp); ++i) {
entity *mem = get_class_member(tp, i);
- if (((verbosity & dump_verbosity_methods) && is_method_type(get_entity_type(mem))) ||
- ((verbosity & dump_verbosity_fields) && !is_method_type(get_entity_type(mem))) ) {
- dump_entitycsv_to_file_prefix(F, mem, " ", verbosity, &max_disp, disp, comma);
+ if (((verbosity & dump_verbosity_methods) && is_Method_type(get_entity_type(mem))) ||
+ ((verbosity & dump_verbosity_fields) && !is_Method_type(get_entity_type(mem))) ) {
+ dump_entitycsv_to_file_prefix(F, mem, " ", verbosity, &max_disp, disp, comma);
}
}
if (max_disp >= 0) {
fprintf(F, "%s__disp_tab%s Load", get_type_name(tp), comma);
for (i = 0; i <= max_disp; ++i) {
- fprintf(F, "%s %d", comma, disp[i]);
+ fprintf(F, "%s %d", comma, disp[i]);
}
fprintf(F, "\n");
}
void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
int i;
- if ((is_class_type(tp)) && (verbosity & dump_verbosity_noClassTypes)) return;
- if ((is_struct_type(tp)) && (verbosity & dump_verbosity_noStructTypes)) return;
- if ((is_union_type(tp)) && (verbosity & dump_verbosity_noUnionTypes)) return;
- if ((is_array_type(tp)) && (verbosity & dump_verbosity_noArrayTypes)) return;
- if ((is_pointer_type(tp)) && (verbosity & dump_verbosity_noPointerTypes)) return;
- if ((is_method_type(tp)) && (verbosity & dump_verbosity_noMethodTypes)) return;
- if ((is_primitive_type(tp)) && (verbosity & dump_verbosity_noPrimitiveTypes)) return;
- if ((is_enumeration_type(tp)) && (verbosity & dump_verbosity_noEnumerationTypes)) return;
+ if ((is_Class_type(tp)) && (verbosity & dump_verbosity_noClassTypes)) return;
+ if ((is_Struct_type(tp)) && (verbosity & dump_verbosity_noStructTypes)) return;
+ if ((is_Union_type(tp)) && (verbosity & dump_verbosity_noUnionTypes)) return;
+ if ((is_Array_type(tp)) && (verbosity & dump_verbosity_noArrayTypes)) return;
+ if ((is_Pointer_type(tp)) && (verbosity & dump_verbosity_noPointerTypes)) return;
+ if ((is_Method_type(tp)) && (verbosity & dump_verbosity_noMethodTypes)) return;
+ if ((is_Primitive_type(tp)) && (verbosity & dump_verbosity_noPrimitiveTypes)) return;
+ if ((is_Enumeration_type(tp)) && (verbosity & dump_verbosity_noEnumerationTypes)) return;
fprintf(F, "%s type %s (%ld)", get_tpop_name(get_type_tpop(tp)), get_type_name(tp), get_type_nr(tp));
if (verbosity & dump_verbosity_onlynames) { fprintf(F, "\n"); return; }
}
for (i = 0; i < get_class_n_members(tp); ++i) {
entity *mem = get_class_member(tp, i);
- if (((verbosity & dump_verbosity_methods) && is_method_type(get_entity_type(mem))) ||
- ((verbosity & dump_verbosity_fields) && !is_method_type(get_entity_type(mem))) ) {
- dump_entity_to_file_prefix(F, mem, " ", verbosity);
+ if (((verbosity & dump_verbosity_methods) && is_Method_type(get_entity_type(mem))) ||
+ ((verbosity & dump_verbosity_fields) && !is_Method_type(get_entity_type(mem))) ) {
+ dump_entity_to_file_prefix(F, mem, " ", verbosity);
}
}
if (verbosity & dump_verbosity_typeattrs) {
fprintf(F, " supertypes: ");
for (i = 0; i < get_class_n_supertypes(tp); ++i) {
- type *stp = get_class_supertype(tp, i);
- fprintf(F, "\n %s", get_type_name(stp));
+ type *stp = get_class_supertype(tp, i);
+ fprintf(F, "\n %s", get_type_name(stp));
}
fprintf(F, "\n subtypes: ");
for (i = 0; i < get_class_n_subtypes(tp); ++i) {
- type *stp = get_class_subtype(tp, i);
- fprintf(F, "\n %s", get_type_name(stp));
+ type *stp = get_class_subtype(tp, i);
+ fprintf(F, "\n %s", get_type_name(stp));
}
fprintf(F, "\n peculiarity: %s", get_peculiarity_string(get_class_peculiarity(tp)));
for (i = 0; i < get_compound_n_members(tp); ++i) {
entity *mem = get_compound_member(tp, i);
if (verbosity & dump_verbosity_fields) {
- dump_entity_to_file_prefix(F, mem, " ", verbosity);
+ dump_entity_to_file_prefix(F, mem, " ", verbosity);
}
}
break;
void dump_types_as_text(unsigned verbosity, const char *suffix) {
const char *basename;
- FILE *F, *CSV;
+ FILE *F, *CSV = NULL;
int i, n_types = get_irp_n_types();
basename = irp_prog_name_is_set() ? get_irp_prog_name() : "TextTypes";
if (is_jack_rts_class(t)) continue;
dump_type_to_file(F, t, verbosity);
- if (verbosity & dump_verbosity_csv) {
+ if (CSV) {
dump_typecsv_to_file(CSV, t, verbosity, "");
}
}
fclose (F);
- if (verbosity & dump_verbosity_csv) fclose (CSV);
+ if (CSV) fclose (CSV);
}
/* Insert irnode `new' in place of irnode `old'
Since `new' may be bigger than `old' replace `old'
by an op_Id which is smaller than everything */
-INLINE void
+void
exchange (ir_node *old, ir_node *nw)
{
ir_node *block;
{
type *call_type = get_Call_type(call);
int params, ress, i, res;
- assert(is_method_type(call_type));
+ assert(is_Method_type(call_type));
params = get_method_n_params(call_type);
ress = get_method_n_ress(call_type);
int __interprocedural_view = false;
int (get_interprocedural_view)(void) {
- return __get_interprocedural_view();
+ return _get_interprocedural_view();
}
void (set_interprocedural_view)(int state) {
int
(is_ir_graph)(const void *thing) {
- return __is_ir_graph(thing);
+ return _is_ir_graph(thing);
}
/* Outputs a unique number for this node */
ir_node *
(get_irg_start_block)(const ir_graph *irg) {
- return __get_irg_start_block(irg);
+ return _get_irg_start_block(irg);
}
void
(set_irg_start_block)(ir_graph *irg, ir_node *node) {
- __set_irg_start_block(irg, node);
+ _set_irg_start_block(irg, node);
}
ir_node *
(get_irg_start)(const ir_graph *irg) {
- return __get_irg_start(irg);
+ return _get_irg_start(irg);
}
void
(set_irg_start)(ir_graph *irg, ir_node *node) {
- __set_irg_start(irg, node);
+ _set_irg_start(irg, node);
}
ir_node *
(get_irg_end_block)(const ir_graph *irg) {
- return __get_irg_end_block(irg);
+ return _get_irg_end_block(irg);
}
void
(set_irg_end_block)(ir_graph *irg, ir_node *node) {
- __set_irg_end_block(irg, node);
+ _set_irg_end_block(irg, node);
}
ir_node *
(get_irg_end)(const ir_graph *irg) {
- return __get_irg_end(irg);
+ return _get_irg_end(irg);
}
void
(set_irg_end)(ir_graph *irg, ir_node *node) {
- __set_irg_end(irg, node);
+ _set_irg_end(irg, node);
}
ir_node *
(get_irg_end_reg)(const ir_graph *irg) {
- return __get_irg_end_reg(irg);
+ return _get_irg_end_reg(irg);
}
void set_irg_end_reg (ir_graph *irg, ir_node *node) {
ir_node *
(get_irg_end_except)(const ir_graph *irg) {
- return __get_irg_end_except(irg);
+ return _get_irg_end_except(irg);
}
void set_irg_end_except (ir_graph *irg, ir_node *node) {
ir_node *
(get_irg_cstore)(const ir_graph *irg) {
- return __get_irg_cstore(irg);
+ return _get_irg_cstore(irg);
}
void
(set_irg_cstore)(ir_graph *irg, ir_node *node) {
- __set_irg_cstore(irg, node);
+ _set_irg_cstore(irg, node);
}
ir_node *
(get_irg_frame)(const ir_graph *irg) {
- return __get_irg_frame(irg);
+ return _get_irg_frame(irg);
}
void
(set_irg_frame)(ir_graph *irg, ir_node *node) {
- __set_irg_frame(irg, node);
+ _set_irg_frame(irg, node);
}
ir_node *
(get_irg_globals)(const ir_graph *irg) {
- return __get_irg_globals(irg);
+ return _get_irg_globals(irg);
}
void
(set_irg_globals)(ir_graph *irg, ir_node *node) {
- __set_irg_globals(irg, node);
+ _set_irg_globals(irg, node);
}
ir_node *
(get_irg_initial_mem)(const ir_graph *irg) {
- return __get_irg_initial_mem(irg);
+ return _get_irg_initial_mem(irg);
}
void
(set_irg_initial_mem)(ir_graph *irg, ir_node *node) {
- __set_irg_initial_mem(irg, node);
+ _set_irg_initial_mem(irg, node);
}
ir_node *
(get_irg_args)(const ir_graph *irg) {
- return __get_irg_args(irg);
+ return _get_irg_args(irg);
}
void
(set_irg_args)(ir_graph *irg, ir_node *node) {
- __set_irg_args(irg, node);
+ _set_irg_args(irg, node);
}
ir_node **
(get_irg_proj_args) (const ir_graph *irg) {
- return __get_irg_proj_args (irg);
+ return _get_irg_proj_args (irg);
}
void
(set_irg_proj_args) (ir_graph *irg, ir_node **nodes) {
- __set_irg_proj_args (irg, nodes);
+ _set_irg_proj_args (irg, nodes);
}
ir_node *
(get_irg_bad)(const ir_graph *irg) {
- return __get_irg_bad(irg);
+ return _get_irg_bad(irg);
}
void
(set_irg_bad)(ir_graph *irg, ir_node *node) {
- __set_irg_bad(irg, node);
+ _set_irg_bad(irg, node);
}
ir_node *
(get_irg_no_mem)(const ir_graph *irg) {
- return __get_irg_no_mem(irg);
+ return _get_irg_no_mem(irg);
}
void
(set_irg_no_mem)(ir_graph *irg, ir_node *node) {
- __set_irg_no_mem(irg, node);
+ _set_irg_no_mem(irg, node);
}
ir_node *
(get_irg_current_block)(const ir_graph *irg) {
- return __get_irg_current_block(irg);
+ return _get_irg_current_block(irg);
}
void
(set_irg_current_block)(ir_graph *irg, ir_node *node) {
- __set_irg_current_block(irg, node);
+ _set_irg_current_block(irg, node);
}
entity *
(get_irg_entity)(const ir_graph *irg) {
- return __get_irg_entity(irg);
+ return _get_irg_entity(irg);
}
void
(set_irg_entity)(ir_graph *irg, entity *ent) {
- __set_irg_entity(irg, ent);
+ _set_irg_entity(irg, ent);
}
type *
(get_irg_frame_type)(const ir_graph *irg) {
- return __get_irg_frame_type(irg);
+ return _get_irg_frame_type(irg);
}
void
(set_irg_frame_type)(ir_graph *irg, type *ftp) {
- __set_irg_frame_type(irg, ftp);
+ _set_irg_frame_type(irg, ftp);
}
int
is_frame_type(const type *ftp) {
int i;
- if (is_class_type(ftp)) {
+ if (is_Class_type(ftp)) {
for (i = 0; i < get_irp_n_irgs(); i++) {
const type *frame_tp = get_irg_frame_type(get_irp_irg(i));
if (ftp == frame_tp) return true;
/* Returns the obstack associated with the graph. */
struct obstack *
(get_irg_obstack)(const ir_graph *irg) {
- return __get_irg_obstack(irg);
+ return _get_irg_obstack(irg);
}
/*
irg_phase_state
(get_irg_phase_state)(const ir_graph *irg) {
- return __get_irg_phase_state(irg);
+ return _get_irg_phase_state(irg);
}
void
(set_irg_phase_low)(ir_graph *irg) {
- __set_irg_phase_low(irg);
+ _set_irg_phase_low(irg);
}
op_pin_state
(get_irg_pinned)(const ir_graph *irg) {
- return __get_irg_pinned(irg);
+ return _get_irg_pinned(irg);
}
irg_outs_state
(get_irg_outs_state)(const ir_graph *irg) {
- return __get_irg_outs_state(irg);
+ return _get_irg_outs_state(irg);
}
void
(set_irg_outs_inconsistent)(ir_graph *irg) {
- __set_irg_outs_inconsistent(irg);
+ _set_irg_outs_inconsistent(irg);
}
irg_dom_state
(get_irg_dom_state)(const ir_graph *irg) {
- return __get_irg_dom_state(irg);
+ return _get_irg_dom_state(irg);
}
void
(set_irg_dom_inconsistent)(ir_graph *irg) {
- __set_irg_dom_inconsistent(irg);
+ _set_irg_dom_inconsistent(irg);
}
irg_loopinfo_state
(get_irg_loopinfo_state)(const ir_graph *irg) {
- return __get_irg_loopinfo_state(irg);
+ return _get_irg_loopinfo_state(irg);
}
void
(set_irg_loopinfo_state)(ir_graph *irg, irg_loopinfo_state s) {
- __set_irg_loopinfo_state(irg, s);
+ _set_irg_loopinfo_state(irg, s);
}
void
void
(set_irg_pinned)(ir_graph *irg, op_pin_state p) {
- __set_irg_pinned(irg, p);
+ _set_irg_pinned(irg, p);
}
irg_callee_info_state
(get_irg_callee_info_state)(const ir_graph *irg) {
- return __get_irg_callee_info_state(irg);
+ return _get_irg_callee_info_state(irg);
}
void
(set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s) {
- __set_irg_callee_info_state(irg, s);
+ _set_irg_callee_info_state(irg, s);
}
irg_inline_property
(get_irg_inline_property)(const ir_graph *irg) {
- return __get_irg_inline_property(irg);
+ return _get_irg_inline_property(irg);
}
void
(set_irg_inline_property)(ir_graph *irg, irg_inline_property s) {
- __set_irg_inline_property(irg, s);
+ _set_irg_inline_property(irg, s);
}
void
(set_irg_link)(ir_graph *irg, void *thing) {
- __set_irg_link(irg, thing);
+ _set_irg_link(irg, thing);
}
void *
(get_irg_link)(const ir_graph *irg) {
- return __get_irg_link(irg);
+ return _get_irg_link(irg);
}
/** maximum visited flag content of all ir_graph visited fields. */
unsigned long
(get_irg_visited)(const ir_graph *irg) {
- return __get_irg_visited(irg);
+ return _get_irg_visited(irg);
}
void
unsigned long
(get_irg_block_visited)(const ir_graph *irg) {
- return __get_irg_block_visited(irg);
+ return _get_irg_block_visited(irg);
}
void
(set_irg_block_visited)(ir_graph *irg, unsigned long visited) {
- __set_irg_block_visited(irg, visited);
+ _set_irg_block_visited(irg, visited);
}
void
(inc_irg_block_visited)(ir_graph *irg) {
- __inc_irg_block_visited(irg);
+ _inc_irg_block_visited(irg);
}
extern int __interprocedural_view;
static INLINE int
-__get_interprocedural_view(void) {
+_get_interprocedural_view(void) {
return __interprocedural_view;
}
static INLINE int
-__is_ir_graph(const void *thing) {
+_is_ir_graph(const void *thing) {
return (get_kind(thing) == k_ir_graph);
}
/** Returns the start block of a graph. */
static INLINE ir_node *
-__get_irg_start_block(const ir_graph *irg) {
+_get_irg_start_block(const ir_graph *irg) {
return irg->start_block;
}
static INLINE void
-__set_irg_start_block(ir_graph *irg, ir_node *node) {
+_set_irg_start_block(ir_graph *irg, ir_node *node) {
irg->start_block = node;
}
static INLINE ir_node *
-__get_irg_start(const ir_graph *irg) {
+_get_irg_start(const ir_graph *irg) {
return irg->start;
}
static INLINE void
-__set_irg_start(ir_graph *irg, ir_node *node) {
+_set_irg_start(ir_graph *irg, ir_node *node) {
irg->start = node;
}
static INLINE ir_node *
-__get_irg_end_block(const ir_graph *irg) {
+_get_irg_end_block(const ir_graph *irg) {
return irg->end_block;
}
static INLINE void
-__set_irg_end_block(ir_graph *irg, ir_node *node) {
+_set_irg_end_block(ir_graph *irg, ir_node *node) {
irg->end_block = node;
}
static INLINE ir_node *
-__get_irg_end(const ir_graph *irg) {
+_get_irg_end(const ir_graph *irg) {
return irg->end;
}
static INLINE void
-__set_irg_end(ir_graph *irg, ir_node *node) {
+_set_irg_end(ir_graph *irg, ir_node *node) {
irg->end = node;
}
static INLINE ir_node *
-__get_irg_end_reg(const ir_graph *irg) {
+_get_irg_end_reg(const ir_graph *irg) {
return irg->end_reg;
}
static INLINE ir_node *
-__get_irg_end_except (const ir_graph *irg) {
+_get_irg_end_except (const ir_graph *irg) {
return irg->end_except;
}
static INLINE ir_node *
-__get_irg_cstore(const ir_graph *irg) {
+_get_irg_cstore(const ir_graph *irg) {
return irg->cstore;
}
static INLINE void
-__set_irg_cstore(ir_graph *irg, ir_node *node) {
+_set_irg_cstore(ir_graph *irg, ir_node *node) {
irg->cstore = node;
}
static INLINE ir_node *
-__get_irg_frame(const ir_graph *irg) {
+_get_irg_frame(const ir_graph *irg) {
return irg->frame;
}
static INLINE void
-__set_irg_frame(ir_graph *irg, ir_node *node) {
+_set_irg_frame(ir_graph *irg, ir_node *node) {
irg->frame = node;
}
static INLINE ir_node *
-__get_irg_globals(const ir_graph *irg) {
+_get_irg_globals(const ir_graph *irg) {
return irg->globals;
}
static INLINE void
-__set_irg_globals(ir_graph *irg, ir_node *node) {
+_set_irg_globals(ir_graph *irg, ir_node *node) {
irg->globals = node;
}
static INLINE ir_node *
-__get_irg_initial_mem(const ir_graph *irg) {
+_get_irg_initial_mem(const ir_graph *irg) {
return irg->initial_mem;
}
static INLINE void
-__set_irg_initial_mem(ir_graph *irg, ir_node *node) {
+_set_irg_initial_mem(ir_graph *irg, ir_node *node) {
irg->initial_mem = node;
}
static INLINE ir_node *
-__get_irg_args(const ir_graph *irg) {
+_get_irg_args(const ir_graph *irg) {
return irg->args;
}
static INLINE void
-__set_irg_args(ir_graph *irg, ir_node *node) {
+_set_irg_args(ir_graph *irg, ir_node *node) {
irg->args = node;
}
static INLINE ir_node **
-__get_irg_proj_args(const ir_graph *irg) {
+_get_irg_proj_args(const ir_graph *irg) {
return irg->proj_args;
}
static INLINE void
-__set_irg_proj_args(ir_graph *irg, ir_node **nodes) {
+_set_irg_proj_args(ir_graph *irg, ir_node **nodes) {
irg->proj_args = nodes;
}
static INLINE ir_node *
-__get_irg_bad(const ir_graph *irg) {
+_get_irg_bad(const ir_graph *irg) {
return irg->bad;
}
static INLINE void
-__set_irg_bad(ir_graph *irg, ir_node *node) {
+_set_irg_bad(ir_graph *irg, ir_node *node) {
irg->bad = node;
}
static INLINE ir_node *
-__get_irg_no_mem(const ir_graph *irg) {
+_get_irg_no_mem(const ir_graph *irg) {
return irg->no_mem;
}
static INLINE void
-__set_irg_no_mem(ir_graph *irg, ir_node *node) {
+_set_irg_no_mem(ir_graph *irg, ir_node *node) {
irg->no_mem = node;
}
static INLINE ir_node *
-__get_irg_current_block(const ir_graph *irg) {
+_get_irg_current_block(const ir_graph *irg) {
return irg->current_block;
}
static INLINE void
-__set_irg_current_block(ir_graph *irg, ir_node *node) {
+_set_irg_current_block(ir_graph *irg, ir_node *node) {
irg->current_block = node;
}
static INLINE entity *
-__get_irg_entity(const ir_graph *irg) {
+_get_irg_entity(const ir_graph *irg) {
assert(irg && irg->ent);
return irg->ent;
}
static INLINE void
-__set_irg_entity(ir_graph *irg, entity *ent) {
+_set_irg_entity(ir_graph *irg, entity *ent) {
irg->ent = ent;
}
static INLINE type *
-__get_irg_frame_type(const ir_graph *irg) {
+_get_irg_frame_type(const ir_graph *irg) {
assert(irg && irg->frame_type);
return irg->frame_type;
}
static INLINE void
-__set_irg_frame_type(ir_graph *irg, type *ftp) {
- assert(is_class_type(ftp));
+_set_irg_frame_type(ir_graph *irg, type *ftp) {
+ assert(is_Class_type(ftp));
irg->frame_type = ftp;
}
static INLINE struct obstack *
-__get_irg_obstack(const ir_graph *irg) {
+_get_irg_obstack(const ir_graph *irg) {
return irg->obst;
}
static INLINE irg_phase_state
-__get_irg_phase_state(const ir_graph *irg) {
+_get_irg_phase_state(const ir_graph *irg) {
return irg->phase_state;
}
static INLINE void
-__set_irg_phase_low(ir_graph *irg) {
+_set_irg_phase_low(ir_graph *irg) {
irg->phase_state = phase_low;
}
static INLINE op_pin_state
-__get_irg_pinned(const ir_graph *irg) {
+_get_irg_pinned(const ir_graph *irg) {
return irg->op_pin_state_pinned;
}
static INLINE irg_outs_state
-__get_irg_outs_state(const ir_graph *irg) {
+_get_irg_outs_state(const ir_graph *irg) {
return irg->outs_state;
}
static INLINE void
-__set_irg_outs_inconsistent(ir_graph *irg) {
+_set_irg_outs_inconsistent(ir_graph *irg) {
irg->outs_state = outs_inconsistent;
}
static INLINE irg_dom_state
-__get_irg_dom_state(const ir_graph *irg) {
+_get_irg_dom_state(const ir_graph *irg) {
return irg->dom_state;
}
static INLINE void
-__set_irg_dom_inconsistent(ir_graph *irg) {
+_set_irg_dom_inconsistent(ir_graph *irg) {
irg->dom_state = dom_inconsistent;
}
static INLINE irg_loopinfo_state
-__get_irg_loopinfo_state(const ir_graph *irg) {
+_get_irg_loopinfo_state(const ir_graph *irg) {
return irg->loopinfo_state;
}
static INLINE void
-__set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s) {
+_set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s) {
irg->loopinfo_state = s;
}
static INLINE void
-__set_irg_pinned(ir_graph *irg, op_pin_state p) {
+_set_irg_pinned(ir_graph *irg, op_pin_state p) {
irg->op_pin_state_pinned = p;
}
static INLINE irg_callee_info_state
-__get_irg_callee_info_state(const ir_graph *irg) {
+_get_irg_callee_info_state(const ir_graph *irg) {
return irg->callee_info_state;
}
static INLINE void
-__set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s) {
+_set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s) {
irg_callee_info_state irp_state = get_irp_callee_info_state();
irg->callee_info_state = s;
}
static INLINE irg_inline_property
-__get_irg_inline_property(const ir_graph *irg) {
+_get_irg_inline_property(const ir_graph *irg) {
return irg->inline_property;
}
static INLINE void
-__set_irg_inline_property(ir_graph *irg, irg_inline_property s) {
+_set_irg_inline_property(ir_graph *irg, irg_inline_property s) {
irg->inline_property = s;
}
static INLINE void
-__set_irg_link(ir_graph *irg, void *thing) {
+_set_irg_link(ir_graph *irg, void *thing) {
irg->link = thing;
}
static INLINE void *
-__get_irg_link(const ir_graph *irg) {
+_get_irg_link(const ir_graph *irg) {
return irg->link;
}
static INLINE unsigned long
-__get_irg_visited(const ir_graph *irg) {
+_get_irg_visited(const ir_graph *irg) {
return irg->visited;
}
static INLINE unsigned long
-__get_irg_block_visited(const ir_graph *irg) {
+_get_irg_block_visited(const ir_graph *irg) {
return irg->block_visited;
}
static INLINE void
-__set_irg_block_visited(ir_graph *irg, unsigned long visited) {
+_set_irg_block_visited(ir_graph *irg, unsigned long visited) {
irg->block_visited = visited;
}
static INLINE void
-__inc_irg_block_visited(ir_graph *irg) {
+_inc_irg_block_visited(ir_graph *irg) {
++irg->block_visited;
}
-#define get_interprocedural_view() __get_interprocedural_view()
-#define is_ir_graph(thing) __is_ir_graph(thing)
-#define get_irg_start_block(irg) __get_irg_start_block(irg)
-#define set_irg_start_block(irg, node) __set_irg_start_block(irg, node)
-#define get_irg_start(irg) __get_irg_start(irg)
-#define set_irg_start(irg, node) __set_irg_start(irg, node)
-#define get_irg_end_block(irg) __get_irg_end_block(irg)
-#define set_irg_end_block(irg, node) __set_irg_end_block(irg, node)
-#define get_irg_end(irg) __get_irg_end(irg)
-#define set_irg_end(irg, node) __set_irg_end(irg, node)
-#define get_irg_end_reg(irg) __get_irg_end_reg(irg)
-#define get_irg_end_except(irg) __get_irg_end_except(irg)
-#define get_irg_cstore(irg) __get_irg_cstore(irg)
-#define set_irg_cstore(irg, node) __set_irg_cstore(irg, node)
-#define get_irg_frame(irg) __get_irg_frame(irg)
-#define set_irg_frame(irg, node) __set_irg_frame(irg, node)
-#define get_irg_globals(irg) __get_irg_globals(irg)
-#define set_irg_globals(irg, node) __set_irg_globals(irg, node)
-#define get_irg_initial_mem(irg) __get_irg_initial_mem(irg)
-#define set_irg_initial_mem(irg, node) __set_irg_initial_mem(irg, node)
-#define get_irg_args(irg) __get_irg_args(irg)
-#define set_irg_args(irg, node) __set_irg_args(irg, node)
-#define get_irg_bad(irg) __get_irg_bad(irg)
-#define set_irg_bad(irg, node) __set_irg_bad(irg, node)
-#define get_irg_no_mem(irg) __get_irg_no_mem(irg)
-#define set_irg_no_mem(irg, node) __set_irg_no_mem(irg, node)
-#define get_irg_current_block(irg) __get_irg_current_block(irg)
-#define set_irg_current_block(irg, node) __set_irg_current_block(irg, node)
-#define get_irg_entity(irg) __get_irg_entity(irg)
-#define set_irg_entity(irg, ent) __set_irg_entity(irg, ent)
-#define get_irg_frame_type(irg) __get_irg_frame_type(irg)
-#define set_irg_frame_type(irg, ftp) __set_irg_frame_type(irg, ftp)
-#define get_irg_obstack(irg) __get_irg_obstack(irg)
-#define get_irg_phase_state(irg) __get_irg_phase_state(irg)
-#define set_irg_phase_low(irg) __set_irg_phase_low(irg)
-#define get_irg_pinned(irg) __get_irg_pinned(irg)
-#define get_irg_outs_state(irg) __get_irg_outs_state(irg)
-#define set_irg_outs_inconsistent(irg) __set_irg_outs_inconsistent(irg)
-#define get_irg_dom_state(irg) __get_irg_dom_state(irg)
-#define set_irg_dom_inconsistent(irg) __set_irg_dom_inconsistent(irg)
-#define get_irg_loopinfo_state(irg) __get_irg_loopinfo_state(irg)
-#define set_irg_loopinfo_state(irg, s) __set_irg_loopinfo_state(irg, s)
-#define set_irg_pinned(irg, p) __set_irg_pinned(irg, p)
-#define get_irg_callee_info_state(irg) __get_irg_callee_info_state(irg)
-#define set_irg_callee_info_state(irg, s) __set_irg_callee_info_state(irg, s)
-#define get_irg_inline_property(irg) __get_irg_inline_property(irg)
-#define set_irg_inline_property(irg, s) __set_irg_inline_property(irg, s)
-#define set_irg_link(irg, thing) __set_irg_link(irg, thing)
-#define get_irg_link(irg) __get_irg_link(irg)
-#define get_irg_visited(irg) __get_irg_visited(irg)
-#define get_irg_block_visited(irg) __get_irg_block_visited(irg)
-#define set_irg_block_visited(irg, v) __set_irg_block_visited(irg, v)
-#define inc_irg_block_visited(irg) __inc_irg_block_visited(irg)
+#define get_interprocedural_view() _get_interprocedural_view()
+#define is_ir_graph(thing) _is_ir_graph(thing)
+#define get_irg_start_block(irg) _get_irg_start_block(irg)
+#define set_irg_start_block(irg, node) _set_irg_start_block(irg, node)
+#define get_irg_start(irg) _get_irg_start(irg)
+#define set_irg_start(irg, node) _set_irg_start(irg, node)
+#define get_irg_end_block(irg) _get_irg_end_block(irg)
+#define set_irg_end_block(irg, node) _set_irg_end_block(irg, node)
+#define get_irg_end(irg) _get_irg_end(irg)
+#define set_irg_end(irg, node) _set_irg_end(irg, node)
+#define get_irg_end_reg(irg) _get_irg_end_reg(irg)
+#define get_irg_end_except(irg) _get_irg_end_except(irg)
+#define get_irg_cstore(irg) _get_irg_cstore(irg)
+#define set_irg_cstore(irg, node) _set_irg_cstore(irg, node)
+#define get_irg_frame(irg) _get_irg_frame(irg)
+#define set_irg_frame(irg, node) _set_irg_frame(irg, node)
+#define get_irg_globals(irg) _get_irg_globals(irg)
+#define set_irg_globals(irg, node) _set_irg_globals(irg, node)
+#define get_irg_initial_mem(irg) _get_irg_initial_mem(irg)
+#define set_irg_initial_mem(irg, node) _set_irg_initial_mem(irg, node)
+#define get_irg_args(irg) _get_irg_args(irg)
+#define set_irg_args(irg, node) _set_irg_args(irg, node)
+#define get_irg_bad(irg) _get_irg_bad(irg)
+#define set_irg_bad(irg, node) _set_irg_bad(irg, node)
+#define get_irg_no_mem(irg) _get_irg_no_mem(irg)
+#define set_irg_no_mem(irg, node) _set_irg_no_mem(irg, node)
+#define get_irg_current_block(irg) _get_irg_current_block(irg)
+#define set_irg_current_block(irg, node) _set_irg_current_block(irg, node)
+#define get_irg_entity(irg) _get_irg_entity(irg)
+#define set_irg_entity(irg, ent) _set_irg_entity(irg, ent)
+#define get_irg_frame_type(irg) _get_irg_frame_type(irg)
+#define set_irg_frame_type(irg, ftp) _set_irg_frame_type(irg, ftp)
+#define get_irg_obstack(irg) _get_irg_obstack(irg)
+#define get_irg_phase_state(irg) _get_irg_phase_state(irg)
+#define set_irg_phase_low(irg) _set_irg_phase_low(irg)
+#define get_irg_pinned(irg) _get_irg_pinned(irg)
+#define get_irg_outs_state(irg) _get_irg_outs_state(irg)
+#define set_irg_outs_inconsistent(irg) _set_irg_outs_inconsistent(irg)
+#define get_irg_dom_state(irg) _get_irg_dom_state(irg)
+#define set_irg_dom_inconsistent(irg) _set_irg_dom_inconsistent(irg)
+#define get_irg_loopinfo_state(irg) _get_irg_loopinfo_state(irg)
+#define set_irg_loopinfo_state(irg, s) _set_irg_loopinfo_state(irg, s)
+#define set_irg_pinned(irg, p) _set_irg_pinned(irg, p)
+#define get_irg_callee_info_state(irg) _get_irg_callee_info_state(irg)
+#define set_irg_callee_info_state(irg, s) _set_irg_callee_info_state(irg, s)
+#define get_irg_inline_property(irg) _get_irg_inline_property(irg)
+#define set_irg_inline_property(irg, s) _set_irg_inline_property(irg, s)
+#define set_irg_link(irg, thing) _set_irg_link(irg, thing)
+#define get_irg_link(irg) _get_irg_link(irg)
+#define get_irg_visited(irg) _get_irg_visited(irg)
+#define get_irg_block_visited(irg) _get_irg_block_visited(irg)
+#define set_irg_block_visited(irg, v) _set_irg_block_visited(irg, v)
+#define inc_irg_block_visited(irg) _inc_irg_block_visited(irg)
# endif /* _IRGRAPH_T_H_ */
/* Walk constant array bounds. */
for (i = 0; i < get_irp_n_types(); i++) {
type *tp = get_irp_type(i);
- if (is_array_type(tp)) {
+ if (is_Array_type(tp)) {
for (j = 0; j < get_array_n_dimensions(tp); j++) {
ir_node *n = get_array_lower_bound(tp, j);
if (n) irg_walk(n, pre, post, env);
set_Const_type (ir_node *node, type *tp) {
assert (node->op == op_Const);
if (tp != firm_unknown_type) {
- assert (is_atomic_type(tp));
+ assert (is_Atomic_type(tp));
assert (get_type_mode(tp) == get_irn_mode(node));
}
node->attr.con.tp = tp;
void
set_Call_type (ir_node *node, type *tp) {
assert (node->op == op_Call);
- assert ((get_unknown_type() == tp) || is_method_type(tp));
+ assert ((get_unknown_type() == tp) || is_Method_type(tp));
node->attr.call.cld_tp = tp;
}
"Number of results for Return doesn't match number of results in type.", 0,
show_return_nres(irg, n, mt););
for (i = 0; i < get_Return_n_ress(n); i++) {
- type *res_type = get_method_res_type(mt, i);
+ type *res_type = get_method_res_type(mt, i);
- if (is_atomic_type(res_type)) {
- ASSERT_AND_RET_DBG(
- get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
- "Mode of result for Return doesn't match mode of result type.", 0,
- show_return_modes(irg, n, mt, i);
- );
- }
- else {
- ASSERT_AND_RET_DBG(
- mode_is_reference(get_irn_mode(get_Return_res(n, i))),
- "Mode of result for Return doesn't match mode of result type.", 0,
- show_return_modes(irg, n, mt, i);
- );
- }
+ if (is_Atomic_type(res_type)) {
+ ASSERT_AND_RET_DBG(
+ get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
+ "Mode of result for Return doesn't match mode of result type.", 0,
+ show_return_modes(irg, n, mt, i);
+ );
+ }
+ else {
+ ASSERT_AND_RET_DBG(
+ mode_is_reference(get_irn_mode(get_Return_res(n, i))),
+ "Mode of result for Return doesn't match mode of result type.", 0,
+ show_return_modes(irg, n, mt, i);
+ );
+ }
}
break;
case iro_SymConst:
if (get_SymConst_kind(n) == symconst_addr_ent) {
entity *ent = get_SymConst_entity(n);
- if (is_method_type(get_entity_type(ent)) &&
+ if (is_Method_type(get_entity_type(ent)) &&
get_irn_irg(n) != get_const_code_irg()) {
#if 1
ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
for (i = 0; i < get_method_n_params(mt); i++) {
type *t = get_method_param_type(mt, i);
- if (is_atomic_type(t)) {
+ if (is_Atomic_type(t)) {
ASSERT_AND_RET_DBG(
get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
"Mode of arg for Call doesn't match mode of arg type.", 0,
projects / libfirm / commitdiff