Remove remaining references to LLVM, and make sure comments refer to the backend...
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.cpp
1 /*
2  * Copyright (C) 2011-2012, 2014-2015 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 <algorithm>
30 #include <limits>
31 #include <math.h>
32 #include <mutex>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <wtf/ASCIICType.h>
36 #include <wtf/Compiler.h>
37 #include <wtf/DataLog.h>
38 #include <wtf/NumberOfCores.h>
39 #include <wtf/StdLibExtras.h>
40 #include <wtf/StringExtras.h>
41 #include <wtf/text/StringBuilder.h>
42
43 #if PLATFORM(COCOA)
44 #include <crt_externs.h>
45 #endif
46
47 #if OS(WINDOWS)
48 #include "MacroAssemblerX86.h"
49 #endif
50
51 #define USE_OPTIONS_FILE 0
52 #define OPTIONS_FILENAME "/tmp/jsc.options"
53
54 namespace JSC {
55
56 static bool parse(const char* string, bool& value)
57 {
58     if (!strcasecmp(string, "true") || !strcasecmp(string, "yes") || !strcmp(string, "1")) {
59         value = true;
60         return true;
61     }
62     if (!strcasecmp(string, "false") || !strcasecmp(string, "no") || !strcmp(string, "0")) {
63         value = false;
64         return true;
65     }
66     return false;
67 }
68
69 static bool parse(const char* string, int32_t& value)
70 {
71     return sscanf(string, "%d", &value) == 1;
72 }
73
74 static bool parse(const char* string, unsigned& value)
75 {
76     return sscanf(string, "%u", &value) == 1;
77 }
78
79 static bool parse(const char* string, double& value)
80 {
81     return sscanf(string, "%lf", &value) == 1;
82 }
83
84 static bool parse(const char* string, OptionRange& value)
85 {
86     return value.init(string);
87 }
88
89 static bool parse(const char* string, const char*& value)
90 {
91     if (!strlen(string))
92         string = nullptr;
93     value = string;
94     return true;
95 }
96
97 static bool parse(const char* string, GCLogging::Level& value)
98 {
99     if (!strcasecmp(string, "none") || !strcasecmp(string, "no") || !strcasecmp(string, "false") || !strcmp(string, "0")) {
100         value = GCLogging::None;
101         return true;
102     }
103
104     if (!strcasecmp(string, "basic") || !strcasecmp(string, "yes") || !strcasecmp(string, "true") || !strcmp(string, "1")) {
105         value = GCLogging::Basic;
106         return true;
107     }
108
109     if (!strcasecmp(string, "verbose") || !strcmp(string, "2")) {
110         value = GCLogging::Verbose;
111         return true;
112     }
113
114     return false;
115 }
116
117 template<typename T>
118 bool overrideOptionWithHeuristic(T& variable, const char* name)
119 {
120     const char* stringValue = getenv(name);
121     if (!stringValue)
122         return false;
123     
124     if (parse(stringValue, variable))
125         return true;
126     
127     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
128     return false;
129 }
130
131 bool Options::overrideAliasedOptionWithHeuristic(const char* name)
132 {
133     const char* stringValue = getenv(name);
134     if (!stringValue)
135         return false;
136
137     String aliasedOption;
138     aliasedOption = String(&name[4]) + "=" + stringValue;
139     if (Options::setOption(aliasedOption.utf8().data()))
140         return true;
141
142     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
143     return false;
144 }
145
146 static unsigned computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum = 1)
147 {
148     int cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfWorkerThreads);
149
150     // Be paranoid, it is the OS we're dealing with, after all.
151     ASSERT(cpusToUse >= 1);
152     return std::max(cpusToUse, minimum);
153 }
154
155 static int32_t computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)
156 {
157     if (WTF::numberOfProcessorCores() <= 2)
158         return twoCorePriorityDelta;
159
160     return multiCorePriorityDelta;
161 }
162
163 static unsigned computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)
164 {
165     return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);
166 }
167
168 const char* const OptionRange::s_nullRangeStr = "<null>";
169
170 bool OptionRange::init(const char* rangeString)
171 {
172     // rangeString should be in the form of [!]<low>[:<high>]
173     // where low and high are unsigned
174
175     bool invert = false;
176
177     if (!rangeString) {
178         m_state = InitError;
179         return false;
180     }
181
182     if (!strcmp(rangeString, s_nullRangeStr)) {
183         m_state = Uninitialized;
184         return true;
185     }
186     
187     m_rangeString = rangeString;
188
189     if (*rangeString == '!') {
190         invert = true;
191         rangeString++;
192     }
193
194     int scanResult = sscanf(rangeString, " %u:%u", &m_lowLimit, &m_highLimit);
195
196     if (!scanResult || scanResult == EOF) {
197         m_state = InitError;
198         return false;
199     }
200
201     if (scanResult == 1)
202         m_highLimit = m_lowLimit;
203
204     if (m_lowLimit > m_highLimit) {
205         m_state = InitError;
206         return false;
207     }
208
209     m_state = invert ? Inverted : Normal;
210
211     return true;
212 }
213
214 bool OptionRange::isInRange(unsigned count)
215 {
216     if (m_state < Normal)
217         return true;
218
219     if ((m_lowLimit <= count) && (count <= m_highLimit))
220         return m_state == Normal ? true : false;
221
222     return m_state == Normal ? false : true;
223 }
224
225 void OptionRange::dump(PrintStream& out) const
226 {
227     out.print(m_rangeString);
228 }
229
230 Options::Entry Options::s_options[Options::numberOfOptions];
231 Options::Entry Options::s_defaultOptions[Options::numberOfOptions];
232
233 // Realize the names for each of the options:
234 const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {
235 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
236     { #name_, description_, Options::Type::type_##Type },
237     JSC_OPTIONS(FOR_EACH_OPTION)
238 #undef FOR_EACH_OPTION
239 };
240
241 static void scaleJITPolicy()
242 {
243     auto& scaleFactor = Options::jitPolicyScale();
244     if (scaleFactor > 1.0)
245         scaleFactor = 1.0;
246     else if (scaleFactor < 0.0)
247         scaleFactor = 0.0;
248
249     struct OptionToScale {
250         Options::OptionID id;
251         int32_t minVal;
252     };
253
254     static const OptionToScale optionsToScale[] = {
255         { Options::thresholdForJITAfterWarmUpID, 0 },
256         { Options::thresholdForJITSoonID, 0 },
257         { Options::thresholdForOptimizeAfterWarmUpID, 1 },
258         { Options::thresholdForOptimizeAfterLongWarmUpID, 1 },
259         { Options::thresholdForOptimizeSoonID, 1 },
260         { Options::thresholdForFTLOptimizeSoonID, 2 },
261         { Options::thresholdForFTLOptimizeAfterWarmUpID, 2 }
262     };
263
264     const int numberOfOptionsToScale = sizeof(optionsToScale) / sizeof(OptionToScale);
265     for (int i = 0; i < numberOfOptionsToScale; i++) {
266         Option option(optionsToScale[i].id);
267         ASSERT(option.type() == Options::Type::int32Type);
268         option.int32Val() *= scaleFactor;
269         option.int32Val() = std::max(option.int32Val(), optionsToScale[i].minVal);
270     }
271 }
272
273 static void recomputeDependentOptions()
274 {
275 #if !defined(NDEBUG)
276     Options::validateDFGExceptionHandling() = true;
277 #endif
278 #if !ENABLE(JIT)
279     Options::useLLInt() = true;
280     Options::useJIT() = false;
281     Options::useDFGJIT() = false;
282     Options::useFTLJIT() = false;
283 #endif
284 #if !ENABLE(YARR_JIT)
285     Options::useRegExpJIT() = false;
286 #endif
287 #if !ENABLE(CONCURRENT_JIT)
288     Options::useConcurrentJIT() = false;
289 #endif
290 #if !ENABLE(DFG_JIT)
291     Options::useDFGJIT() = false;
292     Options::useFTLJIT() = false;
293 #endif
294 #if !ENABLE(FTL_JIT)
295     Options::useFTLJIT() = false;
296 #endif
297 #if OS(WINDOWS) && CPU(X86) 
298     // Disable JIT on Windows if SSE2 is not present 
299     if (!MacroAssemblerX86::supportsFloatingPoint())
300         Options::useJIT() = false;
301 #endif
302     if (Options::dumpDisassembly()
303         || Options::dumpDFGDisassembly()
304         || Options::dumpFTLDisassembly()
305         || Options::dumpBytecodeAtDFGTime()
306         || Options::dumpGraphAtEachPhase()
307         || Options::dumpDFGGraphAtEachPhase()
308         || Options::dumpDFGFTLGraphAtEachPhase()
309         || Options::dumpB3GraphAtEachPhase()
310         || Options::dumpAirGraphAtEachPhase()
311         || Options::verboseCompilation()
312         || Options::verboseFTLCompilation()
313         || Options::logCompilationChanges()
314         || Options::validateGraph()
315         || Options::validateGraphAtEachPhase()
316         || Options::verboseOSR()
317         || Options::verboseCompilationQueue()
318         || Options::reportCompileTimes()
319         || Options::reportFTLCompileTimes()
320         || Options::verboseCFA()
321         || Options::verboseFTLFailure())
322         Options::alwaysComputeHash() = true;
323
324     if (Option(Options::jitPolicyScaleID).isOverridden())
325         scaleJITPolicy();
326     
327     if (Options::forceEagerCompilation()) {
328         Options::thresholdForJITAfterWarmUp() = 10;
329         Options::thresholdForJITSoon() = 10;
330         Options::thresholdForOptimizeAfterWarmUp() = 20;
331         Options::thresholdForOptimizeAfterLongWarmUp() = 20;
332         Options::thresholdForOptimizeSoon() = 20;
333         Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
334         Options::thresholdForFTLOptimizeSoon() = 20;
335         Options::maximumEvalCacheableSourceLength() = 150000;
336         Options::useConcurrentJIT() = false;
337     }
338     if (Options::useMaximalFlushInsertionPhase()) {
339         Options::useOSREntryToDFG() = false;
340         Options::useOSREntryToFTL() = false;
341     }
342
343     // Compute the maximum value of the reoptimization retry counter. This is simply
344     // the largest value at which we don't overflow the execute counter, when using it
345     // to left-shift the execution counter by this amount. Currently the value ends
346     // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
347     // total on a 32-bit processor.
348     Options::reoptimizationRetryCounterMax() = 0;
349     while ((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << (Options::reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()))
350         Options::reoptimizationRetryCounterMax()++;
351
352     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) > 0);
353     ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
354 }
355
356 void Options::initialize()
357 {
358     static std::once_flag initializeOptionsOnceFlag;
359     
360     std::call_once(
361         initializeOptionsOnceFlag,
362         [] {
363             // Initialize each of the options with their default values:
364 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
365             name_() = defaultValue_;                                    \
366             name_##Default() = defaultValue_;
367             JSC_OPTIONS(FOR_EACH_OPTION)
368 #undef FOR_EACH_OPTION
369                 
370             // Allow environment vars to override options if applicable.
371             // The evn var should be the name of the option prefixed with
372             // "JSC_".
373 #if PLATFORM(COCOA)
374             bool hasBadOptions = false;
375             for (char** envp = *_NSGetEnviron(); *envp; envp++) {
376                 const char* env = *envp;
377                 if (!strncmp("JSC_", env, 4)) {
378                     if (!Options::setOption(&env[4])) {
379                         dataLog("ERROR: invalid option: ", *envp, "\n");
380                         hasBadOptions = true;
381                     }
382                 }
383             }
384             if (hasBadOptions && Options::validateOptions())
385                 CRASH();
386 #else // PLATFORM(COCOA)
387 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
388             overrideOptionWithHeuristic(name_(), "JSC_" #name_);
389             JSC_OPTIONS(FOR_EACH_OPTION)
390 #undef FOR_EACH_OPTION
391 #endif // PLATFORM(COCOA)
392
393 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence_) \
394             overrideAliasedOptionWithHeuristic("JSC_" #aliasedName_);
395             JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
396 #undef FOR_EACH_OPTION
397
398 #if 0
399                 ; // Deconfuse editors that do auto indentation
400 #endif
401     
402             recomputeDependentOptions();
403
404 #if USE(OPTIONS_FILE)
405             {
406                 const char* filename = OPTIONS_FILENAME;
407                 FILE* optionsFile = fopen(filename, "r");
408                 if (!optionsFile) {
409                     dataLogF("Failed to open file %s. Did you add the file-read-data entitlement to WebProcess.sb?\n", filename);
410                     return;
411                 }
412                 
413                 StringBuilder builder;
414                 char* line;
415                 char buffer[BUFSIZ];
416                 while ((line = fgets(buffer, sizeof(buffer), optionsFile)))
417                     builder.append(buffer);
418                 
419                 const char* optionsStr = builder.toString().utf8().data();
420                 dataLogF("Setting options: %s\n", optionsStr);
421                 setOptions(optionsStr);
422                 
423                 int result = fclose(optionsFile);
424                 if (result)
425                     dataLogF("Failed to close file %s: %s\n", filename, strerror(errno));
426             }
427 #endif
428
429             // Do range checks where needed and make corrections to the options:
430             ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
431             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= Options::thresholdForOptimizeSoon());
432             ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
433
434             dumpOptionsIfNeeded();
435             ensureOptionsAreCoherent();
436         });
437 }
438
439 void Options::dumpOptionsIfNeeded()
440 {
441     if (Options::dumpOptions()) {
442         DumpLevel level = static_cast<DumpLevel>(Options::dumpOptions());
443         if (level > DumpLevel::Verbose)
444             level = DumpLevel::Verbose;
445             
446         const char* title = nullptr;
447         switch (level) {
448         case DumpLevel::None:
449             break;
450         case DumpLevel::Overridden:
451             title = "Overridden JSC options:";
452             break;
453         case DumpLevel::All:
454             title = "All JSC options:";
455             break;
456         case DumpLevel::Verbose:
457             title = "All JSC options with descriptions:";
458             break;
459         }
460
461         StringBuilder builder;
462         dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
463         dataLog(builder.toString());
464     }
465 }
466
467 bool Options::setOptions(const char* optionsStr)
468 {
469     Vector<char*> options;
470
471     size_t length = strlen(optionsStr);
472     char* optionsStrCopy = WTF::fastStrDup(optionsStr);
473     char* end = optionsStrCopy + length;
474     char* p = optionsStrCopy;
475
476     while (p < end) {
477         // Skip white space.
478         while (p < end && isASCIISpace(*p))
479             p++;
480         if (p == end)
481             break;
482
483         char* optionStart = p;
484         p = strstr(p, "=");
485         if (!p) {
486             dataLogF("'=' not found in option string: %p\n", optionStart);
487             return false;
488         }
489         p++;
490
491         char* valueBegin = p;
492         bool hasStringValue = false;
493         const int minStringLength = 2; // The min is an empty string i.e. 2 double quotes.
494         if ((p + minStringLength < end) && (*p == '"')) {
495             p = strstr(p + 1, "\"");
496             if (!p) {
497                 dataLogF("Missing trailing '\"' in option string: %p\n", optionStart);
498                 return false; // End of string not found.
499             }
500             hasStringValue = true;
501         }
502
503         // Find next white space.
504         while (p < end && !isASCIISpace(*p))
505             p++;
506         if (!p)
507             p = end; // No more " " separator. Hence, this is the last arg.
508
509         // If we have a well-formed string value, strip the quotes.
510         if (hasStringValue) {
511             char* valueEnd = p;
512             ASSERT((*valueBegin == '"') && ((valueEnd - valueBegin) >= minStringLength) && (valueEnd[-1] == '"'));
513             memmove(valueBegin, valueBegin + 1, valueEnd - valueBegin - minStringLength);
514             valueEnd[-minStringLength] = '\0';
515         }
516
517         // Strip leading -- if present.
518         if ((p -  optionStart > 2) && optionStart[0] == '-' && optionStart[1] == '-')
519             optionStart += 2;
520
521         *p++ = '\0';
522         options.append(optionStart);
523     }
524
525     bool success = true;
526     for (auto& option : options) {
527         bool optionSuccess = setOption(option);
528         if (!optionSuccess) {
529             dataLogF("Failed to set option : %s\n", option);
530             success = false;
531         }
532     }
533
534     dumpOptionsIfNeeded();
535     return success;
536 }
537
538 // Parses a single command line option in the format "<optionName>=<value>"
539 // (no spaces allowed) and set the specified option if appropriate.
540 bool Options::setOptionWithoutAlias(const char* arg)
541 {
542     // arg should look like this:
543     //   <jscOptionName>=<appropriate value>
544     const char* equalStr = strchr(arg, '=');
545     if (!equalStr)
546         return false;
547
548     const char* valueStr = equalStr + 1;
549
550     // For each option, check if the specify arg is a match. If so, set the arg
551     // if the value makes sense. Otherwise, move on to checking the next option.
552 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
553     if (strlen(#name_) == static_cast<size_t>(equalStr - arg)      \
554         && !strncmp(arg, #name_, equalStr - arg)) {                \
555         type_ value;                                               \
556         value = (defaultValue_);                                   \
557         bool success = parse(valueStr, value);                     \
558         if (success) {                                             \
559             name_() = value;                                       \
560             recomputeDependentOptions();                           \
561             return true;                                           \
562         }                                                          \
563         return false;                                              \
564     }
565
566     JSC_OPTIONS(FOR_EACH_OPTION)
567 #undef FOR_EACH_OPTION
568
569     return false; // No option matched.
570 }
571
572 static bool invertBoolOptionValue(const char* valueStr, const char*& invertedValueStr)
573 {
574     bool boolValue;
575     if (!parse(valueStr, boolValue))
576         return false;
577     invertedValueStr = boolValue ? "false" : "true";
578     return true;
579 }
580
581
582 bool Options::setAliasedOption(const char* arg)
583 {
584     // arg should look like this:
585     //   <jscOptionName>=<appropriate value>
586     const char* equalStr = strchr(arg, '=');
587     if (!equalStr)
588         return false;
589
590 #if COMPILER(CLANG)
591 #if __has_warning("-Wtautological-compare")
592 #pragma clang diagnostic push
593 #pragma clang diagnostic ignored "-Wtautological-compare"
594 #endif
595 #endif
596
597     // For each option, check if the specify arg is a match. If so, set the arg
598     // if the value makes sense. Otherwise, move on to checking the next option.
599 #define FOR_EACH_OPTION(aliasedName_, unaliasedName_, equivalence) \
600     if (strlen(#aliasedName_) == static_cast<size_t>(equalStr - arg)    \
601         && !strncmp(arg, #aliasedName_, equalStr - arg)) {              \
602         String unaliasedOption(#unaliasedName_);                        \
603         if (equivalence == SameOption)                                  \
604             unaliasedOption = unaliasedOption + equalStr;               \
605         else {                                                          \
606             ASSERT(equivalence == InvertedOption);                      \
607             const char* invertedValueStr = nullptr;                     \
608             if (!invertBoolOptionValue(equalStr + 1, invertedValueStr)) \
609                 return false;                                           \
610             unaliasedOption = unaliasedOption + "=" + invertedValueStr; \
611         }                                                               \
612         return setOptionWithoutAlias(unaliasedOption.utf8().data());   \
613     }
614
615     JSC_ALIASED_OPTIONS(FOR_EACH_OPTION)
616 #undef FOR_EACH_OPTION
617
618 #if COMPILER(CLANG)
619 #if __has_warning("-Wtautological-compare")
620 #pragma clang diagnostic pop
621 #endif
622 #endif
623
624     return false; // No option matched.
625 }
626
627 bool Options::setOption(const char* arg)
628 {
629     bool success = setOptionWithoutAlias(arg);
630     if (success)
631         return true;
632     return setAliasedOption(arg);
633 }
634
635
636 void Options::dumpAllOptions(StringBuilder& builder, DumpLevel level, const char* title,
637     const char* separator, const char* optionHeader, const char* optionFooter, DumpDefaultsOption dumpDefaultsOption)
638 {
639     if (title) {
640         builder.append(title);
641         builder.append('\n');
642     }
643
644     for (int id = 0; id < numberOfOptions; id++) {
645         if (separator && id)
646             builder.append(separator);
647         dumpOption(builder, level, static_cast<OptionID>(id), optionHeader, optionFooter, dumpDefaultsOption);
648     }
649 }
650
651 void Options::dumpAllOptionsInALine(StringBuilder& builder)
652 {
653     dumpAllOptions(builder, DumpLevel::All, nullptr, " ", nullptr, nullptr, DontDumpDefaults);
654 }
655
656 void Options::dumpAllOptions(FILE* stream, DumpLevel level, const char* title)
657 {
658     StringBuilder builder;
659     dumpAllOptions(builder, level, title, nullptr, "   ", "\n", DumpDefaults);
660     fprintf(stream, "%s", builder.toString().utf8().data());
661 }
662
663 void Options::dumpOption(StringBuilder& builder, DumpLevel level, OptionID id,
664     const char* header, const char* footer, DumpDefaultsOption dumpDefaultsOption)
665 {
666     if (id >= numberOfOptions)
667         return; // Illegal option.
668
669     Option option(id);
670     bool wasOverridden = option.isOverridden();
671     bool needsDescription = (level == DumpLevel::Verbose && option.description());
672
673     if (level == DumpLevel::Overridden && !wasOverridden)
674         return;
675
676     if (header)
677         builder.append(header);
678     builder.append(option.name());
679     builder.append('=');
680     option.dump(builder);
681
682     if (wasOverridden && (dumpDefaultsOption == DumpDefaults)) {
683         builder.append(" (default: ");
684         option.defaultOption().dump(builder);
685         builder.append(")");
686     }
687
688     if (needsDescription) {
689         builder.append("   ... ");
690         builder.append(option.description());
691     }
692
693     builder.append(footer);
694 }
695
696 void Options::ensureOptionsAreCoherent()
697 {
698     bool coherent = true;
699     if (!(useLLInt() || useJIT())) {
700         coherent = false;
701         dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
702     }
703     if (!coherent)
704         CRASH();
705 }
706
707 void Option::dump(StringBuilder& builder) const
708 {
709     switch (type()) {
710     case Options::Type::boolType:
711         builder.append(m_entry.boolVal ? "true" : "false");
712         break;
713     case Options::Type::unsignedType:
714         builder.appendNumber(m_entry.unsignedVal);
715         break;
716     case Options::Type::doubleType:
717         builder.appendNumber(m_entry.doubleVal);
718         break;
719     case Options::Type::int32Type:
720         builder.appendNumber(m_entry.int32Val);
721         break;
722     case Options::Type::optionRangeType:
723         builder.append(m_entry.optionRangeVal.rangeString());
724         break;
725     case Options::Type::optionStringType: {
726         const char* option = m_entry.optionStringVal;
727         if (!option)
728             option = "";
729         builder.append('"');
730         builder.append(option);
731         builder.append('"');
732         break;
733     }
734     case Options::Type::gcLogLevelType: {
735         builder.append(GCLogging::levelAsString(m_entry.gcLogLevelVal));
736         break;
737     }
738     }
739 }
740
741 bool Option::operator==(const Option& other) const
742 {
743     switch (type()) {
744     case Options::Type::boolType:
745         return m_entry.boolVal == other.m_entry.boolVal;
746     case Options::Type::unsignedType:
747         return m_entry.unsignedVal == other.m_entry.unsignedVal;
748     case Options::Type::doubleType:
749         return (m_entry.doubleVal == other.m_entry.doubleVal) || (std::isnan(m_entry.doubleVal) && std::isnan(other.m_entry.doubleVal));
750     case Options::Type::int32Type:
751         return m_entry.int32Val == other.m_entry.int32Val;
752     case Options::Type::optionRangeType:
753         return m_entry.optionRangeVal.rangeString() == other.m_entry.optionRangeVal.rangeString();
754     case Options::Type::optionStringType:
755         return (m_entry.optionStringVal == other.m_entry.optionStringVal)
756             || (m_entry.optionStringVal && other.m_entry.optionStringVal && !strcmp(m_entry.optionStringVal, other.m_entry.optionStringVal));
757     case Options::Type::gcLogLevelType:
758         return m_entry.gcLogLevelVal == other.m_entry.gcLogLevelVal;
759     }
760     return false;
761 }
762
763 } // namespace JSC
764