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