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