*
* - ent The entity describing this procedure.
*
+ * - anchor A node having several important nodes of the graph as its
+ * operands. The operands of the anchor are described in the
+ * following.
+ *
* The beginning and end of a graph:
*
* - start_block This ir_node is the block that contains the unique
* further nodes.
* - end This ir_node is the unique end node of the procedure.
*
- * The following nodes are Projs from the Start node, held in ir_graph for
+ * The following nodes are Projs from the Start node, held by the anchor for
* simple access:
*
* - frame The ir_node producing the pointer to the stack frame of
* edges. Therefore FIRM has to represent them in the stack
* frame.
*
- * - globals This models a pointer to a space in the memory where
- * _all_ global things are held. Select from this pointer
- * with a Sel node the pointer to a global variable /
- * procedure / compiler known function... .
- *
- * - tls This models a pointer to a space in the memory where
- * thread local things are held. Select from this pointer
- * with a Sel node the pointer to a thread local variable.
+ * - initial_mem The memory monad passed to the function when calling it.
+ * This is Proj pn_Start_M of the Start node.
*
* - args The ir_node that produces the arguments of the method as
- * 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.
+ * its result. This is Proj pn_Start_T_args of the Start
+ * node.
*
* - no_mem The NoMem node is an auxiliary node. It is needed only once,
* so there is this globally reachable node.
* to this block. It can be set with set_cur_block(block).
* Only needed for ir construction.
*
- * - params/n_loc An int giving the number of local variables in this
- * procedure. This is needed for ir construction. Name will
- * be changed.
+ * - n_loc An int giving the number of local variables in this
+ * procedure. This is needed for ir construction.
*
* - value_table This hash table (pset) is used for global value numbering
* for optimizing use in iropt.c.
*
- * - Phi_in_stack; a stack needed for automatic Phi construction, needed only
- * during ir construction.
- *
* - 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.
* 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 its
- * seven results (X, M, P, P, P, T, P).
+ * - The start block containing a start node and Proj nodes for its results.
* - 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 its number of predecessors.)
- * - The current block, which is empty and also not matured.
+ * - 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
* data structure is used to build the Phi nodes and removed after
* completion of the graph. There is no path from end to start in the
- * graph after calling ir_graph.
+ * graph after calling new_ir_graph().
*
* The op_pin_state of the graph is set to "op_pin_state_pinned"
* if no global cse was performed on the graph.
/** Frees the passed irgraph.
* Deallocates all nodes in this graph and the ir_graph structure.
* Sets the field irgraph in the corresponding entity to NULL.
- * Does not remove the irgraph from the list in irprog (requires
- * inefficient search, call remove_irp_irg by hand).
+ * Removes the irgraph from the list in irprog.
* Does not free types, entities or modes that are used only by this
* graph, nor the entity standing for this graph.
*/
*/
FIRM_API ir_node *get_idx_irn(const ir_graph *irg, unsigned idx);
-
-/** 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).
- */
-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. */
-FIRM_API irg_phase_state get_irg_phase_state(const ir_graph *irg);
-
-/** Sets the phase state of an IR graph. */
-FIRM_API void set_irg_phase_state(ir_graph *irg, irg_phase_state state);
-
/** state: op_pin_state_pinned
The graph is "op_pin_state_pinned" if all nodes are associated with a basic block.
It is in state "op_pin_state_floats" if nodes are in arbitrary blocks. In state
/** 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);
-/** property:
- * Tells how to handle an ir graph in inlining.
- */
-typedef enum {
- irg_inline_any, /**< No restriction on inlining. Default. */
- irg_inline_forbidden, /**< The graph must 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. */
-FIRM_API irg_inline_property get_irg_inline_property(const ir_graph *irg);
-/** Sets the inline property of a graph. */
-FIRM_API void set_irg_inline_property(ir_graph *irg, irg_inline_property s);
-
-/**
- * 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_properties().
- *
- * @return a bitset of mtp_additional_properties values
- */
-FIRM_API mtp_additional_properties get_irg_additional_properties(const ir_graph *irg);
-
-/** Sets the mask of the additional graph properties. */
-FIRM_API void set_irg_additional_properties(ir_graph *irg,
- mtp_additional_properties property_mask);
-
-/** Sets one additional graph property. */
-FIRM_API void add_irg_additional_properties(ir_graph *irg,
- mtp_additional_properties flag);
-
/** A void * field to link arbitrary information to the node. */
FIRM_API void set_irg_link(ir_graph *irg, void *thing);
/** Return void* field previously set by set_irg_link() */
#endif
/**
- * graph state. This is used for 2 things:
- * - stating properties about a graph
- * - disallow certain transformations for the graph (typically highlevel
- * constructs are disallowed after lowering them)
+ * 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 {
+typedef enum ir_graph_constraints_t {
/**
* Should not construct more nodes which irarch potentially breaks down
*/
- IR_GRAPH_STATE_ARCH_DEP = 1U << 0,
+ 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_STATE_MODEB_LOWERED = 1U << 1,
+ 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_STATE_NORMALISATION2 = 1U << 2,
- /**
- * Defines the semantic of Load(Sel(x)), if x has a bit offset (Bitfields!).
- * Normally, the frontend is responsible for bitfield masking operations.
- * Sets IMPLICIT_BITFIELD_MASKING, if the lowering phase must insert masking
- * operations.
- */
- IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING = 1U << 3,
+ 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_STATE_OPTIMIZE_UNREACHABLE_CODE = 1U << 4,
+ 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);
+
+/**
+ * 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.
+ */
+typedef enum ir_graph_properties_t {
+ IR_GRAPH_PROPERTIES_NONE = 0,
/** graph contains no critical edges */
- IR_GRAPH_STATE_NO_CRITICAL_EDGES = 1U << 5,
+ IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES = 1U << 0,
/** graph contains no Bad nodes */
- IR_GRAPH_STATE_NO_BADS = 1U << 6,
+ 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_STATE_NO_UNREACHABLE_CODE = 1U << 7,
+ IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE = 1U << 3,
/** graph contains at most one return */
- IR_GRAPH_STATE_ONE_RETURN = 1U << 8,
+ IR_GRAPH_PROPERTY_ONE_RETURN = 1U << 4,
/** dominance information about the graph is valid */
- IR_GRAPH_STATE_CONSISTENT_DOMINANCE = 1U << 9,
+ IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE = 1U << 5,
/** postdominance information about the graph is valid */
- IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE = 1U << 10,
+ 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_STATE_CONSISTENT_OUT_EDGES = 1U << 11,
+ IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES = 1U << 8,
/** outs (irouts) are computed and up to date */
- IR_GRAPH_STATE_CONSISTENT_OUTS = 1U << 12,
+ IR_GRAPH_PROPERTY_CONSISTENT_OUTS = 1U << 9,
/** loopinfo is computed and up to date */
- IR_GRAPH_STATE_CONSISTENT_LOOPINFO = 1U << 13,
+ IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO = 1U << 10,
/** entity usage information is computed and up to date */
- IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE = 1U << 14,
- /** extended basic blocks have been formed and are up to date */
- IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS = 1U << 15,
+ IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE = 1U << 11,
/** graph contains as many returns as possible */
- IR_GRAPH_STATE_MANY_RETURNS = 1U << 16,
-} ir_graph_state_t;
-ENUM_BITSET(ir_graph_state_t)
+ 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,
-/** Sets some state flags on the graph (this does not clear the other flags) */
-FIRM_API void set_irg_state(ir_graph *irg, ir_graph_state_t state);
-/** Clears some state flags of the graph */
-FIRM_API void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
-/** Queries whether a set of graph state flags are activated */
-FIRM_API int is_irg_state(const ir_graph *irg, ir_graph_state_t state);
+ /**
+ * 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 a estimated node count of the irg. This count is updated
- * after every irg_walk_graph().
- */
-FIRM_API unsigned get_irg_estimated_node_cnt(const ir_graph *irg);
-
/** Returns the last irn index for this graph. */
FIRM_API unsigned get_irg_last_idx(const ir_graph *irg);
FIRM_API void set_irg_fp_model(ir_graph *irg, unsigned model);
/**
- * 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.
- * @param type The type of the data you registered.
- * @param off The value returned by register_additional_graph_data().
- * @return A pointer of type @p type.
- */
-#define get_irg_data(graph,type,off) \
- (assert(off > 0 && "Invalid graph data offset"), (type *) ((char *) (graph) - (off)))
-
-/**
- * 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.
+ * Ensures that a graph fulfills all properties stated in @p state.
+ * Performs graph transformations if necessary.
*/
-#define get_irg_data_base(data,off) \
- (assert(off > 0 && "Invalid graph data offset"), (ir_graph *) ((char *) (data) + (off)))
+FIRM_API void assure_irg_properties(ir_graph *irg, ir_graph_properties_t props);
/**
- * 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.
+ * Invalidates all graph properties/analysis data except the ones specified
+ * in @p props.
+ * This should be called after a transformation phase.
*/
-FIRM_API size_t register_additional_graph_data(size_t size);
+FIRM_API void confirm_irg_properties(ir_graph *irg, ir_graph_properties_t props);
/** @} */
projects / libfirm / blobdiff