X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firflag.c;h=21bc81012ca61e10c4ccaf74a0525652abe3d59c;hb=637542932dc27dcdfc7def09b58d9d5d4c34fb77;hp=a207eddc83d1cb8ad2d0b14891dad0f7ed10f9d0;hpb=677f67f9b487e35b983148f48b933d54ee383db6;p=libfirm diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c index a207eddc8..21bc81012 100644 --- a/ir/ir/irflag.c +++ b/ir/ir/irflag.c @@ -1,131 +1,387 @@ -/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Christian Schaefer -** -** irflag --- optimization flags -*/ - -/* $Id$ */ +/* + * 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. + */ #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif -#include "irflag.h" #include "firm_common.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 +optimization_state_t libFIRM_opt = + ENABLE(OPT_OPTIMIZED) | + ENABLE(OPT_CSE) | + DISABLE(OPT_GLOBAL_CSE) | + ENABLE(OPT_LOOP_UNROLLING) | + 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_CLASS_CASTS) | + DISABLE(OPT_SUPPRESS_DOWNCAST_OPT) | + ENABLE(OPT_NORMALIZE) | + ENABLE(OPT_TAIL_RECURSION) | + ENABLE(OPT_PRECISE_EXC_CONTEXT) | + DISABLE(OPT_FRAGILE_OPS) | + ENABLE(OPT_IF_CONVERSION) | + ENABLE(OPT_REAL_FUNC_CALL) | + 0; -/* 0 - don't do this optimization - 1 - lets see, if there is a better graph */ -int optimized = 1; /* Turn off all optimizations */ +optimization_state_t libFIRM_verb = + DISABLE(OPT_OPTIMIZED) | + DISABLE(OPT_CSE) | + DISABLE(OPT_GLOBAL_CSE) | + DISABLE(OPT_LOOP_UNROLLING) | + 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_CLASS_CASTS) | + DISABLE(OPT_NORMALIZE) | + DISABLE(OPT_TAIL_RECURSION) | + DISABLE(OPT_PRECISE_EXC_CONTEXT) | + DISABLE(OPT_FRAGILE_OPS) | + DISABLE(OPT_IF_CONVERSION) | + DISABLE(OPT_REAL_FUNC_CALL) | + 0; -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 */ +/** The Firm verbosity level */ +int firm_verbosity_level; /* set the flags with set_flagname, get the flag with get_flagname */ -INLINE void -set_opt_cse (int value) +void set_opt_cse (int value) +{ + if (value) + libFIRM_opt |= OPT_CSE; + else + libFIRM_opt &= ~OPT_CSE; +} + +int (get_opt_cse)(void) { + return _get_opt_cse(); +} + +void set_opt_global_cse(int value) { - opt_cse = value; + if (value) + libFIRM_opt |= OPT_GLOBAL_CSE; + else + libFIRM_opt &= ~OPT_GLOBAL_CSE; } -INLINE int -get_opt_cse (void) +void set_opt_loop_unrolling (int value) { - return opt_cse; + if (value) + libFIRM_opt |= OPT_LOOP_UNROLLING; + else + libFIRM_opt &= ~OPT_LOOP_UNROLLING; } -void set_opt_global_cse (int value) +void set_opt_loop_unrolling_verbose (int value) { - opt_global_cse = value; + if (value) + libFIRM_verb |= OPT_LOOP_UNROLLING; + else + libFIRM_verb &= ~OPT_LOOP_UNROLLING; } -int get_opt_global_cse (void) +void set_opt_strength_red (int value) { - return opt_global_cse; + if (value) + libFIRM_opt |= OPT_STRENGTH_RED; + else + libFIRM_opt &= ~OPT_STRENGTH_RED; } -INLINE void -set_opt_constant_folding (int value) +void set_opt_strength_red_verbose (int value) { - opt_constant_folding=value; + if (value) + libFIRM_verb |= OPT_STRENGTH_RED; + else + libFIRM_verb &= ~OPT_STRENGTH_RED; } -INLINE int -get_opt_constant_folding (void) +void +set_opt_constant_folding(int value) { - return opt_constant_folding; + 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; } -INLINE void +void set_opt_unreachable_code(int value) { - opt_unreachable_code = 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; +} + +/* 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; +} + +void set_opt_critical_edges(int value) +{ + if (value) + libFIRM_opt |= OPT_CRITICAL_EDGES; + else + libFIRM_opt &= ~OPT_CRITICAL_EDGES; +} + +void set_opt_reassociation(int value) +{ + if (value) + libFIRM_opt |= OPT_REASSOCIATION; + else + libFIRM_opt &= ~OPT_REASSOCIATION; +} + +void set_opt_dead_node_elimination(int value) +{ + if (value) + libFIRM_opt |= OPT_DEAD_NODE_ELIMINATION; + else + libFIRM_opt &= ~OPT_DEAD_NODE_ELIMINATION; +} + +void set_opt_dead_method_elimination (int value) { + if (value) + libFIRM_opt |= OPT_DEAD_METHOD_ELIMINATION; + else + libFIRM_opt &= ~OPT_DEAD_METHOD_ELIMINATION; +} + +void set_opt_dead_method_elimination_verbose (int value) { + if (value) + libFIRM_verb |= OPT_DEAD_METHOD_ELIMINATION; + else + libFIRM_verb &= ~OPT_DEAD_METHOD_ELIMINATION; +} + +void set_optimize(int value) +{ + if (value) + libFIRM_opt |= OPT_OPTIMIZED; + else + libFIRM_opt &= ~OPT_OPTIMIZED; +} + +int get_optimize(void) +{ + return get_opt_optimize(); +} + + +void set_firm_verbosity (int value) { + firm_verbosity_level = value; +} + +int (get_firm_verbosity) (void) { + return _get_firm_verbosity(); +} + + + +/* Enable/Disables inlining. */ +void set_opt_inline(int value) +{ + if (value) + libFIRM_opt |= OPT_INLINE; + else + libFIRM_opt &= ~OPT_INLINE; } -INLINE int -get_opt_unreachable_code(void) +/* Enable/Disable optimization of dynamic method dispatch */ +void set_opt_dyn_meth_dispatch (int value) { - return opt_unreachable_code; + if (value) + libFIRM_opt |= OPT_DYN_METH_DISPATCH; + else + libFIRM_opt &= ~OPT_DYN_METH_DISPATCH; } -INLINE void set_opt_control_flow(int value) { - opt_control_flow = value; +int (get_opt_dyn_meth_dispatch)(void) { + return _get_opt_dyn_meth_dispatch(); } -INLINE int get_opt_control_flow(void) { - return opt_control_flow; +void set_opt_optimize_class_casts (int value) +{ + if (value) + libFIRM_opt |= OPT_CLASS_CASTS; + else + libFIRM_opt &= ~OPT_CLASS_CASTS; +} +int (get_opt_optimize_class_casts) (void) { + return _get_opt_optimize_class_casts(); +} +void set_opt_optimize_class_casts_verbose (int value) +{ + if (value) + libFIRM_verb |= OPT_CLASS_CASTS; + else + libFIRM_verb &= ~OPT_CLASS_CASTS; +} +int (get_opt_optimize_class_casts_verbose) (void) { + return _get_opt_optimize_class_casts_verbose(); +} +void set_opt_suppress_downcast_optimization(int value) +{ + if (value) + libFIRM_opt |= OPT_SUPPRESS_DOWNCAST_OPT; + else + libFIRM_opt &= ~OPT_SUPPRESS_DOWNCAST_OPT; +} +int (get_opt_suppress_downcast_optimization)(void) { + return _get_opt_suppress_downcast_optimization(); } -INLINE void -set_opt_reassociation(int value) + +/* Enable/Disable normalizations of the firm representation. */ +void set_opt_normalize(int value) { - opt_reassociation = value; + if (value) + libFIRM_opt |= OPT_NORMALIZE; + else + libFIRM_opt &= ~OPT_NORMALIZE; } -INLINE int -get_opt_reassociation(void) +/* Enable/Disable optimization of tail-recursion calls. */ +void set_opt_tail_recursion(int value) { - return opt_reassociation; + if (value) + libFIRM_opt |= OPT_TAIL_RECURSION; + else + libFIRM_opt &= ~OPT_TAIL_RECURSION; } -INLINE void -set_opt_dead_node_elimination (int value) +/* Enable/Disable optimization of tail-recursion calls. */ +void set_opt_tail_recursion_verbose(int value) { - opt_dead_node_elimination = value; + if (value) + libFIRM_verb |= OPT_TAIL_RECURSION; + else + libFIRM_verb &= ~OPT_TAIL_RECURSION; } -INLINE int -get_opt_dead_node_elimination (void) +/* Enable/Disable precise exception context. */ +void set_opt_precise_exc_context(int value) { - return opt_dead_node_elimination; +#if PRECISE_EXC_CONTEXT + if (value) + libFIRM_opt |= OPT_PRECISE_EXC_CONTEXT; + else + libFIRM_opt &= ~OPT_PRECISE_EXC_CONTEXT; +#endif } -INLINE void -set_optimize (int value) +void set_opt_fragile_ops(int value) { - optimized = value; + if (value) + libFIRM_opt |= OPT_FRAGILE_OPS; + else + libFIRM_opt &= ~OPT_FRAGILE_OPS; } -INLINE int -get_optimize (void) +/* Enable/Disable if conversion. */ +void set_opt_if_conversion(int value) { - return optimized; + if (value) + libFIRM_opt |= OPT_IF_CONVERSION; + else + libFIRM_opt &= ~OPT_IF_CONVERSION; } +/* Enable/Disable real function call optimization. */ +void set_opt_real_function_call(int value) +{ + if (value) + libFIRM_opt |= OPT_REAL_FUNC_CALL; + else + libFIRM_opt &= ~OPT_REAL_FUNC_CALL; +} -INLINE void set_opt_inline (int value) { - opt_inline = value; +/* Save the current optimization state. */ +void save_optimization_state(optimization_state_t *state) +{ + *state = libFIRM_opt; } -INLINE int get_opt_inline (void) { - return opt_inline; +/* Restore the current optimization state. */ +void restore_optimization_state(const optimization_state_t *state) +{ + libFIRM_opt = *state; }