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