X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firflag.c;h=d1317a8cfc8011eec4979c6a6e8717e7f576a1cf;hb=e0de495ee85f3abf9a9004a1af4bd81045590bc1;hp=1166f048e703ebcb41f72311711ed04ae47bdbee;hpb=e3a46c8cd9fe439429b953b39b35061acc5e3898;p=libfirm diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c index 1166f048e..d1317a8cf 100644 --- a/ir/ir/irflag.c +++ b/ir/ir/irflag.c @@ -1,294 +1,165 @@ /* - * Project: libFIRM - * File name: ir/ir/irflag.c - * Purpose: Flags to control optimizations. - * Author: Christian Schaefer, Goetz Lindenmaier - * Modified by: - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1999-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. */ +/** + * @file + * @brief Flags to control optimizations. + * @author Michael Beck, Sebastian Hack + * @version $Id$ + */ #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif +#include + +#include "lc_opts.h" + #include "firm_common.h" +#include "irtools.h" #include "irflag_t.h" /* DISABLE - don't do this optimization ENABLE - lets see, if there is a better graph */ -#define ENABLE(a) a -#define DISABLE(a) 0 +#define ON (-1) +#define OFF (0) -optimization_state_t libFIRM_opt = - ENABLE(OPT_OPTIMIZED) | - ENABLE(OPT_CSE) | - DISABLE(OPT_GLOBAL_CSE) | - ENABLE(OPT_STRENGTH_RED) | - ENABLE(OPT_CONSTANT_FOLDING) | - ENABLE(OPT_REDUNDANT_LOADSTORE) | - ENABLE(OPT_UNREACHABLE_CODE) | - ENABLE(OPT_CONTROL_FLOW_STRAIGHTENING) | - ENABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION) | - ENABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) | - ENABLE(OPT_CRITICAL_EDGES) | - ENABLE(OPT_DEAD_NODE_ELIMINATION) | - ENABLE(OPT_DEAD_METHOD_ELIMINATION) | - ENABLE(OPT_REASSOCIATION) | - ENABLE(OPT_INLINE) | - ENABLE(OPT_DYN_METH_DISPATCH) | - ENABLE(OPT_NORMALIZE) | - ENABLE(OPT_TAIL_RECURSION) | - ENABLE(OPT_PRECISE_EXC_CONTEXT) | - 0; +#define FLAG(name, value, def) (irf_##name & def) | +#define E_FLAG(name, value, def) FLAG(name, value, def) +#define I_FLAG(name, value, def) FLAG(name, value, def) +#define R_FLAG(name, value) -optimization_state_t libFIRM_verb = - DISABLE(OPT_OPTIMIZED) | - DISABLE(OPT_CSE) | - DISABLE(OPT_GLOBAL_CSE) | - DISABLE(OPT_STRENGTH_RED) | - DISABLE(OPT_CONSTANT_FOLDING) | - DISABLE(OPT_REDUNDANT_LOADSTORE) | - DISABLE(OPT_UNREACHABLE_CODE) | - DISABLE(OPT_CONTROL_FLOW_STRAIGHTENING) | - DISABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION) | - DISABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) | - DISABLE(OPT_CRITICAL_EDGES) | - DISABLE(OPT_DEAD_NODE_ELIMINATION) | - DISABLE(OPT_DEAD_METHOD_ELIMINATION) | - DISABLE(OPT_REASSOCIATION) | - DISABLE(OPT_INLINE) | - DISABLE(OPT_DYN_METH_DISPATCH) | - DISABLE(OPT_NORMALIZE) | - DISABLE(OPT_TAIL_RECURSION) | - DISABLE(OPT_PRECISE_EXC_CONTEXT) | +optimization_state_t libFIRM_opt = +#include "irflag_t.def" 0; -/** The Firm verbosity level */ -int firm_verbosity_level; - -/* set the flags with set_flagname, get the flag with get_flagname */ -void set_opt_cse (int value) -{ - if (value) - libFIRM_opt |= OPT_CSE; - else - libFIRM_opt &= ~OPT_CSE; -} - -void set_opt_global_cse(int value) -{ - if (value) - libFIRM_opt |= OPT_GLOBAL_CSE; - else - libFIRM_opt &= ~OPT_GLOBAL_CSE; -} - -void set_opt_strength_red (int value) -{ - if (value) - libFIRM_opt |= OPT_STRENGTH_RED; - else - libFIRM_opt &= ~OPT_STRENGTH_RED; -} - -void set_opt_strength_red_verbose (int value) -{ - if (value) - libFIRM_verb |= OPT_STRENGTH_RED; - else - libFIRM_verb &= ~OPT_STRENGTH_RED; -} - -void -set_opt_constant_folding(int value) -{ - if (value) - libFIRM_opt |= OPT_CONSTANT_FOLDING; - else - libFIRM_opt &= ~OPT_CONSTANT_FOLDING; -} - -void -set_opt_redundant_LoadStore(int value) { - if (value) - libFIRM_opt |= OPT_REDUNDANT_LOADSTORE; - else - libFIRM_opt &= ~OPT_REDUNDANT_LOADSTORE; -} - -void -set_opt_unreachable_code(int value) -{ - if (value) - libFIRM_opt |= OPT_UNREACHABLE_CODE; - else - libFIRM_opt &= ~OPT_UNREACHABLE_CODE; -} - -void set_opt_control_flow(int value) -{ - set_opt_control_flow_straightening(value); - set_opt_control_flow_weak_simplification(value); - set_opt_control_flow_strong_simplification(value); - set_opt_critical_edges(value); -} - -/* Performs Straightening */ -void set_opt_control_flow_straightening(int value) -{ - if (value) - libFIRM_opt |= OPT_CONTROL_FLOW_STRAIGHTENING; - else - libFIRM_opt &= ~OPT_CONTROL_FLOW_STRAIGHTENING; -} - -/* Performs if simplifications in local optimizations. */ -void set_opt_control_flow_weak_simplification(int value) -{ - if (value) - libFIRM_opt |= OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION; - else - libFIRM_opt &= ~OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION; -} +#undef FLAG +#undef E_FLAG +#undef I_FLAG +#undef R_FLAG -/* Performs strong if and loop simplification (in optimize_cf). */ -void set_opt_control_flow_strong_simplification(int value) -{ - if (value) - libFIRM_opt |= OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION; - else - libFIRM_opt &= ~OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION; -} +/** The bitset of currently running phases. */ +optimization_state_t libFIRM_running = 0; -void set_opt_critical_edges(int value) -{ - if (value) - libFIRM_opt |= OPT_CRITICAL_EDGES; - else - libFIRM_opt &= ~OPT_CRITICAL_EDGES; -} +/* verbose is always off on default */ +optimization_state_t libFIRM_verb = 0; -void set_opt_reassociation(int value) -{ - if (value) - libFIRM_opt |= OPT_REASSOCIATION; - else - libFIRM_opt &= ~OPT_REASSOCIATION; +/* an external flag can be set and get from outside */ +#define E_FLAG(name, value, def) \ +void set_opt_##name(int flag) { \ + if (flag) libFIRM_opt |= irf_##name; \ + else libFIRM_opt &= ~irf_##name; \ +} \ +void set_opt_##name##_verbose(int flag) { \ + if (flag) libFIRM_verb |= irf_##name; \ + else libFIRM_verb &= ~irf_##name; \ +} \ +int (get_opt_##name)(void) { \ + return _get_opt_##name(); \ } -void set_opt_dead_node_elimination(int value) -{ - if (value) - libFIRM_opt |= OPT_DEAD_NODE_ELIMINATION; - else - libFIRM_opt &= ~OPT_DEAD_NODE_ELIMINATION; +/* an internal flag can only be set from outside */ +#define I_FLAG(name, value, def) \ +void set_opt_##name(int flag) { \ + if (flag) libFIRM_opt |= irf_##name; \ + else libFIRM_opt &= ~irf_##name; \ +} \ +void set_opt_##name##_verbose(int flag) { \ + if (flag) libFIRM_verb |= irf_##name; \ + else libFIRM_verb &= ~irf_##name; \ } -void set_opt_dead_method_elimination (int value) { - if (value) - libFIRM_opt |= OPT_DEAD_METHOD_ELIMINATION; - else - libFIRM_opt &= ~OPT_DEAD_METHOD_ELIMINATION; -} +#define R_FLAG(name, value) -void set_opt_dead_method_elimination_verbose (int value) { - if (value) - libFIRM_verb |= OPT_DEAD_METHOD_ELIMINATION; - else - libFIRM_verb &= ~OPT_DEAD_METHOD_ELIMINATION; -} +/* generate them */ +#include "irflag_t.def" -void set_optimize(int value) -{ - if (value) - libFIRM_opt |= OPT_OPTIMIZED; - else - libFIRM_opt &= ~OPT_OPTIMIZED; -} +#undef I_FLAG +#undef E_FLAG +#undef R_FLAG -int get_optimize(void) -{ - return get_opt_optimize(); +/* for compatibility reasons */ +void set_optimize(int value) { + if (value) libFIRM_opt |= irf_optimize; + else libFIRM_opt &= ~irf_optimize; } - -void set_firm_verbosity (int value) { - firm_verbosity_level = value; +int (get_optimize)(void) { + return get_opt_optimize(); } -int (get_firm_verbosity) (void) { - return _get_firm_verbosity(); +void set_opt_control_flow(int value) { + set_opt_control_flow_straightening(value); + set_opt_control_flow_weak_simplification(value); + set_opt_control_flow_strong_simplification(value); } - - -/* Enable/Disables inlining. */ -void set_opt_inline(int value) -{ - if (value) - libFIRM_opt |= OPT_INLINE; - else - libFIRM_opt &= ~OPT_INLINE; -} - -/* Enable/Disable optimization of dynamic method dispatch */ -void set_opt_dyn_meth_dispatch (int value) -{ - if (value) - libFIRM_opt |= OPT_DYN_METH_DISPATCH; - else - libFIRM_opt &= ~OPT_DYN_METH_DISPATCH; +/* Save the current optimization state. */ +void save_optimization_state(optimization_state_t *state) { + *state = libFIRM_opt; } -/* Enable/Disable normalizations of the firm representation. */ -void set_opt_normalize(int value) -{ - if (value) - libFIRM_opt |= OPT_NORMALIZE; - else - libFIRM_opt &= ~OPT_NORMALIZE; +/* Restore the current optimization state. */ +void restore_optimization_state(const optimization_state_t *state) { + libFIRM_opt = *state; +} + +/* Switches ALL optimizations off */ +void all_optimizations_off(void) { + libFIRM_opt = 0; +} + +#ifdef _DEBUG +/* only for debugging */ +void firm_show_flags(FILE *f) { + if (! f) + f = stdout; + printf("Firm optimization state:\n"); +#define E_FLAG(name, value, def) printf(" %-20s = %s\n", #name, get_opt_##name() ? "ON" : "OFF"); +#define I_FLAG(name, value, def) printf(" %-20s = %s\n", #name, get_opt_##name() ? "ON" : "OFF"); +#define R_FLAG(name, value) printf(" %-20s = %s\n", #name, is_##name##_running() ? "is running" : "not running"); +#include "irflag_t.def" +#undef I_FLAG +#undef E_FLAG +#undef R_FLAG + printf("\n"); } +#endif -/* Enable/Disable optimization of tail-recursion calls. */ -void set_opt_tail_recursion(int value) -{ - if (value) - libFIRM_opt |= OPT_TAIL_RECURSION; - else - libFIRM_opt &= ~OPT_TAIL_RECURSION; -} +static const lc_opt_table_entry_t firm_flags[] = { +#define I_FLAG(name, val, def) LC_OPT_ENT_BIT(#name, #name, &libFIRM_opt, (1 << val)), +#define E_FLAG(name, val, def) LC_OPT_ENT_BIT(#name, #name, &libFIRM_opt, (1 << val)), +#define R_FLAG(name, val) +#include "irflag_t.def" +#undef I_FLAG +#undef E_FLAG +#undef R_FLAG + LC_OPT_LAST +}; -/* Enable/Disable optimization of tail-recursion calls. */ -void set_opt_tail_recursion_verbose(int value) -{ - if (value) - libFIRM_verb |= OPT_TAIL_RECURSION; - else - libFIRM_verb &= ~OPT_TAIL_RECURSION; +void firm_init_flags(void) { + lc_opt_entry_t *grp = lc_opt_get_grp(firm_opt_get_root(), "opt"); + lc_opt_add_table(grp, firm_flags); } -/* Enable/Disable precise exception context. */ -void set_opt_precise_exc_context(int value) -{ -#if PRECISE_EXC_CONTEXT - if (value) - libFIRM_opt |= OPT_PRECISE_EXC_CONTEXT; - else - libFIRM_opt &= ~OPT_PRECISE_EXC_CONTEXT; -#endif -} +firm_verification_t opt_do_node_verification = FIRM_VERIFICATION_ON; -/* Save the current optimization state. */ -void save_optimization_state(optimization_state_t *state) -{ - *state = libFIRM_opt; -} - -/* Restore the current optimization state. */ -void restore_optimization_state(const optimization_state_t *state) -{ - libFIRM_opt = *state; +void do_node_verification(firm_verification_t mode) { + opt_do_node_verification = mode; }