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