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