X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=d44f835bb9cbf2f750307d4612641d0d92d0664e;hb=bbcec654890da41c2299bf3b07d4cb51e9ed48e1;hp=66eb23634904bb851c6026900235c5365b836b11;hpb=6f2933b9dd830b276ddf99bedcef41d7b70b9f42;p=libfirm diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index 66eb23634..d44f835bb 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -23,14 +23,11 @@ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" -#ifdef HAVE_STRING_H -# include -#endif +#include +#include "pset_new.h" #include "ident.h" #include "irnode_t.h" #include "irgraph_t.h" @@ -46,10 +43,12 @@ #include "irhooks.h" #include "irtools.h" +#include "beinfo.h" + /* some constants fixing the positions of nodes predecessors in the in array */ #define CALL_PARAM_OFFSET 2 -#define FUNCCALL_PARAM_OFFSET 1 +#define BUILDIN_PARAM_OFFSET 1 #define SEL_INDEX_OFFSET 2 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */ #define END_KEEPALIVE_OFFSET 0 @@ -138,7 +137,9 @@ new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mod char *p; int i; - assert(irg && op && mode); + assert(irg); + assert(op); + assert(mode); p = obstack_alloc(irg->obst, node_size); memset(p, 0, node_size); res = (ir_node *)(p + firm_add_node_size); @@ -179,6 +180,9 @@ new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mod edges_notify_edge(res, i - 1, res->in[i], NULL, irg); hook_new_node(irg, res); + if (get_irg_phase_state(irg) == phase_backend) { + be_info_new_node(res); + } return res; } @@ -356,6 +360,8 @@ void (set_irn_dep)(ir_node *node, int pos, ir_node *dep) { int add_irn_dep(ir_node *node, ir_node *dep) { int res = 0; + /* DEP edges are only allowed in backend phase */ + assert(get_irg_phase_state(get_irn_irg(node)) == phase_backend); if (node->deps == NULL) { node->deps = NEW_ARR_F(ir_node *, 1); node->deps[0] = dep; @@ -441,11 +447,11 @@ ident *get_irn_opident(const ir_node *node) { return node->op->name; } -unsigned long (get_irn_visited)(const ir_node *node) { +ir_visited_t (get_irn_visited)(const ir_node *node) { return _get_irn_visited(node); } -void (set_irn_visited)(ir_node *node, unsigned long visited) { +void (set_irn_visited)(ir_node *node, ir_visited_t visited) { _set_irn_visited(node, visited); } @@ -453,14 +459,14 @@ void (mark_irn_visited)(ir_node *node) { _mark_irn_visited(node); } -int (irn_not_visited)(const ir_node *node) { - return _irn_not_visited(node); -} - int (irn_visited)(const ir_node *node) { return _irn_visited(node); } +int (irn_visited_else_mark)(ir_node *node) { + return _irn_visited_else_mark(node); +} + void (set_irn_link)(ir_node *node, void *link) { _set_irn_link(node, link); } @@ -479,7 +485,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); @@ -488,43 +494,6 @@ void set_irn_pinned(ir_node *node, op_pin_state state) { node->attr.except.pin_state = state; } -#ifdef DO_HEAPANALYSIS -/* Access the abstract interpretation information of a node. - Returns NULL if no such information is available. */ -struct abstval *get_irn_abst_value(ir_node *n) { - return n->av; -} -/* Set the abstract interpretation information of a node. */ -void set_irn_abst_value(ir_node *n, struct abstval *os) { - n->av = os; -} -struct section *firm_get_irn_section(ir_node *n) { - return n->sec; -} -void firm_set_irn_section(ir_node *n, struct section *s) { - n->sec = s; -} -#else -/* Dummies needed for firmjni. */ -struct abstval *get_irn_abst_value(ir_node *n) { - (void) n; - return NULL; -} -void set_irn_abst_value(ir_node *n, struct abstval *os) { - (void) n; - (void) os; -} -struct section *firm_get_irn_section(ir_node *n) { - (void) n; - return NULL; -} -void firm_set_irn_section(ir_node *n, struct section *s) { - (void) n; - (void) s; -} -#endif /* DO_HEAPANALYSIS */ - - /* Outputs a unique number for this node */ long get_irn_node_nr(const ir_node *node) { assert(node); @@ -602,6 +571,11 @@ divmod_attr *get_irn_divmod_attr(ir_node *node) { return &node->attr.divmod; } +builtin_attr *get_irn_builtin_attr(ir_node *node) { + assert(is_Builtin(node)); + return &node->attr.builtin; +} + void *(get_irn_generic_attr)(ir_node *node) { assert(is_ir_node(node)); return _get_irn_generic_attr(node); @@ -669,16 +643,6 @@ ir_type *is_tls_pointer(const ir_node *n) { return NULL; } -/* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base) - * from Start. If so returns 1, else 0. */ -int is_value_arg_pointer(const ir_node *n) { - if (is_Proj(n) && - (get_Proj_proj(n) == pn_Start_P_value_arg_base) && - is_Start(get_Proj_pred(n))) - return 1; - return 0; -} - /* Returns an array with the predecessors of the Block. Depending on the implementation of the graph data structure this can be a copy of the internal representation of predecessors as well as the internal @@ -715,11 +679,11 @@ void set_Block_matured(ir_node *node, int matured) { node->attr.block.is_matured = matured; } -unsigned long (get_Block_block_visited)(const ir_node *node) { +ir_visited_t (get_Block_block_visited)(const ir_node *node) { return _get_Block_block_visited(node); } -void (set_Block_block_visited)(ir_node *node, unsigned long visit) { +void (set_Block_block_visited)(ir_node *node, ir_visited_t visit) { _set_Block_block_visited(node, visit); } @@ -728,10 +692,6 @@ void (mark_Block_block_visited)(ir_node *node) { _mark_Block_block_visited(node); } -int (Block_not_block_visited)(const ir_node *node) { - return _Block_not_block_visited(node); -} - int (Block_block_visited)(const ir_node *node) { return _Block_block_visited(node); } @@ -899,7 +859,6 @@ ir_node *get_End_keepalive(const ir_node *end, int pos) { void add_End_keepalive(ir_node *end, ir_node *ka) { assert(is_End(end)); - assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!"); add_irn_n(end, ka); } @@ -955,11 +914,48 @@ found: end->in[1 + END_KEEPALIVE_OFFSET + idx] = old; edges_notify_edge(end, idx, old, NULL, irg); } + /* now n - 1 keeps, 1 block input */ ARR_RESIZE(ir_node *, end->in, (n - 1) + 1 + END_KEEPALIVE_OFFSET); } -void -free_End(ir_node *end) { +/* remove Bads, NoMems and doublets from the keep-alive set */ +void remove_End_Bads_and_doublets(ir_node *end) { + pset_new_t keeps; + int idx, n = get_End_n_keepalives(end); + ir_graph *irg; + + if (n <= 0) + return; + + irg = get_irn_irg(end); + pset_new_init(&keeps); + + for (idx = n - 1; idx >= 0; --idx) { + ir_node *ka = get_End_keepalive(end, idx); + + if (is_Bad(ka) || is_NoMem(ka) || pset_new_contains(&keeps, ka)) { + /* remove the edge */ + edges_notify_edge(end, idx, NULL, ka, irg); + + if (idx != n - 1) { + /* exchange with the last one */ + ir_node *old = end->in[1 + END_KEEPALIVE_OFFSET + n - 1]; + edges_notify_edge(end, n - 1, NULL, old, irg); + end->in[1 + END_KEEPALIVE_OFFSET + idx] = old; + edges_notify_edge(end, idx, old, NULL, irg); + } + --n; + } else { + pset_new_insert(&keeps, ka); + } + } + /* n keeps, 1 block input */ + ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET); + + pset_new_destroy(&keeps); +} + +void free_End(ir_node *end) { assert(is_End(end)); end->kind = k_BAD; DEL_ARR_F(end->in); @@ -1144,10 +1140,13 @@ set_SymConst_kind(ir_node *node, symconst_kind kind) { } ir_type * -get_SymConst_type(ir_node *node) { +get_SymConst_type(const ir_node *node) { + /* the cast here is annoying, but we have to compensate for + the skip_tip() */ + ir_node *irn = (ir_node *)node; assert(is_SymConst(node) && (SYMCONST_HAS_TYPE(get_SymConst_kind(node)))); - return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p); + return irn->attr.symc.sym.type_p = skip_tid(irn->attr.symc.sym.type_p); } void @@ -1330,7 +1329,7 @@ set_Call_ptr(ir_node *node, ir_node *ptr) { ir_node ** get_Call_param_arr(ir_node *node) { assert(is_Call(node)); - return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1]; + return &get_irn_in(node)[CALL_PARAM_OFFSET + 1]; } int @@ -1339,18 +1338,6 @@ get_Call_n_params(const ir_node *node) { return (get_irn_arity(node) - CALL_PARAM_OFFSET); } -int -get_Call_arity(const ir_node *node) { - assert(is_Call(node)); - return get_Call_n_params(node); -} - -/* void -set_Call_arity(ir_node *node, ir_node *arity) { - assert(is_Call(node)); -} -*/ - ir_node * get_Call_param(const ir_node *node, int pos) { assert(is_Call(node)); @@ -1376,6 +1363,91 @@ set_Call_type(ir_node *node, ir_type *tp) { node->attr.call.cld_tp = tp; } +ir_node * +get_Builtin_mem(const ir_node *node) { + assert(is_Builtin(node)); + return get_irn_n(node, 0); +} + +void +set_Builin_mem(ir_node *node, ir_node *mem) { + assert(is_Builtin(node)); + set_irn_n(node, 0, mem); +} + +ir_builtin_kind +get_Builtin_kind(const ir_node *node) { + assert(is_Builtin(node)); + return node->attr.builtin.kind; +} + +void +set_Builtin_kind(ir_node *node, ir_builtin_kind kind) { + assert(is_Builtin(node)); + node->attr.builtin.kind = kind; +} + +ir_node ** +get_Builtin_param_arr(ir_node *node) { + assert(is_Builtin(node)); + return &get_irn_in(node)[BUILDIN_PARAM_OFFSET + 1]; +} + +int +get_Builtin_n_params(const ir_node *node) { + assert(is_Builtin(node)); + return (get_irn_arity(node) - BUILDIN_PARAM_OFFSET); +} + +ir_node * +get_Builtin_param(const ir_node *node, int pos) { + assert(is_Builtin(node)); + return get_irn_n(node, pos + BUILDIN_PARAM_OFFSET); +} + +void +set_Builtin_param(ir_node *node, int pos, ir_node *param) { + assert(is_Builtin(node)); + set_irn_n(node, pos + BUILDIN_PARAM_OFFSET, param); +} + +ir_type * +get_Builtin_type(ir_node *node) { + assert(is_Builtin(node)); + return node->attr.builtin.builtin_tp = skip_tid(node->attr.builtin.builtin_tp); +} + +void +set_Builtin_type(ir_node *node, ir_type *tp) { + assert(is_Builtin(node)); + assert((get_unknown_type() == tp) || is_Method_type(tp)); + node->attr.builtin.builtin_tp = tp; +} + +/* Returns a human readable string for the ir_builtin_kind. */ +const char *get_builtin_kind_name(ir_builtin_kind kind) { +#define X(a) case a: return #a + 6; + switch (kind) { + X(ir_bk_trap); + X(ir_bk_debugbreak); + X(ir_bk_return_address); + X(ir_bk_frame_addess); + X(ir_bk_prefetch); + X(ir_bk_ffs); + X(ir_bk_clz); + X(ir_bk_ctz); + X(ir_bk_popcount); + X(ir_bk_parity); + X(ir_bk_bswap); + X(ir_bk_inport); + X(ir_bk_outport); + X(ir_bk_inner_trampoline); + } + return ""; +#undef X +} + + int Call_has_callees(const ir_node *node) { assert(is_Call(node)); return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) && @@ -1499,6 +1571,7 @@ void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \ BINOP(Add) +BINOP(Carry) BINOP(Sub) UNOP(Minus) BINOP(Mul) @@ -2064,6 +2137,11 @@ set_Proj_proj(ir_node *node, long proj) { #endif /* INTERPROCEDURAL_VIEW */ } +/* Returns non-zero if a node is a routine parameter. */ +int (is_arg_Proj)(const ir_node *node) { + return _is_arg_Proj(node); +} + ir_node ** get_Tuple_preds_arr(ir_node *node) { assert(is_Tuple(node)); @@ -2196,101 +2274,33 @@ ir_node *get_Filter_cg_pred(ir_node *node, int pos) { /* Mux support */ ir_node *get_Mux_sel(const ir_node *node) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - return get_Psi_cond(node, 0); - } assert(is_Mux(node)); return node->in[1]; } void set_Mux_sel(ir_node *node, ir_node *sel) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - set_Psi_cond(node, 0, sel); - } else { - assert(is_Mux(node)); - node->in[1] = sel; - } + assert(is_Mux(node)); + node->in[1] = sel; } ir_node *get_Mux_false(const ir_node *node) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - return get_Psi_default(node); - } assert(is_Mux(node)); return node->in[2]; } void set_Mux_false(ir_node *node, ir_node *ir_false) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - set_Psi_default(node, ir_false); - } else { - assert(is_Mux(node)); - node->in[2] = ir_false; - } + assert(is_Mux(node)); + node->in[2] = ir_false; } ir_node *get_Mux_true(const ir_node *node) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - return get_Psi_val(node, 0); - } assert(is_Mux(node)); return node->in[3]; } void set_Mux_true(ir_node *node, ir_node *ir_true) { - if (is_Psi(node)) { - assert(get_irn_arity(node) == 3); - set_Psi_val(node, 0, ir_true); - } else { - assert(is_Mux(node)); - node->in[3] = ir_true; - } -} - -/* Psi support */ -ir_node *get_Psi_cond(const ir_node *node, int pos) { - assert(is_Psi(node)); - assert(pos < get_Psi_n_conds(node)); - return get_irn_n(node, 2 * pos); -} - -void set_Psi_cond(ir_node *node, int pos, ir_node *cond) { - assert(is_Psi(node)); - assert(pos < get_Psi_n_conds(node)); - set_irn_n(node, 2 * pos, cond); -} - -ir_node *get_Psi_val(const ir_node *node, int pos) { - assert(is_Psi(node)); - assert(pos < get_Psi_n_conds(node)); - return get_irn_n(node, 2 * pos + 1); -} - -void set_Psi_val(ir_node *node, int pos, ir_node *val) { - assert(is_Psi(node)); - assert(pos < get_Psi_n_conds(node)); - set_irn_n(node, 2 * pos + 1, val); -} - -ir_node *get_Psi_default(const ir_node *node) { - int def_pos = get_irn_arity(node) - 1; - assert(is_Psi(node)); - return get_irn_n(node, def_pos); -} - -void set_Psi_default(ir_node *node, ir_node *val) { - int def_pos = get_irn_arity(node); - assert(is_Psi(node)); - set_irn_n(node, def_pos, val); -} - -int (get_Psi_n_conds)(const ir_node *node) { - return _get_Psi_n_conds(node); + assert(is_Mux(node)); + node->in[3] = ir_true; } /* CopyB support */ @@ -2508,7 +2518,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; } @@ -2546,10 +2556,8 @@ skip_Tuple(ir_node *node) { ir_node *pred; ir_op *op; - if (!get_opt_normalize()) return node; - restart: - if (get_irn_op(node) == op_Proj) { + if (is_Proj(node)) { pred = get_Proj_pred(node); op = get_irn_op(pred); @@ -2559,9 +2567,8 @@ restart: */ if (op == op_Proj) { /* nested Tuple ? */ pred = skip_Tuple(pred); - op = get_irn_op(pred); - if (op == op_Tuple) { + if (is_Tuple(pred)) { node = get_Tuple_pred(pred, get_Proj_proj(node)); goto restart; } @@ -2575,14 +2582,28 @@ restart: /* returns operand of node if node is a Cast */ ir_node *skip_Cast(ir_node *node) { - if (get_irn_op(node) == op_Cast) + if (is_Cast(node)) return get_Cast_op(node); return node; } +/* returns operand of node if node is a Cast */ +const ir_node *skip_Cast_const(const ir_node *node) { + if (is_Cast(node)) + return get_Cast_op(node); + return node; +} + +/* returns operand of node if node is a Pin */ +ir_node *skip_Pin(ir_node *node) { + if (is_Pin(node)) + return get_Pin_op(node); + return 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; } @@ -2692,6 +2713,11 @@ int return _is_Add(node); } +int +(is_Carry)(const ir_node *node) { + return _is_Carry(node); +} + int (is_And)(const ir_node *node) { return _is_And(node); @@ -2737,11 +2763,6 @@ int return _is_Not(node); } -int -(is_Psi)(const ir_node *node) { - return _is_Psi(node); -} - int (is_Id)(const ir_node *node) { return _is_Id(node); @@ -2815,6 +2836,12 @@ int return _is_Call(node); } +/* returns true if node is a Builtin node. */ +int +(is_Builtin)(const ir_node *node) { + return _is_Builtin(node); +} + /* returns true if node is a CallBegin node. */ int (is_CallBegin)(const ir_node *node) { @@ -2827,7 +2854,7 @@ int return _is_Sel(node); } -/* returns true if node is a Mux node or a Psi with only one condition. */ +/* returns true if node is a Mux node. */ int (is_Mux)(const ir_node *node) { return _is_Mux(node); @@ -3204,23 +3231,25 @@ ir_entity *get_Global_entity(const ir_node *node) { } #endif -#ifdef DEBUG_libfirm -void dump_irn(const ir_node *n) { - int i, arity = get_irn_arity(n); - printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n); - if (!is_Block(n)) { - ir_node *pred = get_irn_n(n, -1); - printf(" block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)), - get_irn_node_nr(pred), (void *)pred); - } - printf(" preds: \n"); - for (i = 0; i < arity; ++i) { - ir_node *pred = get_irn_n(n, i); - printf(" %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)), - get_irn_node_nr(pred), (void *)pred); +/* + * Calculate a hash value of a node. + */ +unsigned firm_default_hash(const ir_node *node) { + unsigned h; + int i, irn_arity; + + /* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */ + h = irn_arity = get_irn_intra_arity(node); + + /* consider all in nodes... except the block if not a control flow. */ + for (i = is_cfop(node) ? -1 : 0; i < irn_arity; ++i) { + h = 9*h + HASH_PTR(get_irn_intra_n(node, i)); } -} -#else /* DEBUG_libfirm */ -void dump_irn(const ir_node *n) { (void) n; } -#endif /* DEBUG_libfirm */ + /* ...mode,... */ + h = 9*h + HASH_PTR(get_irn_mode(node)); + /* ...and code */ + h = 9*h + HASH_PTR(get_irn_op(node)); + + return h; +} /* firm_default_hash */