webkitgtk-2.10.2webkitgtk-2.10.2

1 files changed, 628 insertions, 0 deletions

diff --git a/Source/JavaScriptCore/runtime/Options.cpp b/Source/JavaScriptCore/runtime/Options.cpp
new file mode 100644
index 000000000..fe830b47b
--- /dev/null
+++ b/Source/JavaScriptCore/runtime/Options.cpp
@@ -0,0 +1,628 @@
+/*
+ * Copyright (C) 2011-2012, 2014-2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+#include "Options.h"
+
+#include "HeapStatistics.h"
+#include <algorithm>
+#include <limits>
+#include <math.h>
+#include <mutex>
+#include <stdlib.h>
+#include <string.h>
+#include <wtf/DataLog.h>
+#include <wtf/NumberOfCores.h>
+#include <wtf/PageBlock.h>
+#include <wtf/StdLibExtras.h>
+#include <wtf/StringExtras.h>
+#include <wtf/text/StringBuilder.h>
+
+#if OS(DARWIN) && ENABLE(PARALLEL_GC)
+#include <sys/sysctl.h>
+#endif
+
+#if OS(WINDOWS)
+#include "MacroAssemblerX86.h"
+#endif
+
+namespace JSC {
+
+static bool parse(const char* string, bool& value)
+{
+    if (!strcasecmp(string, "true") || !strcasecmp(string, "yes") || !strcmp(string, "1")) {
+        value = true;
+        return true;
+    }
+    if (!strcasecmp(string, "false") || !strcasecmp(string, "no") || !strcmp(string, "0")) {
+        value = false;
+        return true;
+    }
+    return false;
+}
+
+static bool parse(const char* string, int32_t& value)
+{
+    return sscanf(string, "%d", &value) == 1;
+}
+
+static bool parse(const char* string, unsigned& value)
+{
+    return sscanf(string, "%u", &value) == 1;
+}
+
+static bool parse(const char* string, double& value)
+{
+    return sscanf(string, "%lf", &value) == 1;
+}
+
+static bool parse(const char* string, OptionRange& value)
+{
+    return value.init(string);
+}
+
+static bool parse(const char* string, const char*& value)
+{
+    if (!strlen(string))
+        string = nullptr;
+    value = string;
+    return true;
+}
+
+static bool parse(const char* string, GCLogging::Level& value)
+{
+    if (!strcasecmp(string, "none") || !strcasecmp(string, "no") || !strcasecmp(string, "false") || !strcmp(string, "0")) {
+        value = GCLogging::None;
+        return true;
+    }
+
+    if (!strcasecmp(string, "basic") || !strcasecmp(string, "yes") || !strcasecmp(string, "true") || !strcmp(string, "1")) {
+        value = GCLogging::Basic;
+        return true;
+    }
+
+    if (!strcasecmp(string, "verbose") || !strcmp(string, "2")) {
+        value = GCLogging::Verbose;
+        return true;
+    }
+
+    return false;
+}
+
+template<typename T>
+bool overrideOptionWithHeuristic(T& variable, const char* name)
+{
+    const char* stringValue = getenv(name);
+    if (!stringValue)
+        return false;
+    
+    if (parse(stringValue, variable))
+        return true;
+    
+    fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
+    return false;
+}
+
+static unsigned computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum = 1)
+{
+    int cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfWorkerThreads);
+
+    // Be paranoid, it is the OS we're dealing with, after all.
+    ASSERT(cpusToUse >= 1);
+    return std::max(cpusToUse, minimum);
+}
+
+static int32_t computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)
+{
+    if (WTF::numberOfProcessorCores() <= 2)
+        return twoCorePriorityDelta;
+
+    return multiCorePriorityDelta;
+}
+
+static unsigned computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)
+{
+#if ENABLE(PARALLEL_GC)
+    return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);
+#else
+    UNUSED_PARAM(maxNumberOfGCMarkers);
+    return 1;
+#endif
+}
+
+const char* const OptionRange::s_nullRangeStr = "<null>";
+
+bool OptionRange::init(const char* rangeString)
+{
+    // rangeString should be in the form of [!]<low>[:<high>]
+    // where low and high are unsigned
+
+    bool invert = false;
+
+    if (!rangeString) {
+        m_state = InitError;
+        return false;
+    }
+
+    if (!strcmp(rangeString, s_nullRangeStr)) {
+        m_state = Uninitialized;
+        return true;
+    }
+    
+    m_rangeString = rangeString;
+
+    if (*rangeString == '!') {
+        invert = true;
+        rangeString++;
+    }
+
+    int scanResult = sscanf(rangeString, " %u:%u", &m_lowLimit, &m_highLimit);
+
+    if (!scanResult || scanResult == EOF) {
+        m_state = InitError;
+        return false;
+    }
+
+    if (scanResult == 1)
+        m_highLimit = m_lowLimit;
+
+    if (m_lowLimit > m_highLimit) {
+        m_state = InitError;
+        return false;
+    }
+
+    m_state = invert ? Inverted : Normal;
+
+    return true;
+}
+
+bool OptionRange::isInRange(unsigned count)
+{
+    if (m_state < Normal)
+        return true;
+
+    if ((m_lowLimit <= count) && (count <= m_highLimit))
+        return m_state == Normal ? true : false;
+
+    return m_state == Normal ? false : true;
+}
+
+void OptionRange::dump(PrintStream& out) const
+{
+    out.print(m_rangeString);
+}
+
+Options::Entry Options::s_options[Options::numberOfOptions];
+Options::Entry Options::s_defaultOptions[Options::numberOfOptions];
+
+// Realize the names for each of the options:
+const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
+    { #name_, description_, Options::Type::type_##Type },
+    JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+};
+
+static void scaleJITPolicy()
+{
+    auto& scaleFactor = Options::jitPolicyScale();
+    if (scaleFactor > 1.0)
+        scaleFactor = 1.0;
+    else if (scaleFactor < 0.0)
+        scaleFactor = 0.0;
+
+    struct OptionToScale {
+        Options::OptionID id;
+        int32_t minVal;
+    };
+
+    static const OptionToScale optionsToScale[] = {
+        { Options::thresholdForJITAfterWarmUpID, 0 },
+        { Options::thresholdForJITSoonID, 0 },
+        { Options::thresholdForOptimizeAfterWarmUpID, 1 },
+        { Options::thresholdForOptimizeAfterLongWarmUpID, 1 },
+        { Options::thresholdForOptimizeSoonID, 1 },
+        { Options::thresholdForFTLOptimizeSoonID, 2 },
+        { Options::thresholdForFTLOptimizeAfterWarmUpID, 2 }
+    };
+
+    const int numberOfOptionsToScale = sizeof(optionsToScale) / sizeof(OptionToScale);
+    for (int i = 0; i < numberOfOptionsToScale; i++) {
+        Option option(optionsToScale[i].id);
+        ASSERT(option.type() == Options::Type::int32Type);
+        option.int32Val() *= scaleFactor;
+        option.int32Val() = std::max(option.int32Val(), optionsToScale[i].minVal);
+    }
+}
+
+static void recomputeDependentOptions()
+{
+#if !ENABLE(JIT)
+    Options::useLLInt() = true;
+    Options::useJIT() = false;
+    Options::useDFGJIT() = false;
+    Options::useFTLJIT() = false;
+#endif
+#if !ENABLE(YARR_JIT)
+    Options::useRegExpJIT() = false;
+#endif
+#if !ENABLE(CONCURRENT_JIT)
+    Options::enableConcurrentJIT() = false;
+#endif
+#if !ENABLE(DFG_JIT)
+    Options::useDFGJIT() = false;
+    Options::useFTLJIT() = false;
+#endif
+#if !ENABLE(FTL_JIT)
+    Options::useFTLJIT() = false;
+#endif
+#if OS(WINDOWS) && CPU(X86) 
+    // Disable JIT on Windows if SSE2 is not present 
+    if (!MacroAssemblerX86::supportsFloatingPoint())
+        Options::useJIT() = false;
+#endif
+    if (Options::showDisassembly()
+        || Options::showDFGDisassembly()
+        || Options::showFTLDisassembly()
+        || Options::dumpBytecodeAtDFGTime()
+        || Options::dumpGraphAtEachPhase()
+        || Options::verboseCompilation()
+        || Options::verboseFTLCompilation()
+        || Options::logCompilationChanges()
+        || Options::validateGraph()
+        || Options::validateGraphAtEachPhase()
+        || Options::verboseOSR()
+        || Options::verboseCompilationQueue()
+        || Options::reportCompileTimes()
+        || Options::reportFTLCompileTimes()
+        || Options::verboseCFA()
+        || Options::verboseFTLFailure())
+        Options::alwaysComputeHash() = true;
+
+    if (Option(Options::jitPolicyScaleID).isOverridden())
+        scaleJITPolicy();
+    
+    if (Options::forceEagerCompilation()) {
+        Options::thresholdForJITAfterWarmUp() = 10;
+        Options::thresholdForJITSoon() = 10;
+        Options::thresholdForOptimizeAfterWarmUp() = 20;
+        Options::thresholdForOptimizeAfterLongWarmUp() = 20;
+        Options::thresholdForOptimizeSoon() = 20;
+        Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
+        Options::thresholdForFTLOptimizeSoon() = 20;
+        Options::maximumEvalCacheableSourceLength() = 150000;
+        Options::enableConcurrentJIT() = false;
+    }
+
+    // Compute the maximum value of the reoptimization retry counter. This is simply
+    // the largest value at which we don't overflow the execute counter, when using it
+    // to left-shift the execution counter by this amount. Currently the value ends
+    // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
+    // total on a 32-bit processor.
+    Options::reoptimizationRetryCounterMax() = 0;
+    while ((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << (Options::reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()))
+        Options::reoptimizationRetryCounterMax()++;
+
+    ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) > 0);
+    ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
+}
+
+void Options::initialize()
+{
+    static std::once_flag initializeOptionsOnceFlag;
+    
+    std::call_once(
+        initializeOptionsOnceFlag,
+        [] {
+            // Initialize each of the options with their default values:
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
+            name_() = defaultValue_;                                    \
+            name_##Default() = defaultValue_;
+            JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+    
+                // It *probably* makes sense for other platforms to enable this.
+#if PLATFORM(IOS) && CPU(ARM64)
+                enableLLVMFastISel() = true;
+#endif
+        
+            // Allow environment vars to override options if applicable.
+            // The evn var should be the name of the option prefixed with
+            // "JSC_".
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
+            overrideOptionWithHeuristic(name_(), "JSC_" #name_);
+            JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+
+#if 0
+                ; // Deconfuse editors that do auto indentation
+#endif
+    
+            recomputeDependentOptions();
+
+            // Do range checks where needed and make corrections to the options:
+            ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
+            ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= Options::thresholdForOptimizeSoon());
+            ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
+
+            dumpOptionsIfNeeded();
+            ensureOptionsAreCoherent();
+        });
+}
+
+void Options::dumpOptionsIfNeeded()
+{
+    if (Options::showOptions()) {
+        DumpLevel level = static_cast<DumpLevel>(Options::showOptions());
+        if (level > DumpLevel::Verbose)
+            level = DumpLevel::Verbose;
+            
+        const char* title = nullptr;
+        switch (level) {
+        case DumpLevel::None:
+            break;
+        case DumpLevel::Overridden:
+            title = "Overridden JSC options:";
+            break;
+        case DumpLevel::All:
+            title = "All JSC options:";
+            break;
+        case DumpLevel::Verbose:
+            title = "All JSC options with descriptions:";
+            break;
+        }
+
+        StringBuilder builder;
+        dumpAllOptions(builder, level, title, nullptr, "   ", "\n", ShowDefaults);
+        dataLog(builder.toString());
+    }
+}
+
+bool Options::setOptions(const char* optionsStr)
+{
+    Vector<char*> options;
+
+    size_t length = strlen(optionsStr);
+    char* optionsStrCopy = WTF::fastStrDup(optionsStr);
+    char* end = optionsStrCopy + length;
+    char* p = optionsStrCopy;
+
+    while (p < end) {
+        char* optionStart = p;
+        p = strstr(p, "=");
+        if (!p) {
+            dataLogF("'=' not found in option string: %p\n", optionStart);
+            return false;
+        }
+        p++;
+
+        char* valueBegin = p;
+        bool hasStringValue = false;
+        const int minStringLength = 2; // The min is an empty string i.e. 2 double quotes.
+        if ((p + minStringLength < end) && (*p == '"')) {
+            p = strstr(p + 1, "\"");
+            if (!p) {
+                dataLogF("Missing trailing '\"' in option string: %p\n", optionStart);
+                return false; // End of string not found.
+            }
+            hasStringValue = true;
+        }
+
+        p = strstr(p, " ");
+        if (!p)
+            p = end; // No more " " separator. Hence, this is the last arg.
+
+        // If we have a well-formed string value, strip the quotes.
+        if (hasStringValue) {
+            char* valueEnd = p;
+            ASSERT((*valueBegin == '"') && ((valueEnd - valueBegin) >= minStringLength) && (valueEnd[-1] == '"'));
+            memmove(valueBegin, valueBegin + 1, valueEnd - valueBegin - minStringLength);
+            valueEnd[-minStringLength] = '\0';
+        }
+
+        // Strip leading -- if present.
+        if ((p -  optionStart > 2) && optionStart[0] == '-' && optionStart[1] == '-')
+            optionStart += 2;
+
+        *p++ = '\0';
+        options.append(optionStart);
+    }
+
+    bool success = true;
+    for (auto& option : options) {
+        bool optionSuccess = setOption(option);
+        if (!optionSuccess) {
+            dataLogF("Failed to set option : %s\n", option);
+            success = false;
+        }
+    }
+
+    dumpOptionsIfNeeded();
+    return success;
+}
+
+// Parses a single command line option in the format "<optionName>=<value>"
+// (no spaces allowed) and set the specified option if appropriate.
+bool Options::setOption(const char* arg)
+{
+    // arg should look like this:
+    //   <jscOptionName>=<appropriate value>
+    const char* equalStr = strchr(arg, '=');
+    if (!equalStr)
+        return false;
+
+    const char* valueStr = equalStr + 1;
+
+    // For each option, check if the specify arg is a match. If so, set the arg
+    // if the value makes sense. Otherwise, move on to checking the next option.
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
+    if (strlen(#name_) == static_cast<size_t>(equalStr - arg)      \
+        && !strncmp(arg, #name_, equalStr - arg)) {                \
+        type_ value;                                               \
+        value = (defaultValue_);                                   \
+        bool success = parse(valueStr, value);                     \
+        if (success) {                                             \
+            name_() = value;                                       \
+            recomputeDependentOptions();                           \
+            return true;                                           \
+        }                                                          \
+        return false;                                              \
+    }
+
+    JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+
+    return false; // No option matched.
+}
+
+void Options::dumpAllOptions(StringBuilder& builder, DumpLevel level, const char* title,
+    const char* separator, const char* optionHeader, const char* optionFooter, ShowDefaultsOption showDefaultsOption)
+{
+    if (title) {
+        builder.append(title);
+        builder.append('\n');
+    }
+
+    for (int id = 0; id < numberOfOptions; id++) {
+        if (separator && id)
+            builder.append(separator);
+        dumpOption(builder, level, static_cast<OptionID>(id), optionHeader, optionFooter, showDefaultsOption);
+    }
+}
+
+void Options::dumpAllOptionsInALine(StringBuilder& builder)
+{
+    dumpAllOptions(builder, DumpLevel::All, nullptr, " ", nullptr, nullptr, DontShowDefaults);
+}
+
+void Options::dumpAllOptions(FILE* stream, DumpLevel level, const char* title)
+{
+    StringBuilder builder;
+    dumpAllOptions(builder, level, title, nullptr, "   ", "\n", ShowDefaults);
+    fprintf(stream, "%s", builder.toString().ascii().data());
+}
+
+void Options::dumpOption(StringBuilder& builder, DumpLevel level, OptionID id,
+    const char* header, const char* footer, ShowDefaultsOption showDefaultsOption)
+{
+    if (id >= numberOfOptions)
+        return; // Illegal option.
+
+    Option option(id);
+    bool wasOverridden = option.isOverridden();
+    bool needsDescription = (level == DumpLevel::Verbose && option.description());
+
+    if (level == DumpLevel::Overridden && !wasOverridden)
+        return;
+
+    if (header)
+        builder.append(header);
+    builder.append(option.name());
+    builder.append('=');
+    option.dump(builder);
+
+    if (wasOverridden && (showDefaultsOption == ShowDefaults)) {
+        builder.append(" (default: ");
+        option.defaultOption().dump(builder);
+        builder.append(")");
+    }
+
+    if (needsDescription) {
+        builder.append("   ... ");
+        builder.append(option.description());
+    }
+
+    builder.append(footer);
+}
+
+void Options::ensureOptionsAreCoherent()
+{
+    bool coherent = true;
+    if (!(useLLInt() || useJIT())) {
+        coherent = false;
+        dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
+    }
+    if (!coherent)
+        CRASH();
+}
+
+void Option::dump(StringBuilder& builder) const
+{
+    switch (type()) {
+    case Options::Type::boolType:
+        builder.append(m_entry.boolVal ? "true" : "false");
+        break;
+    case Options::Type::unsignedType:
+        builder.appendNumber(m_entry.unsignedVal);
+        break;
+    case Options::Type::doubleType:
+        builder.appendNumber(m_entry.doubleVal);
+        break;
+    case Options::Type::int32Type:
+        builder.appendNumber(m_entry.int32Val);
+        break;
+    case Options::Type::optionRangeType:
+        builder.append(m_entry.optionRangeVal.rangeString());
+        break;
+    case Options::Type::optionStringType: {
+        const char* option = m_entry.optionStringVal;
+        if (!option)
+            option = "";
+        builder.append('"');
+        builder.append(option);
+        builder.append('"');
+        break;
+    }
+    case Options::Type::gcLogLevelType: {
+        builder.append(GCLogging::levelAsString(m_entry.gcLogLevelVal));
+        break;
+    }
+    }
+}
+
+bool Option::operator==(const Option& other) const
+{
+    switch (type()) {
+    case Options::Type::boolType:
+        return m_entry.boolVal == other.m_entry.boolVal;
+    case Options::Type::unsignedType:
+        return m_entry.unsignedVal == other.m_entry.unsignedVal;
+    case Options::Type::doubleType:
+        return (m_entry.doubleVal == other.m_entry.doubleVal) || (isnan(m_entry.doubleVal) && isnan(other.m_entry.doubleVal));
+    case Options::Type::int32Type:
+        return m_entry.int32Val == other.m_entry.int32Val;
+    case Options::Type::optionRangeType:
+        return m_entry.optionRangeVal.rangeString() == other.m_entry.optionRangeVal.rangeString();
+    case Options::Type::optionStringType:
+        return (m_entry.optionStringVal == other.m_entry.optionStringVal)
+            || (m_entry.optionStringVal && other.m_entry.optionStringVal && !strcmp(m_entry.optionStringVal, other.m_entry.optionStringVal));
+    case Options::Type::gcLogLevelType:
+        return m_entry.gcLogLevelVal == other.m_entry.gcLogLevelVal;
+    }
+    return false;
+}
+
+} // namespace JSC
+