X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firflag.c;h=d1317a8cfc8011eec4979c6a6e8717e7f576a1cf;hb=672b5c243e900427b5dcae01441d4fa3327d692c;hp=4e95b08ddfdd20239428d7b0b1f9fc8f051af871;hpb=5c27107154d63252e27639ebb34e98022f9b3358;p=libfirm diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c index 4e95b08dd..d1317a8cf 100644 --- a/ir/ir/irflag.c +++ b/ir/ir/irflag.c @@ -1,131 +1,165 @@ -/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Christian Schaefer -** -** irflag --- optimization flags -*/ - -/* $Id$ */ - +/* + * 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 "irflag.h" -#include "common.h" - - -/* 0 - don't do this optimization - 1 - lets see, if there is a better graph */ -int optimized = 1; /* Turn off all optimizations */ - -int opt_cse = 1; /* Hash the nodes */ -int opt_global_cse = 0; /* Don't use block predecessor for comparison */ -/* @@@ 0 solage code placement fehlt */ -int opt_constant_folding = 1; /* Evaluate operations */ -int opt_unreachable_code = 1; /* Bad node propagation */ -int opt_control_flow = 1; /* control flow optimizations. */ -int opt_dead_node_elimination = 1; /* Reclaim memory */ -int opt_reassociation = 1; /* Reassociate nodes */ -int opt_inline = 1; /* Do inlining transformation */ - -/* set the flags with set_flagname, get the flag with get_flagname */ -INLINE void -set_opt_cse (int value) -{ - opt_cse = value; -} +#include -INLINE int -get_opt_cse (void) -{ - return opt_cse; -} +#include "lc_opts.h" -void set_opt_global_cse (int value) -{ - opt_global_cse = value; -} +#include "firm_common.h" +#include "irtools.h" +#include "irflag_t.h" -int get_opt_global_cse (void) -{ - return opt_global_cse; -} +/* DISABLE - don't do this optimization + ENABLE - lets see, if there is a better graph */ +#define ON (-1) +#define OFF (0) -INLINE void -set_opt_constant_folding (int value) -{ - opt_constant_folding=value; -} +#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) -INLINE int -get_opt_constant_folding (void) -{ - return opt_constant_folding; -} +optimization_state_t libFIRM_opt = +#include "irflag_t.def" + 0; -INLINE void -set_opt_unreachable_code(int value) -{ - opt_unreachable_code = value; -} +#undef FLAG +#undef E_FLAG +#undef I_FLAG +#undef R_FLAG + +/** The bitset of currently running phases. */ +optimization_state_t libFIRM_running = 0; -INLINE int -get_opt_unreachable_code(void) -{ - return opt_unreachable_code; +/* verbose is always off on default */ +optimization_state_t libFIRM_verb = 0; + +/* 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(); \ } -INLINE void set_opt_control_flow(int value) { - opt_control_flow = value; +/* 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; \ } -INLINE int get_opt_control_flow(void) { - return opt_control_flow; +#define R_FLAG(name, value) + +/* generate them */ +#include "irflag_t.def" + +#undef I_FLAG +#undef E_FLAG +#undef R_FLAG + +/* for compatibility reasons */ +void set_optimize(int value) { + if (value) libFIRM_opt |= irf_optimize; + else libFIRM_opt &= ~irf_optimize; } -INLINE void -set_opt_reassociation(int value) -{ - opt_reassociation = value; +int (get_optimize)(void) { + return get_opt_optimize(); } -INLINE int -get_opt_reassociation(void) -{ - return opt_reassociation; +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); } -INLINE void -set_opt_dead_node_elimination (int value) -{ - opt_dead_node_elimination = value; +/* Save the current optimization state. */ +void save_optimization_state(optimization_state_t *state) { + *state = libFIRM_opt; } -INLINE int -get_opt_dead_node_elimination (void) -{ - return opt_dead_node_elimination; +/* Restore the current optimization state. */ +void restore_optimization_state(const optimization_state_t *state) { + libFIRM_opt = *state; } -INLINE void -set_optimize (int value) -{ - optimized = value; +/* Switches ALL optimizations off */ +void all_optimizations_off(void) { + libFIRM_opt = 0; } -INLINE int -get_optimize (void) -{ - return optimized; +#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 +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 +}; -INLINE void set_opt_inline (int value) { - opt_inline = value; +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); } -INLINE int get_opt_inline (void) { - return opt_inline; +firm_verification_t opt_do_node_verification = FIRM_VERIFICATION_ON; + +void do_node_verification(firm_verification_t mode) { + opt_do_node_verification = mode; }