X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firgraph.h;h=3c892c25f3937494922178ead67ddc8c4aec91c5;hb=64252961a7d41265ff28353949e63f0662a1cd03;hp=2ed8968604f829e74e24a4774dd38764ca264645;hpb=8fd12b1714e2024889e81aa4b351d1b6640e1c79;p=libfirm diff --git a/include/libfirm/irgraph.h b/include/libfirm/irgraph.h index 2ed896860..3c892c25f 100644 --- a/include/libfirm/irgraph.h +++ b/include/libfirm/irgraph.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -21,7 +21,6 @@ * @file * @brief Entry point to the representation of procedure code. * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier - * @version $Id$ */ #ifndef FIRM_IR_IRGRAPH_H #define FIRM_IR_IRGRAPH_H @@ -29,13 +28,10 @@ #include #include "firm_types.h" -#include "irop.h" -#include "iropt.h" -#include "irextbb.h" -#include "typerep.h" +#include "begin.h" /** - * @page ir_graph The struct ir_graph + * @defgroup ir_graph Procedure Graph * * This struct contains all information about a procedure. * It's allocated directly to memory. @@ -79,14 +75,11 @@ * with a Sel node the pointer to a thread local variable. * * - args The ir_node that produces the arguments of the method as - * it's result. This is a Proj node on the fourth output of + * its result. This is a Proj node on the fourth output of * the start node. This output is tagged as pn_Start_T_args. * * - proj_args The proj nodes of the args node. * - * - bad The Bad node is an auxiliary node. It is needed only once, - * so there is this globally reachable node. - * * - no_mem The NoMem node is an auxiliary node. It is needed only once, * so there is this globally reachable node. * @@ -112,27 +105,9 @@ * - visited A int used as flag to traverse the ir_graph. * * - block_visited A int used as a flag to traverse block nodes in the graph. - */ - -/** Global variable holding the current ir graph. * - * This global variable is used by the ir construction - * interface in ircons and by the optimizations. - * Further it is set by all walker functions. + * @{ */ -extern ir_graph *current_ir_graph; - -ir_graph *get_current_ir_graph(void); -void set_current_ir_graph(ir_graph *graph); - -#ifdef INTERPROCEDURAL_VIEW -/** This flag indicate the current view. The behavior of some methods - * (get_irn_*, set_irn_*) is influenced by this flag. */ -int get_interprocedural_view(void); -void set_interprocedural_view(int state); -#else -#define get_interprocedural_view() 0 -#endif /** * Create a new ir graph to build ir for a procedure. @@ -147,16 +122,15 @@ void set_interprocedural_view(int state); * represent a procedure in FIRM. * * It allocates an ir_graph and sets the field irg of the entity ent - * as well as current_ir_graph to point to this graph. - * Further it allocates the following nodes needed for every - * procedure: + * to point to this graph. Further it allocates the following nodes needed + * for every procedure: * - * - The start block containing a start node and Proj nodes for it's + * - The start block containing a start node and Proj nodes for its * seven results (X, M, P, P, P, T, P). * - The end block containing an end node. This block is not matured * after executing new_ir_graph() as predecessors need to be added to it. - * (Maturing a block means fixing it's number of predecessors.) - * - The current block, which is empty and also not matured. + * (Maturing a block means fixing its number of predecessors.) + * - The current block, which is empty and matured. * * Further it enters the global store into the data structure of the start * block that contains all valid values in this block (set_store()). This @@ -172,7 +146,7 @@ void set_interprocedural_view(int state); * * @see new_pseudo_ir_graph() */ -ir_graph *new_ir_graph (ir_entity *ent, int n_loc); +FIRM_API ir_graph *new_ir_graph(ir_entity *ent, int n_loc); /** Frees the passed irgraph. * Deallocates all nodes in this graph and the ir_graph structure. @@ -182,9 +156,7 @@ ir_graph *new_ir_graph (ir_entity *ent, int n_loc); * Does not free types, entities or modes that are used only by this * graph, nor the entity standing for this graph. */ -void free_ir_graph (ir_graph *irg); - -/* --- access routines for all ir_graph attributes --- */ +FIRM_API void free_ir_graph(ir_graph *irg); /** * Checks whether a pointer points to a ir graph. @@ -192,133 +164,89 @@ void free_ir_graph (ir_graph *irg); * @param thing an arbitrary pointer * * @return - * true if the thing is a ir graph, else false + * true if the thing is a IR graph, else false */ -int is_ir_graph(const void *thing); - -/* #define get_irg_entity get_irg_ent */ -/* #define set_irg_entity set_irg_ent */ -ir_entity *get_irg_entity (const ir_graph *irg); -void set_irg_entity (ir_graph *irg, ir_entity *ent); - -ir_type *get_irg_frame_type (ir_graph *irg); -void set_irg_frame_type (ir_graph *irg, ir_type *ftp); - -ir_node *get_irg_start_block (const ir_graph *irg); -void set_irg_start_block (ir_graph *irg, ir_node *node); - -ir_node *get_irg_start (const ir_graph *irg); -void set_irg_start (ir_graph *irg, ir_node *node); - -ir_node *get_irg_end_block (const ir_graph *irg); -void set_irg_end_block (ir_graph *irg, ir_node *node); - -ir_node *get_irg_end (const ir_graph *irg); -void set_irg_end (ir_graph *irg, ir_node *node); - -/* The fields end_reg and end_except contain the end nodes of the - interprocedural view. If the view is not constructed they contain - the normal end node. */ -ir_node *get_irg_end_reg (const ir_graph *irg); -void set_irg_end_reg (ir_graph *irg, ir_node *node); - -ir_node *get_irg_end_except (const ir_graph *irg); -void set_irg_end_except (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the frame pointer. */ -ir_node *get_irg_frame (const ir_graph *irg); -/** Sets the node that represents the frame pointer. */ -void set_irg_frame (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the global pointer. */ -ir_node *get_irg_globals (const ir_graph *irg); -/** Sets the node that represents the global pointer. */ -void set_irg_globals (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the tls pointer. */ -ir_node *get_irg_tls (const ir_graph *irg); -/** Sets the node that represents the tls pointer. */ -void set_irg_tls (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the initial memory. */ -ir_node *get_irg_initial_mem (const ir_graph *irg); -/** Sets the node that represents the initial memory. */ -void set_irg_initial_mem (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the argument pointer. */ -ir_node *get_irg_args (const ir_graph *irg); -/** Sets the node that represents the argument pointer. */ -void set_irg_args (ir_graph *irg, ir_node *node); - -/** Returns the node that represents the value parameter base pointer. */ -ir_node *get_irg_value_param_base (const ir_graph *irg); -/** Sets the node that represents the value parameter base pointer. */ -void set_irg_value_param_base (ir_graph *irg, ir_node *node); - -/** Returns an array of the nodes of the argument pointer. */ -ir_node **get_irg_proj_args (const ir_graph *irg); -/** Sets the array of the nodes of the argument pointer. */ -void set_irg_proj_args (ir_graph *irg, ir_node **nodes); - -/** Returns the current block of a graph. */ -ir_node *get_irg_current_block (const ir_graph *irg); -/** Sets the current block of a graph. */ -void set_irg_current_block (ir_graph *irg, ir_node *node); - -/** Returns the Bad node. Use new_Bad() instead!! */ -ir_node *get_irg_bad (const ir_graph *irg); -void set_irg_bad (ir_graph *irg, ir_node *node); - -/** Returns the NoMem node. Use new_NoMem() instead!! */ -ir_node *get_irg_no_mem (const ir_graph *irg); -void set_irg_no_mem (ir_graph *irg, ir_node *node); - -/** Returns the number of value numbers of a graph. */ -int get_irg_n_locs (ir_graph *irg); +FIRM_API int is_ir_graph(const void *thing); + +/** Returns the entity of an IR graph. */ +FIRM_API ir_entity *get_irg_entity(const ir_graph *irg); +/** Sets the entity of an IR graph. */ +FIRM_API void set_irg_entity(ir_graph *irg, ir_entity *ent); + +/** Returns the frame type of an IR graph. */ +FIRM_API ir_type *get_irg_frame_type(ir_graph *irg); +/** Sets the frame type of an IR graph. */ +FIRM_API void set_irg_frame_type(ir_graph *irg, ir_type *ftp); + +/** Returns the start block of an IR graph. */ +FIRM_API ir_node *get_irg_start_block(const ir_graph *irg); +/** Sets the start block of an IR graph. */ +FIRM_API void set_irg_start_block(ir_graph *irg, ir_node *node); + +/** Returns the Start node of an IR graph. */ +FIRM_API ir_node *get_irg_start(const ir_graph *irg); +/** Sets the Start node of an IR graph. */ +FIRM_API void set_irg_start(ir_graph *irg, ir_node *node); + +/** Returns the end block of an IR graph. */ +FIRM_API ir_node *get_irg_end_block(const ir_graph *irg); +/** Sets the end block of an IR graph. */ +FIRM_API void set_irg_end_block(ir_graph *irg, ir_node *node); + +/** Returns the End node of an IR graph. */ +FIRM_API ir_node *get_irg_end(const ir_graph *irg); +/** Sets the End node of an IR graph. */ +FIRM_API void set_irg_end(ir_graph *irg, ir_node *node); + +/** Returns the node that represents the initial control flow of the given + * IR graph. */ +FIRM_API ir_node *get_irg_initial_exec(const ir_graph *irg); +/** Sets the node that represents the initial control of the given IR graph. */ +FIRM_API void set_irg_initial_exec(ir_graph *irg, ir_node *node); + +/** Returns the node that represents the frame pointer of the given IR graph. */ +FIRM_API ir_node *get_irg_frame(const ir_graph *irg); +/** Sets the node that represents the frame pointer of the given IR graph. */ +FIRM_API void set_irg_frame(ir_graph *irg, ir_node *node); + +/** Returns the node that represents the initial memory of the given IR graph. */ +FIRM_API ir_node *get_irg_initial_mem(const ir_graph *irg); +/** Sets the node that represents the initial memory of the given IR graph. */ +FIRM_API void set_irg_initial_mem(ir_graph *irg, ir_node *node); + +/** Returns the node that represents the argument pointer of the given IR graph. */ +FIRM_API ir_node *get_irg_args(const ir_graph *irg); +/** Sets the node that represents the argument pointer of the given IR graph. */ +FIRM_API void set_irg_args(ir_graph *irg, ir_node *node); + +/** Returns the NoMem node of the given IR graph. */ +FIRM_API ir_node *get_irg_no_mem(const ir_graph *irg); +/** Sets the NoMem node of graph @p irg. */ +FIRM_API void set_irg_no_mem(ir_graph *irg, ir_node *node); + +/** Returns the number of value numbers of an IR graph. */ +FIRM_API int get_irg_n_locs(ir_graph *irg); /** Returns the graph number. */ -long get_irg_graph_nr(ir_graph *irg); - -/********************************************************************************/ -/* States of an ir_graph. */ -/********************************************************************************/ - -/* - information associated with the graph. Optimizations invalidate these - states. */ +FIRM_API long get_irg_graph_nr(const ir_graph *irg); -/** The states of an ir graph. - * - * state phase values: phase_building, phase_high, phase_low, phase_backend. - * - * The graph is in phase_building during construction of the irgraph. - * The construction is finished by a call to finalize_cons(). - * - * Finalize_cons() sets the state to phase_high. All standard Firm nodes are - * allowed. - * - * To get the irgraph into phase_low all Sel nodes must be removed and - * replaced by explicit address computations. SymConst size and - * type tag nodes must be removed (@@@ really?). Initialization of - * memory allocated by Alloc must be explicit. @@@ More conditions? - * - * phase_backend is set if architecture specific machine nodes are inserted - * (and probably most standard Firm are removed). +/** + * Returns the graph number. This is a unique number for the graph and is + * smaller than get_irp_last_idx() + * Note: you cannot use this number for get_irp_irg() */ -typedef enum { - phase_building, /**< The graph is still being constructed. */ - phase_high, /**< The construction of the graph is finish, high level nodes may be present. */ - phase_low, /**< High level nodes are removed. */ - phase_backend /**< The graph is taken by the backend. Machine specific nodes may be present. */ -} irg_phase_state; - -/** returns the phase_state of an IR graph. */ -irg_phase_state get_irg_phase_state (const ir_graph *irg); - -/** sets the phase state of an IR graph. */ -void set_irg_phase_state(ir_graph *irg, irg_phase_state state); +FIRM_API size_t get_irg_idx(const ir_graph *irg); -#define set_irg_phase_low(irg) set_irg_phase_state(irg, phase_low) +/** + * Returns the node for an index. + * @param irg The graph. + * @param idx The index you want the node for. + * @return The node with that index or NULL, if there is no node with that + * index. + * @note The node you got might be dead. + * @see get_irn_idx() + */ +FIRM_API ir_node *get_idx_irn(const ir_graph *irg, unsigned idx); /** state: op_pin_state_pinned The graph is "op_pin_state_pinned" if all nodes are associated with a basic block. @@ -327,95 +255,7 @@ void set_irg_phase_state(ir_graph *irg, irg_phase_state state); invalid block, i.e., the block is not a dominator of all the uses of the node. The enum op_pin_state is defined in irop.h. */ -op_pin_state get_irg_pinned (const ir_graph *irg); - -/** state: outs_state - * Outs are the back edges or def-use edges of ir nodes. - * Values: outs_none, outs_consistent, outs_inconsistent */ -typedef enum { - outs_none, /**< Outs are not computed, no memory is allocated. */ - outs_consistent, /**< Outs are computed and correct. */ - outs_inconsistent /**< Outs have been computed, memory is still allocated, - but the graph has been changed since. */ -} irg_outs_state; -irg_outs_state get_irg_outs_state(const ir_graph *irg); -void set_irg_outs_inconsistent(ir_graph *irg); - -/** state: extended basic block state. */ -typedef enum { - extblk_none = 0, /**< No extended basic block information is constructed. Default. */ - extblk_valid = 1, /**< Extended basic block information is valid. */ - extblk_invalid = 2 /**< Extended basic block information is constructed but invalid. */ -} irg_extblk_state; -irg_extblk_state get_irg_extblk_state(const ir_graph *irg); -void set_irg_extblk_inconsistent(ir_graph *irg); - -/** state: dom_state - * Signals the state of the dominator / post dominator information. - */ -typedef enum { - dom_none, /**< dominator are not computed, no memory is allocated */ - dom_consistent, /**< dominator information is computed and correct */ - dom_inconsistent /**< dominator information is computed but the graph has been changed since */ -} irg_dom_state; - -/** returns the dominator state of an IR graph. */ -irg_dom_state get_irg_dom_state(const ir_graph *irg); - -/** returns the post dominator state of an IR graph. */ -irg_dom_state get_irg_postdom_state(const ir_graph *irg); - -/** sets the dominator and post dominator state of an IR graph to inconsistent. */ -void set_irg_doms_inconsistent(ir_graph *irg); - -/** state: loopinfo_state - * Loop information describes the loops within the control and - * data flow of the procedure. - */ -typedef enum { - loopinfo_none = 0, /**< No loop information is constructed. Default. */ - loopinfo_constructed = 1, /**< Some kind of loop information is constructed. */ - loopinfo_valid = 2, /**< Loop information is valid. */ - loopinfo_cf = 4, /**< Loop information constructed for control flow only. */ - loopinfo_inter = 8, /**< Loop information for interprocedural view. */ - - loopinfo_for_firmjni = 16, /**< A hack for firmjni: all enums must differ as they - are used in a switch. */ - - /** IntRAprocedural loop information constructed and valid. */ - loopinfo_consistent = loopinfo_constructed | loopinfo_for_firmjni | loopinfo_valid, - /** IntRAprocedural loop information constructed and invalid. */ - loopinfo_inconsistent = loopinfo_constructed | loopinfo_for_firmjni, - - /** IntERprocedural loop information constructed and valid. */ - loopinfo_ip_consistent = loopinfo_constructed | loopinfo_inter | loopinfo_valid, - /** IntERprocedural loop information constructed and invalid. */ - loopinfo_ip_inconsistent = loopinfo_constructed | loopinfo_inter, - - /** IntRAprocedural control loop information constructed and valid. */ - loopinfo_cf_consistent = loopinfo_constructed | loopinfo_cf | loopinfo_valid, - /** IntRAprocedural control loop information constructed and invalid. */ - loopinfo_cf_inconsistent = loopinfo_constructed | loopinfo_cf, - - /** IntERprocedural control loop information constructed and valid. */ - loopinfo_cf_ip_consistent = loopinfo_constructed | loopinfo_cf | loopinfo_inter | loopinfo_valid, - /** IntERprocedural control loop information constructed and invalid. */ - loopinfo_cf_ip_inconsistent = loopinfo_constructed | loopinfo_cf | loopinfo_inter -} irg_loopinfo_state; - -/** Return the current loop information state. */ -irg_loopinfo_state get_irg_loopinfo_state(const ir_graph *irg); - -/** Sets the current loop information state. */ -void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s); - -/** Sets the loop information state to the appropriate inconsistent state. - * If state is 'none' does not change. */ -void set_irg_loopinfo_inconsistent(ir_graph *irg); -/** Sets the loop information state to the appropriate inconsistent state. - * If state is 'none' does not change. - * Does this for all irgs. */ -void set_irp_loopinfo_inconsistent(void); +FIRM_API op_pin_state get_irg_pinned(const ir_graph *irg); /** state: callee_information_state * Call nodes contain a list of possible callees. This list must be @@ -430,118 +270,245 @@ typedef enum { irg_callee_info_inconsistent } irg_callee_info_state; -/** returns the callee_info_state of an IR graph. */ -irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg); - -/** sets the callee_info_state of an IR graph. */ -void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s); - -/** property: - * Tells how to handle an ir graph in inlineing. - */ -typedef enum { - irg_inline_any, /**< No restriction on inlineing. Default. */ - irg_inline_forbidden, /**< The graph may not be inlined. */ - irg_inline_recomended, /**< The graph should be inlined. */ - irg_inline_forced, /**< The graph must be inlined. */ - irg_inline_forced_no_body /**< The graph must be inlined. No body is allowed - to be emitted. */ -} irg_inline_property; - -/** Returns the inline property of a graph. */ -irg_inline_property get_irg_inline_property(const ir_graph *irg); -/** Sets the inline property of a graph. */ -void set_irg_inline_property(ir_graph *irg, irg_inline_property s); +/** Returns the callee_info_state of an IR graph. */ +FIRM_API irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg); -/** - * Returns the mask of the additional graph properties. - * The properties are automatically inherited from the method type - * if they were not set using set_irg_additional_properties() or - * set_irg_additional_property(). - * - * @return a bitset of mtp_additional_property values - */ -unsigned get_irg_additional_properties(const ir_graph *irg); - -/** Sets the mask of the additional graph properties. */ -void set_irg_additional_properties(ir_graph *irg, unsigned property_mask); - -/** Sets one additional graph property. */ -void set_irg_additional_property(ir_graph *irg, mtp_additional_property flag); +/** Sets the callee_info_state of an IR graph. */ +FIRM_API void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s); /** A void * field to link arbitrary information to the node. */ -void set_irg_link (ir_graph *irg, void *thing); -void *get_irg_link (const ir_graph *irg); - -/** Increments visited flag by one. - * @see also: get_irn_visited() get_irg_block_visited(). */ -void inc_irg_visited (ir_graph *irg); -unsigned long get_irg_visited (const ir_graph *irg); -void set_irg_visited (ir_graph *irg, unsigned long i); -/** An interprocedural flag valid for all irgs. - * @see also: get_irn_visited() get_irg_block_visited(). */ -unsigned long get_max_irg_visited (void); -void set_max_irg_visited (int val); -unsigned long inc_max_irg_visited (void); - -/** Increments block_visited by one. - * @see also: get_irn_visited() get_irg_block_visited(). */ -void inc_irg_block_visited (ir_graph *irg); -unsigned long get_irg_block_visited (const ir_graph *irg); -void set_irg_block_visited (ir_graph *irg, unsigned long i); +FIRM_API void set_irg_link(ir_graph *irg, void *thing); +/** Return void* field previously set by set_irg_link() */ +FIRM_API void *get_irg_link(const ir_graph *irg); + +/** Increments node visited counter by one. + * @see @ref visited_counters, irn_visited(), mark_irn_visited() */ +FIRM_API void inc_irg_visited(ir_graph *irg); +/** Returns node visited counter. + * @see @ref visited_counters */ +FIRM_API ir_visited_t get_irg_visited(const ir_graph *irg); +/** Sets node visited counter. + * @see @ref visited_counters */ +FIRM_API void set_irg_visited(ir_graph *irg, ir_visited_t i); +/** Returns interprocedural node visited counter. + * @see @ref visited_counters */ +FIRM_API ir_visited_t get_max_irg_visited(void); +/** Sets interprocedural node visited counter. + * @see @ref visited_counters */ +FIRM_API void set_max_irg_visited(int val); +/** Increment interprocedural node visited counter by one. + * @see @ref visited_counters */ +FIRM_API ir_visited_t inc_max_irg_visited(void); + +/** Increments block visited counter by one. + * @see @ref visited_counters, Block_block_visited(), mark_Block_block_visited() */ +FIRM_API void inc_irg_block_visited(ir_graph *irg); +/** Returns block visited counter. + * @see @ref visited_counters */ +FIRM_API ir_visited_t get_irg_block_visited(const ir_graph *irg); +/** Sets block visited counter. + * @see @ref visited_counters */ +FIRM_API void set_irg_block_visited(ir_graph *irg, ir_visited_t i); /** * Debug helpers: You can indicate whether you are currently using visited or * block_visited flags. If NDEBUG is not defined, then the compiler will abort * if 2 parties try to use the flags. */ +typedef enum ir_resources_t { + IR_RESOURCE_NONE = 0, /**< no resource */ + IR_RESOURCE_BLOCK_VISITED = 1 << 0, /**< Block visited flags are used. */ + IR_RESOURCE_BLOCK_MARK = 1 << 1, /**< Block mark bits are used. */ + IR_RESOURCE_IRN_VISITED = 1 << 2, /**< IR-node visited flags are used. */ + IR_RESOURCE_IRN_LINK = 1 << 3, /**< IR-node link fields are used. */ + IR_RESOURCE_LOOP_LINK = 1 << 4, /**< IR-loop link fields are used. */ + IR_RESOURCE_PHI_LIST = 1 << 5 /**< Block Phi lists are used. */ +} ir_resources_t; +ENUM_BITSET(ir_resources_t) + #ifndef NDEBUG -void set_using_block_visited(ir_graph *irg); -void clear_using_block_visited(ir_graph *irg); -int using_block_visited(const ir_graph *irg); -void set_using_visited(ir_graph *irg); -void clear_using_visited(ir_graph *irg); -int using_visited(const ir_graph *irg); -void set_using_irn_link(ir_graph *irg); -void clear_using_irn_link(ir_graph *irg); -int using_irn_link(const ir_graph *irg); +/** + * Reserves resources of a graph. + * + * This is a debug tool: All code should properly allocate the resources it uses + * so if two interlocked algorithms use the same resources that bug will get + * detected. + */ +FIRM_API void ir_reserve_resources(ir_graph *irg, ir_resources_t resources); +/** Frees previously reserved resources. */ +FIRM_API void ir_free_resources(ir_graph *irg, ir_resources_t resources); +/** Returns currently reserved resources. */ +FIRM_API ir_resources_t ir_resources_reserved(const ir_graph *irg); #else -static INLINE void set_using_block_visited(ir_graph *irg) { (void) irg; } -static INLINE void clear_using_block_visited(ir_graph *irg) { (void) irg; } -static INLINE int using_block_visited(const ir_graph *irg) { (void) irg; return 0; } -static INLINE void set_using_visited(ir_graph *irg) { (void) irg; } -static INLINE void clear_using_visited(ir_graph *irg) { (void) irg; } -static INLINE int using_visited(const ir_graph *irg) { (void) irg; return 0; } -static INLINE void set_using_irn_link(ir_graph *irg) { (void) irg; } -static INLINE void clear_using_irn_link(ir_graph *irg) { (void) irg; } -static INLINE int using_irn_link(const ir_graph *irg) { (void) irg; return 0; } +#define ir_reserve_resources(irg,resources) (void)0 +#define ir_free_resources(irg,resources) (void)0 +#define ir_resources_reserved(irg) 0 #endif -/** Normalization: Move Proj nodes into the same block as its predecessors */ -void normalize_proj_nodes(ir_graph *irg); - -/** set a description for local value n */ -void set_irg_loc_description(ir_graph *irg, int n, void *description); - -/** get the description for local value n */ -void *get_irg_loc_description(ir_graph *irg, int n); +/** + * graph constraints: + * These are typically used when lowering a graph for a target machine, + * typically you get stricter constraints the closer you get to a real + * machine. + */ +typedef enum ir_graph_constraints_t { + /** + * Should not construct more nodes which irarch potentially breaks down + */ + IR_GRAPH_CONSTRAINT_ARCH_DEP = 1U << 0, + /** + * mode_b nodes have been lowered so you should not create any new nodes + * with mode_b (except for Cmp) + */ + IR_GRAPH_CONSTRAINT_MODEB_LOWERED = 1U << 1, + /** + * There are normalisations where there is no "best" representative. + * In this case we first normalise into 1 direction (!NORMALISATION2) and + * later in the other (NORMALISATION2). + */ + IR_GRAPH_CONSTRAINT_NORMALISATION2 = 1U << 2, + /** + * Allows localopts to remove edges to unreachable code. + * Warning: It is only safe to enable this when you are sure that you + * apply all localopts to the fixpunkt. (=in optimize_graph_df) + */ + IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE = 1U << 3, + /** + * The graph is being constructed: We have a current_block set, + * and blocks contain mapping of variable numbers to current + * values. + */ + IR_GRAPH_CONSTRAINT_CONSTRUCTION = 1U << 4, + /** + * Intermediate language constructs not supported by the backend have + * been lowered. + */ + IR_GRAPH_CONSTRAINT_TARGET_LOWERED = 1U << 5, + /** + * We have a backend graph: all data values have register constraints + * annotated. + */ + IR_GRAPH_CONSTRAINT_BACKEND = 1U << 6, +} ir_graph_constraints_t; +ENUM_BITSET(ir_graph_constraints_t) + +/** sets @p constraints on the graph @p irg */ +FIRM_API void add_irg_constraints(ir_graph *irg, + ir_graph_constraints_t constraints); +/** clears some graph constraints */ +FIRM_API void clear_irg_constraints(ir_graph *irg, + ir_graph_constraints_t constraints); +/** queries whether @p irg is at least as constrained as @p constraints. */ +FIRM_API int irg_is_constrained(const ir_graph *irg, + ir_graph_constraints_t constraints); -/** Returns a estimated node count of the irg. This count is updated - * after every irg_walk_graph(). +/** + * graph state. They properties about a graph. + * Graph transformations may destroy these properties and have to explicitely + * state when they did not affect some properties and want to keep them. */ -unsigned get_irg_estimated_node_cnt(const ir_graph *irg); +typedef enum ir_graph_properties_t { + IR_GRAPH_PROPERTIES_NONE = 0, + /** graph contains no critical edges */ + IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES = 1U << 0, + /** graph contains no Bad nodes */ + IR_GRAPH_PROPERTY_NO_BADS = 1U << 1, + /** No tuple nodes exist in the graph */ + IR_GRAPH_PROPERTY_NO_TUPLES = 1U << 2, + /** + * there exists no (obviously) unreachable code in the graph. + * Unreachable in this context is code that you can't reach by following + * execution flow from the start block. + */ + IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE = 1U << 3, + /** graph contains at most one return */ + IR_GRAPH_PROPERTY_ONE_RETURN = 1U << 4, + /** dominance information about the graph is valid */ + IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE = 1U << 5, + /** postdominance information about the graph is valid */ + IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE = 1U << 6, + /** dominance frontiers information is calculated */ + IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS = 1U << 7, + /** + * out edges (=iredges) are enable and there is no dead code that can be + * reached by following them + */ + IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES = 1U << 8, + /** outs (irouts) are computed and up to date */ + IR_GRAPH_PROPERTY_CONSISTENT_OUTS = 1U << 9, + /** loopinfo is computed and up to date */ + IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO = 1U << 10, + /** entity usage information is computed and up to date */ + IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE = 1U << 11, + /** graph contains as many returns as possible */ + IR_GRAPH_PROPERTY_MANY_RETURNS = 1U << 12, + + /** + * List of all graph properties that are only affected by control flow + * changes. + */ + IR_GRAPH_PROPERTIES_CONTROL_FLOW = + IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES + | IR_GRAPH_PROPERTY_ONE_RETURN + | IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE + | IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO + | IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE + | IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE + | IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS, + + /** + * List of all graph properties. + */ + IR_GRAPH_PROPERTIES_ALL = + IR_GRAPH_PROPERTIES_CONTROL_FLOW + | IR_GRAPH_PROPERTY_NO_BADS + | IR_GRAPH_PROPERTY_NO_TUPLES + | IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES + | IR_GRAPH_PROPERTY_CONSISTENT_OUTS + | IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE + | IR_GRAPH_PROPERTY_MANY_RETURNS, + +} ir_graph_properties_t; +ENUM_BITSET(ir_graph_properties_t) + +/** sets some state properties on the graph */ +FIRM_API void add_irg_properties(ir_graph *irg, ir_graph_properties_t props); +/** clears some graph properties */ +FIRM_API void clear_irg_properties(ir_graph *irg, ir_graph_properties_t props); +/** queries whether @p irg has the @p props properties set */ +FIRM_API int irg_has_properties(const ir_graph *irg, + ir_graph_properties_t props); + +/** Sets a description for local value n. */ +FIRM_API void set_irg_loc_description(ir_graph *irg, int n, void *description); + +/** Returns the description for local value n. */ +FIRM_API void *get_irg_loc_description(ir_graph *irg, int n); /** Returns the last irn index for this graph. */ -unsigned get_irg_last_idx(const ir_graph *irg); +FIRM_API unsigned get_irg_last_idx(const ir_graph *irg); /** Returns the floating point model of this graph. */ -unsigned get_irg_fp_model(const ir_graph *irg); +FIRM_API unsigned get_irg_fp_model(const ir_graph *irg); /** Sets a floating point model for this graph. */ -void set_irg_fp_model(ir_graph *irg, unsigned model); +FIRM_API void set_irg_fp_model(ir_graph *irg, unsigned model); /** - * Access custom graph data. + * Ensures that a graph fulfills all properties stated in @p state. + * Performs graph transformations if necessary. + */ +FIRM_API void assure_irg_properties(ir_graph *irg, ir_graph_properties_t props); + +/** + * Invalidates all graph properties/analysis data except the ones specified + * in @p props. + * This should be called after a transformation phase. + */ +FIRM_API void confirm_irg_properties(ir_graph *irg, ir_graph_properties_t props); + +/** + * Accesses custom graph data. * The data must have been registered with * register_additional_graph_data() before. * @param graph The graph to get the data from. @@ -553,7 +520,7 @@ void set_irg_fp_model(ir_graph *irg, unsigned model); (assert(off > 0 && "Invalid graph data offset"), (type *) ((char *) (graph) - (off))) /** - * Get the pointer to the node some custom data belongs to. + * Returns the pointer to the node some custom data belongs to. * @param data The pointer to the custom data. * @param off The number as returned by register_additional_graph_data(). * @return A pointer to the ir node the custom data belongs to. @@ -562,12 +529,16 @@ void set_irg_fp_model(ir_graph *irg, unsigned model); (assert(off > 0 && "Invalid graph data offset"), (ir_graph *) ((char *) (data) + (off))) /** - * Request additional data to be allocated with an ir graph. + * Requests additional data to be allocated with an ir graph. * @param size The size of the additional data required. * @return A positive number, if the operation was successful, which * must be passed to the access macro get_irg_data(), 0 if the * registration failed. */ -size_t register_additional_graph_data(size_t size); +FIRM_API size_t register_additional_graph_data(size_t size); + +/** @} */ + +#include "end.h" #endif