From 4b1138a9eee25ce11adbb7d7162eaa49421e8b51 Mon Sep 17 00:00:00 2001 From: Christoph Mallon Date: Thu, 11 Sep 2008 08:21:51 +0000 Subject: [PATCH] s/get_irn_op(x) {==,!=} op_FOO/{,!}is_FOO(x)/. [r21832] --- ir/ana/callgraph.c | 2 +- ir/ana/cgana.c | 2 +- ir/ana/execution_frequency.c | 23 +++++++-------- ir/ana/field_temperature.c | 15 +++++----- ir/ana/interval_analysis.c | 5 ++-- ir/ana/irscc.c | 15 +++++----- ir/ana/irsimpletype.c | 6 ++-- ir/ana/rta.c | 2 +- ir/ana/trouts.c | 6 ++-- ir/arch/archop.c | 2 +- ir/be/TEMPLATE/TEMPLATE_transform.c | 4 +-- ir/be/arm/arm_transform.c | 2 +- ir/be/arm/bearch_arm.c | 6 ++-- ir/be/belistsched.c | 2 +- ir/be/bespillremat.c | 2 +- ir/be/mips/bearch_mips.c | 2 +- ir/be/ppc32/ppc32_emitter.c | 2 +- ir/ir/ircgcons.c | 24 ++++++++-------- ir/ir/ircons.c | 10 +++---- ir/ir/irdump.c | 4 +-- ir/ir/irdumptxt.c | 26 ++++++++--------- ir/ir/irgraph.c | 2 +- ir/ir/irgwalk.c | 43 +++++++++++++++-------------- ir/ir/irnode.c | 6 ++-- ir/ir/iropt.c | 2 +- ir/ir/irvrfy.c | 12 ++++---- ir/lower/lower_hl.c | 7 ++--- ir/lower/lower_intrinsics.c | 2 +- ir/opt/cfopt.c | 4 +-- ir/opt/data_flow_scalar_replace.c | 40 ++++++++++++--------------- ir/opt/escape_ana.c | 4 +-- ir/opt/funccall.c | 5 ++-- ir/opt/ldstopt.c | 14 ++++------ ir/opt/opt_confirms.c | 2 +- ir/opt/opt_osr.c | 2 +- ir/opt/opt_polymorphy.c | 2 +- ir/opt/proc_cloning.c | 4 +-- ir/opt/scalar_replace.c | 7 ++--- ir/opt/tailrec.c | 2 +- ir/opt/tropt.c | 8 +++--- ir/stat/dags.c | 6 ++-- ir/stat/firmstat.c | 10 +++---- ir/tr/tr_inheritance.c | 2 +- ir/tr/type.c | 8 +++--- 44 files changed, 172 insertions(+), 184 deletions(-) diff --git a/ir/ana/callgraph.c b/ir/ana/callgraph.c index e0a2431e1..f9098c664 100644 --- a/ir/ana/callgraph.c +++ b/ir/ana/callgraph.c @@ -728,7 +728,7 @@ static int is_ip_head(ir_graph *n, ir_graph *pred) for (i = 0; i < arity; i++) { ir_node *pred_cfop = skip_Proj(get_Block_cfgpred(sblock, i)); //printf(" "); DDMN(pred_cfop); - if (get_irn_op(pred_cfop) == op_CallBegin) { /* could be Unknown */ + if (is_CallBegin(pred_cfop)) { /* could be Unknown */ ir_graph *ip_pred = get_irn_irg(pred_cfop); //printf(" "); DDMG(ip_pred); if ((ip_pred == pred) && is_backedge(sblock, i)) { diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c index 8c034616e..f3cf4b600 100644 --- a/ir/ana/cgana.c +++ b/ir/ana/cgana.c @@ -348,7 +348,7 @@ static void free_mark_proj(ir_node * node, long n, eset * set) { * op_Tuple oder ein Knoten, der in "free_ana_walker" behandelt * wird. */ ir_node * pred = get_Proj_pred(node); - if (get_irn_link(pred) != MARK && get_irn_op(pred) == op_Tuple) { + if (get_irn_link(pred) != MARK && is_Tuple(pred)) { free_mark_proj(get_Tuple_pred(pred, get_Proj_proj(node)), n, set); } else { /* nothing: da in "free_ana_walker" behandelt. */ diff --git a/ir/ana/execution_frequency.c b/ir/ana/execution_frequency.c index d95f84496..b20f5513f 100644 --- a/ir/ana/execution_frequency.c +++ b/ir/ana/execution_frequency.c @@ -192,12 +192,12 @@ static void my_irg_walk_current_graph(irg_walk_func *pre, irg_walk_func *post, v static void walk_pre(ir_node *n, void *env) { (void) env; - if (get_irn_op(n) == op_Raise) + if (is_Raise(n)) just_passed_a_Raise = 1; - if ( (get_irn_op(n) == op_Proj) - && (get_irn_op(get_Proj_pred(n)) == op_Cond) - && (just_passed_a_Raise)) { + if (get_irn_op(n) == op_Proj && + is_Cond(get_Proj_pred(n)) && + just_passed_a_Raise) { ir_node *other_proj; ir_node *c = get_Proj_pred(n); @@ -215,7 +215,7 @@ static void walk_pre(ir_node *n, void *env) } } - if (get_irn_op(n) == op_Cond) { + if (is_Cond(n)) { set_irn_link(n, Cond_list); Cond_list = n; } @@ -224,13 +224,14 @@ static void walk_pre(ir_node *n, void *env) static void walk_post(ir_node *n, void *env) { (void) env; - if (get_irn_op(n) == op_Raise) + if (is_Raise(n)) just_passed_a_Raise = 0; - if ( (get_irn_op(n) == op_Proj) - && (get_irn_op(get_Proj_pred(n)) == op_Cond) - && ((get_ProjX_probability(n) == Cond_prob_exception_taken) || - (get_ProjX_probability(n) == Cond_prob_was_exception_taken) )) { + if (get_irn_op(n) == op_Proj && + is_Cond(get_Proj_pred(n)) && ( + get_ProjX_probability(n) == Cond_prob_exception_taken || + get_ProjX_probability(n) == Cond_prob_was_exception_taken + )) { just_passed_a_Raise = 1; } } @@ -315,7 +316,7 @@ static INLINE double get_weighted_region_exec_freq(void *reg, int pos) { ir_node *cfop; if (is_ir_node(reg)) { cfop = get_Block_cfgpred((ir_node *)reg, pos); - if (is_Proj(cfop) && (get_irn_op(get_Proj_pred(cfop)) != op_Cond)) + if (is_Proj(cfop) && !is_Cond(get_Proj_pred(cfop))) cfop = skip_Proj(cfop); } else { assert(is_ir_loop(reg)); diff --git a/ir/ana/field_temperature.c b/ir/ana/field_temperature.c index 8b69bf29b..79cc55200 100644 --- a/ir/ana/field_temperature.c +++ b/ir/ana/field_temperature.c @@ -171,8 +171,8 @@ int get_type_estimated_n_fields(ir_type *tp) { case tpo_array: { long n_elt = DEFAULT_N_ARRAY_ELEMENTS; assert(get_array_n_dimensions(tp) == 1 && "other not implemented"); - if ((get_irn_op(get_array_lower_bound(tp, 0)) == op_Const) && - (get_irn_op(get_array_upper_bound(tp, 0)) == op_Const) ) { + if (is_Const(get_array_lower_bound(tp, 0)) && + is_Const(get_array_upper_bound(tp, 0))) { n_elt = get_array_upper_bound_int(tp, 0) - get_array_upper_bound_int(tp, 0); } s = n_elt; @@ -214,8 +214,8 @@ int get_type_estimated_size_bytes(ir_type *tp) { int elt_s = get_type_estimated_size_bytes(get_array_element_type(tp)); long n_elt = DEFAULT_N_ARRAY_ELEMENTS; assert(get_array_n_dimensions(tp) == 1 && "other not implemented"); - if ((get_irn_op(get_array_lower_bound(tp, 0)) == op_Const) && - (get_irn_op(get_array_upper_bound(tp, 0)) == op_Const) ) { + if (is_Const(get_array_lower_bound(tp, 0)) && + is_Const(get_array_upper_bound(tp, 0))) { n_elt = get_array_upper_bound_int(tp, 0) - get_array_lower_bound_int(tp, 0); } s = n_elt * elt_s; @@ -306,7 +306,7 @@ double get_entity_estimated_n_loads(ir_entity *ent) { double n_loads = 0; for (i = 0; i < n_acc; ++i) { ir_node *acc = get_entity_access(ent, i); - if (get_irn_op(acc) == op_Load) { + if (is_Load(acc)) { n_loads += get_irn_final_cost(acc); } } @@ -318,7 +318,7 @@ double get_entity_estimated_n_stores(ir_entity *ent) { double n_stores = 0; for (i = 0; i < n_acc; ++i) { ir_node *acc = get_entity_access(ent, i); - if (get_irn_op(acc) == op_Store) + if (is_Store(acc)) n_stores += get_irn_final_cost(acc); } return n_stores; @@ -330,8 +330,7 @@ double get_entity_estimated_n_calls(ir_entity *ent) { double n_calls = 0; for (i = 0; i < n_acc; ++i) { ir_node *acc = get_entity_access(ent, i); - if (get_irn_op(acc) == op_Call) - + if (is_Call(acc)) n_calls += get_irn_final_cost(acc); } return n_calls; diff --git a/ir/ana/interval_analysis.c b/ir/ana/interval_analysis.c index 9db46b604..fe96c3683 100644 --- a/ir/ana/interval_analysis.c +++ b/ir/ana/interval_analysis.c @@ -261,7 +261,7 @@ static void construct_interval_block(ir_node *b, ir_loop *l) { cfop = get_Block_cfgpred(b, i); if (is_Proj(cfop)) { - if (get_irn_op(get_Proj_pred(cfop)) != op_Cond) { + if (!is_Cond(get_Proj_pred(cfop))) { cfop = skip_Proj(cfop); } else { assert(get_nodes_block(cfop) == get_nodes_block(skip_Proj(cfop))); @@ -270,8 +270,7 @@ static void construct_interval_block(ir_node *b, ir_loop *l) { pred = skip_Proj(get_nodes_block(cfop)); /* We want nice blocks. */ - assert( get_irn_op(pred) != op_Bad - && get_irn_op(skip_Proj(get_Block_cfgpred(b, i))) != op_Bad); + assert(!is_Bad(pred) && !is_Bad(skip_Proj(get_Block_cfgpred(b, i)))); pred_l = get_irn_loop(pred); if (pred_l == l) { add_region_in(b, pred); diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c index 260b4a928..4ccbe9afb 100644 --- a/ir/ana/irscc.c +++ b/ir/ana/irscc.c @@ -393,11 +393,12 @@ static INLINE int get_start_index(ir_node *n) { not reachable. I.e., with this code, the order on the loop tree is correct. But a (single) test showed the loop tree is deeper. */ - if (get_irn_op(n) == op_Phi || - get_irn_op(n) == op_Block || - (get_irn_op(n) == op_Filter && get_interprocedural_view()) || - (get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats && - get_irn_pinned(n) == op_pin_state_floats)) + if (get_irn_op(n) == op_Phi || + is_Block(n) || + (is_Filter(n) && get_interprocedural_view()) || ( + get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats && + get_irn_pinned(n) == op_pin_state_floats + )) // Here we could test for backedge at -1 which is illegal return 0; else @@ -410,7 +411,7 @@ static INLINE int get_start_index(ir_node *n) { But it guarantees that Blocks are analysed before nodes contained in the block. If so, we can set the value to undef if the block is not \ executed. */ - if (is_cfop(n) || is_fragile_op(n) || get_irn_op(n) == op_Start) + if (is_cfop(n) || is_fragile_op(n) || is_Start(n)) return -1; else return 0; @@ -833,7 +834,7 @@ static void my_scc(ir_node *n) { ir_node *m; if (is_backedge(n, i)) continue; m = get_irn_n(n, i); /* get_irn_ip_pred(n, i); */ - /* if ((!m) || (get_irn_op(m) == op_Unknown)) continue; */ + /* if (!m || is_Unknown(m)) continue; */ my_scc(m); if (irn_is_in_stack(m)) { /* Uplink of m is smaller if n->m is a backedge. diff --git a/ir/ana/irsimpletype.c b/ir/ana/irsimpletype.c index 63c6c0a8a..918d78d0c 100644 --- a/ir/ana/irsimpletype.c +++ b/ir/ana/irsimpletype.c @@ -117,13 +117,13 @@ static ir_type *find_type_for_Proj(ir_node *n) { /* Deal with Start / Call here: we need to know the Proj Nr. */ assert(get_irn_mode(pred) == mode_T); pred_pred = get_Proj_pred(pred); - if (get_irn_op(pred_pred) == op_Start) { + if (is_Start(pred_pred)) { ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred))); tp = get_method_param_type(mtp, get_Proj_proj(n)); - } else if (get_irn_op(pred_pred) == op_Call) { + } else if (is_Call(pred_pred)) { ir_type *mtp = get_Call_type(pred_pred); tp = get_method_res_type(mtp, get_Proj_proj(n)); - } else if (get_irn_op(pred_pred) == op_Tuple) { + } else if (is_Tuple(pred_pred)) { panic("Encountered nested Tuple"); } else { DB((dbg, SET_LEVEL_1, "Proj %ld from Proj from ??: unknown type\n", get_irn_node_nr(n))); diff --git a/ir/ana/rta.c b/ir/ana/rta.c index 202433797..6c0b869b5 100644 --- a/ir/ana/rta.c +++ b/ir/ana/rta.c @@ -353,7 +353,7 @@ static void force_description (ir_entity *ent, ir_entity *addr) ir_node *f_addr = get_atomic_ent_value (over); ir_entity *impl_ent = get_SymConst_entity (f_addr); - assert ((get_irn_op(f_addr) == op_SymConst) && "can't do complex addrs"); + assert(is_SymConst(f_addr) && "can't do complex addrs"); if (impl_ent == addr) { assert (0 && "gibt's denn sowas"); force_description (over, addr); diff --git a/ir/ana/trouts.c b/ir/ana/trouts.c index cc84fa843..9a89857c4 100644 --- a/ir/ana/trouts.c +++ b/ir/ana/trouts.c @@ -548,10 +548,10 @@ static void chain_accesses(ir_node *n, void *env) { ir_node *addr; (void) env; - if (get_irn_op(n) == op_Alloc) { + if (is_Alloc(n)) { add_type_alloc(get_Alloc_type(n), n); return; - } else if (get_irn_op(n) == op_Cast) { + } else if (is_Cast(n)) { add_type_cast(get_Cast_type(n), n); return; } else if (is_Sel(n)) { @@ -562,7 +562,7 @@ static void chain_accesses(ir_node *n, void *env) { return; } else if (is_memop(n)) { addr = get_memop_ptr(n); - } else if (get_irn_op(n) == op_Call) { + } else if (is_Call(n)) { addr = get_Call_ptr(n); if (! is_Sel(addr)) return; /* Sels before Calls mean a Load / polymorphic Call. */ } else { diff --git a/ir/arch/archop.c b/ir/arch/archop.c index 1264df948..f255688aa 100644 --- a/ir/arch/archop.c +++ b/ir/arch/archop.c @@ -240,7 +240,7 @@ ir_node *arch_transform_node_Mux(ir_node *n) return n; cmp = get_Proj_pred(proj); - if (get_irn_op(cmp) == op_Cmp) { + if (is_Cmp(cmp)) { ir_node *a = get_Cmp_left(cmp); ir_node *b = get_Cmp_right(cmp); ir_node *t = get_Mux_true(n); diff --git a/ir/be/TEMPLATE/TEMPLATE_transform.c b/ir/be/TEMPLATE/TEMPLATE_transform.c index f345e3dbf..58edd66c9 100644 --- a/ir/be/TEMPLATE/TEMPLATE_transform.c +++ b/ir/be/TEMPLATE/TEMPLATE_transform.c @@ -402,8 +402,8 @@ void TEMPLATE_transform_node(ir_node *node, void *env) { default: if (get_irn_op(node) == get_op_Max() || - get_irn_op(node) == get_op_Min() || - get_irn_op(node) == get_op_Mulh()) + get_irn_op(node) == get_op_Min() || + is_Mulh(node)) { /* TODO: implement */ /* ignore for now */ diff --git a/ir/be/arm/arm_transform.c b/ir/be/arm/arm_transform.c index aa376a911..ee4588b4d 100644 --- a/ir/be/arm/arm_transform.c +++ b/ir/be/arm/arm_transform.c @@ -1493,7 +1493,7 @@ static ir_node *gen_Proj(ir_node *node) { return gen_Proj_be_AddSP(node); } else if (is_Cmp(pred)) { return gen_Proj_Cmp(node); - } else if (get_irn_op(pred) == op_Start) { + } else if (is_Start(pred)) { if (proj == pn_Start_X_initial_exec) { ir_node *block = get_nodes_block(pred); ir_node *jump; diff --git a/ir/be/arm/bearch_arm.c b/ir/be/arm/bearch_arm.c index b2a3d74f6..b71106532 100644 --- a/ir/be/arm/bearch_arm.c +++ b/ir/be/arm/bearch_arm.c @@ -383,8 +383,7 @@ static ir_node *convert_dbl_to_int(ir_node *bl, ir_node *arg, ir_node *mem, v = (v << 8) | get_tarval_sub_bits(tv, 1); v = (v << 8) | get_tarval_sub_bits(tv, 0); *resL = new_Const_long(mode_Is, v); - } - else if (get_irn_op(skip_Proj(arg)) == op_Load) { + } else if (is_Load(skip_Proj(arg))) { /* FIXME: handling of low/high depends on LE/BE here */ assert(0); } @@ -423,8 +422,7 @@ static ir_node *convert_sng_to_int(ir_node *bl, ir_node *arg) v = (v << 8) | get_tarval_sub_bits(tv, 1); v = (v << 8) | get_tarval_sub_bits(tv, 0); return new_Const_long(mode_Is, v); - } - else if (get_irn_op(skip_Proj(arg)) == op_Load) { + } else if (is_Load(skip_Proj(arg))) { ir_node *load; load = skip_Proj(arg); diff --git a/ir/be/belistsched.c b/ir/be/belistsched.c index cf31ea45e..53f2616ff 100644 --- a/ir/be/belistsched.c +++ b/ir/be/belistsched.c @@ -229,7 +229,7 @@ static INLINE int make_ready(block_sched_env_t *env, ir_node *pred, ir_node *irn /* if irn is an End we have keep-alives and op might be a block, skip that */ if (is_Block(op)) { - assert(get_irn_op(irn) == op_End); + assert(is_End(irn)); continue; } diff --git a/ir/be/bespillremat.c b/ir/be/bespillremat.c index 2d418f637..f293b8ed6 100644 --- a/ir/be/bespillremat.c +++ b/ir/be/bespillremat.c @@ -482,7 +482,7 @@ is_rematerializable(const spill_ilp_t * si, const ir_node * irn) for (n = get_irn_arity(irn)-1; n>=0 && remat; --n) { ir_node *op = get_irn_n(irn, n); - remat &= has_reg_class(si, op) || arch_irn_get_flags(arch_env, op) & arch_irn_flags_ignore || (get_irn_op(op) == op_NoMem); + remat &= has_reg_class(si, op) || arch_irn_get_flags(arch_env, op) & arch_irn_flags_ignore || is_NoMem(op); // if(!remat) // ir_fprintf(stderr, " Argument %d (%+F) of Node %+F has wrong regclass\n", i, op, irn); diff --git a/ir/be/mips/bearch_mips.c b/ir/be/mips/bearch_mips.c index ca2d99487..58aa6a657 100644 --- a/ir/be/mips/bearch_mips.c +++ b/ir/be/mips/bearch_mips.c @@ -398,7 +398,7 @@ typedef struct _wenv_t { static void collect_copyb_nodes(ir_node *node, void *env) { wenv_t *wenv = env; - if (get_irn_op(node) == op_CopyB) { + if (is_CopyB(node)) { set_irn_link(node, wenv->list); wenv->list = node; } diff --git a/ir/be/ppc32/ppc32_emitter.c b/ir/be/ppc32/ppc32_emitter.c index 6acdf712a..a5a0d6e0e 100644 --- a/ir/be/ppc32/ppc32_emitter.c +++ b/ir/be/ppc32/ppc32_emitter.c @@ -494,7 +494,7 @@ static void emit_be_Perm(const ir_node *irn) { static void emit_Proj(const ir_node *irn) { ir_node *pred = get_Proj_pred(irn); - if (get_irn_op(pred) == op_Start) { + if (is_Start(pred)) { if (get_Proj_proj(irn) == pn_Start_X_initial_exec) { emit_Jmp(irn); } diff --git a/ir/ir/ircgcons.c b/ir/ir/ircgcons.c index d1fff05f8..f6596d661 100644 --- a/ir/ir/ircgcons.c +++ b/ir/ir/ircgcons.c @@ -96,7 +96,7 @@ static void caller_init(int arr_length, ir_entity ** free_methods) { ir_node * call; /* We collected all call nodes in a link list at the end node. */ for (call = get_irn_link(get_irg_end(irg)); call; call = get_irn_link(call)) { - if (get_irn_op(call) != op_Call) continue; + if (!is_Call(call)) continue; for (j = get_Call_n_callees(call) - 1; j >= 0; --j) { ir_entity * ent = get_Call_callee(call, j); if (get_entity_irg(ent)) { @@ -126,7 +126,7 @@ static INLINE ir_node * tail(ir_node * node) { * (auch bei Proj->Call Operationen) und Phi-Operationen in die Liste ihres * Grundblocks einfügen. */ static void collect_phicallproj_walker(ir_node * node, ir_node ** call_tail) { - if (get_irn_op(node) == op_Call) { + if (is_Call(node)) { /* Die Liste von Call an call_tail anhängen. */ ir_node * link; assert(get_irn_link(*call_tail) == NULL); @@ -261,9 +261,9 @@ static void prepare_irg(ir_graph * irg, irg_data_t * data) { * dass oben für "verschiedene" Proj-Operationen wegen CSE nur eine * Filter-Operation erzeugt worden sein kann. */ for (link = get_irg_start(irg), proj = get_irn_link(link); proj; proj = get_irn_link(proj)) { - if (get_irn_op(proj) == op_Id) { /* replaced with filter */ + if (is_Id(proj)) { /* replaced with filter */ ir_node * filter = get_Id_pred(proj); - assert(get_irn_op(filter) == op_Filter); + assert(is_Filter(filter)); if (filter != link && get_irn_link(filter) == NULL) { set_irn_link(link, filter); link = filter; @@ -279,7 +279,7 @@ static void prepare_irg(ir_graph * irg, irg_data_t * data) { if (data->open) { set_Block_cg_cfgpred(start_block, 0, get_cg_Unknown(mode_X)); for (proj = get_irn_link(get_irg_start(irg)); proj; proj = get_irn_link(proj)) { - if (get_irn_op(proj) == op_Filter) { + if (is_Filter(proj)) { set_Filter_cg_pred(proj, 0, get_cg_Unknown(get_irn_mode(proj))); } } @@ -457,7 +457,7 @@ static void move_nodes(ir_node * from_block, ir_node * to_block, ir_node * node) /* Move projs of this node. */ proj = get_irn_link(node); for (; proj; proj = skip_Id(get_irn_link(proj))) { - if (get_irn_op(proj) != op_Proj && get_irn_op(proj) != op_Filter) continue; + if (get_irn_op(proj) != op_Proj && !is_Filter(proj)) continue; if ((get_nodes_block(proj) == from_block) && (skip_Proj(get_irn_n(proj, 0)) == node)) set_nodes_block(proj, to_block); } @@ -482,7 +482,7 @@ static void construct_start(ir_entity * caller, ir_entity * callee, set_Block_cg_cfgpred(get_nodes_block(start), data->count, exec); for (filter = get_irn_link(start); filter; filter = get_irn_link(filter)) { - if (get_irn_op(filter) != op_Filter) continue; + if (!is_Filter(filter)) continue; if (get_Proj_pred(filter) == start) { switch ((int) get_Proj_proj(filter)) { case pn_Start_M: @@ -573,7 +573,7 @@ static ir_node * get_except(ir_node * call) { * Aufrufstelle nur ein einziges Mal aufgerufen. */ ir_node * proj; for (proj = get_irn_link(call); proj && get_irn_op(proj) == op_Proj; proj = get_irn_link(proj)) { - if (get_Proj_proj(proj) == 1 && get_irn_op(get_Proj_pred(proj)) == op_Call) { + if (get_Proj_proj(proj) == 1 && is_Call(get_Proj_pred(proj))) { return proj; } } @@ -857,7 +857,7 @@ void cg_construct(int arr_len, ir_entity ** free_methods_arr) { current_ir_graph = get_irp_irg(i); for (node = get_irn_link(get_irg_end(current_ir_graph)); node; node = get_irn_link(node)) { - if (get_irn_op(node) == op_Call) { + if (is_Call(node)) { int j, n_callees = get_Call_n_callees(node); for (j = 0; j < n_callees; ++j) if (get_entity_irg(get_Call_callee(node, j))) @@ -881,7 +881,7 @@ void cg_construct(int arr_len, ir_entity ** free_methods_arr) { static void destruct_walker(ir_node * node, void * env) { (void) env; - if (get_irn_op(node) == op_Block) { + if (is_Block(node)) { remove_Block_cg_cfgpred_arr(node); /* Do not turn Break into Jmp. Better: merge blocks right away. Well, but there are Breaks left. @@ -891,13 +891,13 @@ static void destruct_walker(ir_node * node, void * env) if (get_irn_op(pred) == op_Break) exchange(node, get_nodes_block(pred)); } - } else if (get_irn_op(node) == op_Filter) { + } else if (is_Filter(node)) { set_irg_current_block(current_ir_graph, get_nodes_block(node)); exchange(node, new_Proj(get_Filter_pred(node), get_irn_mode(node), get_Filter_proj(node))); } else if (get_irn_op(node) == op_Break) { set_irg_current_block(current_ir_graph, get_nodes_block(node)); exchange(node, new_Jmp()); - } else if (get_irn_op(node) == op_Call) { + } else if (is_Call(node)) { remove_Call_callee_arr(node); } else if (get_irn_op(node) == op_Proj) { /* some ProjX end up in strange blocks. */ diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index b901811e9..3809b8b83 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -254,7 +254,7 @@ new_bd_Phi(dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode) res->attr.phi.u.backedge = new_backedge_arr(irg->obst, arity); for (i = arity - 1; i >= 0; --i) - if (get_irn_op(in[i]) == op_Unknown) { + if (is_Unknown(in[i])) { has_unknown = 1; break; } @@ -1744,7 +1744,7 @@ new_d_Block(dbg_info *db, int arity, ir_node **in) { } for (i = arity-1; i >= 0; i--) - if (get_irn_op(in[i]) == op_Unknown) { + if (is_Unknown(in[i])) { has_unknown = 1; break; } @@ -1897,11 +1897,11 @@ static INLINE ir_node **new_frag_arr(ir_node *n) { finished yet. */ opt = get_opt_optimize(); set_optimize(0); /* Here we rely on the fact that all frag ops have Memory as first result! */ - if (get_irn_op(n) == op_Call) + if (is_Call(n)) { arr[0] = new_Proj(n, mode_M, pn_Call_M_except); - else if (get_irn_op(n) == op_CopyB) + } else if (is_CopyB(n)) { arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except); - else { + } else { assert((pn_Quot_M == pn_DivMod_M) && (pn_Quot_M == pn_Div_M) && (pn_Quot_M == pn_Mod_M) && diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 6fd63ce49..9f3355a2e 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -801,7 +801,7 @@ int dump_node_opcode(FILE *F, ir_node *n) case iro_CallBegin: { ir_node *addr = get_CallBegin_ptr(n); ir_entity *ent = NULL; - if (get_irn_op(addr) == op_Sel) + if (is_Sel(addr)) ent = get_Sel_entity(addr); else if (is_Global(addr)) ent = get_Global_entity(addr); @@ -2728,7 +2728,7 @@ dump_block_to_cfg(ir_node *block, void *env) { fprintf(F, "}\n"); /* Dump the edges */ for ( i = 0; i < get_Block_n_cfgpreds(block); i++) - if (get_irn_op(skip_Proj(get_Block_cfgpred(block, i))) != op_Bad) { + if (!is_Bad(skip_Proj(get_Block_cfgpred(block, i)))) { pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i))); fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(block); diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c index c543596c8..918bf62e2 100644 --- a/ir/ir/irdumptxt.c +++ b/ir/ir/irdumptxt.c @@ -180,9 +180,9 @@ int dump_irnode_to_file(FILE *F, ir_node *n) { } /* This is not nice, output it as a marker in the predecessor list. */ - if ((get_irn_op(n) == op_Block) || - (get_irn_op(n) == op_Phi) || - ((get_irn_op(n) == op_Filter) && get_interprocedural_view())) { + if (is_Block(n) || + get_irn_op(n) == op_Phi || + (is_Filter(n) && get_interprocedural_view())) { fprintf(F, " backedges:"); comma = ' '; for (i = 0; i < get_irn_arity(n); i++) @@ -831,14 +831,14 @@ void dump_entity_to_file_prefix(FILE *F, ir_entity *ent, char *prefix, unsigned ir_node *acc = get_entity_access(ent, i); int depth = get_weighted_loop_depth(acc); assert(depth < max_depth); - if ((get_irn_op(acc) == op_Load) || (get_irn_op(acc) == op_Call)) { + if (is_Load(acc) || is_Call(acc)) { L_freq[depth]++; max_L_freq = (depth > max_L_freq) ? depth : max_L_freq; if (addr_is_alloc(acc)) { LA_freq[depth]++; max_LA_freq = (depth > max_LA_freq) ? depth : max_LA_freq; } - } else if (get_irn_op(acc) == op_Store) { + } else if (is_Store(acc)) { S_freq[depth]++; max_S_freq = (depth > max_S_freq) ? depth : max_S_freq; if (addr_is_alloc(acc)) { @@ -964,7 +964,7 @@ void dump_entitycsv_to_file_prefix(FILE *F, ir_entity *ent, char *prefix, ir_node *acc = get_entity_access(ent, i); int depth = get_weighted_loop_depth(acc); assert(depth <= max_depth); - if ((get_irn_op(acc) == op_Load) || (get_irn_op(acc) == op_Call)) { + if (is_Load(acc) || is_Call(acc)) { L_freq[depth]++; max_L_freq = (depth > max_L_freq) ? depth : max_L_freq; if (addr_is_alloc(acc)) { @@ -975,7 +975,7 @@ void dump_entitycsv_to_file_prefix(FILE *F, ir_entity *ent, char *prefix, disp[depth]++; *max_disp = (depth > *max_disp) ? depth : *max_disp; } - } else if (get_irn_op(acc) == op_Store) { + } else if (is_Store(acc)) { S_freq[depth]++; max_S_freq = (depth > max_S_freq) ? depth : max_S_freq; if (addr_is_alloc(acc)) { @@ -1069,7 +1069,7 @@ void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const assert(depth <= max_depth); freq[depth]++; max_freq = (depth > max_freq) ? depth : max_freq; - assert(get_irn_op(all) == op_Alloc); + assert(is_Alloc(all)); } fprintf(F, "%s ", get_type_name(tp)); @@ -1222,16 +1222,16 @@ void dump_type_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity) { fprintf(F, "["); - if (get_irn_op(lower) == op_Const) + if (is_Const(lower)) { fprintf(F, "%ld .. ", get_tarval_long(get_Const_tarval(lower))); - else { + } else { dump_node_opcode(F, lower); fprintf(F, " %ld .. ", get_irn_node_nr(lower)); } - if (get_irn_op(upper) == op_Const) + if (is_Const(upper)) { fprintf(F, "%ld]", get_tarval_long(get_Const_tarval(lower))); - else { + } else { dump_node_opcode(F, upper); fprintf(F, " %ld]", get_irn_node_nr(upper)); } @@ -1339,7 +1339,7 @@ void dump_type_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity) { assert(depth <= max_depth); freq[depth]++; max_freq = (depth > max_freq) ? depth : max_freq; - assert(get_irn_op(all) == op_Alloc); + assert(is_Alloc(all)); } if (max_freq >= 0) { diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 81d2de588..16fd03682 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -643,7 +643,7 @@ ir_node * void (set_irg_end_except)(ir_graph *irg, ir_node *node) { - assert(get_irn_op(node) == op_EndExcept || get_irn_op(node) == op_End); + assert(get_irn_op(node) == op_EndExcept || is_End(node)); _set_irg_end_except(irg, node); } diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c index 9fe4f81b4..cd6aac5a8 100644 --- a/ir/ir/irgwalk.c +++ b/ir/ir/irgwalk.c @@ -66,43 +66,44 @@ static void irg_walk_cg(ir_node * node, unsigned long visited, if (pre) pre(node, env); pred = skip_Proj(node); - if (get_irn_op(pred) == op_CallBegin - || get_irn_op(pred) == op_EndReg - || get_irn_op(pred) == op_EndExcept) { - current_ir_graph = get_irn_irg(pred); + if (is_CallBegin(pred) || + get_irn_op(pred) == op_EndReg || + get_irn_op(pred) == op_EndExcept) { + current_ir_graph = get_irn_irg(pred); } if (is_no_Block(node)) { /* not block */ irg_walk_cg(get_nodes_block(node), visited, irg_set, pre, post, env); } - if (get_irn_op(node) == op_Block) { /* block */ + if (is_Block(node)) { /* block */ for (i = get_irn_arity(node) - 1; i >= 0; --i) { ir_node * exec = get_irn_n(node, i); ir_node * pred = skip_Proj(exec); - if ((get_irn_op(pred) != op_CallBegin - && get_irn_op(pred) != op_EndReg - && get_irn_op(pred) != op_EndExcept) - || pset_new_contains(irg_set, get_irn_irg(pred))) { - irg_walk_cg(exec, visited, irg_set, pre, post, env); + if (( + !is_CallBegin(pred) && + get_irn_op(pred) != op_EndReg && + get_irn_op(pred) != op_EndExcept + ) || pset_new_contains(irg_set, get_irn_irg(pred))) { + irg_walk_cg(exec, visited, irg_set, pre, post, env); } } - } else if (get_irn_op(node) == op_Filter) { /* filter */ + } else if (is_Filter(node)) { /* filter */ for (i = get_irn_arity(node) - 1; i >= 0; --i) { ir_node * pred = get_irn_n(node, i); - if (get_irn_op(pred) == op_Unknown || get_irn_op(pred) == op_Bad) { + if (is_Unknown(pred) || is_Bad(pred)) { irg_walk_cg(pred, visited, irg_set, pre, post, env); } else { ir_node * exec; exec = skip_Proj(get_Block_cfgpred(get_nodes_block(node), i)); - if (op_Bad == get_irn_op (exec)) { + if (is_Bad(exec)) { continue; } - assert(get_irn_op(exec) == op_CallBegin - || get_irn_op(exec) == op_EndReg - || get_irn_op(exec) == op_EndExcept); + assert(is_CallBegin(exec) || + get_irn_op(exec) == op_EndReg || + get_irn_op(exec) == op_EndExcept); if (pset_new_contains(irg_set, get_irn_irg(exec))) { current_ir_graph = get_irn_irg(exec); irg_walk_cg(pred, visited, irg_set, pre, post, env); @@ -458,9 +459,9 @@ switch_irg(ir_node *n, int index) { if (get_interprocedural_view()) { /* Only Filter and Block nodes can have predecessors in other graphs. */ - if (get_irn_op(n) == op_Filter) + if (is_Filter(n)) n = get_nodes_block(n); - if (get_irn_op(n) == op_Block) { + if (is_Block(n)) { ir_node *cfop = skip_Proj(get_Block_cfgpred(n, index)); if (is_ip_cfop(cfop)) { current_ir_graph = get_irn_irg(cfop); @@ -613,15 +614,15 @@ void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void ir_reserve_resources(irg, IR_RESOURCE_BLOCK_VISITED); inc_irg_block_visited(irg); block = is_Block(node) ? node : get_nodes_block(node); - assert(get_irn_op(block) == op_Block); + assert(is_Block(block)); irg_block_walk_2(block, pre, post, env); /* keepalive: the endless loops ... */ - if (get_irn_op(node) == op_End) { + if (is_End(node)) { int arity = get_irn_arity(node); for (i = 0; i < arity; i++) { pred = get_irn_n(node, i); - if (get_irn_op(pred) == op_Block) + if (is_Block(pred)) irg_block_walk_2(pred, pre, post, env); } /* Sometimes the blocks died, but are still reachable through Phis. diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index c485e94a0..a82224df1 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -483,7 +483,7 @@ op_pin_state (is_irn_pinned_in_irg) (const ir_node *node) { void set_irn_pinned(ir_node *node, op_pin_state state) { /* due to optimization an opt may be turned into a Tuple */ - if (get_irn_op(node) == op_Tuple) + if (is_Tuple(node)) return; assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned); @@ -2449,7 +2449,7 @@ get_irn_irg(const ir_node *node) { node = get_irn_n(node, -1); if (is_Bad(node)) /* sometimes bad is predecessor of nodes instead of block: in case of optimization */ node = get_irn_n(node, -1); - assert(get_irn_op(node) == op_Block); + assert(is_Block(node)); return node->attr.block.irg; } @@ -2537,7 +2537,7 @@ ir_node *skip_Pin(ir_node *node) { /* returns operand of node if node is a Confirm */ ir_node *skip_Confirm(ir_node *node) { - if (get_irn_op(node) == op_Confirm) + if (is_Confirm(node)) return get_Confirm_value(node); return node; } diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 219c7d72a..a43b9306c 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -4341,7 +4341,7 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) { else if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) { if (tv != tarval_bad) { /* c >= 0 : Abs(a) <= c ==> (unsigned)(a + c) <= 2*c */ - if (get_irn_op(left) == op_Abs) { // TODO something is missing here + if (is_Abs(left)) { // TODO something is missing here } } } diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index 457bc623b..57d5a283a 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -283,7 +283,7 @@ static void show_phi_inputs(ir_node *phi, ir_node *block) { * @param ptr the node representing the address */ static ir_entity *get_ptr_entity(ir_node *ptr) { - if (get_irn_op(ptr) == op_Sel) { + if (is_Sel(ptr)) { return get_Sel_entity(ptr); } else if (is_SymConst_addr_ent(ptr)) { return get_SymConst_entity(ptr); @@ -394,15 +394,15 @@ static int verify_node_Proj_Call(ir_node *n, ir_node *p) { /* if we have exception flow, we must have a real Memory input */ if (proj == pn_Call_X_regular) ASSERT_AND_RET( - get_irn_op(get_Call_mem(n)) != op_NoMem, + !is_NoMem(get_Call_mem(n)), "Regular Proj from FunctionCall", 0); else if (proj == pn_Call_X_except) ASSERT_AND_RET( - get_irn_op(get_Call_mem(n)) != op_NoMem, + !is_NoMem(get_Call_mem(n)), "Exception Proj from FunctionCall", 0); else if (proj == pn_Call_M_regular || proj == pn_Call_M_except) ASSERT_AND_RET( - (get_irn_op(get_Call_mem(n)) != op_NoMem || 1), + (!is_NoMem(get_Call_mem(n)) || 1), "Memory Proj from FunctionCall", 0); return 1; } @@ -1614,7 +1614,7 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) { /* Phi: BB x dataM^n --> dataM */ for (i = get_irn_arity(n) - 1; i >= 0; --i) { ir_node *pred = get_irn_n(n, i); - if (!is_Bad(pred) && (get_irn_op(pred) != op_Unknown)) { + if (!is_Bad(pred) && !is_Unknown(pred)) { ASSERT_AND_RET_DBG( get_irn_mode(pred) == mymode, "Phi node", 0, @@ -2145,7 +2145,7 @@ static void check_bads(ir_node *node, void *env) { } if ((venv->flags & TUPLE) == 0) { - if (get_irn_op(node) == op_Tuple) { + if (is_Tuple(node)) { venv->res |= TUPLE; if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { diff --git a/ir/lower/lower_hl.c b/ir/lower/lower_hl.c index f1263f8f1..dbb35c3e0 100644 --- a/ir/lower/lower_hl.c +++ b/ir/lower/lower_hl.c @@ -354,7 +354,7 @@ static void lower_bitfields_loads(ir_node *proj, ir_node *load) { int offset, bit_offset, bits, bf_bits, old_cse; dbg_info *db; - if (get_irn_op(sel) != op_Sel) + if (!is_Sel(sel)) return; ent = get_Sel_entity(sel); @@ -447,7 +447,7 @@ static void lower_bitfields_stores(ir_node *store) { dbg_info *db; /* check bitfield access */ - if (get_irn_op(sel) != op_Sel) + if (!is_Sel(sel)) return; ent = get_Sel_entity(sel); @@ -568,9 +568,8 @@ static void lower_bf_access(ir_node *irn, void *env) { { long proj = get_Proj_proj(irn); ir_node *pred = get_Proj_pred(irn); - ir_op *op = get_irn_op(pred); - if ((proj == pn_Load_res) && (op == op_Load)) + if (proj == pn_Load_res && is_Load(pred)) lower_bitfields_loads(irn, pred); break; } diff --git a/ir/lower/lower_intrinsics.c b/ir/lower/lower_intrinsics.c index 6c95c3107..cd4240eed 100644 --- a/ir/lower/lower_intrinsics.c +++ b/ir/lower/lower_intrinsics.c @@ -949,7 +949,7 @@ int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt) { set_Tuple_pred(node, i, new_r_Bad(irg)); if (rt->mem_proj_nr >= 0) set_Tuple_pred(node, rt->mem_proj_nr, new_r_Proj(irg, bl, call, mode_M, pn_Call_M_regular)); - if (get_irn_op(mem) != op_NoMem) { + if (!is_NoMem(mem)) { /* Exceptions can only be handled with real memory */ if (rt->regular_proj_nr >= 0) set_Tuple_pred(node, rt->regular_proj_nr, new_r_Proj(irg, bl, call, mode_X, pn_Call_X_regular)); diff --git a/ir/opt/cfopt.c b/ir/opt/cfopt.c index e0cd1ac0d..36afa0f36 100644 --- a/ir/opt/cfopt.c +++ b/ir/opt/cfopt.c @@ -788,9 +788,7 @@ restart: ir_node *ka = get_End_keepalive(end, i); if (irn_not_visited(ka)) { - ir_op *op = get_irn_op(ka); - - if ((op == op_Block) && !Block_block_visited(ka)) { + if (is_Block(ka) && !Block_block_visited(ka)) { /* irg_block_walk() will increase the block visited flag, but we must visit only these blocks that are not visited yet, so decrease it first. */ set_irg_block_visited(irg, get_irg_block_visited(irg) - 1); diff --git a/ir/opt/data_flow_scalar_replace.c b/ir/opt/data_flow_scalar_replace.c index fb7800402..8d3f0882a 100644 --- a/ir/opt/data_flow_scalar_replace.c +++ b/ir/opt/data_flow_scalar_replace.c @@ -233,7 +233,7 @@ static int is_const_sel(ir_node *sel) { for (i = 0; i < n; ++i) { ir_node *idx = get_Sel_index(sel, i); - if (get_irn_op(idx) != op_Const) + if (!is_Const(idx)) return 0; } return 1; @@ -302,9 +302,8 @@ static void link_all_leave_sels(ir_entity *ent, ir_node *sel) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(sel, i); - if (get_irn_op(succ) == op_Sel) + if (is_Sel(succ)) link_all_leave_sels(ent, succ); - } /* if Sel nodes with memory inputs are used, a entity can be @@ -361,7 +360,7 @@ static int find_possible_replacements(ir_graph *irg) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); set_entity_link(ent, NULL); } @@ -375,7 +374,7 @@ static int find_possible_replacements(ir_graph *irg) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); ir_type *ent_type; @@ -421,7 +420,7 @@ static int is_leave_sel(ir_node *sel) { for(i = get_irn_n_outs(sel) - 1; i >= 0; i--) { succ = get_irn_out(sel, i); - if(get_irn_op(succ) == op_Sel) + if (is_Sel(succ)) return 0; } @@ -444,7 +443,7 @@ static path_t *find_path(ir_node *sel, unsigned len) n = get_Sel_n_indexs(sel); len += n + 1; - if (get_irn_op(pred) != op_Sel) { + if (!is_Sel(pred)) { /* we found the root */ res = xmalloc(sizeof(*res) + (len - 1) * sizeof(res->path)); @@ -459,7 +458,7 @@ static path_t *find_path(ir_node *sel, unsigned len) for (i = 0; i < n; ++i) { ir_node *index = get_Sel_index(sel, i); - if(get_irn_op(index) == op_Const) + if (is_Const(index)) res->path[pos++].tv = get_Const_tarval(index); } return res; @@ -658,7 +657,7 @@ static void sync_stored_scalars(ir_node *blk, env_t *env) { /* We must check this, why it is possible to get a Bad node * form new_r_Sync(), when the node can be optimized. * In this case we must do nothing.*/ - if(get_irn_op(sync) == op_Sync) { + if (is_Sync(sync)) { val_arr[env->gl_mem_vnum].mem_edge_state = sync; /* We add this sync node to the sync's fix list.*/ add_sync_to_fixlist(val_arr[env->gl_mem_vnum].mem_edge_state, unk_vnum, env); @@ -885,8 +884,7 @@ static void split_call_mem_edge(env_t *env, ir_node *call, pset *accessed_entiti /* We must check this, why it is possible to get a Bad node * form new_r_Sync(), when the node can be optimized. * In this case we must do nothing.*/ - if(get_irn_op(sync) == op_Sync) { - + if (is_Sync(sync)) { set_Call_mem(call, sync); if(ARR_LEN(accessed_leaves_vnum)) /* We add this sync node to the sync's fix list.*/ @@ -943,7 +941,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) { /* Calls that have a NoMem input do neither read nor write memory. We can completely ignore them here. */ - if (get_irn_op(get_Call_mem(irn)) == op_NoMem) + if (is_NoMem(get_Call_mem(irn))) return; /* We save in this set all entities, @@ -955,7 +953,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) { sel = get_Call_param(irn, i); value_sels = NULL; - if(get_irn_op(sel) == op_Sel) { + if (is_Sel(sel)) { key_sels.sel = sel; value_sels = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel)); @@ -1100,7 +1098,7 @@ static void fix_syncs(env_t *env) pred = get_nodes_block(pred); /* We first repair the global memory edge at the first position of sync predecessors.*/ - if(get_irn_op(get_irn_n(sync, 0)) == op_Unknown) { + if (is_Unknown(get_irn_n(sync, 0))) { inc_irg_block_visited(current_ir_graph); val = find_vnum_value(pred, env->gl_mem_vnum); @@ -1112,7 +1110,7 @@ static void fix_syncs(env_t *env) /* We repair the leaves*/ assert(k <= ARR_LEN(l->accessed_vnum) && "The algorythm for sync repair is wron"); - if(get_irn_op(get_irn_n(sync, i)) == op_Unknown) { + if (is_Unknown(get_irn_n(sync, i))) { inc_irg_block_visited(current_ir_graph); val = find_vnum_value(pred, l->accessed_vnum[k++]); @@ -1218,7 +1216,6 @@ static void analyse_calls(ir_node *irn, void *ctx) { int i, vnum; unsigned int acces_type; ir_node *param, *call_ptr, *blk; - ir_op *op; ir_entity *meth_ent; sels_t key_sels, *value_sels; call_access_t key_call, *value_call; @@ -1226,18 +1223,18 @@ static void analyse_calls(ir_node *irn, void *ctx) { env_t *env; env = ctx; - if(get_irn_op(irn) != op_Call) + if (!is_Call(irn)) return; /* Calls that have a NoMem input do neither read nor write memory. We can completely ignore them here. */ - if (get_irn_op(get_Call_mem(irn)) == op_NoMem) + if (is_NoMem(get_Call_mem(irn))) return; /* We iterate over the parameters of this call nodes.*/ for ( i = get_Call_n_params(irn) - 1; i >= 0; i--) { param = get_Call_param(irn, i); - if(get_irn_op(param) == op_Sel) { + if (is_Sel(param)) { /* We have found a parameter with operation sel.*/ key_sels.sel = param; value_sels = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel)); @@ -1245,9 +1242,8 @@ static void analyse_calls(ir_node *irn, void *ctx) { /* We have found a call, that have as parameter a sel from our set_sels.*/ call_ptr = get_Call_ptr(irn); - op = get_irn_op(call_ptr); - if(op == op_SymConst && get_SymConst_kind(call_ptr) == symconst_addr_ent) { + if (is_SymConst(call_ptr) && get_SymConst_kind(call_ptr) == symconst_addr_ent) { meth_ent = get_SymConst_entity(call_ptr); /* we get the access type for our sel.*/ acces_type = get_method_param_access(meth_ent, i); @@ -1516,7 +1512,7 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) { for (i = 0 ; i < get_irn_n_outs(irg_frame); i++) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); if (get_entity_link(ent) == NULL || get_entity_link(ent) == ADDRESS_TAKEN) diff --git a/ir/opt/escape_ana.c b/ir/opt/escape_ana.c index 106abe4b7..ea0f4e00b 100644 --- a/ir/opt/escape_ana.c +++ b/ir/opt/escape_ana.c @@ -122,7 +122,7 @@ static int is_method_leaving_raise(ir_node *raise) static ir_node *is_depend_alloc(ir_node *adr) { ir_node *alloc; - if (get_irn_op(adr) != op_Sel) + if (!is_Sel(adr)) return NULL; /* should be a simple Sel */ @@ -130,7 +130,7 @@ static ir_node *is_depend_alloc(ir_node *adr) { return NULL; alloc = skip_Proj(get_Sel_ptr(adr)); - if (get_irn_op(alloc) != op_Alloc) + if (!is_Alloc(alloc)) return NULL; /* hmm, we depend on this Alloc */ diff --git a/ir/opt/funccall.c b/ir/opt/funccall.c index 8fb3d0cdf..1b44fa488 100644 --- a/ir/opt/funccall.c +++ b/ir/opt/funccall.c @@ -207,7 +207,7 @@ static void fix_const_call_list(ir_graph *irg, ir_node *call_list, ir_node *proj mem = get_irn_link(call); /* beware of calls in the pure call list */ - if (! mem || get_irn_op(mem) == op_Call) + if (!mem || is_Call(mem)) continue; assert(get_irn_mode(mem) == mode_M); @@ -463,8 +463,7 @@ static unsigned _follow_mem(ir_node *node) { case iro_Call: /* A call is only tolerable if its either constant or pure. */ ptr = get_Call_ptr(node); - if (get_irn_op(ptr) == op_SymConst && - get_SymConst_kind(ptr) == symconst_addr_ent) { + if (is_SymConst(ptr) && get_SymConst_kind(ptr) == symconst_addr_ent) { ir_entity *ent = get_SymConst_entity(ptr); ir_graph *irg = get_entity_irg(ent); diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index b67bafedd..cab268246 100644 --- a/ir/opt/ldstopt.c +++ b/ir/opt/ldstopt.c @@ -256,14 +256,12 @@ static void collect_nodes(ir_node *node, void *env) static ir_entity *find_constant_entity(ir_node *ptr) { for (;;) { - ir_op *op = get_irn_op(ptr); - - if (op == op_SymConst && (get_SymConst_kind(ptr) == symconst_addr_ent)) { + if (is_SymConst(ptr) && get_SymConst_kind(ptr) == symconst_addr_ent) { ir_entity *ent = get_SymConst_entity(ptr); if (variability_constant == get_entity_variability(ent)) return ent; return NULL; - } else if (op == op_Sel) { + } else if (is_Sel(ptr)) { ir_entity *ent = get_Sel_entity(ptr); ir_type *tp = get_entity_owner(ent); @@ -336,7 +334,7 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { ir_entity *root, *field; int path_len, pos; - if (get_irn_op(ptr) == op_SymConst) { + if (is_SymConst(ptr)) { /* a SymConst. If the depth is 0, this is an access to a global * entity and we don't need a component path, else we know * at least it's length. @@ -345,7 +343,7 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { root = get_SymConst_entity(ptr); res = (depth == 0) ? NULL : new_compound_graph_path(get_entity_type(root), depth); } else { - assert(get_irn_op(ptr) == op_Sel); + assert(is_Sel(ptr)); /* it's a Sel, go up until we find the root */ res = rec_get_accessed_path(get_Sel_ptr(ptr), depth+1); @@ -927,7 +925,7 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) { if (rel != ir_no_alias) break; pred = skip_Proj(get_Store_mem(pred)); - } else if (get_irn_op(pred) == op_Load) { + } else if (is_Load(pred)) { ir_alias_relation rel = get_alias_relation( current_ir_graph, get_Load_ptr(pred), get_Load_mode(pred), ptr, mode); @@ -1031,7 +1029,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) store = skip_Proj(projM); old_store = store; - if (get_irn_op(store) != op_Store) + if (!is_Store(store)) return 0; block = get_nodes_block(store); diff --git a/ir/opt/opt_confirms.c b/ir/opt/opt_confirms.c index 4792d4255..0908cb66a 100644 --- a/ir/opt/opt_confirms.c +++ b/ir/opt/opt_confirms.c @@ -241,7 +241,7 @@ value_classify_sign classify_value_sign(ir_node *n) { } break; } - if (get_irn_op(n) != op_Confirm) + if (!is_Confirm(n)) return value_classified_unknown; tv = value_of(get_Confirm_bound(n)); diff --git a/ir/opt/opt_osr.c b/ir/opt/opt_osr.c index efa3bafe8..4bf905010 100644 --- a/ir/opt/opt_osr.c +++ b/ir/opt/opt_osr.c @@ -1189,7 +1189,7 @@ static void do_lftr(ir_node *cmp, void *ctx) { ir_node *iv, *rc; ir_node *nleft = NULL, *nright = NULL; - if (get_irn_op(cmp) != op_Cmp) + if (!is_Cmp(cmp)) return; left = get_Cmp_left(cmp); diff --git a/ir/opt/opt_polymorphy.c b/ir/opt/opt_polymorphy.c index af2604435..8a4fd6857 100644 --- a/ir/opt/opt_polymorphy.c +++ b/ir/opt/opt_polymorphy.c @@ -49,7 +49,7 @@ */ ir_type *default_firm_get_Alloc(ir_node *n) { n = skip_Proj(n); - if (get_irn_op(n) == op_Alloc) { + if (is_Alloc(n)) { return get_Alloc_type(n); } return NULL; diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c index 0e9f492d9..62a2e5ce9 100644 --- a/ir/opt/proc_cloning.c +++ b/ir/opt/proc_cloning.c @@ -274,7 +274,7 @@ static void set_preds(ir_node *irn, void *env) { } else { /* First we set the block our copy if it is not a block.*/ set_nodes_block(irn_copy, get_irn_link(get_nodes_block(irn))); - if (get_irn_op(irn) == op_End) { + if (is_End(irn)) { /* Handle the keep-alives. This must be done separately, because the End node was NOT copied */ for (i = 0; i < get_End_n_keepalives(irn); ++i) @@ -533,7 +533,7 @@ restart: /* we know, that a SymConst is here */ ptr = get_Call_ptr(call); - assert(get_irn_op(ptr) == op_SymConst); + assert(is_SymConst(ptr)); callee = get_SymConst_entity(ptr); if (callee != entry->q.ent) { diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c index e69000b50..eaa8ee64a 100644 --- a/ir/opt/scalar_replace.c +++ b/ir/opt/scalar_replace.c @@ -131,7 +131,7 @@ static int is_const_sel(ir_node *sel) { for (i = 0; i < n; ++i) { ir_node *idx = get_Sel_index(sel, i); - if (get_irn_op(idx) != op_Const) + if (!is_Const(idx)) return 0; } return 1; @@ -488,12 +488,11 @@ typedef struct _env_t { */ static void topologic_walker(ir_node *node, void *ctx) { env_t *env = ctx; - ir_op *op = get_irn_op(node); ir_node *adr, *block, *mem, *val; ir_mode *mode; unsigned vnum; - if (op == op_Load) { + if (is_Load(node)) { /* a load, check if we can resolve it */ adr = get_Load_ptr(node); @@ -537,7 +536,7 @@ static void topologic_walker(ir_node *node, void *ctx) { set_Tuple_pred(node, pn_Load_res, val); set_Tuple_pred(node, pn_Load_X_regular, new_Jmp()); set_Tuple_pred(node, pn_Load_X_except, new_Bad()); - } else if (op == op_Store) { + } else if (is_Store(node)) { DB((dbg, SET_LEVEL_3, " checking %+F for replacement ", node)); /* a Store always can be replaced */ diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c index 681a3f8b6..45f1b50ca 100644 --- a/ir/opt/tailrec.c +++ b/ir/opt/tailrec.c @@ -78,7 +78,7 @@ static void collect_data(ir_node *node, void *env) { if (op == op_Proj) { ir_node *start = get_Proj_pred(pred); - if (get_irn_op(start) == op_Start) { + if (is_Start(start)) { if (get_Proj_proj(pred) == pn_Start_T_args) { /* found Proj(ProjT(Start)) */ set_irn_link(node, data->proj_data); diff --git a/ir/opt/tropt.c b/ir/opt/tropt.c index e936b7fec..e41c69360 100644 --- a/ir/opt/tropt.c +++ b/ir/opt/tropt.c @@ -247,7 +247,7 @@ static void cancel_out_casts(ir_node *cast) { ir_type *tp_cast, *tp_pred, *tp_orig; int ref_depth = 0; - if (get_irn_op(pred) != op_Cast) return; + if (!is_Cast(pred)) return; orig = get_Cast_op(pred); tp_cast = get_Cast_type(cast); @@ -299,7 +299,7 @@ static void concretize_selected_entity(ir_node *sel) { sel_ent = get_Sel_entity(sel); cast = get_Sel_ptr(sel); - while (get_irn_op(cast) == op_Cast) { + while (is_Cast(cast)) { cast_tp = get_Cast_type(cast); ptr = get_Cast_op(cast); orig_tp = get_irn_typeinfo_type(ptr); @@ -340,7 +340,7 @@ static void concretize_Phi_type(ir_node *phi) { if (n_preds == 0) return; pred[0] = get_Phi_pred(phi, 0); - if (get_irn_op(pred[0]) != op_Cast) return; + if (!is_Cast(pred[0])) return; if (!is_Cast_upcast(pred[0])) return; @@ -350,7 +350,7 @@ static void concretize_Phi_type(ir_node *phi) { pred[0] = get_Cast_op(pred[0]); for (i = 1; i < n_preds; ++i) { pred[i] = get_Phi_pred(phi, i); - if (get_irn_op(pred[i]) != op_Cast) return; + if (!is_Cast(pred[i])) return; if (get_irn_typeinfo_type(get_Cast_op(pred[i])) != fromtype) return; pred[i] = get_Cast_op(pred[i]); } diff --git a/ir/stat/dags.c b/ir/stat/dags.c index 6ac7e92fc..d52a702fd 100644 --- a/ir/stat/dags.c +++ b/ir/stat/dags.c @@ -104,7 +104,7 @@ static int is_arg(ir_node *node) return 0; node = get_Proj_pred(node); - return get_irn_op(node) == op_Start; + return is_Start(node); } /* is_arg */ /** @@ -241,10 +241,10 @@ static void connect_dags(ir_node *node, void *env) } /* if */ /* if this option is set, Loads are always leaves */ - if (dag_env->options & FIRMSTAT_LOAD_IS_LEAVE && get_irn_op(node) == op_Load) + if (dag_env->options & FIRMSTAT_LOAD_IS_LEAVE && is_Load(node)) return; - if (dag_env->options & FIRMSTAT_CALL_IS_LEAVE && get_irn_op(node) == op_Call) + if (dag_env->options & FIRMSTAT_CALL_IS_LEAVE && is_Call(node)) return; entry = get_irn_dag_entry(node); diff --git a/ir/stat/firmstat.c b/ir/stat/firmstat.c index 7da8c79eb..521fa037b 100644 --- a/ir/stat/firmstat.c +++ b/ir/stat/firmstat.c @@ -597,10 +597,10 @@ static ir_op *stat_get_irn_op(ir_node *node) } /* if */ break; case iro_Sel: - if (get_irn_op(get_Sel_ptr(node)) == op_Sel) { + if (is_Sel(get_Sel_ptr(node))) { /* special case, a Sel of a Sel, count on extra counter */ op = status->op_SelSel ? status->op_SelSel : op; - if (get_irn_op(get_Sel_ptr(get_Sel_ptr(node))) == op_Sel) { + if (is_Sel(get_Sel_ptr(get_Sel_ptr(node)))) { /* special case, a Sel of a Sel of a Sel, count on extra counter */ op = status->op_SelSelSel ? status->op_SelSelSel : op; } /* if */ @@ -722,7 +722,7 @@ static void update_extbb_info(ir_node *node, graph_entry_t *graph) cnt_inc(&eb_entry->cnt[bcnt_nodes]); /* don't count keep-alive edges */ - if (get_irn_op(node) == op_End) + if (is_End(node)) return; arity = get_irn_arity(node); @@ -804,7 +804,7 @@ static void stat_update_call(ir_node *call, graph_entry_t *graph) /* found a call, this function is not a leaf */ graph->is_leaf = 0; - if (get_irn_op(ptr) == op_SymConst) { + if (is_SymConst(ptr)) { if (get_SymConst_kind(ptr) == symconst_addr_ent) { /* ok, we seems to know the entity */ ent = get_SymConst_entity(ptr); @@ -872,7 +872,7 @@ static void stat_update_call_2(ir_node *call, graph_entry_t *graph) if (is_Bad(block)) return; - if (get_irn_op(ptr) == op_SymConst) { + if (is_SymConst(ptr)) { if (get_SymConst_kind(ptr) == symconst_addr_ent) { /* ok, we seems to know the entity */ ent = get_SymConst_entity(ptr); diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c index 1a08baa02..bceae17d6 100644 --- a/ir/tr/tr_inheritance.c +++ b/ir/tr/tr_inheritance.c @@ -621,7 +621,7 @@ void verify_irn_class_cast_state(ir_node *n, void *env) { ir_type *fromtype, *totype; int ref_depth = 0; - if (get_irn_op(n) != op_Cast) return; + if (!is_Cast(n)) return; fromtype = get_irn_typeinfo_type(get_Cast_op(n)); totype = get_Cast_type(n); diff --git a/ir/tr/type.c b/ir/tr/type.c index ef772994d..fa686cd35 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -1693,7 +1693,7 @@ void set_array_upper_bound_int(ir_type *array, int dimension, int upper_bound) { int has_array_lower_bound(const ir_type *array, int dimension) { assert(array && (array->type_op == type_array)); - return (get_irn_op(array->attr.aa.lower_bound[dimension]) != op_Unknown); + return !is_Unknown(array->attr.aa.lower_bound[dimension]); } ir_node *get_array_lower_bound(const ir_type *array, int dimension) { @@ -1705,13 +1705,13 @@ long get_array_lower_bound_int(const ir_type *array, int dimension) { ir_node *node; assert(array && (array->type_op == type_array)); node = array->attr.aa.lower_bound[dimension]; - assert(get_irn_op(node) == op_Const); + assert(is_Const(node)); return get_tarval_long(get_Const_tarval(node)); } int has_array_upper_bound(const ir_type *array, int dimension) { assert(array && (array->type_op == type_array)); - return get_irn_op(array->attr.aa.upper_bound[dimension]) != op_Unknown; + return !is_Unknown(array->attr.aa.upper_bound[dimension]); } ir_node *get_array_upper_bound(const ir_type *array, int dimension) { @@ -1723,7 +1723,7 @@ long get_array_upper_bound_int(const ir_type *array, int dimension) { ir_node *node; assert(array && (array->type_op == type_array)); node = array->attr.aa.upper_bound[dimension]; - assert(get_irn_op(node) == op_Const); + assert(is_Const(node)); return get_tarval_long(get_Const_tarval(node)); } -- 2.20.1