nsz Git - libfirm/blob - include/libfirm/firmstat.h

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Statistics for Firm.
  23  * @author  Michael Beck
  24  */
  25 #ifndef FIRM_STAT_FIRMSTAT_H
  26 #define FIRM_STAT_FIRMSTAT_H
  27
  28 #include "irhooks.h"
  29 #include "begin.h"
  30
  31 /**
  32  * Statistic options, can be or'ed.
  33  */
  34 enum firmstat_options_t {
  35         FIRMSTAT_ENABLED         = 0x00000001,    /**< enable statistics */
  36         FIRMSTAT_PATTERN_ENABLED = 0x00000002,    /**< enable pattern calculation */
  37         FIRMSTAT_COUNT_STRONG_OP = 0x00000004,    /**< if set, count Mul/Div/Mod by constant */
  38         FIRMSTAT_COUNT_DAG       = 0x00000008,    /**< if set, count DAG statistics */
  39         FIRMSTAT_COUNT_DELETED   = 0x00000010,    /**< if set, count deleted graphs */
  40         FIRMSTAT_COUNT_SELS      = 0x00000020,    /**< if set, count Sel(Sel(..)) differently */
  41         FIRMSTAT_COUNT_CONSTS    = 0x00000040,    /**< if set, count Const statistics */
  42         FIRMSTAT_CSV_OUTPUT      = 0x10000000     /**< CSV output of some mini-statistic */
  43 };
  44
  45 /**
  46  * Additional flags for statistics.
  47  */
  48 enum firmstat_optimizations_t {
  49         FS_OPT_NEUTRAL_0  = HOOK_OPT_LAST,        /**< a op 0 = 0 op a = a */
  50         FS_OPT_NEUTRAL_1,                         /**< a op 1 = 1 op a = a */
  51         FS_OPT_ADD_A_A,                           /**< a + a = a * 2 */
  52         FS_OPT_ADD_A_MINUS_B,                     /**< a + -b = a - b */
  53         FS_OPT_ADD_SUB,                           /**< (a + x) - x = (a - x) + x */
  54         FS_OPT_ADD_MUL_A_X_A,                     /**< a * x + a = a * (x + 1) */
  55         FS_OPT_SUB_0_A,                           /**< 0 - a = -a */
  56         FS_OPT_MINUS_SUB,                         /**< - (a - b) = b - a */
  57         FS_OPT_SUB_MINUS,                         /**< a - (-b) = a + b */
  58         FS_OPT_SUB_MUL_A_X_A,                     /**< a * x - a = a * (x - 1) */
  59         FS_OPT_SUB_SUB_X_Y_Z,                     /**< (x - y) - z = x - (y + z) */
  60         FS_OPT_SUB_C_NOT_X,                       /**< c - ~a = a + (c+1) */
  61         FS_OPT_SUB_TO_ADD,                        /**< (-a) - b = -(a + b), a - (b - c) = a + (c - b), a - (b * C) -> a + (b * -C) */
  62         FS_OPT_SUB_TO_NOT,                        /**< -1 - x -> ~x on two's complement */
  63         FS_OPT_SUB_TO_CONV,                       /**< a - NULL = (int)a */
  64         FS_OPT_MUL_MINUS,                         /**< (-a) * (b - c) -> a * (c - b) */
  65         FS_OPT_MUL_MINUS_1,                       /**< a * -1 = -a */
  66         FS_OPT_MINUS_MUL_C,                       /**< (-a) * C = a * (-C) */
  67         FS_OPT_MUL_MINUS_MINUS,                   /**< (-a) * (-b) = a * b */
  68         FS_OPT_OR,                                /**< a | a = a | 0 = 0 | a = a */
  69         FS_OPT_AND,                               /**< a & 0b1...1 = 0b1...1 & a =  a & a = a */
  70         FS_OPT_TO_EOR,                            /**< (a|b) & ~(a&b) = a^b */
  71         FS_OPT_EOR_A_A,                           /**< a ^ a = 0 */
  72         FS_OPT_EOR_A_B_A,                         /**< (a ^ b) ^ a = b */
  73         FS_OPT_EOR_TO_NOT_BOOL,                   /**< bool ^ 1 = !bool */
  74         FS_OPT_EOR_TO_NOT,                        /**< x ^ 0b1..1 = ~x, (a ^ b) & b -> ~a & b */
  75         FS_OPT_NOT_CMP,                           /**< !(a cmp b) = a !cmp b */
  76         FS_OPT_OR_SHFT_TO_ROTL,                   /**< (x << c) | (x >> (bits - c)) == Rotl(x, c) */
  77         FS_OPT_REASSOC_SHIFT,                     /**< (x SHF c1) SHF c2 = x SHF (c1+c2) */
  78         FS_OPT_SHIFT_AND,                         /**< (a SHF c) AND (b SHF c) = (a AND b) SHF c */
  79         FS_OPT_SHIFT_OR,                          /**< (a SHF c) OR (b SHF c) = (a OR b) SHF c */
  80         FS_OPT_SHIFT_EOR,                         /**< (a SHF c) XOR (b SHF c) = (a XOR b) SHF c */
  81         FS_OPT_CONV,                              /**< a Conv could be removed */
  82         FS_OPT_CAST,                              /**< a Cast could be removed */
  83         FS_OPT_MIN_MAX_EQ,                        /**< Min(a,a) = Max(a,a) = a */
  84         FS_OPT_MUX_COMBINE,                       /**< two Mux nodes where combined into one */
  85         FS_OPT_MUX_CONV,                          /**< MuxI(sel, 1, 0) = (I)sel */
  86         FS_OPT_MUX_BOOL,                          /**< Muxb(sel, true, false) = sel */
  87         FS_OPT_MUX_NOT_BOOL,                      /**< Muxb(sel, false, true) = Not(sel) */
  88         FS_OPT_MUX_OR_BOOL,                       /**< Muxb(sel, true, x) = Or(sel, x) */
  89         FS_OPT_MUX_ORNOT_BOOL,                    /**< Muxb(sel, x, true) = Or(Not(sel), x) */
  90         FS_OPT_MUX_AND_BOOL,                      /**< Muxb(sel, x, false) = And(sel, x) */
  91         FS_OPT_MUX_ANDNOT_BOOL,                   /**< Muxb(sel, false, x) = And(Not(sel), x) */
  92         FS_OPT_MUX_C,                             /**< Mux(C, f, t) = C ? t : f */
  93         FS_OPT_MUX_EQ,                            /**< Mux(v, x, x) = x */
  94         FS_OPT_MUX_TRANSFORM,                     /**< Mux(t ==/!= f, t, f) = f/t, Mux(t ==/!= 0, -t, t) = -t/t */
  95         FS_OPT_MUX_TO_MIN,                        /**< Mux(a < b, a, b) = Min(a,b) */
  96         FS_OPT_MUX_TO_MAX,                        /**< Mux(a > b, a, b) = Max(a,b) */
  97         FS_OPT_MUX_TO_BITOP,                      /**< Mux((a & 2^x) ==/!= 0, 2^x, 0) = (a & 2^x) (xor 2^x) */
  98         FS_OPT_IDEM_UNARY,                        /**< Idempotent unary operation */
  99         FS_OPT_MINUS_NOT,                         /**< -(~x) = x + 1 */
 100         FS_OPT_NOT_MINUS_1,                       /**< ~(x - 1) = -x */
 101         FS_OPT_NOT_PLUS_1,                        /**< ~x + 1 = -x */
 102         FS_OPT_ADD_X_NOT_X,                       /**< ~x + x = -1 */
 103         FS_OPT_FP_INV_MUL,                        /**< x / y = x * (1.0/y) */
 104         FS_OPT_CONST_PHI,                         /**< Constant evaluation on Phi */
 105         FS_OPT_PREDICATE,                         /**< Predicate optimization */
 106         FS_OPT_DEMORGAN,                          /**< optimization using DeMorgan's law */
 107         FS_OPT_CMP_OP_OP,                         /**< CMP optimization: Cmp(OP(x), OP(y)) = Cmp(x, y) */
 108         FS_OPT_CMP_OP_C,                          /**< CMP optimization: Cmp(OP(x), c1) = Cmp(x, c2) */
 109         FS_OPT_CMP_CONV_CONV,                     /**< CMP optimization: Cmp(Conv(x), Conv(y)) = Cmp(x, y) */
 110         FS_OPT_CMP_CONV,                          /**< CMP optimization: Cmp(Conv(x), Conv(y)) = Cmp(Conv(x), y) */
 111         FS_OPT_CMP_TO_BOOL,                       /**< CMP optimization: Cmp(x, y) = BoolOP(x, y) */
 112         FS_OPT_CMP_CNST_MAGN,                     /**< CMP optimization: reduced magnitude of a const */
 113         FS_OPT_CMP_SHF_TO_AND,                    /**< CMP optimization: transformed shift into And */
 114         FS_OPT_CMP_MOD_TO_AND,                    /**< CMP optimization: transformed Mod into And */
 115         FS_OPT_NOP,                               /**< the operation is a NOP */
 116         FS_OPT_GVN_FOLLOWER,                      /**< GVN-PRE: replaced a follower */
 117         FS_OPT_GVN_FULLY,                         /**< GVN-PRE: replaced by fully redundant value */
 118         FS_OPT_GVN_PARTLY,                        /**< GVN-PRE: replaced by partly redundant value */
 119         FS_OPT_COMBO_CONST,                       /**< Combo: evaluated into Constant */
 120         FS_OPT_COMBO_CF,                          /**< Combo: removed conditional control flow */
 121         FS_OPT_COMBO_FOLLOWER,                    /**< Combo: replaced a follower */
 122         FS_OPT_COMBO_CONGRUENT,                   /**< Combo: replaced by congruent */
 123         FS_OPT_JUMPTHREADING,                     /**< Jump threading: removed conditional control flow */
 124         FS_OPT_RTS_ABS,                           /**< RTS optimization: call to abs() replaced */
 125         FS_OPT_RTS_ALLOCA,                        /**< RTS optimization: call to alloca() replaced */
 126         FS_OPT_RTS_SQRT,                          /**< RTS optimization: call to sqrt() replaced */
 127         FS_OPT_RTS_CBRT,                          /**< RTS optimization: call to cbrt() replaced */
 128         FS_OPT_RTS_POW,                           /**< RTS optimization: call to pow() replaced */
 129         FS_OPT_RTS_EXP,                           /**< RTS optimization: call to exp() replaced */
 130         FS_OPT_RTS_LOG,                           /**< RTS optimization: call to log() replaced */
 131         FS_OPT_RTS_SIN,                           /**< RTS optimization: call to sin() replaced */
 132         FS_OPT_RTS_COS,                           /**< RTS optimization: call to cos() replaced */
 133         FS_OPT_RTS_TAN,                           /**< RTS optimization: call to tan() replaced */
 134         FS_OPT_RTS_ASIN,                          /**< RTS optimization: call to asin() replaced */
 135         FS_OPT_RTS_ACOS,                          /**< RTS optimization: call to acos() replaced */
 136         FS_OPT_RTS_ATAN,                          /**< RTS optimization: call to atan() replaced */
 137         FS_OPT_RTS_SINH,                          /**< RTS optimization: call to sinh() replaced */
 138         FS_OPT_RTS_COSH,                          /**< RTS optimization: call to cosh() replaced */
 139         FS_OPT_RTS_TANH,                          /**< RTS optimization: call to tanh() replaced */
 140         FS_OPT_RTS_SYMMETRIC,                     /**< RTS optimization: call to symmetric function f(-x) replaced by f(x) */
 141         FS_OPT_RTS_STRCMP,                        /**< RTS optimization: call to strcmp() replaced */
 142         FS_OPT_RTS_STRNCMP,                       /**< RTS optimization: call to strncmp() replaced */
 143         FS_OPT_RTS_STRCPY,                        /**< RTS optimization: call to strcpy() replaced */
 144         FS_OPT_RTS_STRLEN,                        /**< RTS optimization: call to strlen() replaced */
 145         FS_OPT_RTS_MEMCPY,                        /**< RTS optimization: call to memcpy() replaced */
 146         FS_OPT_RTS_MEMPCPY,                       /**< RTS optimization: call to mempcpy() replaced */
 147         FS_OPT_RTS_MEMMOVE,                       /**< RTS optimization: call to memmove() replaced */
 148         FS_OPT_RTS_MEMSET,                        /**< RTS optimization: call to memset() replaced */
 149         FS_OPT_RTS_MEMCMP,                        /**< RTS optimization: call to memcmp() replaced */
 150         FS_BE_IA32_LEA,                           /**< Lea was created */
 151         FS_BE_IA32_LOAD_LEA,                      /**< Load merged with a Lea */
 152         FS_BE_IA32_STORE_LEA,                     /**< Store merged with a Lea */
 153         FS_BE_IA32_AM_S,                          /**< Source address mode node created */
 154         FS_BE_IA32_AM_D,                          /**< Destination address mode node created */
 155         FS_BE_IA32_CJMP,                          /**< CJmp created to save a cmp/test */
 156         FS_BE_IA32_2ADDRCPY,                      /**< Copy created due to 2-Addresscode constraints */
 157         FS_BE_IA32_SPILL2ST,                      /**< Created Store for a Spill */
 158         FS_BE_IA32_RELOAD2LD,                     /**< Created Load for a Reload */
 159         FS_BE_IA32_SUB2NEGADD,                    /**< Created Neg-Add for a Sub due to 2-Addresscode constraints */
 160         FS_BE_IA32_LEA2ADD,                       /**< Transformed Lea back into Add */
 161         FS_OPT_MAX
 162 };
 163
 164 /**
 165  * Dump a snapshot of the statistic values.
 166  * Never called from libFirm should be called from user.
 167  *
 168  * @param fname  base name of the statistic output file
 169  * @param phase  a phase name. Prefix will be firmstat-\<phase\>-
 170  */
 171 FIRM_API void stat_dump_snapshot(const char *fname, const char *phase);
 172
 173 /**
 174  * Creates an ir_prog pass for stat_dump_snapshot().
 175  *
 176  * @param name    the name of this pass or NULL
 177  * @param fname   base name of the statistic output file
 178  * @param phase   a phase name. Prefix will be firmstat-\<phase\>-
 179  *
 180  * @return  the newly created ir_prog pass
 181  */
 182 FIRM_API ir_prog_pass_t *stat_dump_snapshot_pass(
 183         const char *name, const char *fname, const char *phase);
 184
 185 /**
 186  * initialize the statistics module.
 187  * Should be called directly after ir_init
 188  *
 189  * @param enable_options  a bitmask containing the statistic options
 190  */
 191 FIRM_API void firm_init_stat(unsigned enable_options);
 192
 193 /**
 194  * terminates the statistics module, frees all memory
 195  */
 196 FIRM_API void stat_term(void);
 197
 198 /**
 199  * returns 1 if statistic module is active, 0 otherwise
 200  */
 201 FIRM_API int stat_is_active(void);
 202
 203 #include "end.h"
 204
 205 #endif