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