Reland r216808, underlying lldb bug has been fixed.
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.h
1 /*
2  * Copyright (C) 2011-2017 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 #pragma once
27
28 #include "GCLogging.h"
29 #include "JSExportMacros.h"
30 #include <stdint.h>
31 #include <stdio.h>
32 #include <wtf/PrintStream.h>
33 #include <wtf/StdLibExtras.h>
34
35 namespace WTF {
36 class StringBuilder;
37 }
38 using WTF::StringBuilder;
39
40 namespace JSC {
41
42 // How do JSC VM options work?
43 // ===========================
44 // The JSC_OPTIONS() macro below defines a list of all JSC options in use,
45 // along with their types and default values. The options values are actually
46 // realized as an array of Options::Entry elements.
47 //
48 //     Options::initialize() will initialize the array of options values with
49 // the defaults specified in JSC_OPTIONS() below. After that, the values can
50 // be programmatically read and written to using an accessor method with the
51 // same name as the option. For example, the option "useJIT" can be read and
52 // set like so:
53 //
54 //     bool jitIsOn = Options::useJIT();  // Get the option value.
55 //     Options::useJIT() = false;         // Sets the option value.
56 //
57 //     If you want to tweak any of these values programmatically for testing
58 // purposes, you can do so in Options::initialize() after the default values
59 // are set.
60 //
61 //     Alternatively, you can override the default values by specifying
62 // environment variables of the form: JSC_<name of JSC option>.
63 //
64 // Note: Options::initialize() tries to ensure some sanity on the option values
65 // which are set by doing some range checks, and value corrections. These
66 // checks are done after the option values are set. If you alter the option
67 // values after the sanity checks (for your own testing), then you're liable to
68 // ensure that the new values set are sane and reasonable for your own run.
69
70 class OptionRange {
71 private:
72     enum RangeState { Uninitialized, InitError, Normal, Inverted };
73 public:
74     OptionRange& operator= (const int& rhs)
75     { // Only needed for initialization
76         if (!rhs) {
77             m_state = Uninitialized;
78             m_rangeString = 0;
79             m_lowLimit = 0;
80             m_highLimit = 0;
81         }
82         return *this;
83     }
84
85     bool init(const char*);
86     bool isInRange(unsigned);
87     const char* rangeString() const { return (m_state > InitError) ? m_rangeString : s_nullRangeStr; }
88     
89     void dump(PrintStream& out) const;
90
91 private:
92     static const char* const s_nullRangeStr;
93
94     RangeState m_state;
95     const char* m_rangeString;
96     unsigned m_lowLimit;
97     unsigned m_highLimit;
98 };
99
100 typedef OptionRange optionRange;
101 typedef const char* optionString;
102
103 #if PLATFORM(IOS)
104 #define MAXIMUM_NUMBER_OF_FTL_COMPILER_THREADS 2
105 #else
106 #define MAXIMUM_NUMBER_OF_FTL_COMPILER_THREADS 8
107 #endif
108
109 #define JSC_OPTIONS(v) \
110     v(bool, validateOptions, false, Normal, "crashes if mis-typed JSC options were passed to the VM") \
111     v(unsigned, dumpOptions, 0, Normal, "dumps JSC options (0 = None, 1 = Overridden only, 2 = All, 3 = Verbose)") \
112     v(optionString, configFile, nullptr, Normal, "file to configure JSC options and logging location") \
113     \
114     v(bool, useLLInt,  true, Normal, "allows the LLINT to be used if true") \
115     v(bool, useJIT,    true, Normal, "allows the baseline JIT to be used if true") \
116     v(bool, useDFGJIT, true, Normal, "allows the DFG JIT to be used if true") \
117     v(bool, useRegExpJIT, true, Normal, "allows the RegExp JIT to be used if true") \
118     v(bool, useDOMJIT, true, Normal, "allows the DOMJIT to be used if true") \
119     \
120     v(bool, reportMustSucceedExecutableAllocations, false, Normal, nullptr) \
121     \
122     v(unsigned, maxPerThreadStackUsage, 4 * MB, Normal, "Max allowed stack usage by the VM") \
123     v(unsigned, softReservedZoneSize, 128 * KB, Normal, "A buffer greater than reservedZoneSize that reserves space for stringifying exceptions.") \
124     v(unsigned, reservedZoneSize, 64 * KB, Normal, "The amount of stack space we guarantee to our clients (and to interal VM code that does not call out to clients).") \
125     \
126     v(bool, crashIfCantAllocateJITMemory, false, Normal, nullptr) \
127     v(unsigned, jitMemoryReservationSize, 0, Normal, "Set this number to change the executable allocation size in ExecutableAllocatorFixedVMPool. (In bytes.)") \
128     v(bool, useSeparatedWXHeap, false, Normal, nullptr) \
129     \
130     v(bool, forceCodeBlockLiveness, false, Normal, nullptr) \
131     v(bool, forceICFailure, false, Normal, nullptr) \
132     \
133     v(unsigned, repatchCountForCoolDown, 8, Normal, nullptr) \
134     v(unsigned, initialCoolDownCount, 20, Normal, nullptr) \
135     v(unsigned, repatchBufferingCountdown, 8, Normal, nullptr) \
136     \
137     v(bool, dumpGeneratedBytecodes, false, Normal, nullptr) \
138     v(bool, dumpBytecodeLivenessResults, false, Normal, nullptr) \
139     v(bool, validateBytecode, false, Normal, nullptr) \
140     v(bool, forceDebuggerBytecodeGeneration, false, Normal, nullptr) \
141     v(bool, dumpBytecodesBeforeGeneratorification, false, Normal, nullptr) \
142     \
143     v(bool, useFunctionDotArguments, true, Normal, nullptr) \
144     v(bool, useTailCalls, true, Normal, nullptr) \
145     v(bool, alwaysUseShadowChicken, false, Normal, nullptr) \
146     v(unsigned, shadowChickenLogSize, 1000, Normal, nullptr) \
147     v(unsigned, shadowChickenMaxTailDeletedFramesSize, 128, Normal, nullptr) \
148     \
149     /* dumpDisassembly implies dumpDFGDisassembly. */ \
150     v(bool, dumpDisassembly, false, Normal, "dumps disassembly of all JIT compiled code upon compilation") \
151     v(bool, asyncDisassembly, false, Normal, nullptr) \
152     v(bool, dumpDFGDisassembly, false, Normal, "dumps disassembly of DFG function upon compilation") \
153     v(bool, dumpFTLDisassembly, false, Normal, "dumps disassembly of FTL function upon compilation") \
154     v(bool, dumpAllDFGNodes, false, Normal, nullptr) \
155     v(optionRange, bytecodeRangeToJITCompile, 0, Normal, "bytecode size range to allow compilation on, e.g. 1:100") \
156     v(optionRange, bytecodeRangeToDFGCompile, 0, Normal, "bytecode size range to allow DFG compilation on, e.g. 1:100") \
157     v(optionRange, bytecodeRangeToFTLCompile, 0, Normal, "bytecode size range to allow FTL compilation on, e.g. 1:100") \
158     v(optionString, jitWhitelist, nullptr, Normal, "file with list of function signatures to allow compilation on") \
159     v(optionString, dfgWhitelist, nullptr, Normal, "file with list of function signatures to allow DFG compilation on") \
160     v(optionString, ftlWhitelist, nullptr, Normal, "file with list of function signatures to allow FTL compilation on") \
161     v(bool, dumpSourceAtDFGTime, false, Normal, "dumps source code of JS function being DFG compiled") \
162     v(bool, dumpBytecodeAtDFGTime, false, Normal, "dumps bytecode of JS function being DFG compiled") \
163     v(bool, dumpGraphAfterParsing, false, Normal, nullptr) \
164     v(bool, dumpGraphAtEachPhase, false, Normal, nullptr) \
165     v(bool, dumpDFGGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase of DFG compilation (note this excludes DFG graphs during FTL compilation)") \
166     v(bool, dumpDFGFTLGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase of DFG compilation when compiling FTL code") \
167     v(bool, dumpB3GraphAtEachPhase, false, Normal, "dumps the B3 graph at each phase of compilation") \
168     v(bool, dumpAirGraphAtEachPhase, false, Normal, "dumps the Air graph at each phase of compilation") \
169     v(bool, verboseDFGByteCodeParsing, false, Normal, nullptr) \
170     v(bool, safepointBeforeEachPhase, true, Normal, nullptr) \
171     v(bool, verboseCompilation, false, Normal, nullptr) \
172     v(bool, verboseFTLCompilation, false, Normal, nullptr) \
173     v(bool, logCompilationChanges, false, Normal, nullptr) \
174     v(bool, printEachOSRExit, false, Normal, nullptr) \
175     v(bool, validateGraph, false, Normal, nullptr) \
176     v(bool, validateGraphAtEachPhase, false, Normal, nullptr) \
177     v(bool, verboseValidationFailure, false, Normal, nullptr) \
178     v(bool, verboseOSR, false, Normal, nullptr) \
179     v(bool, verboseFTLOSRExit, false, Normal, nullptr) \
180     v(bool, verboseCallLink, false, Normal, nullptr) \
181     v(bool, verboseCompilationQueue, false, Normal, nullptr) \
182     v(bool, reportCompileTimes, false, Normal, "dumps JS function signature and the time it took to compile in all tiers") \
183     v(bool, reportBaselineCompileTimes, false, Normal, "dumps JS function signature and the time it took to BaselineJIT compile") \
184     v(bool, reportDFGCompileTimes, false, Normal, "dumps JS function signature and the time it took to DFG and FTL compile") \
185     v(bool, reportFTLCompileTimes, false, Normal, "dumps JS function signature and the time it took to FTL compile") \
186     v(bool, reportDFGPhaseTimes, false, Normal, "dumps JS function name and the time is took for each DFG phase") \
187     v(bool, reportTotalCompileTimes, false, Normal, nullptr) \
188     v(bool, verboseExitProfile, false, Normal, nullptr) \
189     v(bool, verboseCFA, false, Normal, nullptr) \
190     v(bool, verboseFTLToJSThunk, false, Normal, nullptr) \
191     v(bool, verboseFTLFailure, false, Normal, nullptr) \
192     v(bool, alwaysComputeHash, false, Normal, nullptr) \
193     v(bool, testTheFTL, false, Normal, nullptr) \
194     v(bool, verboseSanitizeStack, false, Normal, nullptr) \
195     v(bool, useGenerationalGC, true, Normal, nullptr) \
196     v(bool, useConcurrentBarriers, true, Normal, nullptr) \
197     v(bool, useConcurrentGC, true, Normal, nullptr) \
198     v(bool, collectContinuously, false, Normal, nullptr) \
199     v(double, collectContinuouslyPeriodMS, 1, Normal, nullptr) \
200     v(bool, forceFencedBarrier, false, Normal, nullptr) \
201     v(bool, verboseVisitRace, false, Normal, nullptr) \
202     v(bool, optimizeParallelSlotVisitorsForStoppedMutator, false, Normal, nullptr) \
203     v(unsigned, largeHeapSize, 32 * 1024 * 1024, Normal, nullptr) \
204     v(unsigned, smallHeapSize, 1 * 1024 * 1024, Normal, nullptr) \
205     v(double, smallHeapRAMFraction, 0.25, Normal, nullptr) \
206     v(double, smallHeapGrowthFactor, 2, Normal, nullptr) \
207     v(double, mediumHeapRAMFraction, 0.5, Normal, nullptr) \
208     v(double, mediumHeapGrowthFactor, 1.5, Normal, nullptr) \
209     v(double, largeHeapGrowthFactor, 1.24, Normal, nullptr) \
210     v(double, criticalGCMemoryThreshold, 0.80, Normal, "percent memory in use the GC considers critical.  The collector is much more aggressive above this threshold") \
211     v(double, minimumMutatorUtilization, 0, Normal, nullptr) \
212     v(double, maximumMutatorUtilization, 0.7, Normal, nullptr) \
213     v(double, epsilonMutatorUtilization, 0.01, Normal, nullptr) \
214     v(double, concurrentGCMaxHeadroom, 1.5, Normal, nullptr) \
215     v(double, concurrentGCPeriodMS, 2, Normal, nullptr) \
216     v(bool, useStochasticMutatorScheduler, true, Normal, nullptr) \
217     v(double, minimumGCPauseMS, 0.3, Normal, nullptr) \
218     v(double, gcPauseScale, 0.3, Normal, nullptr) \
219     v(double, gcIncrementBytes, 10000, Normal, nullptr) \
220     v(double, gcIncrementMaxBytes, 100000, Normal, nullptr) \
221     v(double, gcIncrementScale, 0, Normal, nullptr) \
222     v(bool, scribbleFreeCells, false, Normal, nullptr) \
223     v(double, sizeClassProgression, 1.4, Normal, nullptr) \
224     v(unsigned, largeAllocationCutoff, 100000, Normal, nullptr) \
225     v(bool, dumpSizeClasses, false, Normal, nullptr) \
226     v(bool, useBumpAllocator, true, Normal, nullptr) \
227     v(bool, stealEmptyBlocksFromOtherAllocators, true, Normal, nullptr) \
228     v(bool, eagerlyUpdateTopCallFrame, false, Normal, nullptr) \
229     \
230     v(bool, useOSREntryToDFG, true, Normal, nullptr) \
231     v(bool, useOSREntryToFTL, true, Normal, nullptr) \
232     \
233     v(bool, useFTLJIT, true, Normal, "allows the FTL JIT to be used if true") \
234     v(bool, useFTLTBAA, true, Normal, nullptr) \
235     v(bool, validateFTLOSRExitLiveness, false, Normal, nullptr) \
236     v(unsigned, defaultB3OptLevel, 2, Normal, nullptr) \
237     v(bool, b3AlwaysFailsBeforeCompile, false, Normal, nullptr) \
238     v(bool, b3AlwaysFailsBeforeLink, false, Normal, nullptr) \
239     v(bool, ftlCrashes, false, Normal, nullptr) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
240     v(bool, clobberAllRegsInFTLICSlowPath, !ASSERT_DISABLED, Normal, nullptr) \
241     v(bool, useAccessInlining, true, Normal, nullptr) \
242     v(unsigned, maxAccessVariantListSize, 8, Normal, nullptr) \
243     v(bool, usePolyvariantDevirtualization, true, Normal, nullptr) \
244     v(bool, usePolymorphicAccessInlining, true, Normal, nullptr) \
245     v(bool, usePolymorphicCallInlining, true, Normal, nullptr) \
246     v(bool, usePolymorphicCallInliningForNonStubStatus, false, Normal, nullptr) \
247     v(unsigned, maxPolymorphicCallVariantListSize, 15, Normal, nullptr) \
248     v(unsigned, maxPolymorphicCallVariantListSizeForTopTier, 5, Normal, nullptr) \
249     v(unsigned, maxPolymorphicCallVariantListSizeForWebAssemblyToJS, 5, Normal, nullptr) \
250     v(unsigned, maxPolymorphicCallVariantsForInlining, 5, Normal, nullptr) \
251     v(unsigned, frequentCallThreshold, 2, Normal, nullptr) \
252     v(double, minimumCallToKnownRate, 0.51, Normal, nullptr) \
253     v(bool, createPreHeaders, true, Normal, nullptr) \
254     v(bool, useMovHintRemoval, true, Normal, nullptr) \
255     v(bool, usePutStackSinking, true, Normal, nullptr) \
256     v(bool, useObjectAllocationSinking, true, Normal, nullptr) \
257     v(bool, logExecutableAllocation, false, Normal, nullptr) \
258     \
259     v(bool, useConcurrentJIT, true, Normal, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
260     v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1, Normal, nullptr) \
261     v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(MAXIMUM_NUMBER_OF_FTL_COMPILER_THREADS, 2) - 1, Normal, nullptr) \
262     v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), Normal, nullptr) \
263     v(int32, priorityDeltaOfFTLCompilerThreads, computePriorityDeltaOfWorkerThreads(-2, 0), Normal, nullptr) \
264     v(int32, priorityDeltaOfWasmCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), Normal, nullptr) \
265     \
266     v(bool, useProfiler, false, Normal, nullptr) \
267     v(bool, disassembleBaselineForProfiler, true, Normal, nullptr) \
268     \
269     v(bool, useArchitectureSpecificOptimizations, true, Normal, nullptr) \
270     \
271     v(bool, breakOnThrow, false, Normal, nullptr) \
272     \
273     v(unsigned, maximumOptimizationCandidateInstructionCount, 100000, Normal, nullptr) \
274     \
275     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 180, Normal, nullptr) \
276     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 100, Normal, nullptr) \
277     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 100, Normal, nullptr) \
278     \
279     v(unsigned, maximumFTLCandidateInstructionCount, 20000, Normal, nullptr) \
280     \
281     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
282     v(unsigned, maximumInliningDepth, 5, Normal, "maximum allowed inlining depth.  Depth of 1 means no inlining") \
283     v(unsigned, maximumInliningRecursion, 2, Normal, nullptr) \
284     \
285     /* Maximum size of a caller for enabling inlining. This is purely to protect us */\
286     /* from super long compiles that take a lot of memory. */\
287     v(unsigned, maximumInliningCallerSize, 10000, Normal, nullptr) \
288     \
289     v(unsigned, maximumVarargsForInlining, 100, Normal, nullptr) \
290     \
291     v(bool, usePolyvariantCallInlining, true, Normal, nullptr) \
292     v(bool, usePolyvariantByIdInlining, true, Normal, nullptr) \
293     \
294     v(bool, useMaximalFlushInsertionPhase, false, Normal, "Setting to true allows the DFG's MaximalFlushInsertionPhase to run.") \
295     \
296     v(unsigned, maximumBinaryStringSwitchCaseLength, 50, Normal, nullptr) \
297     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000, Normal, nullptr) \
298     \
299     v(double, jitPolicyScale, 1.0, Normal, "scale JIT thresholds to this specified ratio between 0.0 (compile ASAP) and 1.0 (compile like normal).") \
300     v(bool, forceEagerCompilation, false, Normal, nullptr) \
301     v(int32, thresholdForJITAfterWarmUp, 500, Normal, nullptr) \
302     v(int32, thresholdForJITSoon, 100, Normal, nullptr) \
303     \
304     v(int32, thresholdForOptimizeAfterWarmUp, 1000, Normal, nullptr) \
305     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000, Normal, nullptr) \
306     v(int32, thresholdForOptimizeSoon, 1000, Normal, nullptr) \
307     v(int32, executionCounterIncrementForLoop, 1, Normal, nullptr) \
308     v(int32, executionCounterIncrementForEntry, 15, Normal, nullptr) \
309     \
310     v(int32, thresholdForFTLOptimizeAfterWarmUp, 100000, Normal, nullptr) \
311     v(int32, thresholdForFTLOptimizeSoon, 1000, Normal, nullptr) \
312     v(int32, ftlTierUpCounterIncrementForLoop, 1, Normal, nullptr) \
313     v(int32, ftlTierUpCounterIncrementForReturn, 15, Normal, nullptr) \
314     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15, Normal, nullptr) \
315     v(unsigned, ftlOSREntryRetryThreshold, 100, Normal, nullptr) \
316     \
317     v(int32, evalThresholdMultiplier, 10, Normal, nullptr) \
318     v(unsigned, maximumEvalCacheableSourceLength, 256, Normal, nullptr) \
319     \
320     v(bool, randomizeExecutionCountsBetweenCheckpoints, false, Normal, nullptr) \
321     v(int32, maximumExecutionCountsBetweenCheckpointsForBaseline, 1000, Normal, nullptr) \
322     v(int32, maximumExecutionCountsBetweenCheckpointsForUpperTiers, 50000, Normal, nullptr) \
323     \
324     v(unsigned, likelyToTakeSlowCaseMinimumCount, 20, Normal, nullptr) \
325     v(unsigned, couldTakeSlowCaseMinimumCount, 10, Normal, nullptr) \
326     \
327     v(unsigned, osrExitCountForReoptimization, 100, Normal, nullptr) \
328     v(unsigned, osrExitCountForReoptimizationFromLoop, 5, Normal, nullptr) \
329     \
330     v(unsigned, reoptimizationRetryCounterMax, 0, Normal, nullptr)  \
331     \
332     v(unsigned, minimumOptimizationDelay, 1, Normal, nullptr) \
333     v(unsigned, maximumOptimizationDelay, 5, Normal, nullptr) \
334     v(double, desiredProfileLivenessRate, 0.75, Normal, nullptr) \
335     v(double, desiredProfileFullnessRate, 0.35, Normal, nullptr) \
336     \
337     v(double, doubleVoteRatioForDoubleFormat, 2, Normal, nullptr) \
338     v(double, structureCheckVoteRatioForHoisting, 1, Normal, nullptr) \
339     v(double, checkArrayVoteRatioForHoisting, 1, Normal, nullptr) \
340     \
341     v(unsigned, maximumDirectCallStackSize, 200, Normal, nullptr) \
342     \
343     v(unsigned, minimumNumberOfScansBetweenRebalance, 100, Normal, nullptr) \
344     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(8), Normal, nullptr) \
345     v(unsigned, opaqueRootMergeThreshold, 1000, Normal, nullptr) \
346     v(double, minHeapUtilization, 0.8, Normal, nullptr) \
347     v(double, minMarkedBlockUtilization, 0.9, Normal, nullptr) \
348     v(unsigned, slowPathAllocsBetweenGCs, 0, Normal, "force a GC on every Nth slow path alloc, where N is specified by this option") \
349     \
350     v(double, percentCPUPerMBForFullTimer, 0.0003125, Normal, nullptr) \
351     v(double, percentCPUPerMBForEdenTimer, 0.0025, Normal, nullptr) \
352     v(double, collectionTimerMaxPercentCPU, 0.05, Normal, nullptr) \
353     \
354     v(bool, forceWeakRandomSeed, false, Normal, nullptr) \
355     v(unsigned, forcedWeakRandomSeed, 0, Normal, nullptr) \
356     \
357     v(bool, useZombieMode, false, Normal, "debugging option to scribble over dead objects with 0xbadbeef0") \
358     v(bool, useImmortalObjects, false, Normal, "debugging option to keep all objects alive forever") \
359     v(bool, sweepSynchronously, false, Normal, "debugging option to sweep all dead objects synchronously at GC end before resuming mutator") \
360     v(unsigned, maxSingleAllocationSize, 0, Configurable, "debugging option to limit individual allocations to a max size (0 = limit not set, N = limit size in bytes)") \
361     \
362     v(gcLogLevel, logGC, GCLogging::None, Normal, "debugging option to log GC activity (0 = None, 1 = Basic, 2 = Verbose)") \
363     v(bool, useGC, true, Normal, nullptr) \
364     v(bool, gcAtEnd, false, Normal, "If true, the jsc CLI will do a GC before exiting") \
365     v(bool, forceGCSlowPaths, false, Normal, "If true, we will force all JIT fast allocations down their slow paths.")\
366     v(unsigned, gcMaxHeapSize, 0, Normal, nullptr) \
367     v(unsigned, forceRAMSize, 0, Normal, nullptr) \
368     v(bool, recordGCPauseTimes, false, Normal, nullptr) \
369     v(bool, logHeapStatisticsAtExit, false, Normal, nullptr) \
370     v(bool, forceCodeBlockToJettisonDueToOldAge, false, Normal, "If true, this means that anytime we can jettison a CodeBlock due to old age, we do.") \
371     v(bool, useEagerCodeBlockJettisonTiming, false, Normal, "If true, the time slices for jettisoning a CodeBlock due to old age are shrunk significantly.") \
372     \
373     v(bool, useTypeProfiler, false, Normal, nullptr) \
374     v(bool, useControlFlowProfiler, false, Normal, nullptr) \
375     \
376     v(bool, useSamplingProfiler, false, Normal, nullptr) \
377     v(unsigned, sampleInterval, 1000, Normal, "Time between stack traces in microseconds.") \
378     v(bool, collectSamplingProfilerDataForJSCShell, false, Normal, "This corresponds to the JSC shell's --sample option.") \
379     v(unsigned, samplingProfilerTopFunctionsCount, 12, Normal, "Number of top functions to report when using the command line interface.") \
380     v(unsigned, samplingProfilerTopBytecodesCount, 40, Normal, "Number of top bytecodes to report when using the command line interface.") \
381     v(optionString, samplingProfilerPath, nullptr, Normal, "The path to the directory to write sampiling profiler output to. This probably will not work with WK2 unless the path is in the whitelist.") \
382     v(bool, sampleCCode, false, Normal, "Causes the sampling profiler to record profiling data for C frames.") \
383     \
384     v(bool, alwaysGeneratePCToCodeOriginMap, false, Normal, "This will make sure we always generate a PCToCodeOriginMap for JITed code.") \
385     \
386     v(bool, verifyHeap, false, Normal, nullptr) \
387     v(unsigned, numberOfGCCyclesToRecordForVerification, 3, Normal, nullptr) \
388     \
389     v(unsigned, exceptionStackTraceLimit, 100, Normal, "Stack trace limit for internal Exception object") \
390     v(unsigned, defaultErrorStackTraceLimit, 100, Normal, "The default value for Error.stackTraceLimit") \
391     v(bool, useExceptionFuzz, false, Normal, nullptr) \
392     v(unsigned, fireExceptionFuzzAt, 0, Normal, nullptr) \
393     v(bool, validateDFGExceptionHandling, false, Normal, "Causes the DFG to emit code validating exception handling for each node that can exit") /* This is true by default on Debug builds */\
394     v(bool, dumpSimulatedThrows, false, Normal, "Dumps the call stack at each simulated throw for exception scope verification") \
395     v(bool, validateExceptionChecks, false, Normal, "Verifies that needed exception checks are performed.") \
396     v(unsigned, unexpectedExceptionStackTraceLimit, 100, Normal, "Stack trace limit for debugging unexpected exceptions observed in the VM") \
397     \
398     v(bool, useExecutableAllocationFuzz, false, Normal, nullptr) \
399     v(unsigned, fireExecutableAllocationFuzzAt, 0, Normal, nullptr) \
400     v(unsigned, fireExecutableAllocationFuzzAtOrAfter, 0, Normal, nullptr) \
401     v(bool, verboseExecutableAllocationFuzz, false, Normal, nullptr) \
402     \
403     v(bool, useOSRExitFuzz, false, Normal, nullptr) \
404     v(unsigned, fireOSRExitFuzzAtStatic, 0, Normal, nullptr) \
405     v(unsigned, fireOSRExitFuzzAt, 0, Normal, nullptr) \
406     v(unsigned, fireOSRExitFuzzAtOrAfter, 0, Normal, nullptr) \
407     \
408     v(bool, logB3PhaseTimes, false, Normal, nullptr) \
409     v(double, rareBlockPenalty, 0.001, Normal, nullptr) \
410     v(bool, airLinearScanVerbose, false, Normal, nullptr) \
411     v(bool, airLinearScanSpillsEverything, false, Normal, nullptr) \
412     v(bool, airForceBriggsAllocator, false, Normal, nullptr) \
413     v(bool, airForceIRCAllocator, false, Normal, nullptr) \
414     v(bool, coalesceSpillSlots, true, Normal, nullptr) \
415     v(bool, logAirRegisterPressure, false, Normal, nullptr) \
416     v(unsigned, maxB3TailDupBlockSize, 3, Normal, nullptr) \
417     v(unsigned, maxB3TailDupBlockSuccessors, 3, Normal, nullptr) \
418     \
419     v(bool, useDollarVM, false, Restricted, "installs the $vm debugging tool in global objects") \
420     v(optionString, functionOverrides, nullptr, Restricted, "file with debugging overrides for function bodies") \
421     v(bool, useSigillCrashAnalyzer, false, Configurable, "logs data about SIGILL crashes") \
422     \
423     v(unsigned, watchdog, 0, Normal, "watchdog timeout (0 = Disabled, N = a timeout period of N milliseconds)") \
424     v(bool, usePollingTraps, false, Normal, "use polling (instead of signalling) VM traps") \
425     \
426     v(bool, useMachForExceptions, true, Normal, "Use mach exceptions rather than signals to handle faults and pass thread messages. (This does nothing on platforms without mach)") \
427     \
428     v(bool, useICStats, false, Normal, nullptr) \
429     \
430     v(unsigned, prototypeHitCountForLLIntCaching, 2, Normal, "Number of prototype property hits before caching a prototype in the LLInt. A count of 0 means never cache.") \
431     \
432     v(bool, dumpModuleRecord, false, Normal, nullptr) \
433     v(bool, dumpModuleLoadingState, false, Normal, nullptr) \
434     v(bool, exposeInternalModuleLoader, false, Normal, "expose the internal module loader object to the global space for debugging") \
435     \
436     v(bool, useSuperSampler, false, Normal, nullptr) \
437     \
438     v(bool, reportLLIntStats, false, Configurable, "Reports LLInt statistics") \
439     v(optionString, llintStatsFile, nullptr, Configurable, "File to collect LLInt statistics in") \
440     \
441     v(bool, useSourceProviderCache, true, Normal, "If false, the parser will not use the source provider cache. It's good to verify everything works when this is false. Because the cache is so successful, it can mask bugs.") \
442     v(bool, useCodeCache, true, Normal, "If false, the unlinked byte code cache will not be used.") \
443     \
444     v(bool, useWebAssembly, true, Normal, "Expose the WebAssembly global object.") \
445     \
446     v(bool, failToCompileWebAssemblyCode, false, Normal, "If true, no Wasm::Plan will sucessfully compile a function.") \
447     v(size, webAssemblyPartialCompileLimit, 5000, Normal, "Limit on the number of bytes a Wasm::Plan::compile should attempt before checking for other work.") \
448     v(unsigned, webAssemblyBBQOptimizationLevel, 1, Normal, "B3 Optimization level for BBQ Web Assembly module compilations.") \
449     v(unsigned, webAssemblyOMGOptimizationLevel, Options::defaultB3OptLevel(), Normal, "B3 Optimization level for OMG Web Assembly module compilations.") \
450     \
451     v(bool, useBBQTierUpChecks, true, Normal, "Enables tier up checks for our BBQ code.") \
452     v(unsigned, webAssemblyOMGTierUpCount, 5000, Normal, "The countdown before we tier up a function to OMG.") \
453     v(unsigned, webAssemblyLoopDecrement, 15, Normal, "The amount the tier up countdown is decremented on each loop backedge.") \
454     v(unsigned, webAssemblyFunctionEntryDecrement, 1, Normal, "The amount the tier up countdown is decremented on each function entry.") \
455     \
456     /* FIXME: enable fast memories on iOS and pre-allocate them. https://bugs.webkit.org/show_bug.cgi?id=170774 */ \
457     v(bool, useWebAssemblyFastMemory, !isIOS(), Normal, "If true, we will try to use a 32-bit address space with a signal handler to bounds check wasm memory.") \
458     v(unsigned, webAssemblyFastMemoryRedzonePages, 128, Normal, "WebAssembly fast memories use 4GiB virtual allocations, plus a redzone (counted as multiple of 64KiB WebAssembly pages) at the end to catch reg+imm accesses which exceed 32-bit, anything beyond the redzone is explicitly bounds-checked") \
459     v(bool, crashIfWebAssemblyCantFastMemory, false, Normal, "If true, we will crash if we can't obtain fast memory for wasm.") \
460     v(unsigned, webAssemblyFastMemoryPreallocateCount, 0, Normal, "WebAssembly fast memories can be pre-allocated at program startup and remain cached to avoid fragmentation leading to bounds-checked memory. This number is an upper bound on initial allocation as well as total count of fast memories. Zero means no pre-allocation, no caching, and no limit to the number of runtime allocations.") \
461     v(bool, useWebAssemblyFastTLS, true, Normal, "If true, we will try to use fast thread-local storage if available on the current platform.") \
462     v(bool, useFastTLSForWasmContext, true, Normal, "If true (and fast TLS is enabled), we will store context in fast TLS. If false, we will pin it to a register.") \
463     v(bool, useCallICsForWebAssemblyToJSCalls, true, Normal, "If true, we will use CallLinkInfo to inline cache Wasm to JS calls.")
464
465
466 enum OptionEquivalence {
467     SameOption,
468     InvertedOption,
469 };
470
471 #define JSC_ALIASED_OPTIONS(v) \
472     v(enableFunctionDotArguments, useFunctionDotArguments, SameOption) \
473     v(enableTailCalls, useTailCalls, SameOption) \
474     v(showDisassembly, dumpDisassembly, SameOption) \
475     v(showDFGDisassembly, dumpDFGDisassembly, SameOption) \
476     v(showFTLDisassembly, dumpFTLDisassembly, SameOption) \
477     v(showAllDFGNodes, dumpAllDFGNodes, SameOption) \
478     v(alwaysDoFullCollection, useGenerationalGC, InvertedOption) \
479     v(enableOSREntryToDFG, useOSREntryToDFG, SameOption) \
480     v(enableOSREntryToFTL, useOSREntryToFTL, SameOption) \
481     v(enableAccessInlining, useAccessInlining, SameOption) \
482     v(enablePolyvariantDevirtualization, usePolyvariantDevirtualization, SameOption) \
483     v(enablePolymorphicAccessInlining, usePolymorphicAccessInlining, SameOption) \
484     v(enablePolymorphicCallInlining, usePolymorphicCallInlining, SameOption) \
485     v(enableMovHintRemoval, useMovHintRemoval, SameOption) \
486     v(enableObjectAllocationSinking, useObjectAllocationSinking, SameOption) \
487     v(enableConcurrentJIT, useConcurrentJIT, SameOption) \
488     v(enableProfiler, useProfiler, SameOption) \
489     v(enableArchitectureSpecificOptimizations, useArchitectureSpecificOptimizations, SameOption) \
490     v(enablePolyvariantCallInlining, usePolyvariantCallInlining, SameOption) \
491     v(enablePolyvariantByIdInlining, usePolyvariantByIdInlining, SameOption) \
492     v(enableMaximalFlushInsertionPhase, useMaximalFlushInsertionPhase, SameOption) \
493     v(objectsAreImmortal, useImmortalObjects, SameOption) \
494     v(showObjectStatistics, dumpObjectStatistics, SameOption) \
495     v(disableGC, useGC, InvertedOption) \
496     v(enableTypeProfiler, useTypeProfiler, SameOption) \
497     v(enableControlFlowProfiler, useControlFlowProfiler, SameOption) \
498     v(enableExceptionFuzz, useExceptionFuzz, SameOption) \
499     v(enableExecutableAllocationFuzz, useExecutableAllocationFuzz, SameOption) \
500     v(enableOSRExitFuzz, useOSRExitFuzz, SameOption) \
501     v(enableDollarVM, useDollarVM, SameOption) \
502     v(enableWebAssembly, useWebAssembly, SameOption) \
503
504 class Options {
505 public:
506     enum class DumpLevel {
507         None = 0,
508         Overridden,
509         All,
510         Verbose
511     };
512
513     enum class Availability {
514         Normal = 0,
515         Restricted,
516         Configurable
517     };
518
519     // This typedef is to allow us to eliminate the '_' in the field name in
520     // union inside Entry. This is needed to keep the style checker happy.
521     typedef int32_t int32;
522     typedef size_t size;
523
524     // Declare the option IDs:
525     enum ID {
526 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
527         name_##ID,
528         JSC_OPTIONS(FOR_EACH_OPTION)
529 #undef FOR_EACH_OPTION
530         numberOfOptions
531     };
532
533     enum class Type {
534         boolType,
535         unsignedType,
536         doubleType,
537         int32Type,
538         sizeType,
539         optionRangeType,
540         optionStringType,
541         gcLogLevelType,
542     };
543
544     JS_EXPORT_PRIVATE static void initialize();
545
546     // Parses a string of options where each option is of the format "--<optionName>=<value>"
547     // and are separated by a space. The leading "--" is optional and will be ignored.
548     JS_EXPORT_PRIVATE static bool setOptions(const char* optionsList);
549
550     // Parses a single command line option in the format "<optionName>=<value>"
551     // (no spaces allowed) and set the specified option if appropriate.
552     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
553
554     JS_EXPORT_PRIVATE static void dumpAllOptions(FILE*, DumpLevel, const char* title = nullptr);
555     JS_EXPORT_PRIVATE static void dumpAllOptionsInALine(StringBuilder&);
556
557     JS_EXPORT_PRIVATE static void ensureOptionsAreCoherent();
558
559     JS_EXPORT_PRIVATE static void enableRestrictedOptions(bool enableOrNot);
560
561     // Declare accessors for each option:
562 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
563     ALWAYS_INLINE static type_& name_() { return s_options[name_##ID].type_##Val; } \
564     ALWAYS_INLINE static type_& name_##Default() { return s_defaultOptions[name_##ID].type_##Val; }
565
566     JSC_OPTIONS(FOR_EACH_OPTION)
567 #undef FOR_EACH_OPTION
568
569     static bool isAvailable(ID, Availability);
570
571 private:
572     // For storing for an option value:
573     union Entry {
574         bool boolVal;
575         unsigned unsignedVal;
576         double doubleVal;
577         int32 int32Val;
578         size sizeVal;
579         OptionRange optionRangeVal;
580         const char* optionStringVal;
581         GCLogging::Level gcLogLevelVal;
582     };
583
584     // For storing constant meta data about each option:
585     struct EntryInfo {
586         const char* name;
587         const char* description;
588         Type type;
589         Availability availability;
590     };
591
592     Options();
593
594     enum DumpDefaultsOption {
595         DontDumpDefaults,
596         DumpDefaults
597     };
598     static void dumpOptionsIfNeeded();
599     static void dumpAllOptions(StringBuilder&, DumpLevel, const char* title,
600         const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
601     static void dumpOption(StringBuilder&, DumpLevel, ID,
602         const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
603
604     static bool setOptionWithoutAlias(const char* arg);
605     static bool setAliasedOption(const char* arg);
606     static bool overrideAliasedOptionWithHeuristic(const char* name);
607
608     // Declare the singleton instance of the options store:
609     JS_EXPORTDATA static Entry s_options[numberOfOptions];
610     static Entry s_defaultOptions[numberOfOptions];
611     static const EntryInfo s_optionsInfo[numberOfOptions];
612
613     friend class Option;
614 };
615
616 class Option {
617 public:
618     Option(Options::ID id)
619         : m_id(id)
620         , m_entry(Options::s_options[m_id])
621     {
622     }
623     
624     void dump(StringBuilder&) const;
625
626     bool operator==(const Option& other) const;
627     bool operator!=(const Option& other) const { return !(*this == other); }
628     
629     Options::ID id() const { return m_id; }
630     const char* name() const;
631     const char* description() const;
632     Options::Type type() const;
633     Options::Availability availability() const;
634     bool isOverridden() const;
635     const Option defaultOption() const;
636     
637     bool& boolVal();
638     unsigned& unsignedVal();
639     double& doubleVal();
640     int32_t& int32Val();
641     OptionRange optionRangeVal();
642     const char* optionStringVal();
643     GCLogging::Level& gcLogLevelVal();
644     
645 private:
646     // Only used for constructing default Options.
647     Option(Options::ID id, Options::Entry& entry)
648         : m_id(id)
649         , m_entry(entry)
650     {
651     }
652     
653     Options::ID m_id;
654     Options::Entry& m_entry;
655 };
656
657 inline const char* Option::name() const
658 {
659     return Options::s_optionsInfo[m_id].name;
660 }
661
662 inline const char* Option::description() const
663 {
664     return Options::s_optionsInfo[m_id].description;
665 }
666
667 inline Options::Type Option::type() const
668 {
669     return Options::s_optionsInfo[m_id].type;
670 }
671
672 inline Options::Availability Option::availability() const
673 {
674     return Options::s_optionsInfo[m_id].availability;
675 }
676
677 inline bool Option::isOverridden() const
678 {
679     return *this != defaultOption();
680 }
681
682 inline const Option Option::defaultOption() const
683 {
684     return Option(m_id, Options::s_defaultOptions[m_id]);
685 }
686
687 inline bool& Option::boolVal()
688 {
689     return m_entry.boolVal;
690 }
691
692 inline unsigned& Option::unsignedVal()
693 {
694     return m_entry.unsignedVal;
695 }
696
697 inline double& Option::doubleVal()
698 {
699     return m_entry.doubleVal;
700 }
701
702 inline int32_t& Option::int32Val()
703 {
704     return m_entry.int32Val;
705 }
706
707 inline OptionRange Option::optionRangeVal()
708 {
709     return m_entry.optionRangeVal;
710 }
711
712 inline const char* Option::optionStringVal()
713 {
714     return m_entry.optionStringVal;
715 }
716
717 inline GCLogging::Level& Option::gcLogLevelVal()
718 {
719     return m_entry.gcLogLevelVal;
720 }
721
722 } // namespace JSC