84d7326a24fbe5a5de03c5c38dbf2bdedf2360cb
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.cpp
1 /*
2  * Copyright (C) 2011-2018 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 #include "config.h"
27 #include "Options.h"
28
29 #include "AssemblerCommon.h"
30 #include "LLIntCommon.h"
31 #include "MinimumReservedZoneSize.h"
32 #include "SigillCrashAnalyzer.h"
33 #include <algorithm>
34 #include <limits>
35 #include <math.h>
36 #include <mutex>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <wtf/ASCIICType.h>
40 #include <wtf/Compiler.h>
41 #include <wtf/DataLog.h>
42 #include <wtf/NumberOfCores.h>
43 #include <wtf/PointerPreparations.h>
44 #include <wtf/StdLibExtras.h>
45 #include <wtf/text/StringBuilder.h>
46 #include <wtf/threads/Signals.h>
47
48 #if PLATFORM(COCOA)
49 #include <crt_externs.h>
50 #endif
51
52 #if ENABLE(JIT)
53 #include "MacroAssembler.h"
54 #endif
55
56 namespace JSC {
57
58 namespace {
59 #ifdef NDEBUG
60 bool restrictedOptionsEnabled = false;
61 #else
62 bool restrictedOptionsEnabled = true;
63 #endif
64 }
65
66 void Options::enableRestrictedOptions(bool enableOrNot)
67 {
68     restrictedOptionsEnabled = enableOrNot;
69 }
70     
71 static bool parse(const char* string, bool& value)
72 {
73     if (equalLettersIgnoringASCIICase(string, "true") || equalLettersIgnoringASCIICase(string, "yes") || !strcmp(string, "1")) {
74         value = true;
75         return true;
76     }
77     if (equalLettersIgnoringASCIICase(string, "false") || equalLettersIgnoringASCIICase(string, "no") || !strcmp(string, "0")) {
78         value = false;
79         return true;
80     }
81     return false;
82 }
83
84 static bool parse(const char* string, int32_t& value)
85 {
86     return sscanf(string, "%d", &value) == 1;
87 }
88
89 static bool parse(const char* string, unsigned& value)
90 {
91     return sscanf(string, "%u", &value) == 1;
92 }
93
94 static bool UNUSED_FUNCTION parse(const char* string, unsigned long& value)
95 {
96     return sscanf(string, "%lu", &value);
97 }
98
99 static bool UNUSED_FUNCTION parse(const char* string, unsigned long long& value)
100 {
101     return sscanf(string, "%llu", &value);
102 }
103
104 static bool parse(const char* string, double& value)
105 {
106     return sscanf(string, "%lf", &value) == 1;
107 }
108
109 static bool parse(const char* string, OptionRange& value)
110 {
111     return value.init(string);
112 }
113
114 static bool parse(const char* string, const char*& value)
115 {
116     if (!strlen(string)) {
117         value = nullptr;
118         return true;
119     }
120
121     // FIXME <https://webkit.org/b/169057>: This could leak if this option is set more than once.
122     // Given that Options are typically used for testing, this isn't considered to be a problem.
123     value = WTF::fastStrDup(string);
124     return true;
125 }
126
127 static bool parse(const char* string, GCLogging::Level& value)
128 {
129     if (equalLettersIgnoringASCIICase(string, "none") || equalLettersIgnoringASCIICase(string, "no") || equalLettersIgnoringASCIICase(string, "false") || !strcmp(string, "0")) {
130         value = GCLogging::None;
131         return true;
132     }
133
134     if (equalLettersIgnoringASCIICase(string, "basic") || equalLettersIgnoringASCIICase(string, "yes") || equalLettersIgnoringASCIICase(string, "true") || !strcmp(string, "1")) {
135         value = GCLogging::Basic;
136         return true;
137     }
138
139     if (equalLettersIgnoringASCIICase(string, "verbose") || !strcmp(string, "2")) {
140         value = GCLogging::Verbose;
141         return true;
142     }
143
144     return false;
145 }
146
147 bool Options::isAvailable(Options::ID id, Options::Availability availability)
148 {
149     if (availability == Availability::Restricted)
150         return restrictedOptionsEnabled;
151     ASSERT(availability == Availability::Configurable);
152     
153     UNUSED_PARAM(id);
154 #if !defined(NDEBUG)
155     if (id == maxSingleAllocationSizeID)
156         return true;
157 #endif
158 #if OS(DARWIN)
159     if (id == useSigillCrashAnalyzerID)
160         return true;
161 #endif
162 #if ENABLE(ASSEMBLER) && OS(LINUX)
163     if (id == logJITCodeForPerfID)
164         return true;
165 #endif
166     if (id == traceLLIntExecutionID)
167         return !!LLINT_TRACING;
168     if (id == traceLLIntSlowPathID)
169         return !!LLINT_TRACING;
170     return false;
171 }
172
173 template<typename T>
174 bool overrideOptionWithHeuristic(T& variable, Options::ID id, const char* name, Options::Availability availability)
175 {
176     bool available = (availability == Options::Availability::Normal)
177         || Options::isAvailable(id, availability);
178
179     const char* stringValue = getenv(name);
180     if (!stringValue)
181         return false;
182     
183     if (available && parse(stringValue, variable))
184         return true;
185     
186     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
187     return false;
188 }
189
190 bool Options::overrideAliasedOptionWithHeuristic(const char* name)
191 {
192     const char* stringValue = getenv(name);
193     if (!stringValue)
194         return false;
195
196     String aliasedOption;
197     aliasedOption = String(&name[4]) + "=" + stringValue;
198     if (Options::setOption(aliasedOption.utf8().data()))
199         return true;
200
201     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
202     return false;
203 }
204
205 static unsigned computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum = 1)
206 {
207     int cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfWorkerThreads);
208
209     // Be paranoid, it is the OS we're dealing with, after all.
210     ASSERT(cpusToUse >= 1);
211     return std::max(cpusToUse, minimum);
212 }
213
214 static int32_t computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)
215 {
216     if (WTF::numberOfProcessorCores() <= 2)
217         return twoCorePriorityDelta;
218
219     return multiCorePriorityDelta;
220 }
221
222 static bool jitEnabledByDefault()
223 {
224     return is32Bit() || isAddress64Bit();
225 }
226
227 static unsigned computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)
228 {
229     return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);
230 }
231
232 const char* const OptionRange::s_nullRangeStr = "<null>";
233
234 bool OptionRange::init(const char* rangeString)
235 {
236     // rangeString should be in the form of [!]<low>[:<high>]
237     // where low and high are unsigned
238
239     bool invert = false;
240
241     if (!rangeString) {
242         m_state = InitError;
243         return false;
244     }
245
246     if (!strcmp(rangeString, s_nullRangeStr)) {
247         m_state = Uninitialized;
248         return true;
249     }
250     
251     const char* p = rangeString;
252
253     if (*p == '!') {
254         invert = true;
255         p++;
256     }
257
258     int scanResult = sscanf(p, " %u:%u", &m_lowLimit, &m_highLimit);
259
260     if (!scanResult || scanResult == EOF) {
261         m_state = InitError;
262         return false;
263     }
264
265     if (scanResult == 1)
266         m_highLimit = m_lowLimit;
267
268     if (m_lowLimit > m_highLimit) {
269         m_state = InitError;
270         return false;
271     }
272
273     // FIXME <https://webkit.org/b/169057>: This could leak if this particular option is set more than once.
274     // Given that these options are used for testing, this isn't considered to be problem.
275     m_rangeString = WTF::fastStrDup(rangeString);
276     m_state = invert ? Inverted : Normal;
277
278     return true;
279 }
280
281 bool OptionRange::isInRange(unsigned count)
282 {
283     if (m_state < Normal)
284         return true;
285
286     if ((m_lowLimit <= count) && (count <= m_highLimit))
287         return m_state == Normal ? true : false;
288
289     return m_state == Normal ? false : true;
290 }
291
292 void OptionRange::dump(PrintStream& out) const
293 {
294     out.print(m_rangeString);
295 }
296
297 Options::Entry Options::s_options[Options::numberOfOptions];
298 Options::Entry Options::s_defaultOptions[Options::numberOfOptions];
299
300 // Realize the names for each of the options:
301 const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {
302 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
303     { #name_, description_, Options::Type::type_##Type, Availability::availability_ },
304     JSC_OPTIONS(FOR_EACH_OPTION)
305 #undef FOR_EACH_OPTION
306 };
307
308 static void scaleJITPolicy()
309 {
310     auto& scaleFactor = Options::jitPolicyScale();
311     if (scaleFactor > 1.0)
312         scaleFactor = 1.0;
313     else if (scaleFactor < 0.0)
314         scaleFactor = 0.0;
315
316     struct OptionToScale {
317         Options::ID id;
318         int32_t minVal;
319     };
320
321     static const OptionToScale optionsToScale[] = {
322         { Options::thresholdForJITAfterWarmUpID, 0 },
323         { Options::thresholdForJITSoonID, 0 },
324         { Options::thresholdForOptimizeAfterWarmUpID, 1 },
325         { Options::thresholdForOptimizeAfterLongWarmUpID, 1 },
326         { Options::thresholdForOptimizeSoonID, 1 },
327         { Options::thresholdForFTLOptimizeSoonID, 2 },
328         { Options::thresholdForFTLOptimizeAfterWarmUpID, 2 }
329     };
330
331     const int numberOfOptionsToScale = sizeof(optionsToScale) / sizeof(OptionToScale);
332     for (int i = 0; i < numberOfOptionsToScale; i++) {
333         Option option(optionsToScale[i].id);
334         ASSERT(option.type() == Options::Type::int32Type);
335         option.int32Val() *= scaleFactor;
336         option.int32Val() = std::max(option.int32Val(), optionsToScale[i].minVal);
337     }
338 }
339
340 static void overrideDefaults()
341 {
342 #if !PLATFORM(IOS_FAMILY)
343     if (WTF::numberOfProcessorCores() < 4)
344 #endif
345     {
346         Options::maximumMutatorUtilization() = 0.6;
347         Options::concurrentGCMaxHeadroom() = 1.4;
348         Options::minimumGCPauseMS() = 1;
349         Options::useStochasticMutatorScheduler() = false;
350         if (WTF::numberOfProcessorCores() <= 1)
351             Options::gcIncrementScale() = 1;
352         else
353             Options::gcIncrementScale() = 0;
354     }
355
356 #if PLATFORM(IOS_FAMILY)
357     // On iOS, we control heap growth using process memory footprint. Therefore these values can be agressive.
358     Options::smallHeapRAMFraction() = 0.8;
359     Options::mediumHeapRAMFraction() = 0.9;
360
361 #if !PLATFORM(WATCHOS) && defined(__LP64__)
362     Options::useSigillCrashAnalyzer() = true;
363 #endif
364 #endif
365
366 #if !ENABLE(SIGNAL_BASED_VM_TRAPS)
367     Options::usePollingTraps() = true;
368 #endif
369
370 #if !ENABLE(WEBASSEMBLY_FAST_MEMORY)
371     Options::useWebAssemblyFastMemory() = false;
372 #endif
373
374 #if !HAVE(MACH_EXCEPTIONS)
375     Options::useMachForExceptions() = false;
376 #endif
377 }
378
379 static void correctOptions()
380 {
381     unsigned thresholdForGlobalLexicalBindingEpoch = Options::thresholdForGlobalLexicalBindingEpoch();
382     if (thresholdForGlobalLexicalBindingEpoch == 0 || thresholdForGlobalLexicalBindingEpoch == 1)
383         Options::thresholdForGlobalLexicalBindingEpoch() = UINT_MAX;
384 }
385
386 static void recomputeDependentOptions()
387 {
388 #if !defined(NDEBUG)
389     Options::validateDFGExceptionHandling() = true;
390 #endif
391 #if !ENABLE(JIT)
392     Options::useLLInt() = true;
393     Options::useJIT() = false;
394     Options::useDFGJIT() = false;
395     Options::useFTLJIT() = false;
396     Options::useDOMJIT() = false;
397 #endif
398 #if !ENABLE(YARR_JIT)
399     Options::useRegExpJIT() = false;
400 #endif
401 #if !ENABLE(CONCURRENT_JS)
402     Options::useConcurrentJIT() = false;
403 #endif
404 #if !ENABLE(DFG_JIT)
405     Options::useDFGJIT() = false;
406     Options::useFTLJIT() = false;
407 #endif
408 #if !ENABLE(FTL_JIT)
409     Options::useFTLJIT() = false;
410 #endif
411     
412 #if !CPU(X86_64) && !CPU(ARM64)
413     Options::useConcurrentGC() = false;
414 #endif
415     
416 #if ENABLE(JIT) && CPU(X86)
417     // Disable JIT on IA-32 if SSE2 is not present
418     if (!MacroAssemblerX86::supportsFloatingPoint())
419         Options::useJIT() = false;
420 #endif
421
422     WTF_SET_POINTER_PREPARATION_OPTIONS();
423
424     if (!Options::useJIT())
425         Options::useWebAssembly() = false;
426
427     if (!Options::useWebAssembly())
428         Options::useFastTLSForWasmContext() = false;
429     
430     if (Options::dumpDisassembly()
431         || Options::dumpDFGDisassembly()
432         || Options::dumpFTLDisassembly()
433         || Options::dumpBytecodeAtDFGTime()
434         || Options::dumpGraphAtEachPhase()
435         || Options::dumpDFGGraphAtEachPhase()
436         || Options::dumpDFGFTLGraphAtEachPhase()
437         || Options::dumpB3GraphAtEachPhase()
438         || Options::dumpAirGraphAtEachPhase()
439         || Options::verboseCompilation()
440         || Options::verboseFTLCompilation()
441         || Options::logCompilationChanges()
442         || Options::validateGraph()
443         || Options::validateGraphAtEachPhase()
444         || Options::verboseOSR()
445         || Options::verboseCompilationQueue()
446         || Options::reportCompileTimes()
447         || Options::reportBaselineCompileTimes()
448         || Options::reportDFGCompileTimes()
449         || Options::reportFTLCompileTimes()
450         || Options::logPhaseTimes()
451         || Options::verboseCFA()
452         || Options::verboseDFGFailure()
453         || Options::verboseFTLFailure())
454         Options::alwaysComputeHash() = true;
455     
456     if (!Options::useConcurrentGC())
457         Options::collectContinuously() = false;
458
459     if (Option(Options::jitPolicyScaleID).isOverridden())
460         scaleJITPolicy();
461     
462     if (Options::forceEagerCompilation()) {
463         Options::thresholdForJITAfterWarmUp() = 10;
464         Options::thresholdForJITSoon() = 10;
465         Options::thresholdForOptimizeAfterWarmUp() = 20;
466         Options::thresholdForOptimizeAfterLongWarmUp() = 20;
467         Options::thresholdForOptimizeSoon() = 20;
468         Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
469         Options::thresholdForFTLOptimizeSoon() = 20;
470         Options::maximumEvalCacheableSourceLength() = 150000;
471         Options::useConcurrentJIT() = false;
472     }
473     if (Options::useMaximalFlushInsertionPhase()) {
474         Options::useOSREntryToDFG() = false;
475         Options::useOSREntryToFTL() = false;
476     }
477     
478 #if ENABLE(SEPARATED_WX_HEAP)
479     // Override globally for now. Longer term we'll just make the default
480     // be to have this option enabled, and have platforms that don't support
481     // it just silently use a single mapping.
482     Options::useSeparatedWXHeap() = true;
483 #else
484     Options::useSeparatedWXHeap() = false;
485 #endif
486
487     if (Options::alwaysUseShadowChicken())
488         Options::maximumInliningDepth() = 1;
489
490     // Compute the maximum value of the reoptimization retry counter. This is simply
491     // the largest value at which we don't overflow the execute counter, when using it
492     // to left-shift the execution counter by this amount. Currently the value ends
493     // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
494     // total on a 32-bit processor.
495     Options::reoptimizationRetryCounterMax() = 0;
496     while ((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << (Options::reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()))
497         Options::reoptimizationRetryCounterMax()++;
498
499     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) > 0);
500     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
501
502 #if !defined(NDEBUG)
503     if (Options::maxSingleAllocationSize())
504         fastSetMaxSingleAllocationSize(Options::maxSingleAllocationSize());
505     else
506         fastSetMaxSingleAllocationSize(std::numeric_limits<size_t>::max());
507 #endif
508
509     if (Options::useZombieMode()) {
510         Options::sweepSynchronously() = true;
511         Options::scribbleFreeCells() = true;
512     }
513
514     if (Options::useSigillCrashAnalyzer())
515         enableSigillCrashAnalyzer();
516
517     if (Options::reservedZoneSize() < minimumReservedZoneSize)
518         Options::reservedZoneSize() = minimumReservedZoneSize;
519     if (Options::softReservedZoneSize() < Options::reservedZoneSize() + minimumReservedZoneSize)
520         Options::softReservedZoneSize() = Options::reservedZoneSize() + minimumReservedZoneSize;
521
522 #if USE(JSVALUE32_64)
523     // FIXME: Make probe OSR exit work on 32-bit:
524     // https://bugs.webkit.org/show_bug.cgi?id=177956
525     Options::useProbeOSRExit() = false;
526 #endif
527
528     if (!Options::useCodeCache())
529         Options::diskCachePath() = nullptr;
530 }
531
532 void Options::initialize()
533 {
534     static std::once_flag initializeOptionsOnceFlag;
535     
536     std::call_once(
537         initializeOptionsOnceFlag,
538         [] {
539             // Initialize each of the options with their default values:
540 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
541             name_() = defaultValue_;                                    \
542             name_##Default() = defaultValue_;
543             JSC_OPTIONS(FOR_EACH_OPTION)
544 #undef FOR_EACH_OPTION
545
546             overrideDefaults();
547                 
548             // Allow environment vars to override options if applicable.
549             // The evn var should be the name of the option prefixed with
550             // "JSC_".
551 #if PLATFORM(COCOA)
552             bool hasBadOptions = false;
553             for (char** envp = *_NSGetEnviron(); *envp; envp++) {
554                 const char* env = *envp;
555                 if (!strncmp("JSC_", env, 4)) {
556                     if (!Options::setOption(&env[4])) {
557                         dataLog("ERROR: invalid option: ", *envp, "\n");
558                         hasBadOptions = true;
559                     }
560                 }
561             }
562             if (hasBadOptions && Options::validateOptions())
563                 CRASH();
564 #else // PLATFORM(COCOA)
565 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
566             overrideOptionWithHeuristic(name_(), name_##ID, "JSC_" #name_, Availability::availability_);
567             JSC_OPTIONS(FOR_EACH_OPTION)
568 #undef FOR_EACH_OPTION
569 #endif // PLATFORM(COCOA)
570
571 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence_) \
572             overrideAliasedOptionWithHeuristic("JSC_" #aliasedName_);
573             JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
574 #undef FOR_EACH_OPTION
575
576 #if 0
577                 ; // Deconfuse editors that do auto indentation
578 #endif
579
580             correctOptions();
581     
582             recomputeDependentOptions();
583
584             // Do range checks where needed and make corrections to the options:
585             ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
586             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= Options::thresholdForOptimizeSoon());
587             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
588             ASSERT(Options::criticalGCMemoryThreshold() > 0.0 && Options::criticalGCMemoryThreshold() < 1.0);
589
590             dumpOptionsIfNeeded();
591             ensureOptionsAreCoherent();
592
593 #if HAVE(MACH_EXCEPTIONS)
594             if (Options::useMachForExceptions())
595                 handleSignalsWithMach();
596 #endif
597
598 #if ASAN_ENABLED && OS(LINUX) && ENABLE(WEBASSEMBLY_FAST_MEMORY)
599             if (Options::useWebAssemblyFastMemory()) {
600                 const char* asanOptions = getenv("ASAN_OPTIONS");
601                 bool okToUseWebAssemblyFastMemory = asanOptions
602                     && (strstr(asanOptions, "allow_user_segv_handler=1") || strstr(asanOptions, "handle_segv=0"));
603                 if (!okToUseWebAssemblyFastMemory) {
604                     dataLogLn("WARNING: ASAN interferes with JSC signal handlers; useWebAssemblyFastMemory will be disabled.");
605                     Options::useWebAssemblyFastMemory() = false;
606                 }
607             }
608 #endif
609         });
610 }
611
612 void Options::dumpOptionsIfNeeded()
613 {
614     if (Options::dumpOptions()) {
615         DumpLevel level = static_cast<DumpLevel>(Options::dumpOptions());
616         if (level > DumpLevel::Verbose)
617             level = DumpLevel::Verbose;
618             
619         const char* title = nullptr;
620         switch (level) {
621         case DumpLevel::None:
622             break;
623         case DumpLevel::Overridden:
624             title = "Overridden JSC options:";
625             break;
626         case DumpLevel::All:
627             title = "All JSC options:";
628             break;
629         case DumpLevel::Verbose:
630             title = "All JSC options with descriptions:";
631             break;
632         }
633
634         StringBuilder builder;
635         dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
636         dataLog(builder.toString());
637     }
638 }
639
640 static bool isSeparator(char c)
641 {
642     return isASCIISpace(c) || (c == ',');
643 }
644
645 bool Options::setOptions(const char* optionsStr)
646 {
647     Vector<char*> options;
648
649     size_t length = strlen(optionsStr);
650     char* optionsStrCopy = WTF::fastStrDup(optionsStr);
651     char* end = optionsStrCopy + length;
652     char* p = optionsStrCopy;
653
654     while (p < end) {
655         // Skip separators (white space or commas).
656         while (p < end && isSeparator(*p))
657             p++;
658         if (p == end)
659             break;
660
661         char* optionStart = p;
662         p = strstr(p, "=");
663         if (!p) {
664             dataLogF("'=' not found in option string: %p\n", optionStart);
665             WTF::fastFree(optionsStrCopy);
666             return false;
667         }
668         p++;
669
670         char* valueBegin = p;
671         bool hasStringValue = false;
672         const int minStringLength = 2; // The min is an empty string i.e. 2 double quotes.
673         if ((p + minStringLength < end) && (*p == '"')) {
674             p = strstr(p + 1, "\"");
675             if (!p) {
676                 dataLogF("Missing trailing '\"' in option string: %p\n", optionStart);
677                 WTF::fastFree(optionsStrCopy);
678                 return false; // End of string not found.
679             }
680             hasStringValue = true;
681         }
682
683         // Find next separator (white space or commas).
684         while (p < end && !isSeparator(*p))
685             p++;
686         if (!p)
687             p = end; // No more " " separator. Hence, this is the last arg.
688
689         // If we have a well-formed string value, strip the quotes.
690         if (hasStringValue) {
691             char* valueEnd = p;
692             ASSERT((*valueBegin == '"') && ((valueEnd - valueBegin) >= minStringLength) && (valueEnd[-1] == '"'));
693             memmove(valueBegin, valueBegin + 1, valueEnd - valueBegin - minStringLength);
694             valueEnd[-minStringLength] = '\0';
695         }
696
697         // Strip leading -- if present.
698         if ((p -  optionStart > 2) && optionStart[0] == '-' && optionStart[1] == '-')
699             optionStart += 2;
700
701         *p++ = '\0';
702         options.append(optionStart);
703     }
704
705     bool success = true;
706     for (auto& option : options) {
707         bool optionSuccess = setOption(option);
708         if (!optionSuccess) {
709             dataLogF("Failed to set option : %s\n", option);
710             success = false;
711         }
712     }
713
714     correctOptions();
715
716     recomputeDependentOptions();
717
718     dumpOptionsIfNeeded();
719
720     ensureOptionsAreCoherent();
721
722     WTF::fastFree(optionsStrCopy);
723
724     return success;
725 }
726
727 // Parses a single command line option in the format "<optionName>=<value>"
728 // (no spaces allowed) and set the specified option if appropriate.
729 bool Options::setOptionWithoutAlias(const char* arg)
730 {
731     // arg should look like this:
732     //   <jscOptionName>=<appropriate value>
733     const char* equalStr = strchr(arg, '=');
734     if (!equalStr)
735         return false;
736
737     const char* valueStr = equalStr + 1;
738
739     // For each option, check if the specify arg is a match. If so, set the arg
740     // if the value makes sense. Otherwise, move on to checking the next option.
741 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
742     if (strlen(#name_) == static_cast<size_t>(equalStr - arg)      \
743         && !strncmp(arg, #name_, equalStr - arg)) {                \
744         if (Availability::availability_ != Availability::Normal     \
745             && !isAvailable(name_##ID, Availability::availability_)) \
746             return false;                                          \
747         type_ value;                                               \
748         value = (defaultValue_);                                   \
749         bool success = parse(valueStr, value);                     \
750         if (success) {                                             \
751             name_() = value;                                       \
752             correctOptions();                                      \
753             recomputeDependentOptions();                           \
754             return true;                                           \
755         }                                                          \
756         return false;                                              \
757     }
758
759     JSC_OPTIONS(FOR_EACH_OPTION)
760 #undef FOR_EACH_OPTION
761
762     return false; // No option matched.
763 }
764
765 static bool invertBoolOptionValue(const char* valueStr, const char*& invertedValueStr)
766 {
767     bool boolValue;
768     if (!parse(valueStr, boolValue))
769         return false;
770     invertedValueStr = boolValue ? "false" : "true";
771     return true;
772 }
773
774
775 bool Options::setAliasedOption(const char* arg)
776 {
777     // arg should look like this:
778     //   <jscOptionName>=<appropriate value>
779     const char* equalStr = strchr(arg, '=');
780     if (!equalStr)
781         return false;
782
783     IGNORE_WARNINGS_BEGIN("tautological-compare")
784
785     // For each option, check if the specify arg is a match. If so, set the arg
786     // if the value makes sense. Otherwise, move on to checking the next option.
787 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence) \
788     if (strlen(#aliasedName_) == static_cast<size_t>(equalStr - arg)    \
789         && !strncmp(arg, #aliasedName_, equalStr - arg)) {              \
790         String unaliasedOption(#unaliasedName_);                        \
791         if (equivalence == SameOption)                                  \
792             unaliasedOption = unaliasedOption + equalStr;               \
793         else {                                                          \
794             ASSERT(equivalence == InvertedOption);                      \
795             const char* invertedValueStr = nullptr;                     \
796             if (!invertBoolOptionValue(equalStr + 1, invertedValueStr)) \
797                 return false;                                           \
798             unaliasedOption = unaliasedOption + "=" + invertedValueStr; \
799         }                                                               \
800         return setOptionWithoutAlias(unaliasedOption.utf8().data());   \
801     }
802
803     JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
804 #undef FOR_EACH_OPTION
805
806     IGNORE_WARNINGS_END
807
808     return false; // No option matched.
809 }
810
811 bool Options::setOption(const char* arg)
812 {
813     bool success = setOptionWithoutAlias(arg);
814     if (success)
815         return true;
816     return setAliasedOption(arg);
817 }
818
819
820 void Options::dumpAllOptions(StringBuilder& builder, DumpLevel level, const char* title,
821     const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption dumpDefaultsOption)
822 {
823     if (title) {
824         builder.append(title);
825         builder.append('\n');
826     }
827
828     for (int id = 0; id < numberOfOptions; id++) {
829         if (separator && id)
830             builder.append(separator);
831         dumpOption(builder, level, static_cast<ID>(id), optionHeader, optionFooter, dumpDefaultsOption);
832     }
833 }
834
835 void Options::dumpAllOptionsInALine(StringBuilder& builder)
836 {
837     dumpAllOptions(builder, DumpLevel::All, nullptr, " ", nullptr, nullptr, DontDumpDefaults);
838 }
839
840 void Options::dumpAllOptions(FILE* stream, DumpLevel level, const char* title)
841 {
842     StringBuilder builder;
843     dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
844     fprintf(stream, "%s", builder.toString().utf8().data());
845 }
846
847 void Options::dumpOption(StringBuilder& builder, DumpLevel level, Options::ID id,
848     const char* header, const char* footer, DumpDefaultsOption dumpDefaultsOption)
849 {
850     if (id >= numberOfOptions)
851         return; // Illegal option.
852
853     Option option(id);
854     Availability availability = option.availability();
855     if (availability != Availability::Normal && !isAvailable(id, availability))
856         return;
857
858     bool wasOverridden = option.isOverridden();
859     bool needsDescription = (level == DumpLevel::Verbose && option.description());
860
861     if (level == DumpLevel::Overridden && !wasOverridden)
862         return;
863
864     if (header)
865         builder.append(header);
866     builder.append(option.name());
867     builder.append('=');
868     option.dump(builder);
869
870     if (wasOverridden && (dumpDefaultsOption == DumpDefaults)) {
871         builder.appendLiteral(" (default: ");
872         option.defaultOption().dump(builder);
873         builder.appendLiteral(")");
874     }
875
876     if (needsDescription) {
877         builder.appendLiteral("   ... ");
878         builder.append(option.description());
879     }
880
881     builder.append(footer);
882 }
883
884 void Options::ensureOptionsAreCoherent()
885 {
886     bool coherent = true;
887     if (!(useLLInt() || useJIT())) {
888         coherent = false;
889         dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
890     }
891     if (!coherent)
892         CRASH();
893 }
894
895 void Option::dump(StringBuilder& builder) const
896 {
897     switch (type()) {
898     case Options::Type::boolType:
899         builder.append(m_entry.boolVal ? "true" : "false");
900         break;
901     case Options::Type::unsignedType:
902         builder.appendNumber(m_entry.unsignedVal);
903         break;
904     case Options::Type::sizeType:
905         builder.appendNumber(m_entry.sizeVal);
906         break;
907     case Options::Type::doubleType:
908         builder.appendNumber(m_entry.doubleVal);
909         break;
910     case Options::Type::int32Type:
911         builder.appendNumber(m_entry.int32Val);
912         break;
913     case Options::Type::optionRangeType:
914         builder.append(m_entry.optionRangeVal.rangeString());
915         break;
916     case Options::Type::optionStringType: {
917         const char* option = m_entry.optionStringVal;
918         if (!option)
919             option = "";
920         builder.append('"');
921         builder.append(option);
922         builder.append('"');
923         break;
924     }
925     case Options::Type::gcLogLevelType: {
926         builder.append(GCLogging::levelAsString(m_entry.gcLogLevelVal));
927         break;
928     }
929     }
930 }
931
932 bool Option::operator==(const Option& other) const
933 {
934     switch (type()) {
935     case Options::Type::boolType:
936         return m_entry.boolVal == other.m_entry.boolVal;
937     case Options::Type::unsignedType:
938         return m_entry.unsignedVal == other.m_entry.unsignedVal;
939     case Options::Type::sizeType:
940         return m_entry.sizeVal == other.m_entry.sizeVal;
941     case Options::Type::doubleType:
942         return (m_entry.doubleVal == other.m_entry.doubleVal) || (std::isnan(m_entry.doubleVal) && std::isnan(other.m_entry.doubleVal));
943     case Options::Type::int32Type:
944         return m_entry.int32Val == other.m_entry.int32Val;
945     case Options::Type::optionRangeType:
946         return m_entry.optionRangeVal.rangeString() == other.m_entry.optionRangeVal.rangeString();
947     case Options::Type::optionStringType:
948         return (m_entry.optionStringVal == other.m_entry.optionStringVal)
949             || (m_entry.optionStringVal && other.m_entry.optionStringVal && !strcmp(m_entry.optionStringVal, other.m_entry.optionStringVal));
950     case Options::Type::gcLogLevelType:
951         return m_entry.gcLogLevelVal == other.m_entry.gcLogLevelVal;
952     }
953     return false;
954 }
955
956 } // namespace JSC
957