Get rid of forward exit on DoubleAsInt32
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.h
1 /*
2  * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef Options_h
27 #define Options_h
28
29 #include "JSExportMacros.h"
30 #include <stdint.h>
31 #include <stdio.h>
32
33 namespace JSC {
34
35 // How do JSC VM options work?
36 // ===========================
37 // The JSC_OPTIONS() macro below defines a list of all JSC options in use,
38 // along with their types and default values. The options values are actually
39 // realized as an array of Options::Entry elements.
40 //
41 //     Options::initialize() will initialize the array of options values with
42 // the defaults specified in JSC_OPTIONS() below. After that, the values can
43 // be programmatically read and written to using an accessor method with the
44 // same name as the option. For example, the option "useJIT" can be read and
45 // set like so:
46 //
47 //     bool jitIsOn = Options::useJIT();  // Get the option value.
48 //     Options::useJIT() = false;         // Sets the option value.
49 //
50 //     If you want to tweak any of these values programmatically for testing
51 // purposes, you can do so in Options::initialize() after the default values
52 // are set.
53 //
54 //     Alternatively, you can override the default values by specifying
55 // environment variables of the form: JSC_<name of JSC option>.
56 //
57 // Note: Options::initialize() tries to ensure some sanity on the option values
58 // which are set by doing some range checks, and value corrections. These
59 // checks are done after the option values are set. If you alter the option
60 // values after the sanity checks (for your own testing), then you're liable to
61 // ensure that the new values set are sane and reasonable for your own run.
62
63 class OptionRange {
64 private:
65     enum RangeState { Uninitialized, InitError, Normal, Inverted };
66 public:
67     OptionRange& operator= (const int& rhs)
68     { // Only needed for initialization
69         if (!rhs) {
70             m_state = Uninitialized;
71             m_rangeString = 0;
72             m_lowLimit = 0;
73             m_highLimit = 0;
74         }
75         return *this;
76     }
77
78     bool init(const char*);
79     bool isInRange(unsigned);
80     const char* rangeString() { return (m_state > InitError) ? m_rangeString : "<null>"; }
81
82 private:
83     RangeState m_state;
84     const char* m_rangeString;
85     unsigned m_lowLimit;
86     unsigned m_highLimit;
87 };
88
89 typedef OptionRange optionRange;
90
91 #define JSC_OPTIONS(v) \
92     v(bool, useLLInt,  true) \
93     v(bool, useJIT,    true) \
94     v(bool, useDFGJIT, true) \
95     v(bool, useRegExpJIT, true) \
96     \
97     v(bool, crashIfCantAllocateJITMemory, false) \
98     \
99     v(bool, forceDFGCodeBlockLiveness, false) \
100     \
101     v(bool, dumpGeneratedBytecodes, false) \
102     v(bool, dumpBytecodeLivenessResults, false) \
103     v(bool, validateBytecode, false) \
104     \
105     /* showDisassembly implies showDFGDisassembly. */ \
106     v(bool, showDisassembly, false) \
107     v(bool, showDFGDisassembly, false) \
108     v(bool, showAllDFGNodes, false) \
109     v(optionRange, bytecodeRangeToDFGCompile, 0) \
110     v(bool, dumpBytecodeAtDFGTime, false) \
111     v(bool, dumpGraphAtEachPhase, false) \
112     v(bool, verboseCompilation, false) \
113     v(bool, logCompilationChanges, false) \
114     v(bool, printEachOSRExit, false) \
115     v(bool, validateGraph, false) \
116     v(bool, validateGraphAtEachPhase, false) \
117     v(bool, verboseOSR, false) \
118     v(bool, verboseCallLink, false) \
119     v(bool, verboseCompilationQueue, false) \
120     v(bool, reportCompileTimes, false) \
121     v(bool, verboseCFA, false) \
122     \
123     v(bool, enableOSREntryInLoops, true) \
124     \
125     v(bool, useExperimentalFTL, false) \
126     v(bool, useFTLTBAA, true) \
127     v(bool, enableLLVMFastISel, false) \
128     v(bool, useLLVMSmallCodeModel, false) \
129     v(bool, dumpLLVMIR, false) \
130     v(bool, validateFTLOSRExitLiveness, false) \
131     v(bool, llvmAlwaysFailsBeforeCompile, false) \
132     v(bool, llvmAlwaysFailsBeforeLink, false) \
133     v(bool, llvmSimpleOpt, true) \
134     v(unsigned, llvmBackendOptimizationLevel, 2) \
135     v(unsigned, llvmOptimizationLevel, 2) \
136     v(unsigned, llvmSizeLevel, 0) \
137     v(bool, ftlCrashes, false) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
138     \
139     v(bool, enableConcurrentJIT, true) \
140     v(unsigned, numberOfCompilerThreads, computeNumberOfWorkerThreads(2) - 1) \
141     \
142     v(bool, enableProfiler, false) \
143     \
144     v(bool, forceUDis86Disassembler, false) \
145     v(bool, forceLLVMDisassembler, false) \
146     \
147     v(bool, enableArchitectureSpecificOptimizations, true) \
148     \
149     v(unsigned, maximumOptimizationCandidateInstructionCount, 10000) \
150     \
151     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 180) \
152     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 100) \
153     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 100) \
154     \
155     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
156     v(unsigned, maximumInliningDepth, 5) \
157     \
158     v(unsigned, maximumBinaryStringSwitchCaseLength, 50) \
159     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000) \
160     \
161     v(int32, thresholdForJITAfterWarmUp, 100) \
162     v(int32, thresholdForJITSoon, 100) \
163     \
164     v(int32, thresholdForOptimizeAfterWarmUp, 1000) \
165     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000) \
166     v(int32, thresholdForOptimizeSoon, 1000) \
167     v(int32, executionCounterIncrementForLoop, 1) \
168     v(int32, executionCounterIncrementForEntry, 15) \
169     \
170     v(int32, thresholdForFTLOptimizeAfterWarmUp, 25000) \
171     v(int32, thresholdForFTLOptimizeSoon, 1000) \
172     v(int32, ftlTierUpCounterIncrementForLoop, 1) \
173     v(int32, ftlTierUpCounterIncrementForReturn, 15) \
174     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15) \
175     \
176     v(int32, evalThresholdMultiplier, 10) \
177     \
178     v(bool, randomizeExecutionCountsBetweenCheckpoints, false) \
179     v(int32, maximumExecutionCountsBetweenCheckpoints, 1000) \
180     \
181     v(unsigned, likelyToTakeSlowCaseMinimumCount, 100) \
182     v(unsigned, couldTakeSlowCaseMinimumCount, 10) \
183     \
184     v(unsigned, osrExitCountForReoptimization, 100) \
185     v(unsigned, osrExitCountForReoptimizationFromLoop, 5) \
186     \
187     v(unsigned, reoptimizationRetryCounterMax, 0)  \
188     v(unsigned, reoptimizationRetryCounterStep, 1) \
189     \
190     v(unsigned, minimumOptimizationDelay, 1) \
191     v(unsigned, maximumOptimizationDelay, 5) \
192     v(double, desiredProfileLivenessRate, 0.75) \
193     v(double, desiredProfileFullnessRate, 0.35) \
194     \
195     v(double, doubleVoteRatioForDoubleFormat, 2) \
196     v(double, structureCheckVoteRatioForHoisting, 1) \
197     v(double, checkArrayVoteRatioForHoisting, 1) \
198     \
199     v(unsigned, minimumNumberOfScansBetweenRebalance, 100) \
200     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(7)) \
201     v(unsigned, opaqueRootMergeThreshold, 1000) \
202     v(double, minHeapUtilization, 0.8) \
203     v(double, minCopiedBlockUtilization, 0.9) \
204     \
205     v(bool, forceWeakRandomSeed, false) \
206     v(unsigned, forcedWeakRandomSeed, 0) \
207     \
208     v(bool, useZombieMode, false) \
209     v(bool, objectsAreImmortal, false) \
210     v(bool, showObjectStatistics, false) \
211     \
212     v(bool, logGC, false) \
213     v(unsigned, gcMaxHeapSize, 0) \
214     v(bool, recordGCPauseTimes, false) \
215     v(bool, logHeapStatisticsAtExit, false)
216
217 class Options {
218 public:
219     // This typedef is to allow us to eliminate the '_' in the field name in
220     // union inside Entry. This is needed to keep the style checker happy.
221     typedef int32_t int32;
222
223     // Declare the option IDs:
224     enum OptionID {
225 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
226         OPT_##name_,
227         JSC_OPTIONS(FOR_EACH_OPTION)
228 #undef FOR_EACH_OPTION
229         numberOfOptions
230     };
231
232
233     static void initialize();
234
235     // Parses a single command line option in the format "<optionName>=<value>"
236     // (no spaces allowed) and set the specified option if appropriate.
237     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
238     JS_EXPORT_PRIVATE static void dumpAllOptions(FILE* stream = stdout);
239     static void dumpOption(OptionID id, FILE* stream = stdout, const char* header = "", const char* footer = "");
240
241     // Declare accessors for each option:
242 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
243     ALWAYS_INLINE static type_& name_() { return s_options[OPT_##name_].u.type_##Val; }
244
245     JSC_OPTIONS(FOR_EACH_OPTION)
246 #undef FOR_EACH_OPTION
247
248 private:
249     enum EntryType {
250         boolType,
251         unsignedType,
252         doubleType,
253         int32Type,
254         optionRangeType,
255     };
256
257     // For storing for an option value:
258     struct Entry {
259         union {
260             bool boolVal;
261             unsigned unsignedVal;
262             double doubleVal;
263             int32 int32Val;
264             OptionRange optionRangeVal;
265         } u;
266     };
267
268     // For storing constant meta data about each option:
269     struct EntryInfo {
270         const char* name;
271         EntryType type;
272     };
273
274     Options();
275
276     // Declare the options:
277 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
278     type_ m_##name_;
279     JSC_OPTIONS(FOR_EACH_OPTION)
280 #undef FOR_EACH_OPTION
281
282     // Declare the singleton instance of the options store:
283     JS_EXPORTDATA static Entry s_options[numberOfOptions];
284     static const EntryInfo s_optionsInfo[numberOfOptions];
285 };
286
287 } // namespace JSC
288
289 #endif // Options_h