WebAssembly: JSC::link* shouldn't need a CodeBlock
[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 #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 #define JSC_OPTIONS(v) \
104     v(bool, validateOptions, false, Normal, "crashes if mis-typed JSC options were passed to the VM") \
105     v(unsigned, dumpOptions, 0, Normal, "dumps JSC options (0 = None, 1 = Overridden only, 2 = All, 3 = Verbose)") \
106     \
107     v(bool, useLLInt,  true, Normal, "allows the LLINT to be used if true") \
108     v(bool, useJIT,    true, Normal, "allows the baseline JIT to be used if true") \
109     v(bool, useDFGJIT, true, Normal, "allows the DFG JIT to be used if true") \
110     v(bool, useRegExpJIT, true, Normal, "allows the RegExp JIT to be used if true") \
111     v(bool, useDOMJIT, true, Normal, "allows the DOMJIT to be used if true") \
112     \
113     v(bool, reportMustSucceedExecutableAllocations, false, Normal, nullptr) \
114     \
115     v(unsigned, maxPerThreadStackUsage, 4 * MB, Normal, "Max allowed stack usage by the VM") \
116     v(unsigned, softReservedZoneSize, 128 * KB, Normal, "A buffer greater than reservedZoneSize that reserves space for stringifying exceptions.") \
117     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).") \
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     \
135     v(bool, useFunctionDotArguments, true, Normal, nullptr) \
136     v(bool, useTailCalls, true, Normal, nullptr) \
137     v(bool, alwaysUseShadowChicken, false, Normal, nullptr) \
138     v(unsigned, shadowChickenLogSize, 1000, Normal, nullptr) \
139     v(unsigned, shadowChickenMaxTailDeletedFramesSize, 128, Normal, nullptr) \
140     \
141     /* dumpDisassembly implies dumpDFGDisassembly. */ \
142     v(bool, dumpDisassembly, false, Normal, "dumps disassembly of all JIT compiled code upon compilation") \
143     v(bool, asyncDisassembly, false, Normal, nullptr) \
144     v(bool, dumpDFGDisassembly, false, Normal, "dumps disassembly of DFG function upon compilation") \
145     v(bool, dumpFTLDisassembly, false, Normal, "dumps disassembly of FTL function upon compilation") \
146     v(bool, dumpAllDFGNodes, false, Normal, nullptr) \
147     v(optionRange, bytecodeRangeToJITCompile, 0, Normal, "bytecode size range to allow compilation on, e.g. 1:100") \
148     v(optionRange, bytecodeRangeToDFGCompile, 0, Normal, "bytecode size range to allow DFG compilation on, e.g. 1:100") \
149     v(optionRange, bytecodeRangeToFTLCompile, 0, Normal, "bytecode size range to allow FTL compilation on, e.g. 1:100") \
150     v(optionString, jitWhitelist, nullptr, Normal, "file with list of function signatures to allow compilation on") \
151     v(optionString, dfgWhitelist, nullptr, Normal, "file with list of function signatures to allow DFG compilation on") \
152     v(bool, dumpSourceAtDFGTime, false, Normal, "dumps source code of JS function being DFG compiled") \
153     v(bool, dumpBytecodeAtDFGTime, false, Normal, "dumps bytecode of JS function being DFG compiled") \
154     v(bool, dumpGraphAfterParsing, false, Normal, nullptr) \
155     v(bool, dumpGraphAtEachPhase, false, Normal, nullptr) \
156     v(bool, dumpDFGGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase of DFG compilation (note this excludes DFG graphs during FTL compilation)") \
157     v(bool, dumpDFGFTLGraphAtEachPhase, false, Normal, "dumps the DFG graph at each phase of DFG compilation when compiling FTL code") \
158     v(bool, dumpB3GraphAtEachPhase, false, Normal, "dumps the B3 graph at each phase of compilation") \
159     v(bool, dumpAirGraphAtEachPhase, false, Normal, "dumps the Air graph at each phase of compilation") \
160     v(bool, verboseDFGByteCodeParsing, false, Normal, nullptr) \
161     v(bool, verboseCompilation, false, Normal, nullptr) \
162     v(bool, verboseFTLCompilation, false, Normal, nullptr) \
163     v(bool, logCompilationChanges, false, Normal, nullptr) \
164     v(bool, printEachOSRExit, false, Normal, nullptr) \
165     v(bool, validateGraph, false, Normal, nullptr) \
166     v(bool, validateGraphAtEachPhase, false, Normal, nullptr) \
167     v(bool, verboseValidationFailure, false, Normal, nullptr) \
168     v(bool, verboseOSR, false, Normal, nullptr) \
169     v(bool, verboseFTLOSRExit, false, Normal, nullptr) \
170     v(bool, verboseCallLink, false, Normal, nullptr) \
171     v(bool, verboseCompilationQueue, false, Normal, nullptr) \
172     v(bool, reportCompileTimes, false, Normal, "dumps JS function signature and the time it took to compile in all tiers") \
173     v(bool, reportBaselineCompileTimes, false, Normal, "dumps JS function signature and the time it took to BaselineJIT compile") \
174     v(bool, reportDFGCompileTimes, false, Normal, "dumps JS function signature and the time it took to DFG and FTL compile") \
175     v(bool, reportFTLCompileTimes, false, Normal, "dumps JS function signature and the time it took to FTL compile") \
176     v(bool, reportDFGPhaseTimes, false, Normal, "dumps JS function name and the time is took for each DFG phase") \
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, useConcurrentBarriers, true, Normal, nullptr) \
187     v(bool, useConcurrentGC, true, Normal, nullptr) \
188     v(bool, collectContinuously, false, Normal, nullptr) \
189     v(double, collectContinuouslyPeriodMS, 1, Normal, nullptr) \
190     v(bool, forceFencedBarrier, false, Normal, nullptr) \
191     v(bool, verboseVisitRace, false, Normal, nullptr) \
192     v(bool, optimizeParallelSlotVisitorsForStoppedMutator, false, Normal, nullptr) \
193     v(unsigned, largeHeapSize, 32 * 1024 * 1024, Normal, nullptr) \
194     v(unsigned, smallHeapSize, 1 * 1024 * 1024, Normal, nullptr) \
195     v(double, smallHeapRAMFraction, 0.25, Normal, nullptr) \
196     v(double, smallHeapGrowthFactor, 2, Normal, nullptr) \
197     v(double, mediumHeapRAMFraction, 0.5, Normal, nullptr) \
198     v(double, mediumHeapGrowthFactor, 1.5, Normal, nullptr) \
199     v(double, largeHeapGrowthFactor, 1.24, Normal, nullptr) \
200     v(bool, useCollectorTimeslicing, true, Normal, nullptr) \
201     v(double, minimumMutatorUtilization, 0, Normal, nullptr) \
202     v(double, maximumMutatorUtilization, 0.7, Normal, nullptr) \
203     v(double, concurrentGCMaxHeadroom, 1.5, Normal, nullptr) \
204     v(double, concurrentGCPeriodMS, 2, Normal, nullptr) \
205     v(double, initialExtraPauseRatio, 0, Normal, nullptr) \
206     v(double, extraPauseRatioIterationGrowthRate, 1.1, Normal, nullptr) \
207     v(bool, collectorShouldResumeFirst, false, Normal, nullptr) \
208     v(bool, scribbleFreeCells, false, Normal, nullptr) \
209     v(double, sizeClassProgression, 1.4, Normal, nullptr) \
210     v(unsigned, largeAllocationCutoff, 100000, Normal, nullptr) \
211     v(bool, dumpSizeClasses, false, Normal, nullptr) \
212     v(bool, useBumpAllocator, true, Normal, nullptr) \
213     v(bool, stealEmptyBlocksFromOtherAllocators, true, Normal, nullptr) \
214     v(bool, eagerlyUpdateTopCallFrame, false, Normal, nullptr) \
215     \
216     v(bool, useOSREntryToDFG, true, Normal, nullptr) \
217     v(bool, useOSREntryToFTL, true, Normal, nullptr) \
218     \
219     v(bool, useFTLJIT, true, Normal, "allows the FTL JIT to be used if true") \
220     v(bool, useFTLTBAA, true, Normal, nullptr) \
221     v(bool, validateFTLOSRExitLiveness, false, Normal, nullptr) \
222     v(bool, b3AlwaysFailsBeforeCompile, false, Normal, nullptr) \
223     v(bool, b3AlwaysFailsBeforeLink, false, Normal, nullptr) \
224     v(bool, ftlCrashes, false, Normal, nullptr) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
225     v(bool, clobberAllRegsInFTLICSlowPath, !ASSERT_DISABLED, Normal, nullptr) \
226     v(bool, useAccessInlining, true, Normal, nullptr) \
227     v(unsigned, maxAccessVariantListSize, 8, Normal, nullptr) \
228     v(unsigned, megamorphicLoadCost, 999, Normal, nullptr) /* This used to be 10, but we're temporarily testing what happens when the feature is disabled. */\
229     v(bool, usePolyvariantDevirtualization, true, Normal, nullptr) \
230     v(bool, usePolymorphicAccessInlining, true, Normal, nullptr) \
231     v(bool, usePolymorphicCallInlining, true, Normal, nullptr) \
232     v(bool, usePolymorphicCallInliningForNonStubStatus, false, Normal, nullptr) \
233     v(unsigned, maxPolymorphicCallVariantListSize, 15, Normal, nullptr) \
234     v(unsigned, maxPolymorphicCallVariantListSizeForTopTier, 5, Normal, nullptr) \
235     v(unsigned, maxPolymorphicCallVariantListSizeForWebAssemblyToJS, 5, Normal, nullptr) \
236     v(unsigned, maxPolymorphicCallVariantsForInlining, 5, Normal, nullptr) \
237     v(unsigned, frequentCallThreshold, 2, Normal, nullptr) \
238     v(double, minimumCallToKnownRate, 0.51, Normal, nullptr) \
239     v(bool, createPreHeaders, true, Normal, nullptr) \
240     v(bool, useMovHintRemoval, true, Normal, nullptr) \
241     v(bool, usePutStackSinking, true, Normal, nullptr) \
242     v(bool, useObjectAllocationSinking, true, Normal, nullptr) \
243     v(bool, logExecutableAllocation, false, Normal, nullptr) \
244     \
245     v(bool, useConcurrentJIT, true, Normal, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
246     v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1, Normal, nullptr) \
247     v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(8, 2) - 1, Normal, nullptr) \
248     v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), Normal, nullptr) \
249     v(int32, priorityDeltaOfFTLCompilerThreads, computePriorityDeltaOfWorkerThreads(-2, 0), Normal, nullptr) \
250     \
251     v(bool, useProfiler, false, Normal, nullptr) \
252     v(bool, disassembleBaselineForProfiler, true, Normal, nullptr) \
253     \
254     v(bool, useArchitectureSpecificOptimizations, true, Normal, nullptr) \
255     \
256     v(bool, breakOnThrow, false, Normal, nullptr) \
257     \
258     v(unsigned, maximumOptimizationCandidateInstructionCount, 100000, Normal, nullptr) \
259     \
260     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 180, Normal, nullptr) \
261     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 100, Normal, nullptr) \
262     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 100, Normal, nullptr) \
263     \
264     v(unsigned, maximumFTLCandidateInstructionCount, 20000, Normal, nullptr) \
265     \
266     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
267     v(unsigned, maximumInliningDepth, 5, Normal, "maximum allowed inlining depth.  Depth of 1 means no inlining") \
268     v(unsigned, maximumInliningRecursion, 2, Normal, nullptr) \
269     \
270     /* Maximum size of a caller for enabling inlining. This is purely to protect us */\
271     /* from super long compiles that take a lot of memory. */\
272     v(unsigned, maximumInliningCallerSize, 10000, Normal, nullptr) \
273     \
274     v(unsigned, maximumVarargsForInlining, 100, Normal, nullptr) \
275     \
276     v(bool, usePolyvariantCallInlining, true, Normal, nullptr) \
277     v(bool, usePolyvariantByIdInlining, true, Normal, nullptr) \
278     \
279     v(bool, useMaximalFlushInsertionPhase, false, Normal, "Setting to true allows the DFG's MaximalFlushInsertionPhase to run.") \
280     \
281     v(unsigned, maximumBinaryStringSwitchCaseLength, 50, Normal, nullptr) \
282     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000, Normal, nullptr) \
283     \
284     v(double, jitPolicyScale, 1.0, Normal, "scale JIT thresholds to this specified ratio between 0.0 (compile ASAP) and 1.0 (compile like normal).") \
285     v(bool, forceEagerCompilation, false, Normal, nullptr) \
286     v(int32, thresholdForJITAfterWarmUp, 500, Normal, nullptr) \
287     v(int32, thresholdForJITSoon, 100, Normal, nullptr) \
288     \
289     v(int32, thresholdForOptimizeAfterWarmUp, 1000, Normal, nullptr) \
290     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000, Normal, nullptr) \
291     v(int32, thresholdForOptimizeSoon, 1000, Normal, nullptr) \
292     v(int32, executionCounterIncrementForLoop, 1, Normal, nullptr) \
293     v(int32, executionCounterIncrementForEntry, 15, Normal, nullptr) \
294     \
295     v(int32, thresholdForFTLOptimizeAfterWarmUp, 100000, Normal, nullptr) \
296     v(int32, thresholdForFTLOptimizeSoon, 1000, Normal, nullptr) \
297     v(int32, ftlTierUpCounterIncrementForLoop, 1, Normal, nullptr) \
298     v(int32, ftlTierUpCounterIncrementForReturn, 15, Normal, nullptr) \
299     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15, Normal, nullptr) \
300     v(unsigned, ftlOSREntryRetryThreshold, 100, Normal, nullptr) \
301     \
302     v(int32, evalThresholdMultiplier, 10, Normal, nullptr) \
303     v(unsigned, maximumEvalCacheableSourceLength, 256, Normal, nullptr) \
304     \
305     v(bool, randomizeExecutionCountsBetweenCheckpoints, false, Normal, nullptr) \
306     v(int32, maximumExecutionCountsBetweenCheckpointsForBaseline, 1000, Normal, nullptr) \
307     v(int32, maximumExecutionCountsBetweenCheckpointsForUpperTiers, 50000, Normal, nullptr) \
308     \
309     v(unsigned, likelyToTakeSlowCaseMinimumCount, 20, Normal, nullptr) \
310     v(unsigned, couldTakeSlowCaseMinimumCount, 10, Normal, nullptr) \
311     \
312     v(unsigned, osrExitCountForReoptimization, 100, Normal, nullptr) \
313     v(unsigned, osrExitCountForReoptimizationFromLoop, 5, Normal, nullptr) \
314     \
315     v(unsigned, reoptimizationRetryCounterMax, 0, Normal, nullptr)  \
316     \
317     v(unsigned, minimumOptimizationDelay, 1, Normal, nullptr) \
318     v(unsigned, maximumOptimizationDelay, 5, Normal, nullptr) \
319     v(double, desiredProfileLivenessRate, 0.75, Normal, nullptr) \
320     v(double, desiredProfileFullnessRate, 0.35, Normal, nullptr) \
321     \
322     v(double, doubleVoteRatioForDoubleFormat, 2, Normal, nullptr) \
323     v(double, structureCheckVoteRatioForHoisting, 1, Normal, nullptr) \
324     v(double, checkArrayVoteRatioForHoisting, 1, Normal, nullptr) \
325     \
326     v(unsigned, maximumDirectCallStackSize, 200, Normal, nullptr) \
327     \
328     v(unsigned, minimumNumberOfScansBetweenRebalance, 100, Normal, nullptr) \
329     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(8), Normal, nullptr) \
330     v(unsigned, opaqueRootMergeThreshold, 1000, Normal, nullptr) \
331     v(double, minHeapUtilization, 0.8, Normal, nullptr) \
332     v(double, minMarkedBlockUtilization, 0.9, Normal, nullptr) \
333     v(unsigned, slowPathAllocsBetweenGCs, 0, Normal, "force a GC on every Nth slow path alloc, where N is specified by this option") \
334     v(bool, deferGCShouldCollectWithProbability, false, Normal, "If true, we perform a collection based on flipping a coin according the probability in the 'deferGCProbability' option when DeferGC is destructed.") \
335     v(double, deferGCProbability, 1.0, Normal, "Should be a number between 0 and 1. 1 means DeferGC always GCs when it's destructed and GCing is safe. 0.7 means we force GC 70% the time on DeferGC destruction.") \
336     \
337     v(double, percentCPUPerMBForFullTimer, 0.0003125, Normal, nullptr) \
338     v(double, percentCPUPerMBForEdenTimer, 0.0025, Normal, nullptr) \
339     v(double, collectionTimerMaxPercentCPU, 0.05, Normal, nullptr) \
340     \
341     v(bool, forceWeakRandomSeed, false, Normal, nullptr) \
342     v(unsigned, forcedWeakRandomSeed, 0, Normal, nullptr) \
343     \
344     v(bool, useZombieMode, false, Normal, "debugging option to scribble over dead objects with 0xdeadbeef") \
345     v(bool, useImmortalObjects, false, Normal, "debugging option to keep all objects alive forever") \
346     v(bool, dumpObjectStatistics, false, Normal, nullptr) \
347     v(unsigned, maxSingleAllocationSize, 0, Configurable, "debugging option to limit individual allocations to a max size (0 = limit not set, N = limit size in bytes)") \
348     \
349     v(gcLogLevel, logGC, GCLogging::None, Normal, "debugging option to log GC activity (0 = None, 1 = Basic, 2 = Verbose)") \
350     v(bool, useGC, true, Normal, nullptr) \
351     v(bool, gcAtEnd, false, Normal, "If true, the jsc CLI will do a GC before exiting") \
352     v(bool, forceGCSlowPaths, false, Normal, "If true, we will force all JIT fast allocations down their slow paths.")\
353     v(unsigned, gcMaxHeapSize, 0, Normal, nullptr) \
354     v(unsigned, forceRAMSize, 0, Normal, nullptr) \
355     v(bool, recordGCPauseTimes, false, Normal, nullptr) \
356     v(bool, logHeapStatisticsAtExit, false, Normal, nullptr) \
357     v(bool, forceCodeBlockToJettisonDueToOldAge, false, Normal, "If true, this means that anytime we can jettison a CodeBlock due to old age, we do.") \
358     v(bool, useEagerCodeBlockJettisonTiming, false, Normal, "If true, the time slices for jettisoning a CodeBlock due to old age are shrunk significantly.") \
359     \
360     v(bool, useTypeProfiler, false, Normal, nullptr) \
361     v(bool, useControlFlowProfiler, false, Normal, nullptr) \
362     \
363     v(bool, useSamplingProfiler, false, Normal, nullptr) \
364     v(unsigned, sampleInterval, 1000, Normal, "Time between stack traces in microseconds.") \
365     v(bool, collectSamplingProfilerDataForJSCShell, false, Normal, "This corresponds to the JSC shell's --sample option.") \
366     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.") \
367     \
368     v(bool, alwaysGeneratePCToCodeOriginMap, false, Normal, "This will make sure we always generate a PCToCodeOriginMap for JITed code.") \
369     \
370     v(bool, verifyHeap, false, Normal, nullptr) \
371     v(unsigned, numberOfGCCyclesToRecordForVerification, 3, Normal, nullptr) \
372     \
373     v(bool, useExceptionFuzz, false, Normal, nullptr) \
374     v(unsigned, fireExceptionFuzzAt, 0, Normal, nullptr) \
375     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 */\
376     v(bool, dumpSimulatedThrows, false, Normal, "Dumps the call stack at each simulated throw for exception scope verification") \
377     v(bool, validateExceptionChecks, false, Normal, "Verifies that needed exception checks are performed.") \
378     \
379     v(bool, useExecutableAllocationFuzz, false, Normal, nullptr) \
380     v(unsigned, fireExecutableAllocationFuzzAt, 0, Normal, nullptr) \
381     v(unsigned, fireExecutableAllocationFuzzAtOrAfter, 0, Normal, nullptr) \
382     v(bool, verboseExecutableAllocationFuzz, false, Normal, nullptr) \
383     \
384     v(bool, useOSRExitFuzz, false, Normal, nullptr) \
385     v(unsigned, fireOSRExitFuzzAtStatic, 0, Normal, nullptr) \
386     v(unsigned, fireOSRExitFuzzAt, 0, Normal, nullptr) \
387     v(unsigned, fireOSRExitFuzzAtOrAfter, 0, Normal, nullptr) \
388     \
389     v(bool, logB3PhaseTimes, false, Normal, nullptr) \
390     v(double, rareBlockPenalty, 0.001, Normal, nullptr) \
391     v(bool, airSpillsEverything, false, Normal, nullptr) \
392     v(bool, logAirRegisterPressure, false, Normal, nullptr) \
393     v(unsigned, maxB3TailDupBlockSize, 3, Normal, nullptr) \
394     v(unsigned, maxB3TailDupBlockSuccessors, 3, Normal, nullptr) \
395     \
396     v(bool, useDollarVM, false, Restricted, "installs the $vm debugging tool in global objects") \
397     v(optionString, functionOverrides, nullptr, Restricted, "file with debugging overrides for function bodies") \
398     \
399     v(unsigned, watchdog, 0, Normal, "watchdog timeout (0 = Disabled, N = a timeout period of N milliseconds)") \
400     \
401     v(bool, useICStats, false, Normal, nullptr) \
402     \
403     v(unsigned, prototypeHitCountForLLIntCaching, 2, Normal, "Number of prototype property hits before caching a prototype in the LLInt. A count of 0 means never cache.") \
404     \
405     v(bool, dumpModuleRecord, false, Normal, nullptr) \
406     v(bool, dumpModuleLoadingState, false, Normal, nullptr) \
407     v(bool, exposeInternalModuleLoader, false, Normal, "expose the internal module loader object to the global space for debugging") \
408     \
409     v(bool, dumpAirAsJSBeforeAllocateStack, false, Normal, nullptr) \
410     v(bool, dumpAirAfterAllocateStack, false, Normal, nullptr) \
411     \
412     v(bool, useSuperSampler, false, Normal, nullptr) \
413     \
414     v(bool, reportLLIntStats, false, Configurable, "Reports LLInt statistics") \
415     v(optionString, llintStatsFile, nullptr, Configurable, "File to collect LLInt statistics in") \
416     \
417     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.") \
418     v(bool, useCodeCache, true, Normal, "If false, the unlinked byte code cache will not be used.") \
419     \
420     v(bool, useWebAssembly, false, Normal, "Expose the WebAssembly global object.") \
421
422 enum OptionEquivalence {
423     SameOption,
424     InvertedOption,
425 };
426
427 #define JSC_ALIASED_OPTIONS(v) \
428     v(enableFunctionDotArguments, useFunctionDotArguments, SameOption) \
429     v(enableTailCalls, useTailCalls, SameOption) \
430     v(showDisassembly, dumpDisassembly, SameOption) \
431     v(showDFGDisassembly, dumpDFGDisassembly, SameOption) \
432     v(showFTLDisassembly, dumpFTLDisassembly, SameOption) \
433     v(showAllDFGNodes, dumpAllDFGNodes, SameOption) \
434     v(alwaysDoFullCollection, useGenerationalGC, InvertedOption) \
435     v(enableOSREntryToDFG, useOSREntryToDFG, SameOption) \
436     v(enableOSREntryToFTL, useOSREntryToFTL, SameOption) \
437     v(enableAccessInlining, useAccessInlining, SameOption) \
438     v(enablePolyvariantDevirtualization, usePolyvariantDevirtualization, SameOption) \
439     v(enablePolymorphicAccessInlining, usePolymorphicAccessInlining, SameOption) \
440     v(enablePolymorphicCallInlining, usePolymorphicCallInlining, SameOption) \
441     v(enableMovHintRemoval, useMovHintRemoval, SameOption) \
442     v(enableObjectAllocationSinking, useObjectAllocationSinking, SameOption) \
443     v(enableConcurrentJIT, useConcurrentJIT, SameOption) \
444     v(enableProfiler, useProfiler, SameOption) \
445     v(enableArchitectureSpecificOptimizations, useArchitectureSpecificOptimizations, SameOption) \
446     v(enablePolyvariantCallInlining, usePolyvariantCallInlining, SameOption) \
447     v(enablePolyvariantByIdInlining, usePolyvariantByIdInlining, SameOption) \
448     v(enableMaximalFlushInsertionPhase, useMaximalFlushInsertionPhase, SameOption) \
449     v(objectsAreImmortal, useImmortalObjects, SameOption) \
450     v(showObjectStatistics, dumpObjectStatistics, SameOption) \
451     v(disableGC, useGC, InvertedOption) \
452     v(enableTypeProfiler, useTypeProfiler, SameOption) \
453     v(enableControlFlowProfiler, useControlFlowProfiler, SameOption) \
454     v(enableExceptionFuzz, useExceptionFuzz, SameOption) \
455     v(enableExecutableAllocationFuzz, useExecutableAllocationFuzz, SameOption) \
456     v(enableOSRExitFuzz, useOSRExitFuzz, SameOption) \
457     v(enableDollarVM, useDollarVM, SameOption) \
458     v(enableWebAssembly, useWebAssembly, SameOption) \
459
460 class Options {
461 public:
462     enum class DumpLevel {
463         None = 0,
464         Overridden,
465         All,
466         Verbose
467     };
468
469     enum class Availability {
470         Normal = 0,
471         Restricted,
472         Configurable
473     };
474
475     // This typedef is to allow us to eliminate the '_' in the field name in
476     // union inside Entry. This is needed to keep the style checker happy.
477     typedef int32_t int32;
478
479     // Declare the option IDs:
480     enum ID {
481 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
482         name_##ID,
483         JSC_OPTIONS(FOR_EACH_OPTION)
484 #undef FOR_EACH_OPTION
485         numberOfOptions
486     };
487
488     enum class Type {
489         boolType,
490         unsignedType,
491         doubleType,
492         int32Type,
493         optionRangeType,
494         optionStringType,
495         gcLogLevelType,
496     };
497
498     JS_EXPORT_PRIVATE static void initialize();
499
500     // Parses a string of options where each option is of the format "--<optionName>=<value>"
501     // and are separated by a space. The leading "--" is optional and will be ignored.
502     JS_EXPORT_PRIVATE static bool setOptions(const char* optionsList);
503
504     // Parses a single command line option in the format "<optionName>=<value>"
505     // (no spaces allowed) and set the specified option if appropriate.
506     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
507
508     JS_EXPORT_PRIVATE static void dumpAllOptions(FILE*, DumpLevel, const char* title = nullptr);
509     JS_EXPORT_PRIVATE static void dumpAllOptionsInALine(StringBuilder&);
510
511     JS_EXPORT_PRIVATE static void ensureOptionsAreCoherent();
512
513     JS_EXPORT_PRIVATE static void enableRestrictedOptions(bool enableOrNot);
514
515     // Declare accessors for each option:
516 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
517     ALWAYS_INLINE static type_& name_() { return s_options[name_##ID].type_##Val; } \
518     ALWAYS_INLINE static type_& name_##Default() { return s_defaultOptions[name_##ID].type_##Val; }
519
520     JSC_OPTIONS(FOR_EACH_OPTION)
521 #undef FOR_EACH_OPTION
522
523     static bool isAvailable(ID, Availability);
524
525 private:
526     // For storing for an option value:
527     union Entry {
528         bool boolVal;
529         unsigned unsignedVal;
530         double doubleVal;
531         int32 int32Val;
532         OptionRange optionRangeVal;
533         const char* optionStringVal;
534         GCLogging::Level gcLogLevelVal;
535     };
536
537     // For storing constant meta data about each option:
538     struct EntryInfo {
539         const char* name;
540         const char* description;
541         Type type;
542         Availability availability;
543     };
544
545     Options();
546
547     enum DumpDefaultsOption {
548         DontDumpDefaults,
549         DumpDefaults
550     };
551     static void dumpOptionsIfNeeded();
552     static void dumpAllOptions(StringBuilder&, DumpLevel, const char* title,
553         const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
554     static void dumpOption(StringBuilder&, DumpLevel, ID,
555         const char* optionHeader, const char* optionFooter, DumpDefaultsOption);
556
557     static bool setOptionWithoutAlias(const char* arg);
558     static bool setAliasedOption(const char* arg);
559     static bool overrideAliasedOptionWithHeuristic(const char* name);
560
561     // Declare the singleton instance of the options store:
562     JS_EXPORTDATA static Entry s_options[numberOfOptions];
563     static Entry s_defaultOptions[numberOfOptions];
564     static const EntryInfo s_optionsInfo[numberOfOptions];
565
566     friend class Option;
567 };
568
569 class Option {
570 public:
571     Option(Options::ID id)
572         : m_id(id)
573         , m_entry(Options::s_options[m_id])
574     {
575     }
576     
577     void dump(StringBuilder&) const;
578
579     bool operator==(const Option& other) const;
580     bool operator!=(const Option& other) const { return !(*this == other); }
581     
582     Options::ID id() const { return m_id; }
583     const char* name() const;
584     const char* description() const;
585     Options::Type type() const;
586     Options::Availability availability() const;
587     bool isOverridden() const;
588     const Option defaultOption() const;
589     
590     bool& boolVal();
591     unsigned& unsignedVal();
592     double& doubleVal();
593     int32_t& int32Val();
594     OptionRange optionRangeVal();
595     const char* optionStringVal();
596     GCLogging::Level& gcLogLevelVal();
597     
598 private:
599     // Only used for constructing default Options.
600     Option(Options::ID id, Options::Entry& entry)
601         : m_id(id)
602         , m_entry(entry)
603     {
604     }
605     
606     Options::ID m_id;
607     Options::Entry& m_entry;
608 };
609
610 inline const char* Option::name() const
611 {
612     return Options::s_optionsInfo[m_id].name;
613 }
614
615 inline const char* Option::description() const
616 {
617     return Options::s_optionsInfo[m_id].description;
618 }
619
620 inline Options::Type Option::type() const
621 {
622     return Options::s_optionsInfo[m_id].type;
623 }
624
625 inline Options::Availability Option::availability() const
626 {
627     return Options::s_optionsInfo[m_id].availability;
628 }
629
630 inline bool Option::isOverridden() const
631 {
632     return *this != defaultOption();
633 }
634
635 inline const Option Option::defaultOption() const
636 {
637     return Option(m_id, Options::s_defaultOptions[m_id]);
638 }
639
640 inline bool& Option::boolVal()
641 {
642     return m_entry.boolVal;
643 }
644
645 inline unsigned& Option::unsignedVal()
646 {
647     return m_entry.unsignedVal;
648 }
649
650 inline double& Option::doubleVal()
651 {
652     return m_entry.doubleVal;
653 }
654
655 inline int32_t& Option::int32Val()
656 {
657     return m_entry.int32Val;
658 }
659
660 inline OptionRange Option::optionRangeVal()
661 {
662     return m_entry.optionRangeVal;
663 }
664
665 inline const char* Option::optionStringVal()
666 {
667     return m_entry.optionStringVal;
668 }
669
670 inline GCLogging::Level& Option::gcLogLevelVal()
671 {
672     return m_entry.gcLogLevelVal;
673 }
674
675 } // namespace JSC