Hook up ShadowChicken to the debugger to show tail deleted frames
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.h
1 /*
2  * Copyright (C) 2011-2016 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 "GCLogging.h"
30 #include "JSExportMacros.h"
31 #include <stdint.h>
32 #include <stdio.h>
33 #include <wtf/PrintStream.h>
34 #include <wtf/StdLibExtras.h>
35
36 namespace WTF {
37 class StringBuilder;
38 }
39 using WTF::StringBuilder;
40
41 namespace JSC {
42
43 // How do JSC VM options work?
44 // ===========================
45 // The JSC_OPTIONS() macro below defines a list of all JSC options in use,
46 // along with their types and default values. The options values are actually
47 // realized as an array of Options::Entry elements.
48 //
49 //     Options::initialize() will initialize the array of options values with
50 // the defaults specified in JSC_OPTIONS() below. After that, the values can
51 // be programmatically read and written to using an accessor method with the
52 // same name as the option. For example, the option "useJIT" can be read and
53 // set like so:
54 //
55 //     bool jitIsOn = Options::useJIT();  // Get the option value.
56 //     Options::useJIT() = false;         // Sets the option value.
57 //
58 //     If you want to tweak any of these values programmatically for testing
59 // purposes, you can do so in Options::initialize() after the default values
60 // are set.
61 //
62 //     Alternatively, you can override the default values by specifying
63 // environment variables of the form: JSC_<name of JSC option>.
64 //
65 // Note: Options::initialize() tries to ensure some sanity on the option values
66 // which are set by doing some range checks, and value corrections. These
67 // checks are done after the option values are set. If you alter the option
68 // values after the sanity checks (for your own testing), then you're liable to
69 // ensure that the new values set are sane and reasonable for your own run.
70
71 class OptionRange {
72 private:
73     enum RangeState { Uninitialized, InitError, Normal, Inverted };
74 public:
75     OptionRange& operator= (const int& rhs)
76     { // Only needed for initialization
77         if (!rhs) {
78             m_state = Uninitialized;
79             m_rangeString = 0;
80             m_lowLimit = 0;
81             m_highLimit = 0;
82         }
83         return *this;
84     }
85
86     bool init(const char*);
87     bool isInRange(unsigned);
88     const char* rangeString() const { return (m_state > InitError) ? m_rangeString : s_nullRangeStr; }
89     
90     void dump(PrintStream& out) const;
91
92 private:
93     static const char* const s_nullRangeStr;
94
95     RangeState m_state;
96     const char* m_rangeString;
97     unsigned m_lowLimit;
98     unsigned m_highLimit;
99 };
100
101 typedef OptionRange optionRange;
102 typedef const char* optionString;
103
104 #define JSC_OPTIONS(v) \
105     v(bool, validateOptions, false, Normal, "crashes if mis-typed JSC options were passed to the VM") \
106     v(unsigned, dumpOptions, 0, Normal, "dumps JSC options (0 = None, 1 = Overridden only, 2 = All, 3 = Verbose)") \
107     \
108     v(bool, useLLInt,  true, Normal, "allows the LLINT to be used if true") \
109     v(bool, useJIT,    true, Normal, "allows the baseline JIT to be used if true") \
110     v(bool, useDFGJIT, true, Normal, "allows the DFG JIT to be used if true") \
111     v(bool, useRegExpJIT, true, Normal, "allows the RegExp JIT to be used if true") \
112     \
113     v(bool, reportMustSucceedExecutableAllocations, false, Normal, nullptr) \
114     \
115     v(unsigned, maxPerThreadStackUsage, 4 * MB, Normal, nullptr) \
116     v(unsigned, reservedZoneSize, 128 * KB, Normal, nullptr) \
117     v(unsigned, errorModeReservedZoneSize, 64 * KB, Normal, nullptr) \
118     \
119     v(bool, crashIfCantAllocateJITMemory, false, Normal, nullptr) \
120     v(unsigned, jitMemoryReservationSize, 0, Normal, "Set this number to change the executable allocation size in ExecutableAllocatorFixedVMPool. (In bytes.)") \
121     v(bool, useSeparatedWXHeap, false, Normal, nullptr) \
122     \
123     v(bool, forceCodeBlockLiveness, false, Normal, nullptr) \
124     v(bool, forceICFailure, false, Normal, nullptr) \
125     \
126     v(unsigned, repatchCountForCoolDown, 8, Normal, nullptr) \
127     v(unsigned, initialCoolDownCount, 20, Normal, nullptr) \
128     v(unsigned, repatchBufferingCountdown, 8, Normal, nullptr) \
129     \
130     v(bool, dumpGeneratedBytecodes, false, Normal, nullptr) \
131     v(bool, dumpBytecodeLivenessResults, false, Normal, nullptr) \
132     v(bool, validateBytecode, false, Normal, nullptr) \
133     v(bool, forceDebuggerBytecodeGeneration, false, Normal, nullptr) \
134     v(bool, forceProfilerBytecodeGeneration, false, Normal, nullptr) \
135     \
136     v(bool, useFunctionDotArguments, true, Normal, nullptr) \
137     v(bool, useTailCalls, true, Normal, nullptr) \
138     v(bool, alwaysUseShadowChicken, false, Normal, nullptr) \
139     v(unsigned, shadowChickenLogSize, 1000, Normal, nullptr) \
140     v(unsigned, shadowChickenMaxTailDeletedFramesSize, 128, Normal, nullptr) \
141     \
142     /* dumpDisassembly implies dumpDFGDisassembly. */ \
143     v(bool, dumpDisassembly, false, Normal, "dumps disassembly of all JIT compiled code upon compilation") \
144     v(bool, asyncDisassembly, false, Normal, nullptr) \
145     v(bool, dumpDFGDisassembly, false, Normal, "dumps disassembly of DFG function upon compilation") \
146     v(bool, dumpFTLDisassembly, false, Normal, "dumps disassembly of FTL function upon compilation") \
147     v(bool, dumpAllDFGNodes, false, Normal, nullptr) \
148     v(optionRange, bytecodeRangeToJITCompile, 0, Normal, "bytecode size range to allow compilation on, e.g. 1:100") \
149     v(optionRange, bytecodeRangeToDFGCompile, 0, Normal, "bytecode size range to allow DFG compilation on, e.g. 1:100") \
150     v(optionRange, bytecodeRangeToFTLCompile, 0, Normal, "bytecode size range to allow FTL compilation on, e.g. 1:100") \
151     v(optionString, jitWhitelist, nullptr, Normal, "file with list of function signatures to allow compilation on") \
152     v(optionString, dfgWhitelist, nullptr, Normal, "file with list of function signatures to allow DFG compilation on") \
153     v(bool, dumpSourceAtDFGTime, false, Normal, "dumps source code of JS function being DFG compiled") \
154     v(bool, dumpBytecodeAtDFGTime, false, Normal, "dumps bytecode of JS function being DFG compiled") \
155     v(bool, dumpGraphAfterParsing, false, Normal, nullptr) \
156     v(bool, dumpGraphAtEachPhase, false, Normal, nullptr) \
157     v(bool, dumpDFGGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase DFG of complitaion (note this excludes DFG graphs during FTL compilation)") \
158     v(bool, dumpDFGFTLGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase DFG of complitaion when compiling FTL code") \
159     v(bool, dumpB3GraphAtEachPhase, false, Normal, "dumps the B3 graph at each phase of compilation") \
160     v(bool, dumpAirGraphAtEachPhase, false, Normal, "dumps the Air graph at each phase of compilation") \
161     v(bool, verboseDFGByteCodeParsing, false, Normal, nullptr) \
162     v(bool, verboseCompilation, false, Normal, nullptr) \
163     v(bool, verboseFTLCompilation, false, Normal, nullptr) \
164     v(bool, logCompilationChanges, false, Normal, nullptr) \
165     v(bool, printEachOSRExit, false, Normal, nullptr) \
166     v(bool, validateGraph, false, Normal, nullptr) \
167     v(bool, validateGraphAtEachPhase, false, Normal, nullptr) \
168     v(bool, verboseValidationFailure, false, Normal, nullptr) \
169     v(bool, verboseOSR, false, Normal, nullptr) \
170     v(bool, verboseFTLOSRExit, false, Normal, nullptr) \
171     v(bool, verboseCallLink, false, Normal, nullptr) \
172     v(bool, verboseCompilationQueue, false, Normal, nullptr) \
173     v(bool, reportCompileTimes, false, Normal, "dumps JS function signature and the time it took to compile in all tiers") \
174     v(bool, reportBaselineCompileTimes, false, Normal, "dumps JS function signature and the time it took to BaselineJIT compile") \
175     v(bool, reportDFGCompileTimes, false, Normal, "dumps JS function signature and the time it took to DFG and FTL compile") \
176     v(bool, reportFTLCompileTimes, false, Normal, "dumps JS function signature and the time it took to FTL compile") \
177     v(bool, reportTotalCompileTimes, false, Normal, nullptr) \
178     v(bool, verboseExitProfile, false, Normal, nullptr) \
179     v(bool, verboseCFA, false, Normal, nullptr) \
180     v(bool, verboseFTLToJSThunk, false, Normal, nullptr) \
181     v(bool, verboseFTLFailure, false, Normal, nullptr) \
182     v(bool, alwaysComputeHash, false, Normal, nullptr) \
183     v(bool, testTheFTL, false, Normal, nullptr) \
184     v(bool, verboseSanitizeStack, false, Normal, nullptr) \
185     v(bool, useGenerationalGC, true, Normal, nullptr) \
186     v(bool, eagerlyUpdateTopCallFrame, false, Normal, nullptr) \
187     \
188     v(bool, useOSREntryToDFG, true, Normal, nullptr) \
189     v(bool, useOSREntryToFTL, true, Normal, nullptr) \
190     \
191     v(bool, useFTLJIT, true, Normal, "allows the FTL JIT to be used if true") \
192     v(bool, useFTLTBAA, true, Normal, nullptr) \
193     v(bool, validateFTLOSRExitLiveness, false, Normal, nullptr) \
194     v(bool, b3AlwaysFailsBeforeCompile, false, Normal, nullptr) \
195     v(bool, b3AlwaysFailsBeforeLink, false, Normal, nullptr) \
196     v(bool, ftlCrashes, false, Normal, nullptr) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
197     v(bool, clobberAllRegsInFTLICSlowPath, !ASSERT_DISABLED, Normal, nullptr) \
198     v(bool, useAccessInlining, true, Normal, nullptr) \
199     v(unsigned, maxAccessVariantListSize, 8, Normal, nullptr) \
200     v(unsigned, megamorphicLoadCost, 999, Normal, nullptr) /* This used to be 10, but we're temporarily testing what happens when the feature is disabled. */\
201     v(bool, usePolyvariantDevirtualization, true, Normal, nullptr) \
202     v(bool, usePolymorphicAccessInlining, true, Normal, nullptr) \
203     v(bool, usePolymorphicCallInlining, true, Normal, nullptr) \
204     v(bool, usePolymorphicCallInliningForNonStubStatus, false, Normal, nullptr) \
205     v(unsigned, maxPolymorphicCallVariantListSize, 15, Normal, nullptr) \
206     v(unsigned, maxPolymorphicCallVariantListSizeForTopTier, 5, Normal, nullptr) \
207     v(unsigned, maxPolymorphicCallVariantsForInlining, 5, Normal, nullptr) \
208     v(unsigned, frequentCallThreshold, 2, Normal, nullptr) \
209     v(double, minimumCallToKnownRate, 0.51, Normal, nullptr) \
210     v(bool, createPreHeaders, true, Normal, nullptr) \
211     v(bool, useMovHintRemoval, true, Normal, nullptr) \
212     v(bool, usePutStackSinking, true, Normal, nullptr) \
213     v(bool, useObjectAllocationSinking, true, Normal, nullptr) \
214     v(bool, logExecutableAllocation, false, Normal, nullptr) \
215     \
216     v(bool, useConcurrentJIT, true, Normal, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
217     v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1, Normal, nullptr) \
218     v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(8, 2) - 1, Normal, nullptr) \
219     v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), Normal, nullptr) \
220     v(int32, priorityDeltaOfFTLCompilerThreads, computePriorityDeltaOfWorkerThreads(-2, 0), Normal, nullptr) \
221     \
222     v(bool, useProfiler, false, Normal, nullptr) \
223     v(bool, disassembleBaselineForProfiler, true, Normal, nullptr) \
224     \
225     v(bool, useArchitectureSpecificOptimizations, true, Normal, nullptr) \
226     \
227     v(bool, breakOnThrow, false, Normal, nullptr) \
228     \
229     v(unsigned, maximumOptimizationCandidateInstructionCount, 100000, Normal, nullptr) \
230     \
231     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 180, Normal, nullptr) \
232     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 100, Normal, nullptr) \
233     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 100, Normal, nullptr) \
234     \
235     v(unsigned, maximumFTLCandidateInstructionCount, 20000, Normal, nullptr) \
236     \
237     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
238     v(unsigned, maximumInliningDepth, 5, Normal, "maximum allowed inlining depth.  Depth of 1 means no inlining") \
239     v(unsigned, maximumInliningRecursion, 2, Normal, nullptr) \
240     \
241     /* Maximum size of a caller for enabling inlining. This is purely to protect us */\
242     /* from super long compiles that take a lot of memory. */\
243     v(unsigned, maximumInliningCallerSize, 10000, Normal, nullptr) \
244     \
245     v(unsigned, maximumVarargsForInlining, 100, Normal, nullptr) \
246     \
247     v(bool, usePolyvariantCallInlining, true, Normal, nullptr) \
248     v(bool, usePolyvariantByIdInlining, true, Normal, nullptr) \
249     \
250     v(bool, useMaximalFlushInsertionPhase, false, Normal, "Setting to true allows the DFG's MaximalFlushInsertionPhase to run.") \
251     \
252     v(unsigned, maximumBinaryStringSwitchCaseLength, 50, Normal, nullptr) \
253     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000, Normal, nullptr) \
254     \
255     v(double, jitPolicyScale, 1.0, Normal, "scale JIT thresholds to this specified ratio between 0.0 (compile ASAP) and 1.0 (compile like normal).") \
256     v(bool, forceEagerCompilation, false, Normal, nullptr) \
257     v(int32, thresholdForJITAfterWarmUp, 500, Normal, nullptr) \
258     v(int32, thresholdForJITSoon, 100, Normal, nullptr) \
259     \
260     v(int32, thresholdForOptimizeAfterWarmUp, 1000, Normal, nullptr) \
261     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000, Normal, nullptr) \
262     v(int32, thresholdForOptimizeSoon, 1000, Normal, nullptr) \
263     v(int32, executionCounterIncrementForLoop, 1, Normal, nullptr) \
264     v(int32, executionCounterIncrementForEntry, 15, Normal, nullptr) \
265     \
266     v(int32, thresholdForFTLOptimizeAfterWarmUp, 100000, Normal, nullptr) \
267     v(int32, thresholdForFTLOptimizeSoon, 1000, Normal, nullptr) \
268     v(int32, ftlTierUpCounterIncrementForLoop, 1, Normal, nullptr) \
269     v(int32, ftlTierUpCounterIncrementForReturn, 15, Normal, nullptr) \
270     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15, Normal, nullptr) \
271     v(unsigned, ftlOSREntryRetryThreshold, 100, Normal, nullptr) \
272     \
273     v(int32, evalThresholdMultiplier, 10, Normal, nullptr) \
274     v(unsigned, maximumEvalCacheableSourceLength, 256, Normal, nullptr) \
275     \
276     v(bool, randomizeExecutionCountsBetweenCheckpoints, false, Normal, nullptr) \
277     v(int32, maximumExecutionCountsBetweenCheckpointsForBaseline, 1000, Normal, nullptr) \
278     v(int32, maximumExecutionCountsBetweenCheckpointsForUpperTiers, 50000, Normal, nullptr) \
279     \
280     v(unsigned, likelyToTakeSlowCaseMinimumCount, 20, Normal, nullptr) \
281     v(unsigned, couldTakeSlowCaseMinimumCount, 10, Normal, nullptr) \
282     \
283     v(unsigned, osrExitCountForReoptimization, 100, Normal, nullptr) \
284     v(unsigned, osrExitCountForReoptimizationFromLoop, 5, Normal, nullptr) \
285     \
286     v(unsigned, reoptimizationRetryCounterMax, 0, Normal, nullptr)  \
287     \
288     v(unsigned, minimumOptimizationDelay, 1, Normal, nullptr) \
289     v(unsigned, maximumOptimizationDelay, 5, Normal, nullptr) \
290     v(double, desiredProfileLivenessRate, 0.75, Normal, nullptr) \
291     v(double, desiredProfileFullnessRate, 0.35, Normal, nullptr) \
292     \
293     v(double, doubleVoteRatioForDoubleFormat, 2, Normal, nullptr) \
294     v(double, structureCheckVoteRatioForHoisting, 1, Normal, nullptr) \
295     v(double, checkArrayVoteRatioForHoisting, 1, Normal, nullptr) \
296     \
297     v(unsigned, minimumNumberOfScansBetweenRebalance, 100, Normal, nullptr) \
298     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(7), Normal, nullptr) \
299     v(unsigned, opaqueRootMergeThreshold, 1000, Normal, nullptr) \
300     v(double, minHeapUtilization, 0.8, Normal, nullptr) \
301     v(double, minCopiedBlockUtilization, 0.9, Normal, nullptr) \
302     v(double, minMarkedBlockUtilization, 0.9, Normal, nullptr) \
303     v(unsigned, slowPathAllocsBetweenGCs, 0, Normal, "force a GC on every Nth slow path alloc, where N is specified by this option") \
304     \
305     v(double, percentCPUPerMBForFullTimer, 0.0003125, Normal, nullptr) \
306     v(double, percentCPUPerMBForEdenTimer, 0.0025, Normal, nullptr) \
307     v(double, collectionTimerMaxPercentCPU, 0.05, Normal, nullptr) \
308     \
309     v(bool, forceWeakRandomSeed, false, Normal, nullptr) \
310     v(unsigned, forcedWeakRandomSeed, 0, Normal, nullptr) \
311     \
312     v(bool, useZombieMode, false, Normal, "debugging option to scribble over dead objects with 0xdeadbeef") \
313     v(bool, useImmortalObjects, false, Normal, "debugging option to keep all objects alive forever") \
314     v(bool, dumpObjectStatistics, false, Normal, nullptr) \
315     \
316     v(gcLogLevel, logGC, GCLogging::None, Normal, "debugging option to log GC activity (0 = None, 1 = Basic, 2 = Verbose)") \
317     v(bool, useGC, true, Normal, nullptr) \
318     v(bool, gcAtEnd, false, Normal, "If true, the jsc CLI will do a GC before exiting") \
319     v(bool, forceGCSlowPaths, false, Normal, "If true, we will force all JIT fast allocations down their slow paths.")\
320     v(unsigned, gcMaxHeapSize, 0, Normal, nullptr) \
321     v(unsigned, forceRAMSize, 0, Normal, nullptr) \
322     v(bool, recordGCPauseTimes, false, Normal, nullptr) \
323     v(bool, logHeapStatisticsAtExit, false, Normal, nullptr) \
324     \
325     v(bool, useTypeProfiler, false, Normal, nullptr) \
326     v(bool, useControlFlowProfiler, false, Normal, nullptr) \
327     \
328     v(bool, useSamplingProfiler, false, Normal, nullptr) \
329     v(unsigned, sampleInterval, 1000, Normal, "Time between stack traces in microseconds.") \
330     v(bool, collectSamplingProfilerDataForJSCShell, false, Normal, "This corresponds to the JSC shell's --sample option.") \
331     \
332     v(bool, alwaysGeneratePCToCodeOriginMap, false, Normal, "This will make sure we always generate a PCToCodeOriginMap for JITed code.") \
333     \
334     v(bool, verifyHeap, false, Normal, nullptr) \
335     v(unsigned, numberOfGCCyclesToRecordForVerification, 3, Normal, nullptr) \
336     \
337     v(bool, useExceptionFuzz, false, Normal, nullptr) \
338     v(unsigned, fireExceptionFuzzAt, 0, Normal, nullptr) \
339     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 */\
340     \
341     v(bool, useExecutableAllocationFuzz, false, Normal, nullptr) \
342     v(unsigned, fireExecutableAllocationFuzzAt, 0, Normal, nullptr) \
343     v(unsigned, fireExecutableAllocationFuzzAtOrAfter, 0, Normal, nullptr) \
344     v(bool, verboseExecutableAllocationFuzz, false, Normal, nullptr) \
345     \
346     v(bool, useOSRExitFuzz, false, Normal, nullptr) \
347     v(unsigned, fireOSRExitFuzzAtStatic, 0, Normal, nullptr) \
348     v(unsigned, fireOSRExitFuzzAt, 0, Normal, nullptr) \
349     v(unsigned, fireOSRExitFuzzAtOrAfter, 0, Normal, nullptr) \
350     \
351     v(bool, logB3PhaseTimes, false, Normal, nullptr) \
352     v(double, rareBlockPenalty, 0.001, Normal, nullptr) \
353     v(bool, airSpillsEverything, false, Normal, nullptr) \
354     v(bool, logAirRegisterPressure, false, Normal, nullptr) \
355     v(unsigned, maxB3TailDupBlockSize, 3, Normal, nullptr) \
356     v(unsigned, maxB3TailDupBlockSuccessors, 3, Normal, nullptr) \
357     \
358     v(bool, useDollarVM, false, Restricted, "installs the $vm debugging tool in global objects") \
359     v(optionString, functionOverrides, nullptr, Restricted, "file with debugging overrides for function bodies") \
360     \
361     v(unsigned, watchdog, 0, Normal, "watchdog timeout (0 = Disabled, N = a timeout period of N milliseconds)") \
362     \
363     v(bool, useICStats, false, Normal, nullptr) \
364     \
365     v(bool, dumpModuleRecord, false, Normal, nullptr) \
366     v(bool, dumpModuleLoadingState, false, Normal, nullptr) \
367     v(bool, exposeInternalModuleLoader, false, Normal, "expose the internal module loader object to the global space for debugging") \
368     \
369     v(bool, useSuperSampler, false, Normal, nullptr)
370
371 enum OptionEquivalence {
372     SameOption,
373     InvertedOption,
374 };
375
376 #define JSC_ALIASED_OPTIONS(v) \
377     v(enableFunctionDotArguments, useFunctionDotArguments, SameOption) \
378     v(enableTailCalls, useTailCalls, SameOption) \
379     v(showDisassembly, dumpDisassembly, SameOption) \
380     v(showDFGDisassembly, dumpDFGDisassembly, SameOption) \
381     v(showFTLDisassembly, dumpFTLDisassembly, SameOption) \
382     v(showAllDFGNodes, dumpAllDFGNodes, SameOption) \
383     v(alwaysDoFullCollection, useGenerationalGC, InvertedOption) \
384     v(enableOSREntryToDFG, useOSREntryToDFG, SameOption) \
385     v(enableOSREntryToFTL, useOSREntryToFTL, SameOption) \
386     v(enableAccessInlining, useAccessInlining, SameOption) \
387     v(enablePolyvariantDevirtualization, usePolyvariantDevirtualization, SameOption) \
388     v(enablePolymorphicAccessInlining, usePolymorphicAccessInlining, SameOption) \
389     v(enablePolymorphicCallInlining, usePolymorphicCallInlining, SameOption) \
390     v(enableMovHintRemoval, useMovHintRemoval, SameOption) \
391     v(enableObjectAllocationSinking, useObjectAllocationSinking, SameOption) \
392     v(enableConcurrentJIT, useConcurrentJIT, SameOption) \
393     v(enableProfiler, useProfiler, SameOption) \
394     v(enableArchitectureSpecificOptimizations, useArchitectureSpecificOptimizations, SameOption) \
395     v(enablePolyvariantCallInlining, usePolyvariantCallInlining, SameOption) \
396     v(enablePolyvariantByIdInlining, usePolyvariantByIdInlining, SameOption) \
397     v(enableMaximalFlushInsertionPhase, useMaximalFlushInsertionPhase, SameOption) \
398     v(objectsAreImmortal, useImmortalObjects, SameOption) \
399     v(showObjectStatistics, dumpObjectStatistics, SameOption) \
400     v(disableGC, useGC, InvertedOption) \
401     v(enableTypeProfiler, useTypeProfiler, SameOption) \
402     v(enableControlFlowProfiler, useControlFlowProfiler, SameOption) \
403     v(enableExceptionFuzz, useExceptionFuzz, SameOption) \
404     v(enableExecutableAllocationFuzz, useExecutableAllocationFuzz, SameOption) \
405     v(enableOSRExitFuzz, useOSRExitFuzz, SameOption) \
406     v(enableDollarVM, useDollarVM, SameOption) \
407
408 class Options {
409 public:
410     enum class DumpLevel {
411         None = 0,
412         Overridden,
413         All,
414         Verbose
415     };
416
417     enum class Availability {
418         Normal = 0,
419         Restricted
420     };
421
422     // This typedef is to allow us to eliminate the '_' in the field name in
423     // union inside Entry. This is needed to keep the style checker happy.
424     typedef int32_t int32;
425
426     // Declare the option IDs:
427     enum OptionID {
428 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
429         name_##ID,
430         JSC_OPTIONS(FOR_EACH_OPTION)
431 #undef FOR_EACH_OPTION
432         numberOfOptions
433     };
434
435     enum class Type {
436         boolType,
437         unsignedType,
438         doubleType,
439         int32Type,
440         optionRangeType,
441         optionStringType,
442         gcLogLevelType,
443     };
444
445     JS_EXPORT_PRIVATE static void initialize();
446
447     // Parses a string of options where each option is of the format "--<optionName>=<value>"
448     // and are separated by a space. The leading "--" is optional and will be ignored.
449     JS_EXPORT_PRIVATE static bool setOptions(const char* optionsList);
450
451     // Parses a single command line option in the format "<optionName>=<value>"
452     // (no spaces allowed) and set the specified option if appropriate.
453     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
454
455     JS_EXPORT_PRIVATE static void dumpAllOptions(FILE*, DumpLevel, const char* title = nullptr);
456     JS_EXPORT_PRIVATE static void dumpAllOptionsInALine(StringBuilder&);
457
458     JS_EXPORT_PRIVATE static void ensureOptionsAreCoherent();
459
460     // Declare accessors for each option:
461 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
462     ALWAYS_INLINE static type_& name_() { return s_options[name_##ID].type_##Val; } \
463     ALWAYS_INLINE static type_& name_##Default() { return s_defaultOptions[name_##ID].type_##Val; }
464
465     JSC_OPTIONS(FOR_EACH_OPTION)
466 #undef FOR_EACH_OPTION
467
468 private:
469     // For storing for an option value:
470     union Entry {
471         bool boolVal;
472         unsigned unsignedVal;
473         double doubleVal;
474         int32 int32Val;
475         OptionRange optionRangeVal;
476         const char* optionStringVal;
477         GCLogging::Level gcLogLevelVal;
478     };
479
480     // For storing constant meta data about each option:
481     struct EntryInfo {
482         const char* name;
483         const char* description;
484         Type type;
485         Availability availability;
486     };
487
488     Options();
489
490     enum DumpDefaultsOption {
491         DontDumpDefaults,
492         DumpDefaults
493     };
494     static void dumpOptionsIfNeeded();
495     static void dumpAllOptions(StringBuilder&, DumpLevel, const char* title,
496         const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
497     static void dumpOption(StringBuilder&, DumpLevel, OptionID,
498         const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
499
500     static bool setOptionWithoutAlias(const char* arg);
501     static bool setAliasedOption(const char* arg);
502     static bool overrideAliasedOptionWithHeuristic(const char* name);
503
504     // Declare the singleton instance of the options store:
505     JS_EXPORTDATA static Entry s_options[numberOfOptions];
506     static Entry s_defaultOptions[numberOfOptions];
507     static const EntryInfo s_optionsInfo[numberOfOptions];
508
509     friend class Option;
510 };
511
512 class Option {
513 public:
514     Option(Options::OptionID id)
515         : m_id(id)
516         , m_entry(Options::s_options[m_id])
517     {
518     }
519     
520     void dump(StringBuilder&) const;
521
522     bool operator==(const Option& other) const;
523     bool operator!=(const Option& other) const { return !(*this == other); }
524     
525     const char* name() const;
526     const char* description() const;
527     Options::Type type() const;
528     Options::Availability availability() const;
529     bool isOverridden() const;
530     const Option defaultOption() const;
531     
532     bool& boolVal();
533     unsigned& unsignedVal();
534     double& doubleVal();
535     int32_t& int32Val();
536     OptionRange optionRangeVal();
537     const char* optionStringVal();
538     GCLogging::Level& gcLogLevelVal();
539     
540 private:
541     // Only used for constructing default Options.
542     Option(Options::OptionID id, Options::Entry& entry)
543         : m_id(id)
544         , m_entry(entry)
545     {
546     }
547     
548     Options::OptionID m_id;
549     Options::Entry& m_entry;
550 };
551
552 inline const char* Option::name() const
553 {
554     return Options::s_optionsInfo[m_id].name;
555 }
556
557 inline const char* Option::description() const
558 {
559     return Options::s_optionsInfo[m_id].description;
560 }
561
562 inline Options::Type Option::type() const
563 {
564     return Options::s_optionsInfo[m_id].type;
565 }
566
567 inline Options::Availability Option::availability() const
568 {
569     return Options::s_optionsInfo[m_id].availability;
570 }
571
572 inline bool Option::isOverridden() const
573 {
574     return *this != defaultOption();
575 }
576
577 inline const Option Option::defaultOption() const
578 {
579     return Option(m_id, Options::s_defaultOptions[m_id]);
580 }
581
582 inline bool& Option::boolVal()
583 {
584     return m_entry.boolVal;
585 }
586
587 inline unsigned& Option::unsignedVal()
588 {
589     return m_entry.unsignedVal;
590 }
591
592 inline double& Option::doubleVal()
593 {
594     return m_entry.doubleVal;
595 }
596
597 inline int32_t& Option::int32Val()
598 {
599     return m_entry.int32Val;
600 }
601
602 inline OptionRange Option::optionRangeVal()
603 {
604     return m_entry.optionRangeVal;
605 }
606
607 inline const char* Option::optionStringVal()
608 {
609     return m_entry.optionStringVal;
610 }
611
612 inline GCLogging::Level& Option::gcLogLevelVal()
613 {
614     return m_entry.gcLogLevelVal;
615 }
616
617 } // namespace JSC
618
619 #endif // Options_h