nsz Git - libfirm/blob - ir/ir/irflag.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irflag.c
   4  * Purpose:     Flags to control optimizations.
   5  * Author:      Christian Schaefer, Goetz Lindenmaier
   6  * Modified by:
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1999-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 #include "firm_common.h"
  18 #include "irflag_t.h"
  19
  20 /* DISABLE - don't do this optimization
  21    ENABLE  - lets see, if there is a better graph */
  22 #define ENABLE(a)   a
  23 #define DISABLE(a)  0
  24
  25 optimization_state_t libFIRM_opt =
  26   ENABLE(OPT_OPTIMIZED)                          |
  27   ENABLE(OPT_CSE)                                |
  28   DISABLE(OPT_GLOBAL_CSE)                        |
  29   ENABLE(OPT_STRENGTH_RED)                       |
  30   ENABLE(OPT_CONSTANT_FOLDING)                   |
  31   ENABLE(OPT_REDUNDANT_LOADSTORE)                |
  32   ENABLE(OPT_UNREACHABLE_CODE)                   |
  33   ENABLE(OPT_CONTROL_FLOW_STRAIGHTENING)         |
  34   ENABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION)   |
  35   ENABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) |
  36   ENABLE(OPT_CRITICAL_EDGES)                     |
  37   ENABLE(OPT_DEAD_NODE_ELIMINATION)              |
  38   ENABLE(OPT_DEAD_METHOD_ELIMINATION)            |
  39   ENABLE(OPT_REASSOCIATION)                      |
  40   ENABLE(OPT_INLINE)                             |
  41   ENABLE(OPT_DYN_METH_DISPATCH)                  |
  42   ENABLE(OPT_NORMALIZE)                          |
  43   ENABLE(OPT_TAIL_RECURSION)                     |
  44   ENABLE(OPT_PRECISE_EXC_CONTEXT)                |
  45   DISABLE(OPT_FRAGILE_OPS)                       |
  46   0;
  47
  48 optimization_state_t libFIRM_verb =
  49   DISABLE(OPT_OPTIMIZED)                          |
  50   DISABLE(OPT_CSE)                                |
  51   DISABLE(OPT_GLOBAL_CSE)                         |
  52   DISABLE(OPT_STRENGTH_RED)                       |
  53   DISABLE(OPT_CONSTANT_FOLDING)                   |
  54   DISABLE(OPT_REDUNDANT_LOADSTORE)                |
  55   DISABLE(OPT_UNREACHABLE_CODE)                   |
  56   DISABLE(OPT_CONTROL_FLOW_STRAIGHTENING)         |
  57   DISABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION)   |
  58   DISABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) |
  59   DISABLE(OPT_CRITICAL_EDGES)                     |
  60   DISABLE(OPT_DEAD_NODE_ELIMINATION)              |
  61   DISABLE(OPT_DEAD_METHOD_ELIMINATION)            |
  62   DISABLE(OPT_REASSOCIATION)                      |
  63   DISABLE(OPT_INLINE)                             |
  64   DISABLE(OPT_DYN_METH_DISPATCH)                  |
  65   DISABLE(OPT_NORMALIZE)                          |
  66   DISABLE(OPT_TAIL_RECURSION)                     |
  67   DISABLE(OPT_PRECISE_EXC_CONTEXT)                |
  68   DISABLE(OPT_FRAGILE_OPS)                       |
  69   0;
  70
  71 /** The Firm verbosity level */
  72 int firm_verbosity_level;
  73
  74 /* set the flags with set_flagname, get the flag with get_flagname */
  75 void set_opt_cse (int value)
  76 {
  77   if (value)
  78     libFIRM_opt |= OPT_CSE;
  79   else
  80     libFIRM_opt &= ~OPT_CSE;
  81 }
  82
  83 void set_opt_global_cse(int value)
  84 {
  85   if (value)
  86     libFIRM_opt |= OPT_GLOBAL_CSE;
  87   else
  88     libFIRM_opt &= ~OPT_GLOBAL_CSE;
  89 }
  90
  91 void set_opt_strength_red (int value)
  92 {
  93   if (value)
  94     libFIRM_opt |= OPT_STRENGTH_RED;
  95   else
  96     libFIRM_opt &= ~OPT_STRENGTH_RED;
  97 }
  98
  99 void set_opt_strength_red_verbose (int value)
 100 {
 101   if (value)
 102     libFIRM_verb |= OPT_STRENGTH_RED;
 103   else
 104     libFIRM_verb &= ~OPT_STRENGTH_RED;
 105 }
 106
 107 void
 108 set_opt_constant_folding(int value)
 109 {
 110   if (value)
 111     libFIRM_opt |= OPT_CONSTANT_FOLDING;
 112   else
 113     libFIRM_opt &= ~OPT_CONSTANT_FOLDING;
 114 }
 115
 116 void
 117 set_opt_redundant_LoadStore(int value) {
 118   if (value)
 119     libFIRM_opt |= OPT_REDUNDANT_LOADSTORE;
 120   else
 121     libFIRM_opt &= ~OPT_REDUNDANT_LOADSTORE;
 122 }
 123
 124 void
 125 set_opt_unreachable_code(int value)
 126 {
 127   if (value)
 128     libFIRM_opt |= OPT_UNREACHABLE_CODE;
 129   else
 130     libFIRM_opt &= ~OPT_UNREACHABLE_CODE;
 131 }
 132
 133 void set_opt_control_flow(int value)
 134 {
 135   set_opt_control_flow_straightening(value);
 136   set_opt_control_flow_weak_simplification(value);
 137   set_opt_control_flow_strong_simplification(value);
 138   set_opt_critical_edges(value);
 139 }
 140
 141 /* Performs Straightening */
 142 void set_opt_control_flow_straightening(int value)
 143 {
 144   if (value)
 145     libFIRM_opt |= OPT_CONTROL_FLOW_STRAIGHTENING;
 146   else
 147     libFIRM_opt &= ~OPT_CONTROL_FLOW_STRAIGHTENING;
 148 }
 149
 150 /* Performs if simplifications in local optimizations. */
 151 void set_opt_control_flow_weak_simplification(int value)
 152 {
 153   if (value)
 154     libFIRM_opt |= OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION;
 155   else
 156     libFIRM_opt &= ~OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION;
 157 }
 158
 159 /* Performs strong if and loop simplification (in optimize_cf). */
 160 void set_opt_control_flow_strong_simplification(int value)
 161 {
 162   if (value)
 163     libFIRM_opt |= OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION;
 164   else
 165     libFIRM_opt &= ~OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION;
 166 }
 167
 168 void set_opt_critical_edges(int value)
 169 {
 170   if (value)
 171     libFIRM_opt |= OPT_CRITICAL_EDGES;
 172   else
 173     libFIRM_opt &= ~OPT_CRITICAL_EDGES;
 174 }
 175
 176 void set_opt_reassociation(int value)
 177 {
 178   if (value)
 179     libFIRM_opt |= OPT_REASSOCIATION;
 180   else
 181     libFIRM_opt &= ~OPT_REASSOCIATION;
 182 }
 183
 184 void set_opt_dead_node_elimination(int value)
 185 {
 186   if (value)
 187     libFIRM_opt |= OPT_DEAD_NODE_ELIMINATION;
 188   else
 189     libFIRM_opt &= ~OPT_DEAD_NODE_ELIMINATION;
 190 }
 191
 192 void set_opt_dead_method_elimination (int value) {
 193   if (value)
 194     libFIRM_opt |= OPT_DEAD_METHOD_ELIMINATION;
 195   else
 196     libFIRM_opt &= ~OPT_DEAD_METHOD_ELIMINATION;
 197 }
 198
 199 void set_opt_dead_method_elimination_verbose (int value) {
 200   if (value)
 201     libFIRM_verb |= OPT_DEAD_METHOD_ELIMINATION;
 202   else
 203     libFIRM_verb &= ~OPT_DEAD_METHOD_ELIMINATION;
 204 }
 205
 206 void set_optimize(int value)
 207 {
 208   if (value)
 209     libFIRM_opt |= OPT_OPTIMIZED;
 210   else
 211     libFIRM_opt &= ~OPT_OPTIMIZED;
 212 }
 213
 214 int get_optimize(void)
 215 {
 216   return get_opt_optimize();
 217 }
 218
 219
 220 void set_firm_verbosity (int value) {
 221   firm_verbosity_level = value;
 222 }
 223
 224 int  (get_firm_verbosity) (void) {
 225   return _get_firm_verbosity();
 226 }
 227
 228
 229
 230 /* Enable/Disables inlining. */
 231 void set_opt_inline(int value)
 232 {
 233   if (value)
 234     libFIRM_opt |= OPT_INLINE;
 235   else
 236     libFIRM_opt &= ~OPT_INLINE;
 237 }
 238
 239 /* Enable/Disable optimization of dynamic method dispatch */
 240 void set_opt_dyn_meth_dispatch (int value)
 241 {
 242   if (value)
 243     libFIRM_opt |= OPT_DYN_METH_DISPATCH;
 244   else
 245     libFIRM_opt &= ~OPT_DYN_METH_DISPATCH;
 246 }
 247
 248 /* Enable/Disable normalizations of the firm representation. */
 249 void set_opt_normalize(int value)
 250 {
 251   if (value)
 252     libFIRM_opt |= OPT_NORMALIZE;
 253   else
 254     libFIRM_opt &= ~OPT_NORMALIZE;
 255 }
 256
 257 /* Enable/Disable optimization of tail-recursion calls. */
 258 void set_opt_tail_recursion(int value)
 259 {
 260   if (value)
 261     libFIRM_opt |= OPT_TAIL_RECURSION;
 262   else
 263     libFIRM_opt &= ~OPT_TAIL_RECURSION;
 264 }
 265
 266 /* Enable/Disable optimization of tail-recursion calls. */
 267 void set_opt_tail_recursion_verbose(int value)
 268 {
 269   if (value)
 270     libFIRM_verb |= OPT_TAIL_RECURSION;
 271   else
 272     libFIRM_verb &= ~OPT_TAIL_RECURSION;
 273 }
 274
 275 /* Enable/Disable precise exception context. */
 276 void set_opt_precise_exc_context(int value)
 277 {
 278 #if PRECISE_EXC_CONTEXT
 279   if (value)
 280     libFIRM_opt |= OPT_PRECISE_EXC_CONTEXT;
 281   else
 282     libFIRM_opt &= ~OPT_PRECISE_EXC_CONTEXT;
 283 #endif
 284 }
 285
 286 void set_opt_fragile_ops(int value)
 287 {
 288   if (value)
 289     libFIRM_opt |= OPT_FRAGILE_OPS;
 290   else
 291     libFIRM_opt &= ~OPT_FRAGILE_OPS;
 292 }
 293
 294 /* Save the current optimization state. */
 295 void save_optimization_state(optimization_state_t *state)
 296 {
 297   *state = libFIRM_opt;
 298 }
 299
 300 /* Restore the current optimization state. */
 301 void restore_optimization_state(const optimization_state_t *state)
 302 {
 303   libFIRM_opt = *state;
 304 }