Cache bytecode to disk
[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 recomputeDependentOptions()
380 {
381 #if !defined(NDEBUG)
382     Options::validateDFGExceptionHandling() = true;
383 #endif
384 #if !ENABLE(JIT)
385     Options::useLLInt() = true;
386     Options::useJIT() = false;
387     Options::useDFGJIT() = false;
388     Options::useFTLJIT() = false;
389     Options::useDOMJIT() = false;
390 #endif
391 #if !ENABLE(YARR_JIT)
392     Options::useRegExpJIT() = false;
393 #endif
394 #if !ENABLE(CONCURRENT_JS)
395     Options::useConcurrentJIT() = false;
396 #endif
397 #if !ENABLE(DFG_JIT)
398     Options::useDFGJIT() = false;
399     Options::useFTLJIT() = false;
400 #endif
401 #if !ENABLE(FTL_JIT)
402     Options::useFTLJIT() = false;
403 #endif
404     
405 #if !CPU(X86_64) && !CPU(ARM64)
406     Options::useConcurrentGC() = false;
407 #endif
408     
409 #if ENABLE(JIT) && CPU(X86)
410     // Disable JIT on IA-32 if SSE2 is not present
411     if (!MacroAssemblerX86::supportsFloatingPoint())
412         Options::useJIT() = false;
413 #endif
414
415     WTF_SET_POINTER_PREPARATION_OPTIONS();
416
417     if (!Options::useJIT())
418         Options::useWebAssembly() = false;
419
420     if (!Options::useWebAssembly())
421         Options::useFastTLSForWasmContext() = false;
422     
423     if (Options::dumpDisassembly()
424         || Options::dumpDFGDisassembly()
425         || Options::dumpFTLDisassembly()
426         || Options::dumpBytecodeAtDFGTime()
427         || Options::dumpGraphAtEachPhase()
428         || Options::dumpDFGGraphAtEachPhase()
429         || Options::dumpDFGFTLGraphAtEachPhase()
430         || Options::dumpB3GraphAtEachPhase()
431         || Options::dumpAirGraphAtEachPhase()
432         || Options::verboseCompilation()
433         || Options::verboseFTLCompilation()
434         || Options::logCompilationChanges()
435         || Options::validateGraph()
436         || Options::validateGraphAtEachPhase()
437         || Options::verboseOSR()
438         || Options::verboseCompilationQueue()
439         || Options::reportCompileTimes()
440         || Options::reportBaselineCompileTimes()
441         || Options::reportDFGCompileTimes()
442         || Options::reportFTLCompileTimes()
443         || Options::logPhaseTimes()
444         || Options::verboseCFA()
445         || Options::verboseDFGFailure()
446         || Options::verboseFTLFailure())
447         Options::alwaysComputeHash() = true;
448     
449     if (!Options::useConcurrentGC())
450         Options::collectContinuously() = false;
451
452     if (Option(Options::jitPolicyScaleID).isOverridden())
453         scaleJITPolicy();
454     
455     if (Options::forceEagerCompilation()) {
456         Options::thresholdForJITAfterWarmUp() = 10;
457         Options::thresholdForJITSoon() = 10;
458         Options::thresholdForOptimizeAfterWarmUp() = 20;
459         Options::thresholdForOptimizeAfterLongWarmUp() = 20;
460         Options::thresholdForOptimizeSoon() = 20;
461         Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
462         Options::thresholdForFTLOptimizeSoon() = 20;
463         Options::maximumEvalCacheableSourceLength() = 150000;
464         Options::useConcurrentJIT() = false;
465     }
466     if (Options::useMaximalFlushInsertionPhase()) {
467         Options::useOSREntryToDFG() = false;
468         Options::useOSREntryToFTL() = false;
469     }
470     
471 #if ENABLE(SEPARATED_WX_HEAP)
472     // Override globally for now. Longer term we'll just make the default
473     // be to have this option enabled, and have platforms that don't support
474     // it just silently use a single mapping.
475     Options::useSeparatedWXHeap() = true;
476 #else
477     Options::useSeparatedWXHeap() = false;
478 #endif
479
480     if (Options::alwaysUseShadowChicken())
481         Options::maximumInliningDepth() = 1;
482
483     // Compute the maximum value of the reoptimization retry counter. This is simply
484     // the largest value at which we don't overflow the execute counter, when using it
485     // to left-shift the execution counter by this amount. Currently the value ends
486     // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
487     // total on a 32-bit processor.
488     Options::reoptimizationRetryCounterMax() = 0;
489     while ((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << (Options::reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()))
490         Options::reoptimizationRetryCounterMax()++;
491
492     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) > 0);
493     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
494
495 #if !defined(NDEBUG)
496     if (Options::maxSingleAllocationSize())
497         fastSetMaxSingleAllocationSize(Options::maxSingleAllocationSize());
498     else
499         fastSetMaxSingleAllocationSize(std::numeric_limits<size_t>::max());
500 #endif
501
502     if (Options::useZombieMode()) {
503         Options::sweepSynchronously() = true;
504         Options::scribbleFreeCells() = true;
505     }
506
507     if (Options::useSigillCrashAnalyzer())
508         enableSigillCrashAnalyzer();
509
510     if (Options::reservedZoneSize() < minimumReservedZoneSize)
511         Options::reservedZoneSize() = minimumReservedZoneSize;
512     if (Options::softReservedZoneSize() < Options::reservedZoneSize() + minimumReservedZoneSize)
513         Options::softReservedZoneSize() = Options::reservedZoneSize() + minimumReservedZoneSize;
514
515 #if USE(JSVALUE32_64)
516     // FIXME: Make probe OSR exit work on 32-bit:
517     // https://bugs.webkit.org/show_bug.cgi?id=177956
518     Options::useProbeOSRExit() = false;
519 #endif
520
521     if (!Options::useCodeCache())
522         Options::diskCachePath() = nullptr;
523
524     if (!Options::diskCachePath())
525         Options::forceDiskCache() = false;
526 }
527
528 void Options::initialize()
529 {
530     static std::once_flag initializeOptionsOnceFlag;
531     
532     std::call_once(
533         initializeOptionsOnceFlag,
534         [] {
535             // Initialize each of the options with their default values:
536 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
537             name_() = defaultValue_;                                    \
538             name_##Default() = defaultValue_;
539             JSC_OPTIONS(FOR_EACH_OPTION)
540 #undef FOR_EACH_OPTION
541
542             overrideDefaults();
543                 
544             // Allow environment vars to override options if applicable.
545             // The evn var should be the name of the option prefixed with
546             // "JSC_".
547 #if PLATFORM(COCOA)
548             bool hasBadOptions = false;
549             for (char** envp = *_NSGetEnviron(); *envp; envp++) {
550                 const char* env = *envp;
551                 if (!strncmp("JSC_", env, 4)) {
552                     if (!Options::setOption(&env[4])) {
553                         dataLog("ERROR: invalid option: ", *envp, "\n");
554                         hasBadOptions = true;
555                     }
556                 }
557             }
558             if (hasBadOptions && Options::validateOptions())
559                 CRASH();
560 #else // PLATFORM(COCOA)
561 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
562             overrideOptionWithHeuristic(name_(), name_##ID, "JSC_" #name_, Availability::availability_);
563             JSC_OPTIONS(FOR_EACH_OPTION)
564 #undef FOR_EACH_OPTION
565 #endif // PLATFORM(COCOA)
566
567 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence_) \
568             overrideAliasedOptionWithHeuristic("JSC_" #aliasedName_);
569             JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
570 #undef FOR_EACH_OPTION
571
572 #if 0
573                 ; // Deconfuse editors that do auto indentation
574 #endif
575     
576             recomputeDependentOptions();
577
578             // Do range checks where needed and make corrections to the options:
579             ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
580             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= Options::thresholdForOptimizeSoon());
581             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
582             ASSERT(Options::criticalGCMemoryThreshold() > 0.0 && Options::criticalGCMemoryThreshold() < 1.0);
583
584             dumpOptionsIfNeeded();
585             ensureOptionsAreCoherent();
586
587 #if HAVE(MACH_EXCEPTIONS)
588             if (Options::useMachForExceptions())
589                 handleSignalsWithMach();
590 #endif
591
592 #if ASAN_ENABLED && OS(LINUX) && ENABLE(WEBASSEMBLY_FAST_MEMORY)
593             if (Options::useWebAssemblyFastMemory()) {
594                 const char* asanOptions = getenv("ASAN_OPTIONS");
595                 bool okToUseWebAssemblyFastMemory = asanOptions
596                     && (strstr(asanOptions, "allow_user_segv_handler=1") || strstr(asanOptions, "handle_segv=0"));
597                 if (!okToUseWebAssemblyFastMemory) {
598                     dataLogLn("WARNING: ASAN interferes with JSC signal handlers; useWebAssemblyFastMemory will be disabled.");
599                     Options::useWebAssemblyFastMemory() = false;
600                 }
601             }
602 #endif
603         });
604 }
605
606 void Options::dumpOptionsIfNeeded()
607 {
608     if (Options::dumpOptions()) {
609         DumpLevel level = static_cast<DumpLevel>(Options::dumpOptions());
610         if (level > DumpLevel::Verbose)
611             level = DumpLevel::Verbose;
612             
613         const char* title = nullptr;
614         switch (level) {
615         case DumpLevel::None:
616             break;
617         case DumpLevel::Overridden:
618             title = "Overridden JSC options:";
619             break;
620         case DumpLevel::All:
621             title = "All JSC options:";
622             break;
623         case DumpLevel::Verbose:
624             title = "All JSC options with descriptions:";
625             break;
626         }
627
628         StringBuilder builder;
629         dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
630         dataLog(builder.toString());
631     }
632 }
633
634 static bool isSeparator(char c)
635 {
636     return isASCIISpace(c) || (c == ',');
637 }
638
639 bool Options::setOptions(const char* optionsStr)
640 {
641     Vector<char*> options;
642
643     size_t length = strlen(optionsStr);
644     char* optionsStrCopy = WTF::fastStrDup(optionsStr);
645     char* end = optionsStrCopy + length;
646     char* p = optionsStrCopy;
647
648     while (p < end) {
649         // Skip separators (white space or commas).
650         while (p < end && isSeparator(*p))
651             p++;
652         if (p == end)
653             break;
654
655         char* optionStart = p;
656         p = strstr(p, "=");
657         if (!p) {
658             dataLogF("'=' not found in option string: %p\n", optionStart);
659             WTF::fastFree(optionsStrCopy);
660             return false;
661         }
662         p++;
663
664         char* valueBegin = p;
665         bool hasStringValue = false;
666         const int minStringLength = 2; // The min is an empty string i.e. 2 double quotes.
667         if ((p + minStringLength < end) && (*p == '"')) {
668             p = strstr(p + 1, "\"");
669             if (!p) {
670                 dataLogF("Missing trailing '\"' in option string: %p\n", optionStart);
671                 WTF::fastFree(optionsStrCopy);
672                 return false; // End of string not found.
673             }
674             hasStringValue = true;
675         }
676
677         // Find next separator (white space or commas).
678         while (p < end && !isSeparator(*p))
679             p++;
680         if (!p)
681             p = end; // No more " " separator. Hence, this is the last arg.
682
683         // If we have a well-formed string value, strip the quotes.
684         if (hasStringValue) {
685             char* valueEnd = p;
686             ASSERT((*valueBegin == '"') && ((valueEnd - valueBegin) >= minStringLength) && (valueEnd[-1] == '"'));
687             memmove(valueBegin, valueBegin + 1, valueEnd - valueBegin - minStringLength);
688             valueEnd[-minStringLength] = '\0';
689         }
690
691         // Strip leading -- if present.
692         if ((p -  optionStart > 2) && optionStart[0] == '-' && optionStart[1] == '-')
693             optionStart += 2;
694
695         *p++ = '\0';
696         options.append(optionStart);
697     }
698
699     bool success = true;
700     for (auto& option : options) {
701         bool optionSuccess = setOption(option);
702         if (!optionSuccess) {
703             dataLogF("Failed to set option : %s\n", option);
704             success = false;
705         }
706     }
707
708     recomputeDependentOptions();
709
710     dumpOptionsIfNeeded();
711
712     ensureOptionsAreCoherent();
713
714     WTF::fastFree(optionsStrCopy);
715
716     return success;
717 }
718
719 // Parses a single command line option in the format "<optionName>=<value>"
720 // (no spaces allowed) and set the specified option if appropriate.
721 bool Options::setOptionWithoutAlias(const char* arg)
722 {
723     // arg should look like this:
724     //   <jscOptionName>=<appropriate value>
725     const char* equalStr = strchr(arg, '=');
726     if (!equalStr)
727         return false;
728
729     const char* valueStr = equalStr + 1;
730
731     // For each option, check if the specify arg is a match. If so, set the arg
732     // if the value makes sense. Otherwise, move on to checking the next option.
733 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
734     if (strlen(#name_) == static_cast<size_t>(equalStr - arg)      \
735         && !strncmp(arg, #name_, equalStr - arg)) {                \
736         if (Availability::availability_ != Availability::Normal     \
737             && !isAvailable(name_##ID, Availability::availability_)) \
738             return false;                                          \
739         type_ value;                                               \
740         value = (defaultValue_);                                   \
741         bool success = parse(valueStr, value);                     \
742         if (success) {                                             \
743             name_() = value;                                       \
744             recomputeDependentOptions();                           \
745             return true;                                           \
746         }                                                          \
747         return false;                                              \
748     }
749
750     JSC_OPTIONS(FOR_EACH_OPTION)
751 #undef FOR_EACH_OPTION
752
753     return false; // No option matched.
754 }
755
756 static bool invertBoolOptionValue(const char* valueStr, const char*& invertedValueStr)
757 {
758     bool boolValue;
759     if (!parse(valueStr, boolValue))
760         return false;
761     invertedValueStr = boolValue ? "false" : "true";
762     return true;
763 }
764
765
766 bool Options::setAliasedOption(const char* arg)
767 {
768     // arg should look like this:
769     //   <jscOptionName>=<appropriate value>
770     const char* equalStr = strchr(arg, '=');
771     if (!equalStr)
772         return false;
773
774     IGNORE_WARNINGS_BEGIN("tautological-compare")
775
776     // For each option, check if the specify arg is a match. If so, set the arg
777     // if the value makes sense. Otherwise, move on to checking the next option.
778 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence) \
779     if (strlen(#aliasedName_) == static_cast<size_t>(equalStr - arg)    \
780         && !strncmp(arg, #aliasedName_, equalStr - arg)) {              \
781         String unaliasedOption(#unaliasedName_);                        \
782         if (equivalence == SameOption)                                  \
783             unaliasedOption = unaliasedOption + equalStr;               \
784         else {                                                          \
785             ASSERT(equivalence == InvertedOption);                      \
786             const char* invertedValueStr = nullptr;                     \
787             if (!invertBoolOptionValue(equalStr + 1, invertedValueStr)) \
788                 return false;                                           \
789             unaliasedOption = unaliasedOption + "=" + invertedValueStr; \
790         }                                                               \
791         return setOptionWithoutAlias(unaliasedOption.utf8().data());   \
792     }
793
794     JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
795 #undef FOR_EACH_OPTION
796
797     IGNORE_WARNINGS_END
798
799     return false; // No option matched.
800 }
801
802 bool Options::setOption(const char* arg)
803 {
804     bool success = setOptionWithoutAlias(arg);
805     if (success)
806         return true;
807     return setAliasedOption(arg);
808 }
809
810
811 void Options::dumpAllOptions(StringBuilder& builder, DumpLevel level, const char* title,
812     const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption dumpDefaultsOption)
813 {
814     if (title) {
815         builder.append(title);
816         builder.append('\n');
817     }
818
819     for (int id = 0; id < numberOfOptions; id++) {
820         if (separator && id)
821             builder.append(separator);
822         dumpOption(builder, level, static_cast<ID>(id), optionHeader, optionFooter, dumpDefaultsOption);
823     }
824 }
825
826 void Options::dumpAllOptionsInALine(StringBuilder& builder)
827 {
828     dumpAllOptions(builder, DumpLevel::All, nullptr, " ", nullptr, nullptr, DontDumpDefaults);
829 }
830
831 void Options::dumpAllOptions(FILE* stream, DumpLevel level, const char* title)
832 {
833     StringBuilder builder;
834     dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
835     fprintf(stream, "%s", builder.toString().utf8().data());
836 }
837
838 void Options::dumpOption(StringBuilder& builder, DumpLevel level, Options::ID id,
839     const char* header, const char* footer, DumpDefaultsOption dumpDefaultsOption)
840 {
841     if (id >= numberOfOptions)
842         return; // Illegal option.
843
844     Option option(id);
845     Availability availability = option.availability();
846     if (availability != Availability::Normal && !isAvailable(id, availability))
847         return;
848
849     bool wasOverridden = option.isOverridden();
850     bool needsDescription = (level == DumpLevel::Verbose && option.description());
851
852     if (level == DumpLevel::Overridden && !wasOverridden)
853         return;
854
855     if (header)
856         builder.append(header);
857     builder.append(option.name());
858     builder.append('=');
859     option.dump(builder);
860
861     if (wasOverridden && (dumpDefaultsOption == DumpDefaults)) {
862         builder.appendLiteral(" (default: ");
863         option.defaultOption().dump(builder);
864         builder.appendLiteral(")");
865     }
866
867     if (needsDescription) {
868         builder.appendLiteral("   ... ");
869         builder.append(option.description());
870     }
871
872     builder.append(footer);
873 }
874
875 void Options::ensureOptionsAreCoherent()
876 {
877     bool coherent = true;
878     if (!(useLLInt() || useJIT())) {
879         coherent = false;
880         dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
881     }
882     if (!coherent)
883         CRASH();
884 }
885
886 void Option::dump(StringBuilder& builder) const
887 {
888     switch (type()) {
889     case Options::Type::boolType:
890         builder.append(m_entry.boolVal ? "true" : "false");
891         break;
892     case Options::Type::unsignedType:
893         builder.appendNumber(m_entry.unsignedVal);
894         break;
895     case Options::Type::sizeType:
896         builder.appendNumber(m_entry.sizeVal);
897         break;
898     case Options::Type::doubleType:
899         builder.appendNumber(m_entry.doubleVal);
900         break;
901     case Options::Type::int32Type:
902         builder.appendNumber(m_entry.int32Val);
903         break;
904     case Options::Type::optionRangeType:
905         builder.append(m_entry.optionRangeVal.rangeString());
906         break;
907     case Options::Type::optionStringType: {
908         const char* option = m_entry.optionStringVal;
909         if (!option)
910             option = "";
911         builder.append('"');
912         builder.append(option);
913         builder.append('"');
914         break;
915     }
916     case Options::Type::gcLogLevelType: {
917         builder.append(GCLogging::levelAsString(m_entry.gcLogLevelVal));
918         break;
919     }
920     }
921 }
922
923 bool Option::operator==(const Option& other) const
924 {
925     switch (type()) {
926     case Options::Type::boolType:
927         return m_entry.boolVal == other.m_entry.boolVal;
928     case Options::Type::unsignedType:
929         return m_entry.unsignedVal == other.m_entry.unsignedVal;
930     case Options::Type::sizeType:
931         return m_entry.sizeVal == other.m_entry.sizeVal;
932     case Options::Type::doubleType:
933         return (m_entry.doubleVal == other.m_entry.doubleVal) || (std::isnan(m_entry.doubleVal) && std::isnan(other.m_entry.doubleVal));
934     case Options::Type::int32Type:
935         return m_entry.int32Val == other.m_entry.int32Val;
936     case Options::Type::optionRangeType:
937         return m_entry.optionRangeVal.rangeString() == other.m_entry.optionRangeVal.rangeString();
938     case Options::Type::optionStringType:
939         return (m_entry.optionStringVal == other.m_entry.optionStringVal)
940             || (m_entry.optionStringVal && other.m_entry.optionStringVal && !strcmp(m_entry.optionStringVal, other.m_entry.optionStringVal));
941     case Options::Type::gcLogLevelType:
942         return m_entry.gcLogLevelVal == other.m_entry.gcLogLevelVal;
943     }
944     return false;
945 }
946
947 } // namespace JSC
948