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_LOOP_UNROLLING)                     |
  30   ENABLE(OPT_STRENGTH_RED)                       |
  31   ENABLE(OPT_CONSTANT_FOLDING)                   |
  32   ENABLE(OPT_REDUNDANT_LOADSTORE)                |
  33   ENABLE(OPT_UNREACHABLE_CODE)                   |
  34   ENABLE(OPT_CONTROL_FLOW_STRAIGHTENING)         |
  35   ENABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION)   |
  36   ENABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) |
  37   ENABLE(OPT_CRITICAL_EDGES)                     |
  38   ENABLE(OPT_DEAD_NODE_ELIMINATION)              |
  39   ENABLE(OPT_DEAD_METHOD_ELIMINATION)            |
  40   ENABLE(OPT_REASSOCIATION)                      |
  41   ENABLE(OPT_INLINE)                             |
  42   ENABLE(OPT_DYN_METH_DISPATCH)                  |
  43   ENABLE(OPT_NORMALIZE)                          |
  44   ENABLE(OPT_TAIL_RECURSION)                     |
  45   ENABLE(OPT_PRECISE_EXC_CONTEXT)                |
  46   DISABLE(OPT_FRAGILE_OPS)                       |
  47   0;
  48
  49 optimization_state_t libFIRM_verb =
  50   DISABLE(OPT_OPTIMIZED)                          |
  51   DISABLE(OPT_CSE)                                |
  52   DISABLE(OPT_GLOBAL_CSE)                         |
  53   DISABLE(OPT_LOOP_UNROLLING)                     |
  54   DISABLE(OPT_STRENGTH_RED)                       |
  55   DISABLE(OPT_CONSTANT_FOLDING)                   |
  56   DISABLE(OPT_REDUNDANT_LOADSTORE)                |
  57   DISABLE(OPT_UNREACHABLE_CODE)                   |
  58   DISABLE(OPT_CONTROL_FLOW_STRAIGHTENING)         |
  59   DISABLE(OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION)   |
  60   DISABLE(OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION) |
  61   DISABLE(OPT_CRITICAL_EDGES)                     |
  62   DISABLE(OPT_DEAD_NODE_ELIMINATION)              |
  63   DISABLE(OPT_DEAD_METHOD_ELIMINATION)            |
  64   DISABLE(OPT_REASSOCIATION)                      |
  65   DISABLE(OPT_INLINE)                             |
  66   DISABLE(OPT_DYN_METH_DISPATCH)                  |
  67   DISABLE(OPT_NORMALIZE)                          |
  68   DISABLE(OPT_TAIL_RECURSION)                     |
  69   DISABLE(OPT_PRECISE_EXC_CONTEXT)                |
  70   DISABLE(OPT_FRAGILE_OPS)                       |
  71   0;
  72
  73 /** The Firm verbosity level */
  74 int firm_verbosity_level;
  75
  76 /* set the flags with set_flagname, get the flag with get_flagname */
  77 void set_opt_cse (int value)
  78 {
  79   if (value)
  80     libFIRM_opt |= OPT_CSE;
  81   else
  82     libFIRM_opt &= ~OPT_CSE;
  83 }
  84
  85 int (get_opt_cse)(void) {
  86   return _get_opt_cse();
  87 }
  88
  89 void set_opt_global_cse(int value)
  90 {
  91   if (value)
  92     libFIRM_opt |= OPT_GLOBAL_CSE;
  93   else
  94     libFIRM_opt &= ~OPT_GLOBAL_CSE;
  95 }
  96
  97 void set_opt_loop_unrolling (int value)
  98 {
  99   if (value)
 100     libFIRM_opt |= OPT_LOOP_UNROLLING;
 101   else
 102     libFIRM_opt &= ~OPT_LOOP_UNROLLING;
 103 }
 104
 105 void set_opt_loop_unrolling_verbose (int value)
 106 {
 107   if (value)
 108     libFIRM_verb |= OPT_LOOP_UNROLLING;
 109   else
 110     libFIRM_verb &= ~OPT_LOOP_UNROLLING;
 111 }
 112
 113 void set_opt_strength_red (int value)
 114 {
 115   if (value)
 116     libFIRM_opt |= OPT_STRENGTH_RED;
 117   else
 118     libFIRM_opt &= ~OPT_STRENGTH_RED;
 119 }
 120
 121 void set_opt_strength_red_verbose (int value)
 122 {
 123   if (value)
 124     libFIRM_verb |= OPT_STRENGTH_RED;
 125   else
 126     libFIRM_verb &= ~OPT_STRENGTH_RED;
 127 }
 128
 129 void
 130 set_opt_constant_folding(int value)
 131 {
 132   if (value)
 133     libFIRM_opt |= OPT_CONSTANT_FOLDING;
 134   else
 135     libFIRM_opt &= ~OPT_CONSTANT_FOLDING;
 136 }
 137
 138 void
 139 set_opt_redundant_LoadStore(int value) {
 140   if (value)
 141     libFIRM_opt |= OPT_REDUNDANT_LOADSTORE;
 142   else
 143     libFIRM_opt &= ~OPT_REDUNDANT_LOADSTORE;
 144 }
 145
 146 void
 147 set_opt_unreachable_code(int value)
 148 {
 149   if (value)
 150     libFIRM_opt |= OPT_UNREACHABLE_CODE;
 151   else
 152     libFIRM_opt &= ~OPT_UNREACHABLE_CODE;
 153 }
 154
 155 void set_opt_control_flow(int value)
 156 {
 157   set_opt_control_flow_straightening(value);
 158   set_opt_control_flow_weak_simplification(value);
 159   set_opt_control_flow_strong_simplification(value);
 160   set_opt_critical_edges(value);
 161 }
 162
 163 /* Performs Straightening */
 164 void set_opt_control_flow_straightening(int value)
 165 {
 166   if (value)
 167     libFIRM_opt |= OPT_CONTROL_FLOW_STRAIGHTENING;
 168   else
 169     libFIRM_opt &= ~OPT_CONTROL_FLOW_STRAIGHTENING;
 170 }
 171
 172 /* Performs if simplifications in local optimizations. */
 173 void set_opt_control_flow_weak_simplification(int value)
 174 {
 175   if (value)
 176     libFIRM_opt |= OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION;
 177   else
 178     libFIRM_opt &= ~OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION;
 179 }
 180
 181 /* Performs strong if and loop simplification (in optimize_cf). */
 182 void set_opt_control_flow_strong_simplification(int value)
 183 {
 184   if (value)
 185     libFIRM_opt |= OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION;
 186   else
 187     libFIRM_opt &= ~OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION;
 188 }
 189
 190 void set_opt_critical_edges(int value)
 191 {
 192   if (value)
 193     libFIRM_opt |= OPT_CRITICAL_EDGES;
 194   else
 195     libFIRM_opt &= ~OPT_CRITICAL_EDGES;
 196 }
 197
 198 void set_opt_reassociation(int value)
 199 {
 200   if (value)
 201     libFIRM_opt |= OPT_REASSOCIATION;
 202   else
 203     libFIRM_opt &= ~OPT_REASSOCIATION;
 204 }
 205
 206 void set_opt_dead_node_elimination(int value)
 207 {
 208   if (value)
 209     libFIRM_opt |= OPT_DEAD_NODE_ELIMINATION;
 210   else
 211     libFIRM_opt &= ~OPT_DEAD_NODE_ELIMINATION;
 212 }
 213
 214 void set_opt_dead_method_elimination (int value) {
 215   if (value)
 216     libFIRM_opt |= OPT_DEAD_METHOD_ELIMINATION;
 217   else
 218     libFIRM_opt &= ~OPT_DEAD_METHOD_ELIMINATION;
 219 }
 220
 221 void set_opt_dead_method_elimination_verbose (int value) {
 222   if (value)
 223     libFIRM_verb |= OPT_DEAD_METHOD_ELIMINATION;
 224   else
 225     libFIRM_verb &= ~OPT_DEAD_METHOD_ELIMINATION;
 226 }
 227
 228 void set_optimize(int value)
 229 {
 230   if (value)
 231     libFIRM_opt |= OPT_OPTIMIZED;
 232   else
 233     libFIRM_opt &= ~OPT_OPTIMIZED;
 234 }
 235
 236 int get_optimize(void)
 237 {
 238   return get_opt_optimize();
 239 }
 240
 241
 242 void set_firm_verbosity (int value) {
 243   firm_verbosity_level = value;
 244 }
 245
 246 int  (get_firm_verbosity) (void) {
 247   return _get_firm_verbosity();
 248 }
 249
 250
 251
 252 /* Enable/Disables inlining. */
 253 void set_opt_inline(int value)
 254 {
 255   if (value)
 256     libFIRM_opt |= OPT_INLINE;
 257   else
 258     libFIRM_opt &= ~OPT_INLINE;
 259 }
 260
 261 /* Enable/Disable optimization of dynamic method dispatch */
 262 void set_opt_dyn_meth_dispatch (int value)
 263 {
 264   if (value)
 265     libFIRM_opt |= OPT_DYN_METH_DISPATCH;
 266   else
 267     libFIRM_opt &= ~OPT_DYN_METH_DISPATCH;
 268 }
 269
 270 /* Enable/Disable normalizations of the firm representation. */
 271 void set_opt_normalize(int value)
 272 {
 273   if (value)
 274     libFIRM_opt |= OPT_NORMALIZE;
 275   else
 276     libFIRM_opt &= ~OPT_NORMALIZE;
 277 }
 278
 279 /* Enable/Disable optimization of tail-recursion calls. */
 280 void set_opt_tail_recursion(int value)
 281 {
 282   if (value)
 283     libFIRM_opt |= OPT_TAIL_RECURSION;
 284   else
 285     libFIRM_opt &= ~OPT_TAIL_RECURSION;
 286 }
 287
 288 /* Enable/Disable optimization of tail-recursion calls. */
 289 void set_opt_tail_recursion_verbose(int value)
 290 {
 291   if (value)
 292     libFIRM_verb |= OPT_TAIL_RECURSION;
 293   else
 294     libFIRM_verb &= ~OPT_TAIL_RECURSION;
 295 }
 296
 297 /* Enable/Disable precise exception context. */
 298 void set_opt_precise_exc_context(int value)
 299 {
 300 #if PRECISE_EXC_CONTEXT
 301   if (value)
 302     libFIRM_opt |= OPT_PRECISE_EXC_CONTEXT;
 303   else
 304     libFIRM_opt &= ~OPT_PRECISE_EXC_CONTEXT;
 305 #endif
 306 }
 307
 308 void set_opt_fragile_ops(int value)
 309 {
 310   if (value)
 311     libFIRM_opt |= OPT_FRAGILE_OPS;
 312   else
 313     libFIRM_opt &= ~OPT_FRAGILE_OPS;
 314 }
 315
 316 /* Save the current optimization state. */
 317 void save_optimization_state(optimization_state_t *state)
 318 {
 319   *state = libFIRM_opt;
 320 }
 321
 322 /* Restore the current optimization state. */
 323 void restore_optimization_state(const optimization_state_t *state)
 324 {
 325   libFIRM_opt = *state;
 326 }