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