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