From 70a99776fa03fa4f45379d06e1fae21c2ca103b3 Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Wed, 5 Jan 2005 14:33:43 +0000 Subject: [PATCH] renamed fucntions is_x*_type() to is_X*_type() to prevent name clash with EDg frontend removed INLINE for global functions renamed inline functions __* to _* (__ is reserved to the compiler) [r4819] --- ir/ir/ircgopt.c | 12 +-- ir/ir/ircons.c | 226 +++++++++++++++++++++++----------------------- ir/ir/irdump.c | 6 +- ir/ir/irdumptxt.c | 104 ++++++++++----------- ir/ir/irgmod.c | 2 +- ir/ir/irgopt.c | 2 +- ir/ir/irgraph.c | 112 +++++++++++------------ ir/ir/irgraph_t.h | 218 ++++++++++++++++++++++---------------------- ir/ir/irgwalk.c | 2 +- ir/ir/irnode.c | 4 +- ir/ir/irvrfy.c | 34 +++---- 11 files changed, 361 insertions(+), 361 deletions(-) diff --git a/ir/ir/ircgopt.c b/ir/ir/ircgopt.c index 060fc99e7..a04d95f80 100644 --- a/ir/ir/ircgopt.c +++ b/ir/ir/ircgopt.c @@ -46,14 +46,14 @@ static void make_entity_to_description(type_or_ent *tore, void *env) { 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))); } } } diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index 7966d17a8..7052db01b 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -67,7 +67,7 @@ static default_initialize_local_variable_func_t *default_initialize_local_variab /* 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; @@ -88,7 +88,7 @@ new_rd_Block (dbg_info* db, ir_graph *irg, int arity, ir_node **in) return res; } -INLINE ir_node * +ir_node * new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -100,7 +100,7 @@ new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block) return res; } -INLINE ir_node * +ir_node * new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -113,7 +113,7 @@ new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block) /* 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; @@ -145,7 +145,7 @@ new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in 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; @@ -160,7 +160,7 @@ new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, t 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; @@ -168,7 +168,7 @@ new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval 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; @@ -179,7 +179,7 @@ new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *m 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) { @@ -199,7 +199,7 @@ new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode } -INLINE ir_node * +ir_node * new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, long max_proj) { @@ -211,7 +211,7 @@ new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, 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; @@ -222,12 +222,12 @@ new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode * 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; @@ -236,7 +236,7 @@ new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_ 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; @@ -247,7 +247,7 @@ new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node ** 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) { @@ -262,7 +262,7 @@ new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -277,7 +277,7 @@ new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -289,7 +289,7 @@ new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -304,7 +304,7 @@ new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -320,7 +320,7 @@ new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -336,7 +336,7 @@ new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -352,7 +352,7 @@ new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -368,7 +368,7 @@ new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -383,7 +383,7 @@ new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -398,7 +398,7 @@ new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -413,7 +413,7 @@ new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -425,7 +425,7 @@ new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -440,7 +440,7 @@ new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -455,7 +455,7 @@ new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -470,7 +470,7 @@ new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -485,7 +485,7 @@ new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -497,7 +497,7 @@ new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -512,7 +512,7 @@ new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block, return res; } -INLINE ir_node * +ir_node * new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -523,7 +523,7 @@ new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block) 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; @@ -552,7 +552,7 @@ new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, 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; @@ -579,7 +579,7 @@ new_rd_Return (dbg_info* db, ir_graph *irg, ir_node *block, 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]; @@ -593,7 +593,7 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no 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) { @@ -611,7 +611,7 @@ new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -629,7 +629,7 @@ new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block, 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) { @@ -647,7 +647,7 @@ new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, 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) { @@ -707,7 +707,7 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, 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; @@ -729,7 +729,7 @@ new_rd_SymConst_type (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symb 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) { @@ -757,7 +757,7 @@ ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, type *symbol, type * 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; @@ -768,13 +768,13 @@ new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **i 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; @@ -788,13 +788,13 @@ new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_no 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]; @@ -809,7 +809,7 @@ new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) return res; } -INLINE ir_node * +ir_node * new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -820,7 +820,7 @@ new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block) return res; } -INLINE ir_node * +ir_node * new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -831,7 +831,7 @@ new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block) return res; } -INLINE ir_node * +ir_node * new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block) { ir_node *res; @@ -842,7 +842,7 @@ new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block) 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) { @@ -862,12 +862,12 @@ new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mod 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) { @@ -887,198 +887,198 @@ new_rd_Mux (dbg_info *db, ir_graph *irg, ir_node *block, } -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); } @@ -1205,7 +1205,7 @@ new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *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; @@ -1217,7 +1217,7 @@ new_Phi_in_stack(void) { return res; } -INLINE void +void free_Phi_in_stack(Phi_in_stack *s) { DEL_ARR_F(s->stack); free(s); @@ -1513,8 +1513,8 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) #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 * @@ -2432,7 +2432,7 @@ ir_node *new_d_immBlock (dbg_info* db) { return res; } -INLINE ir_node * +ir_node * new_immBlock (void) { return new_d_immBlock(NULL); } @@ -2470,14 +2470,14 @@ get_d_value (dbg_info* db, int pos, ir_mode *mode) 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); @@ -2486,7 +2486,7 @@ set_value (int pos, ir_node *value) } /* get the current store */ -INLINE ir_node * +ir_node * get_store (void) { assert(get_irg_phase_state (current_ir_graph) == phase_building); @@ -2496,7 +2496,7 @@ get_store (void) } /* set the current store */ -INLINE void +void set_store (ir_node *store) { /* GL: one could call set_value instead */ diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index bd5c5baee..424a7b192 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -1372,7 +1372,7 @@ dump_type_info(type_or_ent *tore, void *env) { 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); } @@ -1492,8 +1492,8 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) { 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 */ diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c index 1167cb736..e29ab5fda 100644 --- a/ir/ir/irdumptxt.c +++ b/ir/ir/irdumptxt.c @@ -396,7 +396,7 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned 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) { @@ -445,7 +445,7 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned } 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)"); @@ -458,26 +458,26 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned 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"); } @@ -493,15 +493,15 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned 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"); @@ -706,7 +706,7 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha 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); @@ -744,16 +744,16 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha 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"); } @@ -766,14 +766,14 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha 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; } @@ -786,21 +786,21 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { } 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))); @@ -813,7 +813,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { 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; @@ -880,7 +880,7 @@ void dump_type(type *tp) { 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"; @@ -897,11 +897,11 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) { 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); } diff --git a/ir/ir/irgmod.c b/ir/ir/irgmod.c index 39f255c8c..2f5b173c1 100644 --- a/ir/ir/irgmod.c +++ b/ir/ir/irgmod.c @@ -46,7 +46,7 @@ turn_into_tuple (ir_node *node, int arity) /* 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; diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c index 034a2a742..2c4272582 100644 --- a/ir/ir/irgopt.c +++ b/ir/ir/irgopt.c @@ -711,7 +711,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph) { 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); diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 570fc14bb..1cb0a6959 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -58,7 +58,7 @@ void set_current_ir_graph(ir_graph *graph) { int __interprocedural_view = false; int (get_interprocedural_view)(void) { - return __get_interprocedural_view(); + return _get_interprocedural_view(); } void (set_interprocedural_view)(int state) { @@ -325,7 +325,7 @@ void free_ir_graph (ir_graph *irg) { int (is_ir_graph)(const void *thing) { - return __is_ir_graph(thing); + return _is_ir_graph(thing); } /* Outputs a unique number for this node */ @@ -342,47 +342,47 @@ get_irg_graph_nr(ir_graph *irg) { 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) { @@ -392,7 +392,7 @@ 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) { @@ -402,112 +402,112 @@ 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); } @@ -515,7 +515,7 @@ void 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; @@ -547,7 +547,7 @@ set_irg_n_loc (ir_graph *irg, int n_loc) /* 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); } /* @@ -573,47 +573,47 @@ int node_is_in_irgs_storage(ir_graph *irg, ir_node *n) 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 @@ -633,37 +633,37 @@ set_irg_loopinfo_inconsistent(ir_graph *irg) { 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. */ @@ -671,7 +671,7 @@ static unsigned long max_irg_visited = 0; unsigned long (get_irg_visited)(const ir_graph *irg) { - return __get_irg_visited(irg); + return _get_irg_visited(irg); } void @@ -720,17 +720,17 @@ inc_max_irg_visited(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); } diff --git a/ir/ir/irgraph_t.h b/ir/ir/irgraph_t.h index 90af43e20..7739f07b0 100644 --- a/ir/ir/irgraph_t.h +++ b/ir/ir/irgraph_t.h @@ -157,241 +157,241 @@ int node_is_in_irgs_storage(ir_graph *irg, ir_node *n); 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; @@ -403,97 +403,97 @@ __set_irg_callee_info_state(ir_graph *irg, 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_ */ diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c index eebda3f51..afa850d47 100644 --- a/ir/ir/irgwalk.c +++ b/ir/ir/irgwalk.c @@ -526,7 +526,7 @@ void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) { /* 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); diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index 8334e4fee..07e6abb95 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -898,7 +898,7 @@ void 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; @@ -1165,7 +1165,7 @@ get_Call_type (ir_node *node) { 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; } diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index f4ad315bf..b1fd42197 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -638,22 +638,22 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) "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; @@ -678,7 +678,7 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) 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), @@ -752,7 +752,7 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) 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, -- 2.20.1