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