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