/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
/**
* @file
* @brief Available Optimisations of libFirm.
- * @version $Id$
*/
#ifndef FIRM_IROPTIMIZE_H
#define FIRM_IROPTIMIZE_H
#include "nodeops.h"
#include "begin.h"
+/**
+ * @defgroup iroptimize Transformations and Optimisations
+ * @{
+ */
+
/**
* Control flow optimization.
*
* Independent of compiler flag it removes Tuples from cf edges,
* Bad predecessors from Blocks and Phis, and unnecessary predecessors of End.
* Destroys backedge information.
- *
- * @bug Chokes on Id nodes if called in a certain order with other
- * optimizations. Call local_optimize_graph() before to remove
- * Ids.
*/
FIRM_API void optimize_cf(ir_graph *irg);
FIRM_API ir_graph_pass_t *opt_jumpthreading_pass(const char *name);
/**
- * Creates an ir_graph pass for opt_loopunroll().
- *
- * @param name the name of this pass or NULL
- *
- * @return the newly created ir_graph pass
- */
-FIRM_API ir_graph_pass_t *opt_loopunroll_pass(const char *name);
-
-
-/**
- * Try to simplify boolean expression in the given ir graph.
+ * Simplifies boolean expression in the given ir graph.
* eg. x < 5 && x < 6 becomes x < 5
*
* @param irg the graph
FIRM_API ir_graph_pass_t *opt_bool_pass(const char *name);
/**
- * Try to reduce the number of conv nodes in the given ir graph.
+ * Reduces the number of Conv nodes in the given ir graph.
*
* @param irg the graph
*
*/
FIRM_API ir_graph_pass_t *conv_opt_pass(const char *name);
-/**
- * Do the scalar replacement optimization.
- * Make a date flow analyze and split the
- * data flow edges.
- *
- * @param irg the graph which should be optimized
- */
-FIRM_API void data_flow_scalar_replacement_opt(ir_graph *irg);
-
/**
* A callback that checks whether a entity is an allocation
* routine.
typedef int (*check_alloc_entity_func)(ir_entity *ent);
/**
- * Do simple and fast escape analysis for one graph.
+ * Performs simple and fast escape analysis for one graph.
*
* @param irg the graph
* @param callback a callback function to check whether a
check_alloc_entity_func callback);
/**
- * Do simple and fast escape analysis for all graphs.
+ * Performs simple and fast escape analysis for all graphs.
*
* This optimization implements a simple and fast but inexact
* escape analysis. Some addresses might be marked as 'escaped' even
* graphs.
*
* If callee information is valid, we also optimize polymorphic Calls.
- *
- * @param force_run if non-zero, an optimization run is started even
- * if no const function graph was detected.
- * Else calls are only optimized if at least one
- * const function graph was detected.
- * @param callback a callback function to check whether a
- * given entity is a allocation call
- *
- * If the frontend created external entities with the irg_const_function
- * property set, the force_run parameter should be set, else
- * should be unset.
- *
- * @note This optimization destroys the link fields of nodes.
*/
-FIRM_API void optimize_funccalls(int force_run,
- check_alloc_entity_func callback);
+FIRM_API void optimize_funccalls(void);
/**
* Creates an ir_prog pass for optimize_funccalls().
*
* @param name the name of this pass or NULL
- * @param force_run if non-zero, an optimization run is started even
- * if no const function graph was detected.
- * Else calls are only optimized if at least one
- * const function graph was detected.
- * @param callback a callback function to check whether a
- * given entity is a allocation call
- *
* @return the newly created ir_prog pass
*/
-FIRM_API ir_prog_pass_t *optimize_funccalls_pass(const char *name,
- int force_run,
- check_alloc_entity_func callback);
+FIRM_API ir_prog_pass_t *optimize_funccalls_pass(const char *name);
/**
* Does Partial Redundancy Elimination combined with
FIRM_API ir_graph_pass_t *opt_if_conv_pass(const char *name);
/**
- * Tries to reduce dependencies for memory nodes where possible by parllelizing
- * them and synchronising with Sync nodes
- * @param irg the graph where memory operations should be parallelised
+ * Tries to reduce dependencies for memory nodes where possible by parallelizing
+ * them and synchronizing with Sync nodes
+ * @param irg the graph where memory operations should be parallelized
*/
FIRM_API void opt_parallelize_mem(ir_graph *irg);
*/
FIRM_API ir_graph_pass_t *opt_parallelize_mem_pass(const char *name);
-/*
+/**
* Check if we can replace the load by a given const from
* the const code irg.
*
*
* @param irg The graph whose loops will be processed
*
- * This function did not change the graph, only it's frame type.
+ * This function did not change the graph, only its frame type.
* The layout state of the frame type will be set to layout_undefined
* if entities were removed.
*/
*
* @param irg The graph whose frame type will be optimized
*
- * This function did not change the graph, only it's frame type.
+ * This function did not change the graph, only its frame type.
* The layout state of the frame type will be set to layout_undefined
* if entities were removed.
*/
induction variables. */
} osr_flags;
-/* FirmJNI cannot handle identical enum values... */
-
/** default setting */
#define osr_flag_default osr_flag_lftr_with_ov_check
/**
- * Do the Operator Scalar Replacement optimization and linear
+ * Performs the Operator Scalar Replacement optimization and linear
* function test replacement for loop control.
* Can be switched off using the set_opt_strength_red() flag.
* In that case, only remove_phi_cycles() is executed.
#define DEFAULT_CLONE_THRESHOLD 20
/**
- * Do procedure cloning. Evaluate a heuristic weight for every
+ * Performs procedure cloning. Evaluate a heuristic weight for every
* Call(..., Const, ...). If the weight is bigger than threshold,
* clone the entity and fix the calls.
*
* and for address expression.
* Works only if Constant folding is activated.
*
- * Uses loop information to detect loop-invariant (ie contant
+ * Uses loop information to detect loop-invariant (i.e. contant
* inside the loop) values.
*
* See Muchnik 12.3.1 Algebraic Simplification and Reassociation of
FIRM_API ir_graph_pass_t *normalize_n_returns_pass(const char *name);
/**
- * Do the scalar replacement optimization.
- * Replace local compound entities (like structures and arrays)
+ * Performs the scalar replacement optimization.
+ * Replaces local compound entities (like structures and arrays)
* with atomic values if possible. Does not handle classes yet.
*
* @param irg the graph which should be optimized
*/
FIRM_API ir_graph_pass_t *scalar_replacement_opt_pass(const char *name);
-/** Performs strength reduction for the passed graph. */
-FIRM_API void reduce_strength(ir_graph *irg);
-
/**
* Optimizes tail-recursion calls by converting them into loops.
* Depends on the flag opt_tail_recursion.
* size are inlined. Further only a limited number of calls are inlined.
* If the method contains more than 1024 inlineable calls none will be
* inlined.
- * Inlining is only performed if flags `optimize' and `inlineing' are set.
+ * Inlining is only performed if flags `optimize' and `inlining' are set.
* The graph may not be in state phase_building.
* It is recommended to call local_optimize_graph() after inlining as this
* function leaves a set of obscure Tuple nodes, e.g. a Proj-Tuple-Jmp
/**
* Inlineing with a different heuristic than inline_small_irgs().
*
- * Inlines leave functions. If inlinening creates new leave
+ * Inlines leave functions. If inlining creates new leave
* function inlines these, too. (If g calls f, and f calls leave h,
* h is first inlined in f and then f in g.)
*
* Then inlines all small functions (this is not recursive).
*
- * For a heuristic this inlineing uses firm node counts. It does
+ * For a heuristic this inlining uses firm node counts. It does
* not count auxiliary nodes as Proj, Tuple, End, Start, Id, Sync.
* If the ignore_runtime flag is set, calls to functions marked with the
* mtp_property_runtime property are ignored.
*
* @param maxsize Do not inline any calls if a method has more than
* maxsize firm nodes. It may reach this limit by
- * inlineing.
+ * inlining.
* @param leavesize Inline leave functions if they have less than leavesize
* nodes.
* @param size Inline all function smaller than size.
* @param name the name of this pass or NULL
* @param maxsize Do not inline any calls if a method has more than
* maxsize firm nodes. It may reach this limit by
- * inlineing.
+ * inlining.
* @param leavesize Inline leave functions if they have less than leavesize
* nodes.
* @param size Inline all function smaller than size.
unsigned maxsize, unsigned leavesize, unsigned size,
int ignore_runtime);
+/** pointer to an optimization function */
typedef void (*opt_ptr)(ir_graph *irg);
/**
*/
FIRM_API ir_graph_pass_t *loop_peeling_pass(const char *name);
-typedef ir_type *(*get_Alloc_func)(ir_node *n);
-/** Set a new get_Alloc_func and returns the old one. */
-FIRM_API get_Alloc_func firm_set_Alloc_func(get_Alloc_func newf);
-
/**
* Creates an ir_graph pass for set_vrp_data()
*
*
* Dead_node_elimination is only performed if options `optimize' and
* `opt_dead_node_elimination' are set. The graph may
- * not be in state phase_building. The outs datasturcture is freed,
+ * not be in state phase_building. The outs datastructure is freed,
* the outs state set to outs_none. Backedge information is conserved.
* Removes old attributes of nodes. Sets link field to NULL.
* Callee information must be freed (irg_callee_info_none).
FIRM_API ir_graph_pass_t *place_code_pass(const char *name);
/**
- * Determine information about the values of nodes and perform simplications
+ * Determines information about the values of nodes and perform simplifications
* using this information. This optimization performs a data-flow analysis to
* find the minimal fixpoint.
*/
/**
* Creates an ir_graph pass for fixpoint_vrp().
* This pass dDetermines information about the values of nodes
- * and perform simplications using this information.
+ * and perform simplifications using this information.
* This optimization performs a data-flow analysis to
* find the minimal fixpoint.
*
*/
FIRM_API ir_graph_pass_t *fixpoint_vrp_irg_pass(const char *name);
-/** Needed for MSVC to suppress warnings because it doest NOT handle const right. */
-typedef const ir_node *ir_node_cnst_ptr;
-
/**
- * Check, if the value of a node is != 0.
+ * Checks if the value of a node is != 0.
*
* This is a often needed case, so we handle here Confirm
* nodes too.
* @param confirm if n is confirmed to be != 0, returns
* the the Confirm-node, else NULL
*/
-FIRM_API int value_not_zero(const ir_node *n, ir_node_cnst_ptr *confirm);
+FIRM_API int value_not_zero(const ir_node *n, const ir_node **confirm);
/**
- * Check, if the value of a node cannot represent a NULL pointer.
+ * Checks if the value of a node cannot represent a NULL pointer.
*
* - If option sel_based_null_check_elim is enabled, all
* Sel nodes can be skipped.
* @param confirm if n is confirmed to be != NULL, returns
* the the Confirm-node, else NULL
*/
-FIRM_API int value_not_null(const ir_node *n, ir_node_cnst_ptr *confirm);
+FIRM_API int value_not_null(const ir_node *n, const ir_node **confirm);
/**
- * Possible return values of value_classify().
- */
-typedef enum ir_value_classify_sign {
- value_classified_unknown = 0, /**< could not classify */
- value_classified_positive = 1, /**< value is positive, i.e. >= 0 */
- value_classified_negative = -1 /**< value is negative, i.e. <= 0 if
- no signed zero exists or < 0 else */
-} ir_value_classify_sign;
-
-/**
- * Check, if the value of a node can be confirmed >= 0 or <= 0,
+ * Checks if the value of a node can be confirmed >= 0 or <= 0,
* If the mode of the value did not honor signed zeros, else
* check for >= 0 or < 0.
*
FIRM_API ir_value_classify_sign classify_value_sign(ir_node *n);
/**
- * Return the value of a Cmp if one or both predecessors
- * are Confirm nodes.
+ * Returns the value of a Cmp if one or both predecessors are Confirm nodes.
*
- * @param cmp the compare node that will be evaluated
- * @param left the left operand of the Cmp
- * @param right the right operand of the Cmp
- * @param pnc the compare relation
+ * @param cmp the compare node that will be evaluated
+ * @param left the left operand of the Cmp
+ * @param right the right operand of the Cmp
+ * @param relation the compare relation
*/
FIRM_API ir_tarval *computed_value_Cmp_Confirm(
- ir_node *cmp, ir_node *left, ir_node *right, pn_Cmp pnc);
+ const ir_node *cmp, ir_node *left, ir_node *right, ir_relation relation);
+
+/** Type of callbacks for createing entities of the compiler library */
+typedef ir_entity *(*compilerlib_entity_creator_t)(ident *id, ir_type *mt);
+
+/**
+ * Sets the compilerlib entity creation callback that is used to create
+ * compilerlib function entities.
+ *
+ * @param cb the new compilerlib entity creation callback
+ */
+FIRM_API void set_compilerlib_entity_creator(compilerlib_entity_creator_t cb);
+
+/** Returns the compilerlib entity creation callback. */
+FIRM_API compilerlib_entity_creator_t get_compilerlib_entity_creator(void);
+
+/**
+ * Constructs the entity for a given function using the current compilerlib
+ * entity creation callback.
+ *
+ * @param id the identifier of the compilerlib function
+ * @param mt the method type of the compilerlib function
+ */
+FIRM_API ir_entity *create_compilerlib_entity(ident *id, ir_type *mt);
+
+/** @} */
#include "end.h"
projects / libfirm / blobdiff