Options.cpp

/*
 * Copyright (C) 2011-2025 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 "ConcurrentButterflyOperations.h"
#include "CPU.h"
#include "JITOperationValidation.h"
#include "LLIntCommon.h"
#include "MacroAssembler.h"
#include "MinimumReservedZoneSize.h"
#include <algorithm>
#include <limits>
#include <mutex>
#include <stdlib.h>
#include <string.h>
#include <wtf/ASCIICType.h>
#include <wtf/BitSet.h>
#include <wtf/Compiler.h>
#include <wtf/DataLog.h>
#include <wtf/FastMalloc.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/NumberOfCores.h>
#include <wtf/StdLibExtras.h>
#include <wtf/TranslatedProcess.h>
#include <wtf/text/MakeString.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/threads/Signals.h>

#if PLATFORM(COCOA)
#include <wtf/darwin/OSLogPrintStream.h>
#endif

#if PLATFORM(COCOA)
#include <crt_externs.h>
#endif

#if ENABLE(JIT_CAGE)
#include <machine/cpu_capabilities.h>
#include <wtf/cocoa/Entitlements.h>
#endif

#if OS(LINUX)
#include <unistd.h>
extern "C" char **environ;
#endif

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

namespace JSC {

bool useOSLogOptionHasChanged = false;
Options::SandboxPolicy Options::machExceptionHandlerSandboxPolicy = Options::SandboxPolicy::Unknown;

namespace OptionsHelper {

// The purpose of Metadata is to hold transient info needed during initialization of
// Options. It will be released in Options::finalize(), and will not be kept during
// VM run time. For now, the only field it contains is a copy of Options defaults
// which are only used to provide more info for Options dumps.
struct Metadata {
    // This struct does not need to be TZONE_ALLOCATED because it is only used for transient memory
    // during Options initialization, and will not be re-allocated thereafter. See comment above.
    WTF_DEPRECATED_MAKE_FAST_ALLOCATED(Metadata);
public:
    OptionsStorage defaults;
};

static LazyNeverDestroyed<std::unique_ptr<Metadata>> g_metadata;
static LazyNeverDestroyed<WTF::BitSet<NumberOfOptions>> g_optionWasOverridden;

struct ConstMetaData {
    ASCIILiteral name;
    ASCIILiteral description;
    Options::Type type;
    Options::Availability availability;
    uint16_t offsetOfOption;
};

// Realize the names for each of the options:
static const ConstMetaData g_constMetaData[NumberOfOptions] = {
#define FILL_OPTION_INFO(type_, name_, defaultValue_, availability_, description_) \
    { #name_ ## _s, description_, Options::Type::type_, Options::Availability::availability_, offsetof(OptionsStorage, name_) },
    FOR_EACH_JSC_OPTION(FILL_OPTION_INFO)
#undef FILL_OPTION_INFO
};

class Option {
public:
    void dump(StringBuilder&) const;

    bool operator==(const Option&) const;

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN
    ASCIILiteral NODELETE name() const { return g_constMetaData[m_id].name; }
    ASCIILiteral NODELETE description() const { return g_constMetaData[m_id].description; }
    Options::Type NODELETE type() const { return g_constMetaData[m_id].type; }
    Options::Availability NODELETE availability() const { return g_constMetaData[m_id].availability; }
WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

    Option(Options::ID id, void* addressOfValue)
        : m_id(id)
    {
        initValue(addressOfValue);
    }

    void initValue(void* addressOfValue);

    Options::ID m_id;
    union {
        bool m_bool;
        unsigned m_unsigned;
        double m_double;
        int32_t m_int32;
        size_t m_size;
        OptionRange m_optionRange;
        const char* m_optionString;
        GCLogging::Level m_gcLogLevel;
        OSLogType m_osLogType;
    };
};

static void initialize()
{
    g_optionWasOverridden.construct();

    // Make a transient copy of the default option values into g_metadata before they get
    // modified. The defaults are only needed to provide more info when dumping options.
    // g_metadata will be released in Options::finalize() (see releaseMetadata()).
    g_metadata.construct();
    auto metadata = makeUnique<Metadata>();
    memcpy(&metadata->defaults, &g_jscConfig.options, sizeof(OptionsStorage));
    g_metadata.get() = WTF::move(metadata);
}

static void releaseMetadata()
{
    g_metadata.get() = nullptr;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

static const Option defaultFor(Options::ID id)
{
    auto offset = g_constMetaData[id].offsetOfOption;
    void* addressOfDefault = reinterpret_cast<uint8_t*>(&g_metadata.get()->defaults) + offset;
    return Option(id, addressOfDefault);
}

inline static void* NODELETE addressOfOption(Options::ID id)
{
    auto offset = g_constMetaData[id].offsetOfOption;
    return reinterpret_cast<uint8_t*>(&g_jscConfig.options) + offset;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

static const Option optionFor(Options::ID id)
{
    return Option(id, addressOfOption(id));
}

inline static bool NODELETE hasMetadata()
{
    return !!g_metadata.get();
}

inline static bool NODELETE wasOverridden(Options::ID id)
{
    ASSERT(id < NumberOfOptions);
    return g_optionWasOverridden->get(id);
}

inline static void NODELETE setWasOverridden(Options::ID id)
{
    ASSERT(id < NumberOfOptions);
    g_optionWasOverridden->set(id);
}

} // namespace OptionsHelper

template<typename T>
std::optional<T> parse(const char* string);

template<>
std::optional<OptionsStorage::Bool> parse(const char* string)
{
    auto span = unsafeSpan(string);
    if (equalLettersIgnoringASCIICase(span, "true"_s) || equalLettersIgnoringASCIICase(span, "yes"_s) || !strcmp(string, "1"))
        return true;
    if (equalLettersIgnoringASCIICase(span, "false"_s) || equalLettersIgnoringASCIICase(span, "no"_s) || !strcmp(string, "0"))
        return false;
    return std::nullopt;
}

template<>
std::optional<OptionsStorage::Int32> parse(const char* string)
{
    int32_t value;
    if (sscanf(string, "%d", &value) == 1)
        return value;
    return std::nullopt;
}

template<>
std::optional<OptionsStorage::Unsigned> parse(const char* string)
{
    unsigned value;
    if (sscanf(string, "%u", &value) == 1)
        return value;
    return std::nullopt;
}

#if CPU(ADDRESS64) || OS(DARWIN) || OS(HAIKU)
template<>
std::optional<OptionsStorage::Size> parse(const char* string)
{
    size_t value;
    if (sscanf(string, "%zu", &value) == 1)
        return value;
    return std::nullopt;
}
#endif // CPU(ADDRESS64) || OS(DARWIN) || OS(HAIKU)

template<>
std::optional<OptionsStorage::Double> parse(const char* string)
{
    double value;
    if (sscanf(string, "%lf", &value) == 1)
        return value;
    return std::nullopt;
}

template<>
std::optional<OptionsStorage::OptionRange> parse(const char* string)
{
    OptionRange range;
    if (range.init(string))
        return range;
    return std::nullopt;
}

template<>
std::optional<OptionsStorage::OptionString> parse(const char* string)
{
    const char* value = nullptr;
    if (!strlen(string))
        return value;

    // FIXME <https://webkit.org/b/169057>: This could leak if this option is set more than once.
    // Given that Options are typically used for testing, this isn't considered to be a problem.
    value = WTF::fastStrDup(string);
    return value;
}

template<>
std::optional<OptionsStorage::GCLogLevel> parse(const char* string)
{
    auto span = unsafeSpan(string);
    if (equalLettersIgnoringASCIICase(span, "none"_s) || equalLettersIgnoringASCIICase(span, "no"_s) || equalLettersIgnoringASCIICase(span, "false"_s) || !strcmp(string, "0"))
        return GCLogging::None;

    if (equalLettersIgnoringASCIICase(span, "basic"_s) || equalLettersIgnoringASCIICase(span, "yes"_s) || equalLettersIgnoringASCIICase(span, "true"_s) || !strcmp(string, "1"))
        return GCLogging::Basic;

    if (equalLettersIgnoringASCIICase(span, "verbose"_s) || !strcmp(string, "2"))
        return GCLogging::Verbose;

    return std::nullopt;
}

template<>
std::optional<OptionsStorage::OSLogType> parse(const char* string)
{
    std::optional<OptionsStorage::OSLogType> result;

    auto span = unsafeSpan(string);
    if (equalLettersIgnoringASCIICase(span, "none"_s) || equalLettersIgnoringASCIICase(span, "false"_s) || !strcmp(string, "0"))
        result = OSLogType::None;
    else if (equalLettersIgnoringASCIICase(span, "true"_s) || !strcmp(string, "1"))
        result = OSLogType::Error;
    else if (equalLettersIgnoringASCIICase(span, "default"_s))
        result = OSLogType::Default;
    else if (equalLettersIgnoringASCIICase(span, "info"_s))
        result = OSLogType::Info;
    else if (equalLettersIgnoringASCIICase(span, "debug"_s))
        result = OSLogType::Debug;
    else if (equalLettersIgnoringASCIICase(span, "error"_s))
        result = OSLogType::Error;
    else if (equalLettersIgnoringASCIICase(span, "fault"_s))
        result = OSLogType::Fault;

    if (result && result.value() != Options::useOSLog())
        useOSLogOptionHasChanged = true;
    return result;
}

#if PLATFORM(COCOA)
static os_log_type_t NODELETE asDarwinOSLogType(OSLogType type)
{
    switch (type) {
    case OSLogType::None:
        RELEASE_ASSERT_NOT_REACHED();
    case OSLogType::Default:
        return OS_LOG_TYPE_DEFAULT;
    case OSLogType::Info:
        return OS_LOG_TYPE_INFO;
    case OSLogType::Debug:
        return OS_LOG_TYPE_DEBUG;
    case OSLogType::Error:
        return OS_LOG_TYPE_ERROR;
    case OSLogType::Fault:
        return OS_LOG_TYPE_FAULT;
    }
    RELEASE_ASSERT_NOT_REACHED();
    return OS_LOG_TYPE_DEFAULT;
}

static void initializeDatafileToUseOSLog()
{
    static bool alreadyInitialized = false;
    RELEASE_ASSERT(!alreadyInitialized);
    WTF::setDataFile(OSLogPrintStream::open("com.apple.JavaScriptCore", "DataLog", asDarwinOSLogType(Options::useOSLog())));
    alreadyInitialized = true;
    // Make sure no one jumped here for nefarious reasons...
    RELEASE_ASSERT(Options::useOSLog() != OSLogType::None);
}
#endif // OS(DARWIN)

static ASCIILiteral asString(OSLogType type)
{
    switch (type) {
    case OSLogType::None:
        return "none"_s;
    case OSLogType::Default:
        return "default"_s;
    case OSLogType::Info:
        return "info"_s;
    case OSLogType::Debug:
        return "debug"_s;
    case OSLogType::Error:
        return "error"_s;
    case OSLogType::Fault:
        return "fault"_s;
    }
    RELEASE_ASSERT_NOT_REACHED();
    return nullptr;
}

bool Options::isAvailable(Options::ID id, Options::Availability availability)
{
    if (availability == Availability::Restricted)
        return g_jscConfig.restrictedOptionsEnabled;
    ASSERT(availability == Availability::Configurable);
    
    UNUSED_PARAM(id);
#if !defined(NDEBUG)
    if (id == maxSingleAllocationSizeID)
        return true;
#endif
    if (id == traceLLIntExecutionID)
        return !!LLINT_TRACING;
    if (id == traceLLIntSlowPathID)
        return !!LLINT_TRACING;
    if (id == validateVMEntryCalleeSavesID)
        return !!ASSERT_ENABLED;
    return false;
}

#if !PLATFORM(COCOA)

template<typename T>
bool overrideOptionWithHeuristic(T& variable, Options::ID id, const char* name, Options::Availability availability)
{
    bool available = (availability == Options::Availability::Normal)
        || Options::isAvailable(id, availability);

    const char* stringValue = getenv(name);
    if (!stringValue)
        return false;
    
    if (available) {
        std::optional<T> value = parse<T>(stringValue);
        if (value) {
            variable = value.value();
            return true;
        }
    }
    
    fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
    return false;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

bool Options::overrideAliasedOptionWithHeuristic(const char* name)
{
    const char* stringValue = getenv(name);
    if (!stringValue)
        return false;

    auto aliasedOption = makeString(unsafeSpan(&name[4]), '=', unsafeSpan(stringValue));
    if (Options::setOption(aliasedOption.utf8().data()))
        return true;

    fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
    return false;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

#endif // !PLATFORM(COCOA)

unsigned Options::computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum)
{
    int cpusToUse = std::min(kernTCSMAwareNumberOfProcessorCores(), maxNumberOfWorkerThreads);

    // Be paranoid, it is the OS we're dealing with, after all.
    ASSERT(cpusToUse >= 1);
    return std::max(cpusToUse, minimum);
}

int32_t Options::computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)
{
    if (kernTCSMAwareNumberOfProcessorCores() <= 2)
        return twoCorePriorityDelta;

    return multiCorePriorityDelta;
}

unsigned Options::computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)
{
    return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);
}

bool Options::defaultTCSMValue()
{
    return true;
}

const char* const OptionRange::s_nullRangeStr = "<null>";

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

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;
    }
    
    const char* p = rangeString;

    if (*p == '!') {
        invert = true;
        p++;
    }

    int scanResult = sscanf(p, " %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;
    }

    // FIXME <https://webkit.org/b/169057>: This could leak if this particular option is set more than once.
    // Given that these options are used for testing, this isn't considered to be problem.
    m_rangeString = WTF::fastStrDup(rangeString);
    m_state = invert ? Inverted : Normal;

    return true;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

bool OptionRange::isInRange(unsigned count) const
{
    if (m_state < Normal)
        return true;

    if ((m_lowLimit <= count) && (count <= m_highLimit))
        return m_state == Normal;

    return m_state != Normal;
}

void OptionRange::dump(PrintStream& out) const
{
    out.print(m_rangeString);
}

static void scaleJITPolicy()
{
    auto& scaleFactor = Options::jitPolicyScale();
    if (scaleFactor > 1.0)
        scaleFactor = 1.0;
    else if (scaleFactor < 0.0)
        scaleFactor = 0.0;

    auto scaleOption = [&] (int32_t& optionValue, int32_t minValue) {
        optionValue *= scaleFactor;
        optionValue = std::max(optionValue, minValue);
    };

    scaleOption(Options::thresholdForJITAfterWarmUp(), 0);
    scaleOption(Options::thresholdForJITSoon(), 0);
    scaleOption(Options::thresholdForOptimizeAfterWarmUp(), 1);
    scaleOption(Options::thresholdForOptimizeAfterLongWarmUp(), 1);
    scaleOption(Options::thresholdForOptimizeSoon(), 1);
    scaleOption(Options::thresholdForFTLOptimizeSoon(), 2);
    scaleOption(Options::thresholdForFTLOptimizeAfterWarmUp(), 2);

    scaleOption(Options::thresholdForBBQOptimizeAfterWarmUp(), 0);
    scaleOption(Options::thresholdForBBQOptimizeSoon(), 0);
    scaleOption(Options::thresholdForOMGOptimizeAfterWarmUp(), 1);
    scaleOption(Options::thresholdForOMGOptimizeSoon(), 1);
}

#if OS(DARWIN)
static void disableAllSignalHandlerBasedOptions();
#endif

static void overrideDefaults()
{
#if OS(DARWIN)
    if (Options::machExceptionHandlerSandboxPolicy == Options::SandboxPolicy::Block)
        disableAllSignalHandlerBasedOptions();
#endif

#if !PLATFORM(IOS_FAMILY)
    if (WTF::numberOfProcessorCores() < 4)
#endif
    {
        Options::maximumMutatorUtilization() = 0.6;
        Options::concurrentGCMaxHeadroom() = 1.4;
        Options::minimumGCPauseMS() = 1;
        Options::useStochasticMutatorScheduler() = false;
        if (WTF::numberOfProcessorCores() <= 1)
            Options::gcIncrementScale() = 1;
        else
            Options::gcIncrementScale() = 0;
    }

#if OS(DARWIN) && CPU(ARM64)
    Options::numberOfGCMarkers() = std::min<unsigned>(4, kernTCSMAwareNumberOfProcessorCores());

    Options::minNumberOfWorklistThreads() = 1;
    Options::maxNumberOfWorklistThreads() = std::min<unsigned>(4, kernTCSMAwareNumberOfProcessorCores());
    Options::numberOfBaselineCompilerThreads() = std::min<unsigned>(4, kernTCSMAwareNumberOfProcessorCores());
    Options::numberOfDFGCompilerThreads() = std::min<unsigned>(4, kernTCSMAwareNumberOfProcessorCores());
    Options::numberOfFTLCompilerThreads() = std::min<unsigned>(4, kernTCSMAwareNumberOfProcessorCores());
    Options::worklistLoadFactor() = 20;
    Options::worklistBaselineLoadWeight() = 2;
    Options::worklistDFGLoadWeight() = 5;
    // Set the FTL load weight equal to the load-factor so that a new thread is started for each FTL plan
    Options::worklistFTLLoadWeight() = 20;
#endif

#if OS(LINUX) && CPU(ARM)
    Options::maximumFunctionForCallInlineCandidateBytecodeCostForDFG() = 77;
    Options::maximumOptimizationCandidateBytecodeCost() = 42403;
    Options::maximumFunctionForClosureCallInlineCandidateBytecodeCostForDFG() = 68;
    Options::maximumInliningCallerBytecodeCost() = 9912;
    Options::maximumInliningDepth() = 8;
    Options::maximumInliningRecursion() = 3;
#endif

#if USE(MEMORY_FOOTPRINT_API)
    // On iOS and conditionally Linux, we control heap growth using process memory footprint. Therefore these values can be agressive.
    Options::smallHeapRAMFraction() = 0.8;
    Options::mediumHeapRAMFraction() = 0.9;
#endif

#if !ENABLE(SIGNAL_BASED_VM_TRAPS)
    Options::usePollingTraps() = true;
#endif

#if !ENABLE(WEBASSEMBLY)
    Options::useWasmFastMemory() = false;
    Options::useWasmFaultSignalHandler() = false;
#endif

#if !HAVE(MACH_EXCEPTIONS)
    Options::useMachForExceptions() = false;
#endif

#if ASAN_ENABLED
    // This is a heuristic because ASAN builds are memory hogs in terms of stack frame usage.
    // So, we need a much larger ReservedZoneSize to allow stack overflow handlers to execute.
    Options::reservedZoneSize() = 3 * Options::reservedZoneSize();
#endif

#if PLATFORM(IOS_FAMILY)
    // This is used to mitigate performance regression rdar://150522186.
    if (Options::usePartialLoopUnrolling())
        Options::maxPartialLoopUnrollingBodyNodeSize() = 50;
#endif
}

bool Options::setAllJITCodeValidations(const char* valueStr)
{
    auto value = parse<OptionsStorage::Bool>(valueStr);
    if (!value)
        return false;
    setAllJITCodeValidations(value.value());
    return true;
}

void Options::setAllJITCodeValidations(bool value)
{
    Options::validateDFGClobberize() = value;
    Options::validateDFGExceptionHandling() = value;
    Options::validateDFGMayExit() = value;
    Options::validateDoesGC() = value;
    Options::useJITAsserts() = value;
}

static inline void NODELETE disableAllWasmJITOptions()
{
#if ENABLE(WEBASSEMBLY)
    // This really only makes sense if could use wasm, otherwise we should not override this.
    Options::useLLInt() = true;
#endif
    Options::useBBQJIT() = false;
    Options::useOMGJIT() = false;

    Options::useWasmSIMD() = Options::useWasmSIMD() && Options::useWasmIPIntSIMD();

    Options::dumpWasmDisassembly() = false;
    Options::dumpBBQDisassembly() = false;
    Options::dumpOMGDisassembly() = false;
}

static inline void NODELETE disableAllWasmOptions()
{
    disableAllWasmJITOptions();

    Options::useWasm() = false;
    Options::useWasmIPInt() = false;
    Options::useWasmIPIntSIMD() = false;
    Options::failToCompileWasmCode() = true;

    Options::useWasmFastMemory() = false;
    Options::useWasmFaultSignalHandler() = false;
    Options::numberOfWasmCompilerThreads() = 0;

    Options::useWasmSIMD() = false;
    Options::useWasmRelaxedSIMD() = false;
    Options::useWasmTailCalls() = false;
}

static inline void NODELETE disableAllJITOptions()
{
#if ENABLE(WEBASSEMBLY)
    // This really only makes sense if could use wasm, otherwise we should not override this.
    Options::useLLInt() = true;
#endif
    Options::useJIT() = false;
    disableAllWasmJITOptions();

    Options::useBaselineJIT() = false;
    Options::useLOLJIT() = false;
    Options::useDFGJIT() = false;
    Options::useFTLJIT() = false;
    Options::useDOMJIT() = false;
    Options::useRegExpJIT() = false;
    Options::useJITCage() = false;
    Options::useConcurrentJIT() = false;

    Options::usePollingTraps() = true;

    Options::dumpDisassembly() = false;
    Options::dumpBaselineDisassembly() = false;
    Options::dumpDFGDisassembly() = false;
    Options::dumpFTLDisassembly() = false;
    Options::dumpRegExpDisassembly() = false;
    Options::needDisassemblySupport() = false;
}

#if OS(DARWIN)
static void NODELETE disableAllSignalHandlerBasedOptions()
{
    Options::usePollingTraps() = true;
    Options::useSharedArrayBuffer() = false;
    Options::useWasmFastMemory() = false;
    Options::useWasmFaultSignalHandler() = false;
}
#endif

void Options::executeDumpOptions()
{
    if (!Options::dumpOptions()) [[likely]]
        return;

    DumpLevel level = static_cast<DumpLevel>(Options::dumpOptions());
    if (level > DumpLevel::Verbose)
        level = DumpLevel::Verbose;

    ASCIILiteral title;
    switch (level) {
    case DumpLevel::None:
        break;
    case DumpLevel::Overridden:
        title = "Modified JSC options:"_s;
        break;
    case DumpLevel::All:
        title = "All JSC options:"_s;
        break;
    case DumpLevel::Verbose:
        title = "All JSC options with descriptions:"_s;
        break;
    }

    StringBuilder builder;
    dumpAllOptions(builder, level, title, nullptr, "   "_s, "\n"_s, DumpDefaults);
    dataLog(builder.toString());
}


WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

void Options::notifyOptionsChanged()
{
    AllowUnfinalizedAccessScope scope;

    // SPEC-vmstate §3 R2 (M_opts2): useJSThreads=1 MUST imply all three
    // vmstate flags. (The prep-stub `useThreads` alias was removed by
    // INTEGRATE-api 9.2-1, so its normalization line is dropped per
    // INTEGRATE-vmstate cross-WS item 14.)
    if (Options::useJSThreads()) {
        Options::useSharedAtomStringTable() = true;
        Options::useVMLite() = true;
        Options::useStructureAllocationLock() = true;
    }

    // UNGIL §0 U0 (config gate; landed at U-T14 with the default flip):
    // GIL-off ("useJSThreads && !useThreadGIL") additionally requires the
    // full trio {useVMLite, useSharedAtomStringTable, useSharedGCHeap}. A
    // GIL-off shape without the trio is REFUSED at option validation by
    // forcing useThreadGIL=1 (ANNEX U0C: gilOffProcess is OPTION-derived
    // from this conjunction at Config finalization). This normalization is
    // what keeps VM::isGILOffProcess() (VM.cpp) and every landed
    // `useJSThreads() && !useThreadGIL()` derivation (ArrayBuffer.cpp,
    // VMInspector.cpp, SamplingProfiler.h, Watchdog.h, JSLock.cpp)
    // mutually equivalent. The M_opts2 normalization above already forces
    // useVMLite/useSharedAtomStringTable under useJSThreads, so in practice
    // this gates on the shared GC server. Flag-off (useJSThreads=0) is
    // byte-identical: the condition is unreachable. The U19 GIL-on oracle
    // (useJSThreads=1, useThreadGIL=1) is unaffected: an explicit
    // useThreadGIL=1 never enters this branch.
    if (Options::useJSThreads() && !Options::useThreadGIL()
        && !(Options::useVMLite() && Options::useSharedAtomStringTable() && Options::useSharedGCHeap()))
        Options::useThreadGIL() = true;

    // UNGIL activation-checklist refusal (review finding against the U-T14
    // close ruling): the trio opt-in alone is NOT a sufficient gate for
    // GIL-off, because useJSThreads=1 auto-forces useVMLite and
    // useSharedAtomStringTable above — so `--useJSThreads=1
    // --useSharedGCHeap=1` (two flags) would construct a live gilOff process
    // while blocker-grade activation items remain open with NO in-code
    // fail-stop on every path (AB-1 LLInt Group-3 split-brain is silently
    // UNSOUND; VM::updateStackLimits still clobbers the single VM-level soft
    // stack limit under N-parallel entry — VMTraps.h checklist item (3); the
    // per-lite trap words still alias the VM word — VMLite.cpp §A.2.1). Per
    // the house rule (fail-stop/refusal over silent corruption), the U0
    // validation REFUSES the gilOff shape outright unless the explicit
    // development escape hatch useThreadGILOffUnsafe is ALSO set. This keeps
    // every "enable the trio" experiment on the GIL'd oracle (the J.1
    // ordering) until the AB list (INTEGRATE-ungil.md AB-1..AB-15) is
    // discharged, at which point this clause is deleted and the trio opt-in
    // again derives gilOff directly.
    if (Options::useJSThreads() && !Options::useThreadGIL() && !Options::useThreadGILOffUnsafe()) {
        dataLogLn("JSC: refusing GIL-off configuration (UNGIL activation checklist incomplete); forcing useThreadGIL=1. Set useThreadGILOffUnsafe=1 to override for development.");
        Options::useThreadGIL() = true;
    }

    // UNGIL §A.2.2 (AB-17 follow-up): the LOL tier has not been audited for
    // the §A.1.3 COMPILED-FOR-VM rule (per-lite Group-3 state, butterfly TID
    // tags, etc. beyond the now-rerouted prologue soft-stack-limit check in
    // LOLJIT.cpp). Per the house rule (fail-stop/refusal over silent
    // corruption), force it off under the GIL-off shape rather than let an
    // unaudited tier compile spawned-thread code. Flag-off and GIL-on are
    // unaffected; delete this once LOL passes the §A.1.3 audit.
    if (Options::useJSThreads() && !Options::useThreadGIL() && Options::useLOLJIT()) {
        dataLogLn("JSC: disabling useLOLJIT under GIL-off (LOL tier not yet audited for UNGIL §A.1.3 COMPILED-FOR-VM; see AB-17).");
        Options::useLOLJIT() = false;
    }

    // UNGIL §A.1.3 (AB-17 round-5 amendment): the wasm tiers have not been
    // audited for COMPILED-FOR-VM either — the wasm<->JS glue still emits
    // raw VM-block exception-word checks (VM::exceptionOffset() loads in
    // WasmToJS.cpp, JSToWasm.cpp, WebAssemblyBuiltinTrampoline.cpp) that are
    // inert spare storage GIL-off, so a throwing callee of a CARRIER-executed
    // wasm<->JS call would be silently missed (the AB-15 SD7 refusal in
    // VMEntryScope.cpp only covers SPAWNED threads calling carrier-created
    // exports). Per the house rule (fail-stop/refusal over silent
    // corruption), force wasm off under the GIL-off shape — LOLJIT precedent
    // above. Flag-off and GIL-on are unaffected; delete this once the wasm
    // glue is rerouted through the mode-keyed exception-slot pattern
    // (AssemblyHelpers::loadException / materializeGILOffExceptionSlot) and
    // passes the §A.1.3 audit.
    if (Options::useJSThreads() && !Options::useThreadGIL() && Options::useWasm()) {
        dataLogLn("JSC: disabling useWasm under GIL-off (wasm glue still reads the raw VM-block exception word; not yet audited for UNGIL §A.1.3 COMPILED-FOR-VM; see AB-17 status block in VMEntryScope.cpp).");
        Options::useWasm() = false;
    }

#if !(CPU(X86_64) || CPU(ARM64)) || ENABLE(C_LOOP)
    // UNGIL §A.1.3 / AB-1 (A6-amend review finding, 2026-06-11): the GIL-off
    // Group-3 mode split is implemented only for the 64-bit JIT
    // configurations. The C++ writers store encodedHostCallReturnValue
    // through group3Primitives() (per-lite copy when a gilOff same-VM lite is
    // current), and the matching mode-split READ sites exist only in
    // LowLevelInterpreter64.asm (llint_get_host_call_return_value AB-1
    // split) and LLIntThunks.cpp getHostCallReturnValueThunk's
    // #if CPU(X86_64) || CPU(ARM64) arm. LowLevelInterpreter32_64.asm
    // (and the CLoop build of it) still reads the raw VM-block words
    // unconditionally, so a spawned thread's host call on such a
    // configuration would consume a stale/garbage return value SILENTLY —
    // writer hits the lite copy, reader the VM block. Per the house rule
    // (fail-stop/refusal over silent corruption), REFUSE the GIL-off shape
    // outright on these configurations instead of relying on the charter
    // convention that GIL-off targets 64-bit JIT builds. Flag-off and
    // GIL-on are unaffected (condition requires useThreadGIL=0); 64-bit
    // JIT builds compile this block away entirely (byte-identical codegen).
    // Delete the relevant arm once the 32_64/CLoop read sites get the same
    // mode split.
    if (Options::useJSThreads() && !Options::useThreadGIL()) {
        dataLogLn("JSC: refusing GIL-off configuration on a non-64-bit-JIT/CLoop build (LowLevelInterpreter32_64 reads the raw VM-block encodedHostCallReturnValue words; the UNGIL AB-1 Group-3 mode split is 64-bit-only); forcing useThreadGIL=1.");
        Options::useThreadGIL() = true;
    }
#endif

    // ANNEX U0C write-once latch backstop (U-T14 amend, reviewer round 2):
    // gilOffProcess is OPTION-derived and IMMUTABLE for the process. The
    // real latch — the JSCConfig gilOffProcess byte — is U-T3's open
    // obligation 9b (INTEGRATE-ungil.md; see AB-1). Until it lands, this
    // shadow latch closes the divergence window between
    // construction-latched consumers (VM::m_gilOff, Watchdog::m_gilOff)
    // and the live-read short forms (ArrayBuffer.cpp gilOffThreadsProcess,
    // VMInspector.cpp isGILOffProcessForInspection, SamplingProfiler.h,
    // JSLock.cpp, VM::isGILOffProcess): Options::setOptions /
    // setOption(verify=true) re-run this function and could otherwise flip
    // the derivation mid-process (including this very U0 normalization
    // forcing useThreadGIL 0 -> 1), silently splitting the lock-arm /
    // detach-table selection across consumers. Options::finalize() runs at
    // the tail of JSC::initialize() (InitializeThreading.cpp), strictly
    // before any VM can be constructed, so refusing post-finalization
    // CHANGES of the derivation is exactly "latched at Config
    // finalization" minus the JSCConfig storage. Pre-finalization calls
    // (Options::initialize, the jsc-shell CommandLine::parseArguments
    // setOption loop, embedder setOptions before JSC::initialize) re-latch
    // freely. Flag-off and U19 GIL-on: the derivation is constant (false),
    // so the assert is unreachable; codegen shape unaffected (host C++
    // only). When the JSCConfig byte lands (U-T3), it subsumes this latch
    // and the statics below should be replaced by it, keeping the
    // RELEASE_ASSERT.
    {
        bool gilOffProcessDerivation = Options::useJSThreads() && !Options::useThreadGIL()
            && Options::useVMLite() && Options::useSharedAtomStringTable() && Options::useSharedGCHeap();
        static bool s_gilOffProcessLatch = false;
        static bool s_gilOffProcessLatchIsSet = false;
        if (!g_jscConfig.options.isFinalized || !s_gilOffProcessLatchIsSet) {
            s_gilOffProcessLatch = gilOffProcessDerivation;
            s_gilOffProcessLatchIsSet = true;
        } else
            RELEASE_ASSERT(gilOffProcessDerivation == s_gilOffProcessLatch);
    }

    // SCALEBENCH §27.S2 (campaign-4 task C1-congc-no-default): deliberately
    // NOT forcing useConcurrentSharedGCMarking=1 under the GIL-off shape.
    // The campaign-3 ceiling hypothesis ("STW collection wall fraction") was
    // MEASURED and REFUTED by gcwall instrumentation (METHOD B, 3-run W=16):
    // STW-GC open-to-resume is 807 ms / 14847 ms = 5.4% of wall with congc
    // OFF, and 765 ms / 15119 ms = 5.1% with congc ON — i.e. congc=1 saves
    // ~42 ms of stop time but adds ~30 extra Reentry-rendezvous windows
    // (57 -> 87-88) and REGRESSES bench wall +1.8% (+270 ms). congcab A/B
    // independently: W=8 median +0.2%, W=16 +1.2%, cpu_util 718 -> 701 (did
    // not rise), 0/16 checksum divergence. So defaulting C1 on here would
    // cost wall, not save it; even a perfect congc caps the gain at 5.4%,
    // far short of the 12600 ms Java-parity target. The actual W=16 ceiling
    // is ~52% thread-0 serial inter-phase work + the parallel-phase 5.6x
    // CPU-waste tax (SCALEBENCH §27.S1/S2). The congc-specific follow-up the
    // profile names — eliminate the ~30 extra Reentry rendezvous windows C1
    // introduces — is recorded in §27.S2 as DEFERRED. Leave the
    // OptionsList.h default at false; revisit only with a fresh gcwall A/B
    // showing >=10% STW wall fraction.

    // SPEC-congc §13.2 stage-flag validation (CG-2; INTEGRATE-congc.md
    // manifest row 1): the §7 prefix rule — a stage flag requires every
    // earlier stage's flag — and all four stages require useSharedGCHeap.
    // Enforced by forcing the dependent flag OFF (house style: refuse the
    // unsupported shape rather than silently run it). Evaluated C1-first so
    // a violation cascades: clearing an earlier stage clears every later
    // one. Flags-off (all default false): every condition is false —
    // byte-identical behavior. NOTE: the flags are development-only until
    // CG-3..CG-6 land the C1-C4 behavior behind them (the windowed arms CG-1
    // staged activate via Heap::sharedGCWindowedStagesEnabled(), but the
    // stage semantics — kill-switch retires, marker scheduling, collector
    // thread, sweeping, assist — are not in-tree yet).
    if (Options::useConcurrentSharedGCMarking() && !Options::useSharedGCHeap()) {
        dataLogLn("JSC: disabling useConcurrentSharedGCMarking (SPEC-congc §13.2: requires useSharedGCHeap).");
        Options::useConcurrentSharedGCMarking() = false;
    }
    if (Options::useSharedGCCollectorThread() && !Options::useConcurrentSharedGCMarking()) {
        dataLogLn("JSC: disabling useSharedGCCollectorThread (SPEC-congc §13.2 prefix rule: requires useConcurrentSharedGCMarking).");
        Options::useSharedGCCollectorThread() = false;
    }
    if (Options::useSharedGCIncrementalSweep() && !Options::useSharedGCCollectorThread()) {
        dataLogLn("JSC: disabling useSharedGCIncrementalSweep (SPEC-congc §13.2 prefix rule: requires useSharedGCCollectorThread).");
        Options::useSharedGCIncrementalSweep() = false;
    }
    if (Options::useSharedGCMutatorAssist() && !Options::useSharedGCIncrementalSweep()) {
        dataLogLn("JSC: disabling useSharedGCMutatorAssist (SPEC-congc §13.2 prefix rule: requires useSharedGCIncrementalSweep).");
        Options::useSharedGCMutatorAssist() = false;
    }

    unsigned thresholdForGlobalLexicalBindingEpoch = Options::thresholdForGlobalLexicalBindingEpoch();
    if (thresholdForGlobalLexicalBindingEpoch == 0 || thresholdForGlobalLexicalBindingEpoch == 1)
        Options::thresholdForGlobalLexicalBindingEpoch() = UINT_MAX;

#if !ENABLE(OFFLINE_ASM_ALT_ENTRY)
    if (Options::useGdbJITInfo())
        dataLogLn("useGdbJITInfo should be used with OFFLINE_ASM_ALT_ENTRY");
#endif

#if !ENABLE(JIT)
    Options::useJIT() = false;
#endif
#if !ENABLE(CONCURRENT_JS)
    Options::useConcurrentJIT() = false;
#endif
#if !ENABLE(YARR_JIT)
    Options::useRegExpJIT() = false;
#endif
#if !ENABLE(DFG_JIT)
    Options::useDFGJIT() = false;
    Options::useFTLJIT() = false;
#endif
#if !ENABLE(FTL_JIT)
    Options::useFTLJIT() = false;
#endif

#if CPU(RISCV64)
    // On RISCV64, JIT levels are enabled at build-time to simplify building JSC, avoiding
    // otherwise rare combinations of build-time configuration. FTL on RISCV64 is disabled
    // at runtime for now, until it gets int a proper working state.
    // https://webkit.org/b/239707
    Options::useFTLJIT() = false;
#endif

#if !CPU(X86_64) && !CPU(ARM64)
    Options::useConcurrentGC() = false;
    Options::forceUnlinkedDFG() = false;
    Options::useWasmSIMD() = false;
    Options::useWasmIPInt() = false;
#if !CPU(ARM_THUMB2)
    Options::useBBQJIT() = false;
#endif
#endif

#if !CPU(ARM64)
    Options::useRandomizingExecutableIslandAllocation() = false;
#endif

    if (!Options::useJSThreadsUnlockHandlerICInFTL())
        Options::useHandlerICInFTL() = false; // Currently, it is not completed. Disable forcefully.

    // SPEC-jit M2b.
    if (Options::useJSThreads()) {
        Options::useHandlerICInFTL() = true;   // §5.2/D1: FTL must not patch property-IC code in place.
        Options::usePollingTraps() = true;     // I21: cooperative polls only; async breakpoint patching = I2 violation.
        Options::useConcurrentJIT() = true;    // Task 12: sync-compile bypasses the JITWorklist dedup backstop (§5.7.3).
        // SCALEBENCH §33 RUN-3.8 / v38: REVERSES the campaign-4 §27.S2
        // C1-congc-no-default decision (see comment above the §13.2 block).
        // That ruling was correct on v33 data (STW-GC 5.4% of wall, congc A/B
        // +1.8% regression) but is STALE on v38: STW parking is now 15.5% of
        // phaseA — past the >=10% revisit threshold the §27.S2 comment set —
        // and a fresh intcs A/B at W=16 shows congc=1 ~7550 ms vs congc=0
        // ~10200 ms (-26%), W=1 neutral (~17.1 s both). So force C1 on under
        // the GIL-off shape. Gated on !useThreadGIL && useSharedGCHeap, NOT
        // on useJSThreads alone (review round, this campaign): (a) the §13.2
        // prefix-rule cascade above runs BEFORE this block, so an unguarded
        // force here would bypass it on the U19 GIL-on / bare-useJSThreads
        // shape (sharedGCHeap=false) and flip
        // Heap::sharedGCWindowedStagesEnabled() true on a non-shared heap —
        // the exact invariant the Heap.h:1403 comment relies on; (b) the
        // GIL-on identity arm (useJSThreads=1 useThreadGIL=1
        // useSharedGCHeap=1) has NO congc A/B data — every cited number is
        // GIL-off — and Heap.cpp setMutatorShouldBeFenced drops the
        // always-fenced forcing when congc && !isGILOffProcess, a live
        // behavior delta on the §30/§31 identity gate. The U0 normalization
        // upstream guarantees !useThreadGIL => useSharedGCHeap, so the
        // sharedGCHeap conjunct is belt-and-suspenders for the §13.2
        // invariant. OptionsList.h default stays false; flag-off path never
        // enters this block — byte-identical.
        //
        // §34 Run 3.9: REVERTED back to opt-in. Release W=32 30/30 + checksum
        // match held (spread tightened 19%->14%), but Debug GIL-off corpus
        // regressed 94/0 -> 41/53 on ASSERT(isMarked(cell)) at
        // Heap::addToRememberedSet — the SPEC-congc rev-12 open
        // remembered-set/barrier-vs-concurrent-mark item, never previously
        // covered (prior congc gates were Release-only). Either the assert is
        // a stale invariant under N-mutator concurrent marking (relax to the
        // mutatorShouldBeFenced tolerant form on the routedClient path) OR a
        // real lost-mark race Release masks. Net perf was only ~-3% W>=8
        // anyway (the earlier -26% was bimodality artifact). Stays opt-in
        // until the assert is resolved; the §34 fast-mode lead is the larger
        // open lever.
        // (intentionally no default-force here)

        // D8 / Task-8 item 6: flag-on requires 64-bit pointers and a JIT-visible TLS
        // mechanism for the R5 tag (ELF initial-exec TLS on Linux x86-64/arm64, or
        // Darwin FAST_TLS via the M4a key slot).
#if !CPU(ADDRESS64) || !(OS(LINUX) && (CPU(X86_64) || CPU(ARM64))) && !(OS(DARWIN) && ENABLE(FAST_TLS_JIT))
        { dataLogLn("useJSThreads is unsupported on this platform (SPEC-jit D8)"); CRASH(); }
#endif
        // Task-8 item 5: the JSValue gigacage does not exist in this tree
        // (Gigacage::Kind has only Primitive), so the cage-vs-tag-mask concern
        // is vacuously satisfied; no assert is emitted here on purpose.

        // SPEC-jit P5/App. R5 (M2c): the main thread must run butterfly-TID-tag
        // init before any flag-on JIT leg emits loadButterflyTIDTag (both
        // per-platform offset/key queries RELEASE_ASSERT prior init), and
        // before Config::finalize on Darwin (the pthread key is mirrored into
        // g_jscConfig). Idempotent; main-thread tag is 0. Spawned threads run
        // the same call on their spawn path (INTEGRATE-api 9.2-8).
        JSC::initializeButterflyTIDTagForCurrentThread();
    }
    // Spec'd invariant check (defense against a later pass re-disabling it):
    if (Options::useJSThreads() && !Options::useHandlerICInFTL()) {
        dataLogLn("FATAL: useJSThreads requires useHandlerICInFTL (SPEC-jit M2b).");
        CRASH();
    }
    Options::forceUnlinkedDFG() = false; // Currently, IC is rapidly changing. We disable this until we get the final form of Data IC.

    if (!Options::allowDoubleShape())
        Options::useJIT() = false; // We don't support JIT with !allowDoubleShape. So disable it.

    if (!Options::useWasm())
        disableAllWasmOptions();

    if (!Options::useJIT())
        disableAllWasmJITOptions();

    if (!Options::useWasmIPInt())
        Options::thresholdForBBQOptimizeAfterWarmUp() = 0; // Trigger immediate BBQ tier up.

#if CPU(ARM_THUMB2)
    // WasmIPInt is not supported on ARM32, so disable wasm if BBQJIT is disabled.
    if (Options::useWasm() && !Options::useBBQJIT())
        Options::useWasm() = false;
#endif

#if ENABLE(WEBASSEMBLY)
#if CPU(ARM64)
    if (Options::enableWasmDebugger()) [[unlikely]] {
        Options::useBBQJIT() = false;
        Options::useOMGJIT() = false;
    }
#else
    Options::enableWasmDebugger() = false;
#endif
#endif

    // At initialization time, we may decide that useJIT should be false for any
    // number of reasons (including failing to allocate JIT memory), and therefore,
    // will / should not be able to enable any JIT related services.
    if (!Options::useJIT()) {
        disableAllJITOptions();
#if OS(DARWIN)
        // If we don't know what the sandbox policy is on mach exception handler use is, we'll
        // take the default behavior of blocking its use if the JIT is disabled. JIT disablement
        // is a good proxy indicator for when mach exception handler use would also be blocked.
        if (machExceptionHandlerSandboxPolicy == SandboxPolicy::Unknown)
            disableAllSignalHandlerBasedOptions();
#endif
    } else {
        if (WTF::isX86BinaryRunningOnARM()) {
            Options::useBaselineJIT() = false;
            Options::useDFGJIT() = false;
            Options::useFTLJIT() = false;
        }

        if (Options::dumpDisassembly()
            || Options::dumpBaselineDisassembly()
            || Options::dumpDFGDisassembly()
            || Options::dumpFTLDisassembly()
            || Options::dumpCSSJITDisassembly()
            || Options::dumpRegExpDisassembly()
            || Options::dumpWasmDisassembly()
            || Options::dumpBBQDisassembly()
            || Options::dumpOMGDisassembly()
            || Options::useProfiler()) // For JIT comments in the profile.
            Options::needDisassemblySupport() = true;

        if (Options::useIRDump() && !Options::useJITDump())
            Options::useIRDump() = false;

        if (Options::useSourceCodeDump() && !Options::useJITDump())
            Options::useSourceCodeDump() = false;
        if (Options::useSourceCodeDump() && Options::useIRDump())
            Options::useSourceCodeDump() = false;

        if (OptionsHelper::wasOverridden(jitPolicyScaleID))
            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::useConcurrentJIT() = 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()));

        if (isX86_64() && !isX86_64_AVX())
            Options::useWasmSIMD() = false;

        if (Options::forceAllFunctionsToUseSIMD() && !Options::useWasmSIMD())
            Options::forceAllFunctionsToUseSIMD() = false;

        if (Options::useWasmSIMD() && !Options::useWasmIPInt()) {
            // The LLInt is responsible for discovering if functions use SIMD.
            // If we can't run using it, then we should be conservative.
            Options::forceAllFunctionsToUseSIMD() = true;
        }
    }

    // TODO
    if (Options::useLOLJIT())
        Options::forceOSRExitToLLInt() = true;

    if (!Options::useConcurrentGC())
        Options::collectContinuously() = false;

    if (Options::useProfiler())
        Options::useConcurrentJIT() = false;

    if (Options::alwaysUseShadowChicken())
        Options::maximumInliningDepth() = 1;
        
#if !defined(NDEBUG)
    if (Options::maxSingleAllocationSize())
        fastSetMaxSingleAllocationSize(Options::maxSingleAllocationSize());
    else
        fastSetMaxSingleAllocationSize(std::numeric_limits<size_t>::max());
#endif

    if (Options::useZombieMode()) {
        Options::sweepSynchronously() = true;
        Options::scribbleFreeCells() = true;
    }

    if (Options::reservedZoneSize() < minimumReservedZoneSize)
        Options::reservedZoneSize() = minimumReservedZoneSize;
    if (Options::softReservedZoneSize() < Options::reservedZoneSize() + minimumReservedZoneSize)
        Options::softReservedZoneSize() = Options::reservedZoneSize() + minimumReservedZoneSize;

    if (!Options::useCodeCache())
        Options::diskCachePath() = nullptr;

    if (Options::randomIntegrityAuditRate() < 0)
        Options::randomIntegrityAuditRate() = 0;
    else if (Options::randomIntegrityAuditRate() > 1.0)
        Options::randomIntegrityAuditRate() = 1.0;

    if (!Options::allowUnsupportedTiers()) {
#define DISABLE_TIERS(option, flags, ...) do { \
            if (!Options::option())            \
                break;                         \
            if (!(flags & SupportsDFG))        \
                Options::useDFGJIT() = false;  \
            if (!(flags & SupportsFTL))        \
                Options::useFTLJIT() = false;  \
        } while (false);

        FOR_EACH_JSC_EXPERIMENTAL_OPTION(DISABLE_TIERS);
    }

#if PLATFORM(COCOA)
    if (useOSLogOptionHasChanged) {
        initializeDatafileToUseOSLog();
        useOSLogOptionHasChanged = false;
    }
#endif

    if (Options::verboseVerifyGC())
        Options::verifyGC() = true;

#if ASAN_ENABLED && OS(LINUX)
    if (Options::useWasmFaultSignalHandler()) {
        const char* asanOptions = getenv("ASAN_OPTIONS");
        bool okToUseWasmFastMemory = asanOptions
            && (strstr(asanOptions, "allow_user_segv_handler=1") || strstr(asanOptions, "handle_segv=0"));
        if (!okToUseWasmFastMemory)
            Options::useWasmFaultSignalHandler() = false;
    }
#endif

    // We can't use our pacibsp system while using posix signals because the signal handler could trash our stack during reifyInlinedCallFrames.
    // If we have JITCage we don't need to restrict ourselves to pacibsp.
    if (!Options::useMachForExceptions() || Options::useJITCage())
        Options::allowNonSPTagging() = true;

    if (!Options::useWasmFaultSignalHandler())
        Options::useWasmFastMemory() = false;

    if (Options::dumpOptimizationTracing()) {
        Options::printEachDFGFTLInlineCall() = true;
        Options::printEachUnrolledLoop() = true;
        // FIXME: Should support for OSR exit as well.
    }

#if CPU(ADDRESS32) || PLATFORM(PLAYSTATION) || OS(WINDOWS)
    Options::useWasmFastMemory() = false;
#endif

    // Do range checks where needed and make corrections to the options:
    ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
    ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
    ASSERT(Options::criticalGCMemoryThreshold() > 0.0 && Options::criticalGCMemoryThreshold() < 1.0);
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

#if OS(WINDOWS)
// FIXME: Use equalLettersIgnoringASCIICase.
inline bool strncasecmp(const char* str1, const char* str2, size_t n)
{
    return _strnicmp(str1, str2, n);
}
#endif

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

void Options::initializeWithOptionsCustomization(const ScopedLambda<void()>& optionsCustomizationCallback)
{
    static std::once_flag initializeOptionsOnceFlag;
    
    std::call_once(
        initializeOptionsOnceFlag,
        [&] {
            AllowUnfinalizedAccessScope scope;

            // Sanity check that options address computation is working.
            RELEASE_ASSERT(OptionsHelper::addressOfOption(useKernTCSMID) ==  &Options::useKernTCSM());
            RELEASE_ASSERT(OptionsHelper::addressOfOption(gcMaxHeapSizeID) ==  &Options::gcMaxHeapSize());
            RELEASE_ASSERT(OptionsHelper::addressOfOption(forceOSRExitToLLIntID) ==  &Options::forceOSRExitToLLInt());

#if defined(ENGINEERING_BUILD) && ENGINEERING_BUILD
            Config::enableRestrictedOptions();
#endif

            // Initialize each of the options with their default values:
#define INIT_OPTION(type_, name_, defaultValue_, availability_, description_) { \
                name_() = defaultValue_; \
            }
            FOR_EACH_JSC_OPTION(INIT_OPTION)
#undef INIT_OPTION
            OptionsHelper::initialize();

            overrideDefaults();

            // Allow environment vars to override options if applicable.
            // The env var should be the name of the option prefixed with
            // "JSC_".
#if PLATFORM(COCOA) || OS(LINUX)
            bool hasBadOptions = false;
#if PLATFORM(COCOA)
            char** envp = *_NSGetEnviron();
#else
            char** envp = environ;
#endif

            for (; *envp; envp++) {
                const char* env = *envp;
                if (!strncmp("JSC_", env, 4)) {
                    if (!Options::setOption(&env[4])) {
                        dataLog("ERROR: invalid option: ", *envp, "\n");
                        hasBadOptions = true;
                    }
                }
            }
            if (hasBadOptions && Options::validateOptions())
                CRASH();
#endif // PLATFORM(COCOA) || OS(LINUX)

#if !PLATFORM(COCOA)
#define OVERRIDE_OPTION_WITH_HEURISTICS(type_, name_, defaultValue_, availability_, description_) \
            overrideOptionWithHeuristic(name_(), name_##ID, "JSC_" #name_, Availability::availability_);
            FOR_EACH_JSC_OPTION(OVERRIDE_OPTION_WITH_HEURISTICS)
#undef OVERRIDE_OPTION_WITH_HEURISTICS

#define OVERRIDE_ALIASED_OPTION_WITH_HEURISTICS(aliasedName_, unaliasedName_, equivalence_) \
            overrideAliasedOptionWithHeuristic("JSC_" #aliasedName_);
            FOR_EACH_JSC_ALIASED_OPTION(OVERRIDE_ALIASED_OPTION_WITH_HEURISTICS)
#undef OVERRIDE_ALIASED_OPTION_WITH_HEURISTICS

#endif // !PLATFORM(COCOA)

#if 0
                ; // Deconfuse editors that do auto indentation
#endif

#if CPU(X86_64) && OS(DARWIN)
            Options::dumpZappedCellCrashData() =
                (hwPhysicalCPUMax() >= 4) && (hwL3CacheSize() >= static_cast<int64_t>(6 * MB));
#endif

            // Client gets the last word on what options they want to override.
            optionsCustomizationCallback();

            // No more options changes after this point. notifyOptionsChanged() will
            // do sanity checks and fix up options as needed.
            notifyOptionsChanged();

            // The code below acts on options that have been finalized.
            // Do not change any options here.
#if HAVE(MACH_EXCEPTIONS)
            if (Options::useMachForExceptions())
                handleSignalsWithMach();
#endif
    });
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

void Options::finalize()
{
    ASSERT(!g_jscConfig.options.allowUnfinalizedAccess);
    g_jscConfig.options.isFinalized = true;

    // The following should only be done at the end after all options
    // have been initialized.
    assertOptionsAreCoherent();
    if (Options::dumpOptions()) [[unlikely]]
        executeDumpOptions();

#if USE(LIBPAS)
    if (Options::libpasForcePGMWithRate())
        WTF::forceEnablePGM(Options::libpasForcePGMWithRate());
#endif

    OptionsHelper::releaseMetadata();
}

static bool NODELETE isSeparator(char c)
{
    return isUnicodeCompatibleASCIIWhitespace(c) || (c == ',');
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

bool Options::setOptions(const char* optionsStr)
{
    AllowUnfinalizedAccessScope scope;
    RELEASE_ASSERT(!g_jscConfig.isPermanentlyFrozen());
    Vector<char*> options;

    size_t length = strlen(optionsStr);
    char* optionsStrCopy = WTF::fastStrDup(optionsStr);
    char* end = optionsStrCopy + length;
    char* p = optionsStrCopy;

    while (p < end) {
        // Skip separators (white space or commas).
        while (p < end && isSeparator(*p))
            p++;
        if (p == end)
            break;

        char* optionStart = p;
        p = strchr(p, '=');
        if (!p) {
            dataLogF("'=' not found in option string: %p\n", optionStart);
            WTF::fastFree(optionsStrCopy);
            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);
                WTF::fastFree(optionsStrCopy);
                return false; // End of string not found.
            }
            hasStringValue = true;
        }

        // Find next separator (white space or commas).
        while (p < end && !isSeparator(*p))
            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;
        }
    }

    notifyOptionsChanged();
    WTF::fastFree(optionsStrCopy);

    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::setOptionWithoutAlias(const char* arg, bool verify)
{
    // 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 specified arg is a match. If so, set the arg
    // if the value makes sense. Otherwise, move on to checking the next option.
#define SET_OPTION_IF_MATCH(type_, name_, defaultValue_, availability_, description_) \
    if (strlen(#name_) == static_cast<size_t>(equalStr - arg)      \
        && !strncasecmp(arg, #name_, equalStr - arg)) {            \
        if (Availability::availability_ != Availability::Normal    \
            && !isAvailable(name_##ID, Availability::availability_)) \
            return false;                                          \
        std::optional<OptionsStorage::type_> value;                \
        value = parse<OptionsStorage::type_>(valueStr);            \
        if (value) {                                               \
            OptionsHelper::setWasOverridden(name_##ID);            \
            name_() = value.value();                               \
            if (verify) notifyOptionsChanged();                    \
            return true;                                           \
        }                                                          \
        return false;                                              \
    }

    FOR_EACH_JSC_OPTION(SET_OPTION_IF_MATCH)
#undef SET_OPTION_IF_MATCH

    return false; // No option matched.
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

static ASCIILiteral invertBoolOptionValue(const char* valueStr)
{
    std::optional<OptionsStorage::Bool> value = parse<OptionsStorage::Bool>(valueStr);
    if (!value)
        return { };
    return value.value() ? "false"_s : "true"_s;
}


WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

bool Options::setAliasedOption(const char* arg, bool verify)
{
    // arg should look like this:
    //   <jscOptionName>=<appropriate value>
    const char* equalStr = strchr(arg, '=');
    if (!equalStr)
        return false;

    IGNORE_WARNINGS_BEGIN("tautological-compare")

    // 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(aliasedName_, unaliasedName_, equivalence) \
    if (strlen(#aliasedName_) == static_cast<size_t>(equalStr - arg)    \
        && !strncasecmp(arg, #aliasedName_, equalStr - arg)) {          \
        auto unaliasedOption = String::fromLatin1(#unaliasedName_);     \
        if (equivalence == SameOption)                                  \
            unaliasedOption = makeString(unaliasedOption, unsafeSpan(equalStr)); \
        else {                                                          \
            ASSERT(equivalence == InvertedOption);                      \
            auto invertedValueStr = invertBoolOptionValue(equalStr + 1); \
            if (invertedValueStr.isNull())                                      \
                return false;                                           \
            unaliasedOption = makeString(unaliasedOption, '=', invertedValueStr); \
        }                                                               \
        return setOptionWithoutAlias(unaliasedOption.utf8().data(), verify);    \
    }

    FOR_EACH_JSC_ALIASED_OPTION(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION

    IGNORE_WARNINGS_END

    return false; // No option matched.
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

bool Options::setOption(const char* arg, bool verify)
{
    AllowUnfinalizedAccessScope scope;
    bool success = setOptionWithoutAlias(arg, verify);
    if (success)
        return true;
    return setAliasedOption(arg, verify);
}


void Options::dumpAllOptions(StringBuilder& builder, DumpLevel level, ASCIILiteral title,
    ASCIILiteral separator, ASCIILiteral optionHeader, ASCIILiteral optionFooter, DumpDefaultsOption dumpDefaultsOption)
{
    AllowUnfinalizedAccessScope scope;
    if (!title.isNull()) {
        builder.append(title);
        builder.append('\n');
    }

    for (size_t id = 0; id < NumberOfOptions; ++id) {
        if (separator && id)
            builder.append(separator);
        dumpOption(builder, level, static_cast<ID>(id), optionHeader, optionFooter, dumpDefaultsOption);
    }
}

void Options::dumpAllOptionsInALine(StringBuilder& builder)
{
    dumpAllOptions(builder, DumpLevel::All, { }, " "_s, { }, { }, DontDumpDefaults);
}

void Options::dumpAllOptions(DumpLevel level, ASCIILiteral title)
{
    StringBuilder builder;
    dumpAllOptions(builder, level, title, { }, "   "_s, "\n"_s, DumpDefaults);
    dataLog(builder.toString().utf8().data());
}

void Options::dumpOption(StringBuilder& builder, DumpLevel level, Options::ID id,
    ASCIILiteral header, ASCIILiteral footer, DumpDefaultsOption dumpDefaultsOption)
{
    RELEASE_ASSERT(static_cast<size_t>(id) < NumberOfOptions);

    auto option = OptionsHelper::optionFor(id);
    Availability availability = option.availability();
    if (availability != Availability::Normal && !isAvailable(id, availability))
        return;

    bool wasOverridden = OptionsHelper::wasOverridden(id);
    bool needsDescription = (level == DumpLevel::Verbose && option.description());

    if (level == DumpLevel::Overridden && !wasOverridden)
        return;

    if (!header.isNull())
        builder.append(header);
    builder.append(option.name(), '=');
    option.dump(builder);

    if (wasOverridden && (dumpDefaultsOption == DumpDefaults) && OptionsHelper::hasMetadata()) {
        auto defaultOption = OptionsHelper::defaultFor(id);
        builder.append(" (default: "_s);
        defaultOption.dump(builder);
        builder.append(')');
    }

    if (needsDescription)
        builder.append("   ... "_s, option.description());

    builder.append(footer);
}

void Options::assertOptionsAreCoherent()
{
    AllowUnfinalizedAccessScope scope;
    bool coherent = true;
    if (!(useLLInt() || useJIT())) {
        coherent = false;
        dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
    }
    if (useWasm() && !(useWasmIPInt() || useBBQJIT())) {
        coherent = false;
        dataLog("INCOHERENT OPTIONS: at least one of useWasmIPInt, or useBBQJIT must be true\n");
    }
    if (useProfiler() && useConcurrentJIT()) {
        coherent = false;
        dataLogLn("Bytecode profiler is not concurrent JIT safe.");
    }
    if (!allowNonSPTagging() && !useMachForExceptions()) {
        coherent = false;
        dataLog("INCOHERENT OPTIONS: can't restrict pointer tagging to pacibsp and use posix signals");
    }

    if (!coherent)
        CRASH();
}

namespace OptionsHelper {

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

void Option::initValue(void* addressOfValue)
{
    Options::Type type = g_constMetaData[m_id].type;
    switch (type) {
    case Options::Type::Bool:
        memcpy(&m_bool, addressOfValue, sizeof(OptionsStorage::Bool));
        break;
    case Options::Type::Unsigned:
        memcpy(&m_unsigned, addressOfValue, sizeof(OptionsStorage::Unsigned));
        break;
    case Options::Type::Double:
        memcpy(&m_double, addressOfValue, sizeof(OptionsStorage::Double));
        break;
    case Options::Type::Int32:
        memcpy(&m_int32, addressOfValue, sizeof(OptionsStorage::Int32));
        break;
    case Options::Type::Size:
        memcpy(&m_size, addressOfValue, sizeof(OptionsStorage::Size));
        break;
    case Options::Type::OptionRange:
        memcpy(&m_optionRange, addressOfValue, sizeof(OptionsStorage::OptionRange));
        break;
    case Options::Type::OptionString:
        memcpy(&m_optionString, addressOfValue, sizeof(OptionsStorage::OptionString));
        break;
    case Options::Type::GCLogLevel:
        memcpy(&m_gcLogLevel, addressOfValue, sizeof(OptionsStorage::GCLogLevel));
        break;
    case Options::Type::OSLogType:
        memcpy(&m_osLogType, addressOfValue, sizeof(OptionsStorage::OSLogType));
        break;
    }
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

void Option::dump(StringBuilder& builder) const
{
    switch (type()) {
    case Options::Type::Bool:
        builder.append(m_bool ? "true"_s : "false"_s);
        break;
    case Options::Type::Unsigned:
        builder.append(m_unsigned);
        break;
    case Options::Type::Size:
        builder.append(m_size);
        break;
    case Options::Type::Double:
        builder.append(m_double);
        break;
    case Options::Type::Int32:
        builder.append(m_int32);
        break;
    case Options::Type::OptionRange:
        builder.append(unsafeSpan(m_optionRange.rangeString()));
        break;
    case Options::Type::OptionString:
        builder.append('"', m_optionString ? unsafeSpan(m_optionString) : ""_span, '"');
        break;
    case Options::Type::GCLogLevel:
        builder.append(m_gcLogLevel);
        break;
    case Options::Type::OSLogType:
        builder.append(asString(m_osLogType));
        break;
    }
}

bool Option::operator==(const Option& other) const
{
    ASSERT(type() == other.type());
    switch (type()) {
    case Options::Type::Bool:
        return m_bool == other.m_bool;
    case Options::Type::Unsigned:
        return m_unsigned == other.m_unsigned;
    case Options::Type::Size:
        return m_size == other.m_size;
    case Options::Type::Double:
        return (m_double == other.m_double) || (std::isnan(m_double) && std::isnan(other.m_double));
    case Options::Type::Int32:
        return m_int32 == other.m_int32;
    case Options::Type::OptionRange:
        return m_optionRange.rangeString() == other.m_optionRange.rangeString();
    case Options::Type::OptionString:
        return (m_optionString == other.m_optionString)
            || (m_optionString && other.m_optionString && !strcmp(m_optionString, other.m_optionString));
    case Options::Type::GCLogLevel:
        return m_gcLogLevel == other.m_gcLogLevel;
    case Options::Type::OSLogType:
        return m_osLogType == other.m_osLogType;
    }
    return false;
}

} // namespace OptionsHelper

#if ENABLE(JIT_CAGE)
SUPPRESS_ASAN bool canUseJITCage()
{
    if (JSC_FORCE_USE_JIT_CAGE)
        return true;
    return JSC_JIT_CAGE_VERSION() && !ASAN_ENABLED && WTF::processHasEntitlement("com.apple.private.verified-jit"_s);
}
#else
bool NODELETE canUseJITCage() { return false; }
#endif

bool NODELETE canUseWasm()
{
#if ENABLE(WEBASSEMBLY) && !PLATFORM(WATCHOS)
    return true;
#else
    return false;
#endif
}

bool NODELETE hasCapacityToUseLargeGigacage()
{
    // Gigacage::hasCapacityToUseLargeGigacage is determined based on EFFECTIVE_ADDRESS_WIDTH.
    // If we have enough address range to potentially use a large gigacage,
    // then we have enough address range to useWasmFastMemory.
    return Gigacage::hasCapacityToUseLargeGigacage;
}

} // namespace JSC

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END