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