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