X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode_t.h;h=084c9634ace73b4c2ec53156cac5f70e354d8859;hb=64d38975c523c9cfe4a3890af23e9192f557e293;hp=569178f93b4791bbfb7a409cb2d1ac7c474542c3;hpb=cb91bddc9cacdab7c28e4336847bd3dc248aa549;p=libfirm diff --git a/ir/ir/irnode_t.h b/ir/ir/irnode_t.h index 569178f93..084c9634a 100644 --- a/ir/ir/irnode_t.h +++ b/ir/ir/irnode_t.h @@ -10,7 +10,6 @@ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ - /** * @file irnode_t.h * @@ -19,28 +18,25 @@ * @author Martin Trapp, Christian Schaefer */ - # ifndef _IRNODE_T_H_ # define _IRNODE_T_H_ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -# include "irnode.h" -# include "irop_t.h" -# include "irgraph_t.h" -# include "irflag_t.h" -# include "firm_common_t.h" -# include "irdom_t.h" /* For size of struct dom_info. */ -# include "dbginfo.h" -# include "irloop.h" -# include "array.h" +#include "firm_config.h" +#include "irnode.h" +#include "irop_t.h" +#include "irgraph_t.h" +#include "irflag_t.h" +#include "firm_common_t.h" +#include "irdom_t.h" /* For size of struct dom_info. */ +#include "dbginfo.h" +#include "irloop.h" +#include "array.h" #include "set.h" #include "entity_t.h" #include "type_t.h" + /** ir node attributes **/ /** Block attributes */ @@ -49,7 +45,8 @@ typedef struct { ir_graph *irg; unsigned long block_visited; /**< for the walker that walks over all blocks. */ /* Attributes private to construction: */ - bool matured; /**< if set, all in-nodes of the block are fixed */ + int matured:1; /**< if set, all in-nodes of the block are fixed */ + int dead:1; /**< if set, the block is dead (and could be replace by a Bad */ struct ir_node **graph_arr; /**< array to store all parameters */ /* Attributes holding analyses information */ struct dom_info dom; /**< Datastructure that holds information about dominators. @@ -78,7 +75,7 @@ typedef struct { typedef struct { cond_kind kind; /**< flavor of Cond */ long default_proj; /**< for optimization: biggest Proj number, i.e. the one - used for default. */ + used for default. */ } cond_attr; /** Const attributes */ @@ -98,21 +95,27 @@ typedef struct { entity *ent; /**< entity to select */ } sel_attr; +/** Exception attributes */ typedef struct { - type *cld_tp; /**< type of called procedure */ + op_pin_state pin_state; /**< the pin state for operations that might generate a exception: + If it's know that no exception will be generated, could be set to + op_pin_state_floats. */ #if PRECISE_EXC_CONTEXT - struct ir_node **frag_arr; /**< For Phi node construction in case of exceptions */ + struct ir_node **frag_arr; /**< For Phi node construction in case of exception */ #endif - entity ** callee_arr; /**< result of callee analysis */ +} except_attr; + +typedef struct { + except_attr exc; /**< the exception attribute. MUST be the first one. */ + type *cld_tp; /**< type of called procedure */ + entity ** callee_arr; /**< result of callee analysis */ } call_attr; /** Alloc attributes */ typedef struct { - type *type; /**< Type of the allocated object. */ - where_alloc where; /**< stack, heap or other managed part of memory */ -#if PRECISE_EXC_CONTEXT - struct ir_node **frag_arr; /**< For Phi node construction in case of exceptions */ -#endif + except_attr exc; /**< the exception attribute. MUST be the first one. */ + type *type; /**< Type of the allocated object. */ + where_alloc where; /**< stack, heap or other managed part of memory */ } alloc_attr; /** InstOf attributes */ @@ -133,16 +136,10 @@ typedef struct { /** EndReg/EndExcept attributes */ typedef struct { char dummy; - /* ir_graph * irg; */ /**< ir_graph this node belongs to (for */ - /* * navigating in interprocedural graphs) */ - /* @@@ now in block */ } end_attr; /** CallBegin attributes */ typedef struct { - /* ir_graph * irg; */ /**< ir_graph this node belongs to (for */ - /* * navigating in interprocedural graphs) */ - /* @@@ now in block */ ir_node * call; /**< associated Call-operation */ } callbegin_attr; @@ -153,26 +150,17 @@ typedef struct { /** Load attributes */ typedef struct { - ir_mode *load_mode; /**< the mode of this Load operation */ + except_attr exc; /**< the exception attribute. MUST be the first one. */ + ir_mode *load_mode; /**< the mode of this Load operation */ ent_volatility volatility; /**< the volatility of a Load/Store operation */ -#if PRECISE_EXC_CONTEXT - struct ir_node **frag_arr; /**< For Phi node construction in case of exception */ -#endif } load_attr; /** Store attributes */ typedef struct { + except_attr exc; /**< the exception attribute. MUST be the first one. */ ent_volatility volatility; /**< the volatility of a Store operation */ -#if PRECISE_EXC_CONTEXT - struct ir_node **frag_arr; /**< For Phi node construction in case of exception */ -#endif } store_attr; -/** Exception attributes */ -typedef struct { - struct ir_node **frag_arr; /**< For Phi node construction in case of exception */ -} except_attr; - typedef pn_Cmp confirm_attr; /** Attribute to hold compare operation */ /** Some irnodes just have one attribute, these are stored here, @@ -199,15 +187,13 @@ typedef union { node takes the role of the obsolete Phi0 node, therefore the name. */ int *phi_backedge; /**< For Phi after construction. - Field n set to true if pred n is backedge. - @todo Ev. replace by bitfield! */ + Field n set to true if pred n is backedge. + @todo Ev. replace by bitfield! */ long proj; /**< For Proj: contains the result position to project */ confirm_attr confirm_cmp; /**< For Confirm: compare operation */ filter_attr filter; /**< For Filter */ end_attr end; /**< For EndReg, EndExcept */ -#if PRECISE_EXC_CONTEXT except_attr except; /**< For Phi node construction in case of exceptions */ -#endif } attr; @@ -245,33 +231,32 @@ struct ir_node { }; -/** Copies all attributes stored in the old node to the new node. - Assumes both have the same opcode and sufficient size. */ -void -copy_attrs(const ir_node *old_node, ir_node *new_node); - - /** Returns the array with the ins. The content of the array may not be changed. */ ir_node **get_irn_in (const ir_node *node); /** @{ */ /** access attributes directly */ -INLINE const_attr get_irn_const_attr (ir_node *node); -INLINE long get_irn_proj_attr (ir_node *node); -INLINE alloc_attr get_irn_alloc_attr (ir_node *node); -INLINE type *get_irn_free_attr (ir_node *node); -INLINE symconst_attr get_irn_symconst_attr (ir_node *node); -type *get_irn_call_attr (ir_node *node); -type *get_irn_funccall_attr (ir_node *node); -sel_attr get_irn_sel_attr (ir_node *node); -int 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); +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); +type *get_irn_free_attr (ir_node *node); +symconst_attr get_irn_symconst_attr (ir_node *node); +type *get_irn_call_attr (ir_node *node); +type *get_irn_funccall_attr (ir_node *node); +sel_attr get_irn_sel_attr (ir_node *node); +int 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); /** @} */ +/* + * The amount of additional space for custom data to be allocated upon creating a new node. + */ +extern unsigned firm_add_node_size; + /*-------------------------------------------------------------------*/ /* These function are most used in libfirm. Give them as static */ /* functions so they can be inlined. */ @@ -291,19 +276,27 @@ __is_ir_node (const void *thing) { * Intern version for libFirm. */ static INLINE ir_op * -__get_irn_op (const ir_node *node) -{ +__get_irn_op (const ir_node *node) { assert (node); return node->op; } +/** Copies all attributes stored in the old node to the new node. + Assumes both have the same opcode and sufficient size. */ +static INLINE void +copy_node_attr(const ir_node *old_node, ir_node *new_node) { + ir_op *op = __get_irn_op(old_node); + + /* must always exist */ + op->copy_attr(old_node, new_node); +} + /** * Gets the opcode of a node. * Intern version for libFirm. */ static INLINE opcode -__get_irn_opcode (const ir_node *node) -{ +__get_irn_opcode (const ir_node *node) { assert (k_ir_node == get_kind(node)); assert (node -> op); return node->op->code; @@ -339,17 +332,15 @@ __get_irn_inter_arity (const ir_node *node) { * Returns the number of predecessors without the block predecessor. * Intern version for libFirm. */ -static INLINE int -__get_irn_arity (const ir_node *node) { - if (interprocedural_view) return __get_irn_inter_arity(node); - return __get_irn_intra_arity(node); -} +extern int (*__get_irn_arity)(const ir_node *node); /** * Intern version for libFirm. */ static INLINE ir_node * -__get_irn_intra_n (ir_node *node, int n) { +__get_irn_intra_n (const ir_node *node, int n) { + assert(node); assert(-1 <= n && n < __get_irn_intra_arity(node)); + return (node->in[n + 1] = skip_Id(node->in[n + 1])); } @@ -357,7 +348,9 @@ __get_irn_intra_n (ir_node *node, int n) { * Intern version for libFirm. */ static INLINE ir_node* -__get_irn_inter_n (ir_node *node, int n) { +__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_opcode(node) == iro_Filter) { assert(node->attr.filter.in_cg); @@ -377,12 +370,7 @@ __get_irn_inter_n (ir_node *node, int n) { * If it is a block, the entry -1 is NULL. * Intern version for libFirm. */ -static INLINE ir_node * -__get_irn_n (ir_node *node, int n) { - assert(node); assert(-1 <= n && n < __get_irn_arity(node)); - if (interprocedural_view) return __get_irn_inter_n (node, n); - return __get_irn_intra_n (node, n); -} +extern ir_node *(*__get_irn_n)(const ir_node *node, int n); /** * Gets the mode of a node. @@ -478,10 +466,72 @@ __set_irn_link(ir_node *node, void *link) { */ static INLINE void * __get_irn_link(const ir_node *node) { - assert (node); + assert (node && is_ir_node(node)); return node->link; } +/** + * Returns the pinned state of a node. + * Intern version of libFirm. + */ +static INLINE op_pin_state +__get_irn_pinned(const ir_node *node) { + assert(node && is_ir_node(node)); + op_pin_state 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 state; +} + +static INLINE int +__is_unop(const ir_node *node) { + assert(node && is_ir_node(node)); + return (node->op->opar == oparity_unary); +} + +static INLINE int +__is_binop(const ir_node *node) { + assert(node && is_ir_node(node)); + return (node->op->opar == oparity_binary); +} + +static INLINE int +__is_Bad(const ir_node *node) { + assert(node); + return (node && __get_irn_op(node) == op_Bad); +} + +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 +__is_Block(const ir_node *node) { + assert(node && is_ir_node(node)); + return (__get_irn_op(node) == op_Block); +} + +static INLINE ir_node * +__set_Block_dead(ir_node *block) { + assert(__get_irn_op(block) == op_Block); + block->attr.block.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.dead; + } +} + /* 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) @@ -501,5 +551,12 @@ __get_irn_link(const ir_node *node) { #define irn_not_visited(node) __irn_not_visited(node) #define set_irn_link(node, link) __set_irn_link(node, link) #define get_irn_link(node) __get_irn_link(node) +#define is_unop(node) __is_unop(node) +#define is_binop(node) __is_binop(node) +#define is_Bad(node) __is_Bad(node) +#define is_no_Block(node) __is_no_Block(node) +#define is_Block(node) __is_Block(node) +#define set_Block_dead(block) __set_Block_dead(block) +#define is_Block_dead(block) __is_Block_dead(block) # endif /* _IRNODE_T_H_ */