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