X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firflag.h;h=c32bf82d69700b06898d606281bf78d65f1e1dd1;hb=ad7dcd5e09ab2e082a395b7b26de2074b9be9320;hp=7ece80a6b877f74375a38c7a9ec9c7d6daedebd7;hpb=d30e5d074dfb44db5d54108c8da839a3464f6fde;p=libfirm diff --git a/ir/ir/irflag.h b/ir/ir/irflag.h index 7ece80a6b..c32bf82d6 100644 --- a/ir/ir/irflag.h +++ b/ir/ir/irflag.h @@ -3,7 +3,7 @@ * File name: ir/ir/irflag.h * Purpose: Flags to control optimizations. * Author: Christian Schaefer, Goetz Lindenmaier - * Modified by: + * Modified by: Michael Beck * Created: * CVS-ID: $Id$ * Copyright: (c) 1999-2003 Universität Karlsruhe @@ -13,14 +13,29 @@ /** * @file irflag.h * - * Optimization flags. + * Flags to customize the behavior of libfirm. * * @author Christian Schaefer + * + * There are the following groups of flags: + * 1. Optimization flags. + * a) There is a flag, 'optimize' to turn on/off all optimizations. + * b) There are flags for each individual optimization. Some flags turns + * transformations in several algorithms on/off. + * 2. Normalization flags. + * These flags steer transformations of the ir that improve it, as removing + * dump Phi nodes (one predecessor, all preds are equal ...), Ids, Tuples ... + * 3. Verbosity flags. + * a) Flags to steer the level of the information. + * b) Flags to steer in which phase information should be dumped. + * 4. Verification flag + * This one controls the behavior of node and type verifications */ - #ifndef _IRFLAG_H_ #define _IRFLAG_H_ +#include "firm_types.h" + /** * A container type to load/restore all optimizations */ @@ -33,7 +48,17 @@ typedef unsigned optimization_state_t; * Default: optimize == 1. */ void set_optimize (int value); -int get_optimize(void); +int get_optimize(void); + +/** This function enables/disables output of information about phases and + * controls the verbosity level. + * + * 0: no output at all. + * 1: very short output + * >>1: very verbose output. + */ +void set_firm_verbosity (int value); +int get_firm_verbosity (void); /** Enables/Disables constant folding optimization. * @@ -47,21 +72,39 @@ int get_optimize(void); */ void set_opt_constant_folding (int value); +/** Enables/Disables loop unrolling. + * + * If opt_loop_unrolling == 1 perform loop_unrolling. + * See loop_unrolling.h. + * + * Default: opt_loop_unrolling = 1; + */ +void set_opt_loop_unrolling (int value); + +/** Enables/Disables output of information about loop unrolling. + */ +void set_opt_loop_unrolling_verbose (int value); + /** Enables/Disables removal of redundant Loads and Stores. * * - Remove Store that overwrites a just stored value (WAW). * - Remove Store if it stores a value just loaded (WAR with the same value). * - Remove Load that loads a value just saved (RAW with the same value). + * - remove Load that loads a value already loaded (RAR) + * - replace Load of constant values with constants (RC) */ -void set_opt_redundant_LoadStore(int value); +void set_opt_redundant_loadstore(int value); -/** Enables/Disables constant subexpression elimination. +/** Enables/Disables common subexpression elimination. * - * If opt_cse == 1 perform constant subexpression elimination. + * If opt_cse == 1 perform common subexpression elimination. * Default: opt_cse == 1. */ void set_opt_cse (int value); +/** Returns constant folding optimization setting. */ +int get_opt_cse(void); + /** Enables/Disables global constant subexpression elimination. * * If opt_global_cse == 1 and opt_cse == 1 perform intra procedure @@ -73,6 +116,19 @@ void set_opt_cse (int value); */ void set_opt_global_cse (int value); +/** Enables/Disables strength reduction. + * + * If opt_strength_red == 1 perform strength reduction. + * See strenth_red.h. + * + * Default: opt_strength_red = 1; + */ +void set_opt_strength_red (int value); + +/** Enables/Disables output of information about strength reduction. + */ +void set_opt_strength_red_verbose (int value); + /** Enables/Disables unreachable code elimination. * * If set, evaluate conditions of conditional branch and replace the @@ -132,13 +188,30 @@ void set_opt_dead_method_elimination_verbose (int value); */ void set_opt_inline (int value); -/** Enable/Disable optimization of dynamic method dispatch +/** Enable/Disable optimization of dynamic method dispatch. * * This flag enables/disables the optimization of dynamic method dispatch. * If the flag is turned on Sel nodes can be replaced by Const nodes representing * the address of a function. */ void set_opt_dyn_meth_dispatch (int value); +int get_opt_dyn_meth_dispatch (void); + +/** Enable/Disable type optimization of cast nodes. + * + * Controls the optimizations in tropt.h. Default: on. + */ +void set_opt_optimize_class_casts (int value); +void set_opt_optimize_class_casts_verbose (int value); + +/** Restricts the behavior of cast optimization. + * + * If set, downcast are not optimized if they might be + * illegal as in (Super)(Sub) (new Super()). Default: + * 0 == not suppressed. + */ +void set_opt_suppress_downcast_optimization(int value); +int get_opt_suppress_downcast_optimization(void); /** Enable/Disable optimization of tail-recursion calls. * @@ -146,7 +219,76 @@ void set_opt_dyn_meth_dispatch (int value); * If the flag is turned on tail-recursion calls are optimized into loops. */ void set_opt_tail_recursion(int value); +void set_opt_tail_recursion_verbose(int value); + +/** Enable/Disable floating of fragile ops. + * + * This flags enables/disables the floating of fragile operations. + * If this flag is on, fragile operations which are known to NOT raise + * an exception can be place to other basic blocks. + * Otherwise they remain in the block they were created. + */ +void set_opt_fragile_ops(int value); + +/** + * Enable/Disable if conversion. + * + * If conversion tries to turn Conds into Mux nodes to eliminate + * control flow. + */ +void set_opt_if_conversion(int value); + +/** + * Enable/Disable real function call optimization. + * + * Real function call optimization detects "real functions" and + * allows the floating of Call nodes. A "real function" is one that + * do only evaluate it's parameters and did not read or write memory + * to compute its results. + */ +void set_opt_real_function_call(int value); +/** + * Enable/Disable Confirm node removal during local optimization. + */ +void set_opt_remove_confirm(int value); + +/** + * Enable/Disable scalar replacement optimization. + */ +void set_opt_scalar_replacement(int value); +void set_opt_scalar_replacement_verbose(int value); + +/** + * Enable/Disable Null exception in Load and Store nodes only. + * + * If enabled, only Null pointer exception can occur at Load and + * store nodes. If it can be proven that the address input of these + * nodes is non-null, the exception edge can safely be removed. + * If disabled, other exceptions (like unaligned access, read-only memory, + * etc.) can occur. + * + * This flag is enabled by default. + */ +void set_opt_ldst_only_null_ptr_exceptions(int value); + +/** + * Enable/Disable Selection based Null pointer check elimination. + * + * In languages, where all addresses are always Sel nodes, Null + * pointers can only occur as input to Sel nodes. + * If Null pointers are the only source for exceptions in Load and + * Store nodes (as typical in high level languages), we can eliminate + * exception edges form Load and Store as we can prove that the Sel + * nodes representing the Load/Store address have non-null inputs. + * Enabling this flag enables this elimination. + * + * Enabling this flag is meaningless if ldst_non_null_exceptions is + * enabled. + * + * This flags should be set for Java style languages. + */ +void set_opt_sel_based_null_check_elim(int value); /** Enable/Disable normalizations of the firm representation. * @@ -162,8 +304,21 @@ void set_opt_tail_recursion(int value); */ void set_opt_normalize (int value); - -/** Enable/Disable precise exception context. */ +/** Enable/Disable precise exception context. + * + * If enabled, all exceptions form a barrier for value, as in the + * following example: + * + * @code + * a = 1; + * b = 3 / 0; + * a = 2; + * @endcode + * + * If precise exception handling is enabled, an exception handler see a == 1, + * else it might see a == 2. + * Enable this for languages with strict exception order like Java. + */ void set_opt_precise_exc_context(int value); /** @@ -176,4 +331,26 @@ void save_optimization_state(optimization_state_t *state); */ void restore_optimization_state(const optimization_state_t *state); -#endif +/** + * Switches ALL optimizations off. + */ +void all_optimizations_off(void); + +/** + * Possible verification modes. + */ +typedef enum _firm_verification_t { + FIRM_VERIFICATION_OFF = 0, /**< do not verify nodes at all */ + FIRM_VERIFICATION_ON = 1, /**< do node verification and assert on error in debug version */ + FIRM_VERIFICATION_REPORT = 2, /**< do node verification, but report to stderr only */ + FIRM_VERIFICATION_ERROR_ONLY = 3 /**< do node verification, but NEVER do assert nor report */ +} firm_verification_t; + +/** Select verification of nodes. + * + * Per default the verification is in mode NODE_VERIFICATION_ASSERT. + * Turn the verification off during development to check partial implementations. + */ +void do_node_verification(firm_verification_t mode); + +#endif /* _IRFLAG_H_ */