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