X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode_t.h;h=376a68e48503c78913683416a71c90e5edf1cab3;hb=917ab46635e6c68aa98c69f6801caf36df29d9c5;hp=88ca56a63b162ff05dd8c5115760cdebe2940899;hpb=671ced672859c875de7c1d9c4a4750a29514446f;p=libfirm diff --git a/ir/ir/irnode_t.h b/ir/ir/irnode_t.h index 88ca56a63..376a68e48 100644 --- a/ir/ir/irnode_t.h +++ b/ir/ir/irnode_t.h @@ -32,6 +32,7 @@ #include "irgraph_t.h" #include "irflag_t.h" #include "array.h" +#include "iredges_t.h" /** * Returns the array with the ins. The content of the array may not be @@ -41,40 +42,11 @@ */ ir_node **get_irn_in (const ir_node *node); -/** @{ */ -/** access attributes directly */ -const_attr *get_irn_const_attr (ir_node *node); -long get_irn_proj_attr (ir_node *node); -alloc_attr *get_irn_alloc_attr (ir_node *node); -free_attr *get_irn_free_attr (ir_node *node); -symconst_attr *get_irn_symconst_attr (ir_node *node); -call_attr *get_irn_call_attr (ir_node *node); -sel_attr *get_irn_sel_attr (ir_node *node); -phi_attr *get_irn_phi_attr (ir_node *node); -block_attr *get_irn_block_attr (ir_node *node); -load_attr *get_irn_load_attr (ir_node *node); -store_attr *get_irn_store_attr (ir_node *node); -except_attr *get_irn_except_attr (ir_node *node); -divmod_attr *get_irn_divmod_attr (ir_node *node); -builtin_attr *get_irn_builtin_attr (ir_node *node); -/** @} */ - /** * The amount of additional space for custom data to be allocated upon creating a new node. */ extern unsigned firm_add_node_size; -/** - * Sets the get_type operation for an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops); - /** * Sets the get_type_attr operation for an ir_op_ops. * @@ -84,7 +56,7 @@ ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops); * @return * The operations. */ -ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops); +ir_op_ops *firm_set_default_get_type_attr(unsigned code, ir_op_ops *ops); /** * Sets the get_entity_attr operation for an ir_op_ops. @@ -95,7 +67,7 @@ ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops); * @return * The operations. */ -ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops); +ir_op_ops *firm_set_default_get_entity_attr(unsigned code, ir_op_ops *ops); /** * Returns an array with the predecessors of the Block. Depending on @@ -161,54 +133,24 @@ static inline unsigned _get_irn_opcode(const ir_node *node) * Returns the number of predecessors without the block predecessor. * Intern version for libFirm. */ -static inline int _get_irn_intra_arity(const ir_node *node) +static inline int _get_irn_arity(const ir_node *node) { - assert(node); - return ARR_LEN(node->in) - 1; + return (int)(ARR_LEN(node->in) - 1); } /** - * Returns the number of predecessors without the block predecessor. * Intern version for libFirm. */ -static inline int _get_irn_inter_arity(const ir_node *node) -{ - assert(node); - if (_get_irn_op(node) == op_Filter) { - assert(node->attr.filter.in_cg); - return ARR_LEN(node->attr.filter.in_cg) - 1; - } else if (_get_irn_op(node) == op_Block && node->attr.block.in_cg) { - return ARR_LEN(node->attr.block.in_cg) - 1; - } - return _get_irn_intra_arity(node); -} - -#ifdef INTERPROCEDURAL_VIEW -/** - * Returns the number of predecessors without the block predecessor. - * Intern version for libFirm. - */ -extern int (*_get_irn_arity)(const ir_node *node); - -#else - -#define _get_irn_arity(n) _get_irn_intra_arity(n) -#endif - -/** - * Intern version for libFirm. - */ -static inline ir_node *_get_irn_intra_n(const ir_node *node, int n) +static inline ir_node *_get_irn_n(const ir_node *node, int n) { ir_node *nn; - assert(node); - assert(-1 <= n && n < _get_irn_intra_arity(node)); + assert(-1 <= n && n < _get_irn_arity(node)); nn = node->in[n + 1]; if (nn == NULL) { /* only block and Anchor inputs are allowed to be NULL */ - assert((node->op == op_Anchor || n == -1) && "NULL input of a node"); + assert((is_Anchor(node) || n == -1) && "NULL input of a node"); return NULL; } if (nn->op != op_Id) return nn; @@ -216,24 +158,6 @@ static inline ir_node *_get_irn_intra_n(const ir_node *node, int n) return (node->in[n + 1] = skip_Id(nn)); } -/** - * Intern version for libFirm. - */ -static inline ir_node *_get_irn_inter_n(const ir_node *node, int n) -{ - assert(node); assert(-1 <= n && n < _get_irn_inter_arity(node)); - - /* handle Filter and Block specially */ - if (_get_irn_op(node) == op_Filter) { - assert(node->attr.filter.in_cg); - return (node->attr.filter.in_cg[n + 1] = skip_Id(node->attr.filter.in_cg[n + 1])); - } else if (_get_irn_op(node) == op_Block && node->attr.block.in_cg) { - return (node->attr.block.in_cg[n + 1] = skip_Id(node->attr.block.in_cg[n + 1])); - } - - return _get_irn_intra_n(node, n); -} - /** * returns a hash value for a node */ @@ -242,36 +166,25 @@ static inline unsigned hash_irn(const ir_node *node) return (unsigned) get_irn_idx(node); } -/** - * Access to the predecessors of a node. - * To iterate over the operands iterate from 0 to i < get_irn_arity(), - * to iterate including the Block predecessor iterate from i = -1 to - * i < get_irn_arity. - * If it is a block, the entry -1 is NULL. - * Intern version for libFirm. - */ -#ifdef INTERPROCEDURAL_VIEW -extern ir_node *(*_get_irn_n)(const ir_node *node, int n); -#else -#define _get_irn_n(n,i) _get_irn_intra_n(n,i) -#endif - static inline int _get_irn_deps(const ir_node *node) { - return node->deps ? ARR_LEN(node->deps) : 0; + return node->deps ? (int)ARR_LEN(node->deps) : 0; } static inline ir_node *_get_irn_dep(const ir_node *node, int pos) { assert(node->deps && "dependency array node yet allocated. use add_irn_dep()"); - assert(pos >= 0 && pos < ARR_LEN(node->deps) && "dependency index out of range"); + assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range"); return node->deps[pos]; } +/* forward declaration outside iredges_t.h to avoid circular include problems */ +void edges_notify_edge_kind(ir_node *src, int pos, ir_node *tgt, ir_node *old_tgt, ir_edge_kind_t kind, ir_graph *irg); + static inline void _set_irn_dep(ir_node *node, int pos, ir_node *dep) { ir_node *old; assert(node->deps && "dependency array node yet allocated. use add_irn_dep()"); - assert(pos >= 0 && pos < ARR_LEN(node->deps) && "dependency index out of range"); + assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range"); old = node->deps[pos]; node->deps[pos] = dep; edges_notify_edge_kind(node, pos, dep, old, EDGE_KIND_DEP, get_irn_irg(node)); @@ -309,18 +222,28 @@ static inline void _set_irn_mode(ir_node *node, ir_mode *mode) node->mode = mode; } +static inline int ir_has_irg_ref(const ir_node *node) +{ + return is_Block(node) || is_Bad(node) || is_Anchor(node); +} + static inline ir_graph *_get_irn_irg(const ir_node *node) { /* - * Do not use get_nodes_Block() here, because this + * Do not use get_nodes_block() here, because this * will check the pinned state. - * However even a 'wrong' block is always in the proper - * irg. + * However even a 'wrong' block is always in the proper irg. */ if (! is_Block(node)) node = get_irn_n(node, -1); - /* note that get_Block_irg() can handle Bad nodes */ - return get_Block_irg(node); + assert(ir_has_irg_ref(node)); + return node->attr.irg.irg; +} + +static inline ir_node *_get_nodes_block(const ir_node *node) +{ + assert(!is_Block(node)); + return get_irn_n(node, -1); } /** @@ -404,7 +327,8 @@ static inline op_pin_state _get_irn_pinned(const ir_node *node) state = _get_op_pinned(_get_irn_op(node)); if (state >= op_pin_state_exc_pinned) - return get_opt_fragile_ops() ? node->attr.except.pin_state : op_pin_state_pinned; + return (op_pin_state)node->attr.except.pin_state; + return state; } @@ -430,30 +354,6 @@ static inline int _is_binop(const ir_node *node) return (node->op->opar == oparity_binary); } -static inline int _is_Phi(const ir_node *node) -{ - ir_op *op; - assert(node); - - op = get_irn_op(node); -#ifdef INTERPROCEDURAL_VIEW - if (op == op_Filter) return get_interprocedural_view(); -#endif - return (op == op_Phi); -} - -static inline int _is_Proj(const ir_node *node) -{ - ir_op *op; - assert(node); - - op = _get_irn_op(node); -#ifdef INTERPROCEDURAL_VIEW - if (op == op_Filter) return !get_interprocedural_view(); -#endif - return (op == op_Proj); -} - static inline int _is_strictConv(const ir_node *node) { return _is_Conv(node) && get_Conv_strict(node); @@ -464,12 +364,6 @@ static inline int _is_SymConst_addr_ent(const ir_node *node) return is_SymConst(node) && get_SymConst_kind(node) == symconst_addr_ent; } -static inline int _is_no_Block(const ir_node *node) -{ - assert(node && _is_ir_node(node)); - return (_get_irn_op(node) != op_Block); -} - static inline int _get_Block_n_cfgpreds(const ir_node *node) { assert(_is_Block(node)); @@ -496,25 +390,28 @@ static inline ir_node *_get_Block_cfgpred(const ir_node *node, int pos) */ static inline ir_node *_get_Block_cfgpred_block(const ir_node *node, int pos) { - ir_node *res = skip_Proj(get_Block_cfgpred(node, pos)); - if (!is_Bad(res)) - res = get_nodes_block(res); - return res; + ir_node *res = get_Block_cfgpred(node, pos); + if (is_Bad(res)) { + /* must return a Bad with mode_BB! */ + ir_graph *irg = get_irn_irg(node); + return new_r_Bad(irg, mode_BB); + } else { + return get_nodes_block(skip_Proj(res)); + } } static inline ir_visited_t _get_Block_block_visited(const ir_node *node) { - assert(node->op == op_Block); + assert(is_Block(node)); return node->attr.block.block_visited; } static inline void _set_Block_block_visited(ir_node *node, ir_visited_t visit) { - assert(node->op == op_Block); + assert(is_Block(node)); node->attr.block.block_visited = visit; } -/* For this current_ir_graph must be set. */ static inline void _mark_Block_block_visited(ir_node *node) { ir_graph *irg = get_Block_irg(node); @@ -527,33 +424,13 @@ static inline int _Block_block_visited(const ir_node *node) return node->attr.block.block_visited >= get_irg_block_visited(irg); } -static inline ir_node *_set_Block_dead(ir_node *block) -{ - assert(_get_irn_op(block) == op_Block); - block->attr.block.dom.dom_depth = -1; - block->attr.block.is_dead = 1; - return block; -} - -static inline int _is_Block_dead(const ir_node *block) -{ - ir_op *op = _get_irn_op(block); - - if (op == op_Bad) - return 1; - else { - assert(op == op_Block); - return block->attr.block.is_dead; - } -} - static inline ir_graph *_get_Block_irg(const ir_node *block) { - assert(is_Block(block) || is_Bad(block)); + assert(is_Block(block)); return block->attr.irg.irg; } -static inline tarval *_get_Const_tarval(const ir_node *node) { +static inline ir_tarval *_get_Const_tarval(const ir_node *node) { assert(_get_irn_op(node) == op_Const); return node->attr.con.tarval; } @@ -574,10 +451,6 @@ static inline int _is_irn_forking(const ir_node *node) { return is_op_forking(_get_irn_op(node)); } -static inline ir_type *_get_irn_type(ir_node *node) { - return _get_irn_op(node)->ops.get_type(node); -} - static inline ir_type *_get_irn_type_attr(ir_node *node) { return _get_irn_op(node)->ops.get_type_attr(node); } @@ -668,19 +541,12 @@ static inline ir_node *_get_Block_phis(const ir_node *block) return block->attr.block.phis; } -/** - * Sets the next link of a Phi. - */ static inline void _set_Phi_next(ir_node *phi, ir_node *next) { assert(_is_Phi(phi)); phi->attr.phi.next = next; } -/** - * Returns the link of a node. - * Intern version of libFirm. - */ static inline ir_node *_get_Phi_next(const ir_node *phi) { assert(_is_Phi(phi)); @@ -690,6 +556,7 @@ static inline ir_node *_get_Phi_next(const ir_node *phi) /** Add a Phi node to the list of Block Phi's. */ static inline void _add_Block_phi(ir_node *block, ir_node *phi) { + assert(_is_Block(block)); _set_Phi_next(phi, _get_Block_phis(block)); _set_Block_phis(block, phi); } @@ -724,15 +591,12 @@ void init_irnode(void); /* this section MUST contain all inline functions */ #define is_ir_node(thing) _is_ir_node(thing) -#define get_irn_intra_arity(node) _get_irn_intra_arity(node) -#define get_irn_inter_arity(node) _get_irn_inter_arity(node) #define get_irn_arity(node) _get_irn_arity(node) -#define get_irn_intra_n(node, n) _get_irn_intra_n(node, n) -#define get_irn_inter_n(node, n) _get_irn_inter_n(node, n) #define get_irn_n(node, n) _get_irn_n(node, n) #define get_irn_mode(node) _get_irn_mode(node) #define set_irn_mode(node, mode) _set_irn_mode(node, mode) #define get_irn_irg(node) _get_irn_irg(node) +#define get_nodes_block(node) _get_nodes_block(node) #define get_irn_op(node) _get_irn_op(node) #define set_irn_op(node, op) _set_irn_op(node, op) #define get_irn_opcode(node) _get_irn_opcode(node) @@ -751,7 +615,6 @@ void init_irnode(void); #define is_Phi(node) _is_Phi(node) #define is_strictConv(node) _is_strictConv(node) #define is_SymConst_addr_ent(node) _is_SymConst_addr_ent(node) -#define is_no_Block(node) _is_no_Block(node) #define get_Block_n_cfgpreds(node) _get_Block_n_cfgpreds(node) #define get_Block_cfgpred(node, pos) _get_Block_cfgpred(node, pos) #define get_Block_cfgpred_block(node, pos) _get_Block_cfgpred_block(node, pos) @@ -759,8 +622,6 @@ void init_irnode(void); #define set_Block_block_visited(node, visit) _set_Block_block_visited(node, visit) #define mark_Block_block_visited(node) _mark_Block_block_visited(node) #define Block_block_visited(node) _Block_block_visited(node) -#define set_Block_dead(block) _set_Block_dead(block) -#define is_Block_dead(block) _is_Block_dead(block) #define get_Block_irg(block) _get_Block_irg(block) #define get_Const_tarval(node) _get_Const_tarval(node) #define is_Const_null(node) _is_Const_null(node)