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