X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firflag.c;h=fdfbd2df0b1eccbcc90f1db5a5eab538ac082a86;hb=e570f00fb465d212dde403160e97ab45d36d1d7e;hp=69004ebc35c8db3e6230960331f4bf61c2e9dba1;hpb=c2b4a9f3d77fda7989e9cbd6293b9f9f58f4221c;p=libfirm diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c index 69004ebc3..fdfbd2df0 100644 --- a/ir/ir/irflag.c +++ b/ir/ir/irflag.c @@ -10,187 +10,267 @@ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ - #ifdef HAVE_CONFIG_H # include #endif -#include "irflag.h" #include "firm_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. - Default must be zero as code placement must - be run right after a local optimize walk with - opt_global_cse on. */ -int opt_constant_folding = 1; /* Evaluate operations. */ -int opt_unreachable_code = 1; /* Bad node propagation. */ -int opt_control_flow_straightening = 1; /* */ -int opt_control_flow_weak_simplification = 1; /* */ -int opt_control_flow_strong_simplification = 1; /* */ -int opt_critical_edges = 1; -int opt_dead_node_elimination = 1; /* Reclaim memory. */ -int opt_reassociation = 1; /* Reassociate nodes. */ -int opt_inline = 1; /* Do inlining transformation. */ -int opt_dyn_meth_dispatch = 1; /* Remove dynamic method dispatch. */ - -int opt_normalize = 1; /* Transformations that normalize the firm representation - as removing Ids and Tuples, useless Phis, SymConst(id) -> - Const(entity) ... */ +#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_CONSTANT_FOLDING) | + 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_REASSOCIATION) | + ENABLE(OPT_INLINE) | + ENABLE(OPT_DYN_METH_DISPATCH) | + ENABLE(OPT_NORMALIZE); /* 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) { - opt_cse = value; + if (value) + libFIRM_opt |= OPT_CSE; + else + libFIRM_opt &= ~OPT_CSE; } -INLINE int -get_opt_cse (void) +void set_opt_global_cse(int value) { - return opt_cse; + if (value) + libFIRM_opt |= OPT_GLOBAL_CSE; + else + libFIRM_opt &= ~OPT_GLOBAL_CSE; } -void set_opt_global_cse (int value) +void +set_opt_constant_folding(int value) { - opt_global_cse = value; + if (value) + libFIRM_opt |= OPT_CONSTANT_FOLDING; + else + libFIRM_opt &= ~OPT_CONSTANT_FOLDING; } -int get_opt_global_cse (void) +void +set_opt_unreachable_code(int value) { - return opt_global_cse; + if (value) + libFIRM_opt |= OPT_UNREACHABLE_CODE; + else + libFIRM_opt &= ~OPT_UNREACHABLE_CODE; } -INLINE void -set_opt_constant_folding (int value) +void set_opt_control_flow(int value) { - opt_constant_folding=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); } -INLINE int -get_opt_constant_folding (void) +/* Performs Straightening */ +void set_opt_control_flow_straightening(int value) { - return opt_constant_folding; + if (value) + libFIRM_opt |= OPT_CONTROL_FLOW_STRAIGHTENING; + else + libFIRM_opt &= ~OPT_CONTROL_FLOW_STRAIGHTENING; } -INLINE void -set_opt_unreachable_code(int value) +/* Performs if simplifications in local optimizations. */ +void set_opt_control_flow_weak_simplification(int value) { - opt_unreachable_code = value; + if (value) + libFIRM_opt |= OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION; + else + libFIRM_opt &= ~OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION; } -INLINE int -get_opt_unreachable_code(void) +/* Performs strong if and loop simplification (in optimize_cf). */ +void set_opt_control_flow_strong_simplification(int value) { - return opt_unreachable_code; + if (value) + libFIRM_opt |= OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION; + else + libFIRM_opt &= ~OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION; } -INLINE 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); +void set_opt_critical_edges(int value) +{ + if (value) + libFIRM_opt |= OPT_CRITICAL_EDGES; + else + libFIRM_opt &= ~OPT_CRITICAL_EDGES; } -/* Performs Straightening */ -void set_opt_control_flow_straightening(int value) { - opt_control_flow_straightening = value; -} -int get_opt_control_flow_straightening(void) { - return opt_control_flow_straightening; +void set_opt_reassociation(int value) +{ + if (value) + libFIRM_opt |= OPT_REASSOCIATION; + else + libFIRM_opt &= ~OPT_REASSOCIATION; } -/* Performs if simplifications in local optimizations. */ -void set_opt_control_flow_weak_simplification(int value) { - opt_control_flow_weak_simplification = value; + +void set_opt_dead_node_elimination(int value) +{ + if (value) + libFIRM_opt |= OPT_DEAD_NODE_ELIMINATION; + else + libFIRM_opt &= ~OPT_DEAD_NODE_ELIMINATION; } -int get_opt_control_flow_weak_simplification(void) { - return opt_control_flow_weak_simplification; + +void set_optimize(int value) +{ + if (value) + libFIRM_opt |= OPT_OPTIMIZED; + else + libFIRM_opt &= ~OPT_OPTIMIZED; } -/* Performs strong if and loop simplification (in optimize_cf). */ -void set_opt_control_flow_strong_simplification(int value) { - opt_control_flow_strong_simplification = value; + +int get_optimize(void) +{ + return get_opt_optimize(); } -int get_opt_control_flow_strong_simplification(void) { - return opt_control_flow_strong_simplification; + +void set_opt_inline(int value) +{ + if (value) + libFIRM_opt |= OPT_INLINE; + else + libFIRM_opt &= ~OPT_INLINE; } -void set_opt_critical_edges(int value) { - opt_critical_edges = value; +/** 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) +{ + if (value) + libFIRM_opt |= OPT_DYN_METH_DISPATCH; + else + libFIRM_opt &= ~OPT_DYN_METH_DISPATCH; } -int get_opt_critical_edges(void) { - return opt_critical_edges; + +void set_opt_normalize(int value) +{ + if (value) + libFIRM_opt |= OPT_NORMALIZE; + else + libFIRM_opt &= ~OPT_NORMALIZE; } +/* Save the current optimization state. */ +void save_optimization_state(optimization_state_t *state) +{ + *state = libFIRM_opt; +} -INLINE void -set_opt_reassociation(int value) +/* Restore the current optimization state. */ +void restore_optimization_state(const optimization_state_t *state) { - opt_reassociation = value; + libFIRM_opt = *state; } -INLINE int -get_opt_reassociation(void) +/* repeat 'inline' methods here */ + +# ifndef USE_GCC_INLINE + +/** Returns constant folding optimization setting. */ +int get_opt_cse(void) /* iropt.c */ { - return opt_reassociation; + return libFIRM_opt & OPT_CSE; } -INLINE void -set_opt_dead_node_elimination (int value) +/** Returns constant subexpression elimination setting. */ +int get_opt_global_cse(void) /* irgopt.c iropt.c */ { - opt_dead_node_elimination = value; + return libFIRM_opt & OPT_GLOBAL_CSE; } -INLINE int -get_opt_dead_node_elimination (void) +/** Returns global constant subexpression elimination setting. */ +int get_opt_constant_folding(void) /* iropt.c */ { - return opt_dead_node_elimination; + return libFIRM_opt & OPT_CONSTANT_FOLDING; } -INLINE void -set_optimize (int value) +/** Returns unreachable code elimination setting. */ +int get_opt_unreachable_code(void) /* iropt.c */ { - optimized = value; + return libFIRM_opt & OPT_UNREACHABLE_CODE; } -INLINE int -get_optimize (void) +/** Returns Straightening setting. */ +int get_opt_control_flow_straightening(void) /* iropt.c, irgopt.c */ { - return optimized; + return libFIRM_opt & OPT_CONTROL_FLOW_STRAIGHTENING; } +/** Returns if simplifications in local optimizations setting. */ +int get_opt_control_flow_weak_simplification(void) /* iropt.c, irgopt.c */ +{ + return libFIRM_opt & OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION; +} -INLINE void set_opt_inline (int value) { - opt_inline = value; +/** Returns strong if and loop simplification setting */ +int get_opt_control_flow_strong_simplification(void) /* irgopt.c */ +{ + return libFIRM_opt & OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION; } -INLINE int get_opt_inline (void) { - return opt_inline; +/** Returns whether critical edges are removed */ +int get_opt_critical_edges(void) /* irgopt.c */ +{ + return libFIRM_opt & OPT_CRITICAL_EDGES; } -/** 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) { - opt_dyn_meth_dispatch = value; +/** Returns reassociation setting. */ +int get_opt_reassociation(void) /* iropt.c */ +{ + return libFIRM_opt & OPT_REASSOCIATION; } -int get_opt_dyn_meth_dispatch (void) { - return opt_dyn_meth_dispatch; + +/** Returns dead node elimination setting. */ +int get_opt_dead_node_elimination(void) /* irgopt.c */ +{ + return libFIRM_opt & OPT_DEAD_NODE_ELIMINATION; } +/** Returns global optimization setting */ +int get_opt_optimize(void) /* iropt.c, irgopt.c */ +{ + return libFIRM_opt & OPT_OPTIMIZED; +} +/** Returns inlining setting. */ /* how appropriate */ +int get_opt_inline(void) /* irgopt.c */ +{ + return libFIRM_opt & OPT_INLINE; +} -INLINE void set_opt_normalize (int value) { - opt_normalize = value; +int get_opt_dyn_meth_dispatch(void) /* cgana.c */ +{ + return libFIRM_opt & OPT_DYN_METH_DISPATCH; } -INLINE int get_opt_normalize (void) { - return opt_normalize; +int get_opt_normalize(void) /* irgopt.c, irnode.c, iropt.c */ +{ + return libFIRM_opt & OPT_NORMALIZE; } + +# endif /* not defined USE_GCC_INLINE */