hphp/hhbbc/options.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16 #ifndef incl_HPHP_HHBBC_OPTIONS_H_
  17 #define incl_HPHP_HHBBC_OPTIONS_H_
  18
  19 #include <string>
  20 #include <utility>
  21
  22 #include "hphp/hhbbc/hhbbc.h"
  23
  24 namespace HPHP {
  25
  26 namespace HHBBC {
  27
  28 //////////////////////////////////////////////////////////////////////
  29
  30 /*
  31  * Publically-settable options that control compilation.
  32  */
  33 struct Options {
  34   /*
  35    * When debugging, it can be useful to ask for certain functions to be traced
  36    * at a higher level than the rest of the program.
  37    */
  38   MethodMap TraceFunctions;
  39
  40   /*
  41    * When debugging, it can be useful to ask for a list of functions
  42    * that use particular bytecodes.
  43    */
  44   OpcodeSet TraceBytecodes;
  45
  46   /*
  47    * If non-empty, dump jemalloc memory profiles at key points during
  48    * the build, using this as a prefix.
  49    */
  50   std::string profileMemory;
  51
  52   //////////////////////////////////////////////////////////////////////
  53
  54   /*
  55    * Flags for various limits on when to perform widening operations.
  56    * See analyze.cpp for details.
  57    */
  58   uint32_t analyzeFuncWideningLimit = 12;
  59   uint32_t analyzeClassWideningLimit = 6;
  60
  61   /*
  62    * When to stop refining return types.
  63    *
  64    * This needs to be limited because types can walk downwards in our
  65    * type lattice indefinitely.  The index never contains incorrect
  66    * return types, since the return types only shrink, which means we
  67    * can just stop refining a return type whenever we want to without
  68    * causing problems.
  69    *
  70    * For an example of where this can occur, imagine the analysis of the
  71    * following function:
  72    *
  73    *    function foo() { return array('x' => foo()); }
  74    *
  75    * Each time we visit `foo', we'll discover a slightly smaller return
  76    * type, in a downward-moving sequence that would never terminate:
  77    *
  78    *   InitCell, CArrN(x:InitCell), CArrN(x:CArrN(x:InitCell)), ...
  79    */
  80   uint32_t returnTypeRefineLimit = 15;
  81
  82   /*
  83    * Limit public static property refinement for the same reason.
  84    */
  85   uint32_t publicSPropRefineLimit = 15;
  86
  87   /*
  88    * Whether to produce extended stats information.  (Takes extra
  89    * time.)
  90    */
  91   bool extendedStats = false;
  92
  93   //////////////////////////////////////////////////////////////////////
  94
  95   /*
  96    * If true, all optimizations are disabled, and analysis isn't even
  97    * performed.
  98    */
  99   bool NoOptimizations = false;
 100
 101   /*
 102    * If true, analyze calls to functions in a context-sensitive way.
 103    *
 104    * Disabled by default because its slow, with very little gain.
 105    */
 106   bool ContextSensitiveInterp = false;
 107
 108   /*
 109    * If true, completely remove jumps to blocks that are inferred to be dead.
 110    * When false, dead blocks are replaced with Fatal bytecodes.
 111    */
 112   bool RemoveDeadBlocks = true;
 113
 114   /*
 115    * Whether to propagate constant values by replacing instructions which are
 116    * known to always produce a constant with instructions that produce that
 117    * constant.
 118    */
 119   bool ConstantProp = true;
 120
 121   /*
 122    * Whether we should evaluate side-effect free builtins at compile time when
 123    * they have compile-time constant arguments.
 124    */
 125   bool ConstantFoldBuiltins = true;
 126
 127   /*
 128    * Whether to perform local or global dead code elimination.  This removes
 129    * unnecessary instructions within a single block, or across blocks,
 130    * respectively.
 131    */
 132   bool LocalDCE = true;
 133   bool GlobalDCE = true;
 134
 135   /*
 136    * Whether to remove completely unused local variables.  This requires
 137    * GlobalDCE.
 138    */
 139   bool RemoveUnusedLocals = true;
 140
 141   /*
 142    * If true, insert opcodes that assert inferred types, so we can assume them
 143    * at runtime.
 144    */
 145   bool InsertAssertions = true;
 146   bool InsertStackAssertions = true;
 147
 148   /*
 149    * If true, try to filter asserts out that are "obvious" (this is a code size
 150    * optimization).  It can be useful to turn this option off for debugging.
 151    *
 152    * Has no effect if !InsertStackAssertions.
 153    */
 154   bool FilterAssertions = true;
 155
 156   /*
 157    * Whether to replace bytecode with less expensive bytecodes when we can.
 158    * E.g. InstanceOf -> InstanceOfD or FCallFunc -> FCallFuncD.
 159    */
 160   bool StrengthReduce = true;
 161
 162   /*
 163    * Whether to enable 'FuncFamily' method resolution.
 164    *
 165    * This allows possible overrides of a method to be resolved as a
 166    * set of candidates when we aren't sure which one it would be.
 167    */
 168   bool FuncFamilies = true;
 169
 170   /*
 171    * Whether or not hhbbc should attempt to do anything intelligent to
 172    * pseudomains.
 173    */
 174   bool AnalyzePseudomains = true;
 175
 176   /*
 177    * Should we do an extra whole-program pass to try to determine the types of
 178    * public static properties.  This will not yield any useful information for
 179    * programs that contain any sets to static properties with both a dynamic
 180    * property name and an unknown class type.
 181    */
 182   bool AnalyzePublicStatics = true;
 183
 184   //////////////////////////////////////////////////////////////////////
 185   // Flags below this line perform optimizations that intentionally
 186   // may have user-visible changes to program behavior.
 187   //////////////////////////////////////////////////////////////////////
 188
 189   /*
 190    * If true, we'll try to infer the types of declared private class
 191    * properties.
 192    *
 193    * This is in the can-potentially-change-program-behavior section
 194    * because if you unserialize specially-constructed strings you
 195    * could create instances with private properties that don't follow
 196    * the inferred types.  HHVM tracks the types that were inferred,
 197    * and if an unserialize happens that would violate what we've
 198    * inferred, we'll raise a notice and unserialize() returns false.
 199    */
 200   bool HardPrivatePropInference = true;
 201
 202   /*
 203    * Whether to flatten trait methods and properties into the classes
 204    * that use them.
 205    */
 206   bool FlattenTraits = true;
 207
 208   /*
 209    * The filepath where to save the stats file.  If the path is empty, then we
 210    * save the stats file to a temporary file.
 211    */
 212   std::string stats_file;
 213 };
 214 extern Options options;
 215
 216 }}
 217
 218 #endif