arkcompiler_ets_runtime/ecmascript/js_runtime_options.h

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ECMASCRIPT_JS_RUNTIME_OPTIONS_H_
#define ECMASCRIPT_JS_RUNTIME_OPTIONS_H_

#include <optional>
#include <string>
#include <string_view>
#include <vector>

#include "ecmascript/compiler/bc_call_signature.h"
#include "ecmascript/mem/mem_common.h"

// namespace panda {
namespace panda::ecmascript {
using arg_list_t = std::vector<std::string>;
enum ArkProperties {
    DEFAULT = -1,  // default value 1000001011100 -> 0x105c
    OPTIONAL_LOG = 1,
    GC_STATS_PRINT = 1 << 1,
    PARALLEL_GC = 1 << 2,  // default enable
    CONCURRENT_MARK = 1 << 3,  // default enable
    CONCURRENT_SWEEP = 1 << 4,  // default enable
    THREAD_CHECK = 1 << 5,
    ENABLE_ARKTOOLS = 1 << 6,  // default enable
    ENABLE_SNAPSHOT_SERIALIZE = 1 << 7,
    ENABLE_SNAPSHOT_DESERIALIZE = 1 << 8,
    EXCEPTION_BACKTRACE = 1 << 9,
    GLOBAL_OBJECT_LEAK_CHECK = 1 << 10,
    GLOBAL_PRIMITIVE_LEAK_CHECK = 1 << 11,
    ENABLE_IDLE_GC = 1 << 12,  // default enable
    CPU_PROFILER_COLD_START_MAIN_THREAD = 1 << 13,
    ENABLE_CPU_PROFILER_VM_TAG = 1 << 14,
    ENABLE_GC_TRACER = 1 << 15,
    CPU_PROFILER_COLD_START_WORKER_THREAD = 1 << 16,
    CPU_PROFILER_ANY_TIME_MAIN_THREAD = 1 << 17,
    CPU_PROFILER_ANY_TIME_WORKER_THREAD = 1 << 18,
    ENABLE_HEAP_VERIFY = 1 << 19,
    ENABLE_MICROJOB_TRACE = 1 << 20,
    ENABLE_INIT_OLD_SOCKET_SESSION = 1 << 21
};

// asm interpreter control parsed option
struct AsmInterParsedOption {
    int handleStart {-1};
    int handleEnd {-1};
    bool enableAsm {false};
};

extern const std::string PUBLIC_API COMMON_HELP_HEAD_MSG;
extern const std::string PUBLIC_API STUB_HELP_HEAD_MSG;
extern const std::string PUBLIC_API COMPILER_HELP_HEAD_MSG;
extern const std::string PUBLIC_API HELP_OPTION_MSG;

enum CommandValues {
    OPTION_DEFAULT,
    OPTION_HELP,
    OPTION_ENABLE_ARK_TOOLS,
    OPTION_STUB_FILE,
    OPTION_ENABLE_FORCE_GC,
    OPTION_FORCE_FULL_GC,
    OPTION_ENABLE_FORCE_SHARED_GC_FREQUENCY,
    OPTION_ARK_PROPERTIES,
    OPTION_ARK_BUNDLENAME,
    OPTION_GC_THREADNUM,
    OPTION_GC_LONG_PAUSED_TIME,
    OPTION_AOT_FILE,
    OPTION_COMPILER_TARGET_TRIPLE,
    OPTION_ASM_OPT_LEVEL,
    OPTION_RELOCATION_MODE,
    OPTION_MAX_UNMOVABLE_SPACE,
    OPTION_ENABLE_ASM_INTERPRETER,
    OPTION_ENABLE_BUILTINS_LAZY,
    OPTION_ASM_OPCODE_DISABLE_RANGE,
    OPTION_SERIALIZER_BUFFER_SIZE_LIMIT,
    OPTION_HEAP_SIZE_LIMIT,
    OPTION_ENABLE_IC,
    OPTION_ICU_DATA_PATH,
    OPTION_STARTUP_TIME,
    OPTION_COMPILER_LOG_OPT,
    OPTION_COMPILER_LOG_METHODS,
    OPTION_COMPILER_TYPE_THRESHOLD,
    OPTION_ENABLE_RUNTIME_STAT,
    OPTION_COMPILER_LOG_SNAPSHOT,
    OPTION_COMPILER_LOG_TIME,
    OPTION_ENABLE_WORKER,
    OPTION_COMPILER_TRACE_BC,
    OPTION_COMPILER_TRACE_DEOPT,
    OPTION_COMPILER_TRACE_INLINE,
    OPTION_COMPILER_MAX_INLINE_BYTECODES,
    OPTION_COMPILER_DEOPT_THRESHOLD,
    OPTION_COMPILER_STRESS_DEOPT,
    OPTION_COMPILER_OPT_CODE_PROFILER,
    OPTION_COMPILER_OPT_BC_RANGE,
    OPTION_LOG_LEVEL,
    OPTION_LOG_DEBUG,
    OPTION_LOG_INFO,
    OPTION_LOG_WARNING,
    OPTION_LOG_ERROR,
    OPTION_LOG_FATAL,
    OPTION_LOG_COMPONENTS,
    OPTION_COMPILER_OPT_MAX_METHOD,
    OPTION_COMPILER_MODULE_METHODS,
    OPTION_ENTRY_POINT,
    OPTION_MERGE_ABC,
    OPTION_ENABLE_CONTEXT,
    OPTION_COMPILER_OPT_TYPE_LOWERING,
    OPTION_COMPILER_OPT_EARLY_ELIMINATION,
    OPTION_COMPILER_OPT_LATER_ELIMINATION,
    OPTION_COMPILER_OPT_STRING,
    OPTION_COMPILER_OPT_VALUE_NUMBERING,
    OPTION_COMPILER_OPT_INLINING,
    OPTION_COMPILER_OPT_PGOTYPE,
    OPTION_COMPILER_OPT_TRACK_FIELD,
    OPTION_COMPILER_PGO_PROFILER_PATH,
    OPTION_COMPILER_PGO_HOTNESS_THRESHOLD,
    OPTION_COMPILER_PGO_SAVE_MIN_INTERVAL,
    OPTION_ENABLE_PGO_PROFILER,
    OPTION_PRINT_EXECUTE_TIME,
    OPTION_SPLIT_ONE,
    OPTION_COMPILER_DEVICE_STATE,
    OPTION_COMPILER_VERIFY_VTABLE,
    OPTION_COMPILER_SELECT_METHODS,
    OPTION_COMPILER_SKIP_METHODS,
    OPTION_TARGET_COMPILER_MODE,
    OPTION_HAP_PATH,
    OPTION_HAP_ABC_OFFSET,
    OPTION_HAP_ABC_SIZE,
    OPTION_COMPILER_NOCHECK,
    OPTION_FAST_AOT_COMPILE_MODE,
    OPTION_COMPILER_OPT_LOOP_PEELING,
    OPTION_COMPILER_OPT_ON_HEAP_CHECK,
    OPTION_COMPILER_PKG_INFO,
    OPTION_COMPILER_EXTERNAL_PKG_INFO,
    OPTION_COMPILER_ENABLE_EXTERNAL_PKG,
    OPTION_COMPILER_FRAMEWORK_ABC_PATH,
    OPTION_COMPILER_OPT_ARRAY_BOUNDS_CHECK_ELIMINATION,
    OPTION_COMPILER_OPT_LOOP_INVARIANT_CODE_MOTION,
    OPTION_COMPILER_OPT_CONSTANT_FOLDING,
    OPTION_COMPILER_ENABLE_LEXENV_SPECIALIZATION,
    OPTION_COMPILER_TRACE_INSTRUCTION_COMBINE,
    OPTION_COMPILER_TRACE_VALUE_NUMBERING,
    OPTION_COMPILER_OPT_INSTRUCTIONE_COMBINE,
    OPTION_COMPILER_OPT_NEW_VALUE_NUMBERING,
    OPTION_COMPILER_ENABLE_NATIVE_INLINE,
    OPTION_COMPILER_ENABLE_LOWERING_BUILTIN,
    OPTION_COMPILER_ENABLE_LITECG,
    OPTION_COMPILER_ENABLE_JIT,
    OPTION_COMPILER_ENABLE_OSR,
    OPTION_COMPILER_JIT_HOTNESS_THRESHOLD,
    OPTION_COMPILER_OSR_HOTNESS_THRESHOLD,
    OPTION_COMPILER_FORCE_JIT_COMPILE_MAIN,
    OPTION_COMPILER_TRACE_JIT,
    OPTION_COMPILER_ENABLE_JIT_PGO,
    OPTION_COMPILER_ENABLE_AOT_PGO,
    OPTION_COMPILER_ENABLE_PROPFILE_DUMP,
    OPTION_ENABLE_ELEMENTSKIND,
    OPTION_COMPILER_TYPED_OP_PROFILER,
    OPTION_COMPILER_OPT_BRANCH_PROFILING,
    OPTION_TEST_ASSERT,
    OPTION_COMPILER_METHODS_RANGE,
    OPTION_COMPILER_CODEGEN_OPT,
    OPTION_COMPILER_OPT_BC_RANGE_HELP,
    OPTION_COMPILER_MEMORY_ANALYSIS,
    OPTION_COMPILER_CHECK_PGO_VERSION,
    OPTION_COMPILER_OPT_ESCAPE_ANALYSIS,
    OPTION_COMPILER_TRACE_ESCAPE_ANALYSIS,
    OPTION_LAST,
    OPTION_COMPILER_OPT_INDUCTION_VARIABLE,
    OPTION_COMPILER_TRACE_INDUCTION_VARIABLE,
    OPTION_COMPILER_ENABLE_BASELINEJIT,
    OPTION_COMPILER_BASELINEJIT_HOTNESS_THRESHOLD,
    OPTION_COMPILER_FORCE_BASELINEJIT_COMPILE_MAIN,
};
static_assert(OPTION_SPLIT_ONE == 64);

class PUBLIC_API JSRuntimeOptions {
public:
    JSRuntimeOptions() {}
    ~JSRuntimeOptions() = default;
    DEFAULT_COPY_SEMANTIC(JSRuntimeOptions);
    DEFAULT_MOVE_SEMANTIC(JSRuntimeOptions);

    bool ParseCommand(const int argc, const char **argv);
    bool SetDefaultValue(char* argv);

    bool EnableArkTools() const
    {
        return (enableArkTools_) ||
            ((static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_ARKTOOLS) != 0);
    }

    void SetEnableArkTools(bool value) {
        enableArkTools_ = value;
    }

    bool WasSetEnableArkTools() const
    {
        return WasOptionSet(OPTION_ENABLE_ARK_TOOLS);
    }

    bool IsEnableRuntimeStat() const
    {
        return enableRuntimeStat_;
    }

    void SetEnableRuntimeStat(bool value)
    {
        enableRuntimeStat_ = value;
    }

    bool WasSetEnableRuntimeStat() const
    {
        return WasOptionSet(OPTION_ENABLE_RUNTIME_STAT);
    }

    std::string GetStubFile() const
    {
        return stubFile_;
    }

    void SetStubFile(std::string value)
    {
        stubFile_ = std::move(value);
    }

    void SetCompilerPkgJsonInfo(std::string pkgJsonInfo)
    {
        compilerPkgInfo_ = std::move(pkgJsonInfo);
    }

    const std::string &GetCompilerPkgJsonInfo() const
    {
        return compilerPkgInfo_;
    }

    void SetCompilerExternalPkgJsonInfo(std::string pkgJsonInfo)
    {
        compilerExternalPkgInfo_ = std::move(pkgJsonInfo);
    }

    const std::string &GetCompilerExternalPkgJsonInfo() const
    {
        return compilerExternalPkgInfo_;
    }

    void SetCompilerEnableExternalPkg(bool compilerEnableExternalPkg)
    {
        compilerEnableExternalPkg_ = compilerEnableExternalPkg;
    }

    bool GetCompilerEnableExternalPkg() const
    {
        return compilerEnableExternalPkg_;
    }

    bool WasStubFileSet() const
    {
        return WasOptionSet(OPTION_STUB_FILE);
    }

    void SetEnableAOT(bool value)
    {
        enableAOT_ = value;
    }

    bool GetEnableAOT() const
    {
        return enableAOT_;
    }

    std::string GetAOTOutputFile() const
    {
        return aotOutputFile_;
    }

    void SetAOTOutputFile(const std::string& value)
    {
        aotOutputFile_ = panda::os::file::File::GetExtendedFilePath(value);
    }

    bool WasAOTOutputFileSet() const
    {
        return WasOptionSet(OPTION_AOT_FILE);
    }

    std::string GetTargetTriple() const
    {
        return targetTriple_;
    }

    void SetTargetTriple(std::string value)
    {
        targetTriple_ = std::move(value);
    }

    size_t GetOptLevel() const
    {
        return asmOptLevel_;
    }

    void SetOptLevel(size_t value)
    {
        asmOptLevel_ = value;
    }

    size_t GetRelocMode() const
    {
        return relocationMode_;
    }

    void SetRelocMode(size_t value)
    {
        relocationMode_ = value;
    }

    bool EnableForceGC() const
    {
        return enableForceGc_;
    }

    void SetEnableForceGC(bool value)
    {
        enableForceGc_ = value;
    }

    bool ForceFullGC() const
    {
        return forceFullGc_;
    }

    void SetForceFullGC(bool value)
    {
        forceFullGc_ = value;
    }

    void SetForceSharedGCFrequency(size_t frequency)
    {
        forceSharedGc_ = frequency;
    }

    uint32_t GetForceSharedGCFrequency() const
    {
        return forceSharedGc_;
    }

    void SetGcThreadNum(size_t num)
    {
        gcThreadNum_ = num;
    }

    size_t GetGcThreadNum() const
    {
        return gcThreadNum_;
    }

    void SetLongPauseTime(size_t time)
    {
        longPauseTime_ = time;
    }

    size_t GetLongPauseTime() const
    {
        return longPauseTime_;
    }

    void SetArkProperties(int prop)
    {
        if (prop != ArkProperties::DEFAULT) {
            arkProperties_ = prop;
        }
    }

    void SetArkBundleName(std::string bundleName)
    {
        if (bundleName != "") {
            arkBundleName_ = bundleName;
        }
    }

    void SetMemConfigProperty(std::string configProperty)
    {
        if (configProperty != "") {
            std::string key;
            std::string value;
            for (char c : configProperty) {
                if (isdigit(c)) {
                    value += c;
                } else {
                    key += c;
                }
            }
            if (key == "jsHeap") {
                heapSize_ = static_cast<size_t>(stoi(value)) * 1_MB;
            }
        }
    }

    size_t GetHeapSize() const
    {
        return heapSize_;
    }

    int GetDefaultProperties()
    {
        return ArkProperties::PARALLEL_GC | ArkProperties::CONCURRENT_MARK | ArkProperties::CONCURRENT_SWEEP |
            ArkProperties::ENABLE_ARKTOOLS | ArkProperties::ENABLE_IDLE_GC;
    }

    int GetArkProperties()
    {
        return arkProperties_;
    }

    std::string GetArkBundleName() const
    {
        return arkBundleName_;
    }

    bool EnableOptionalLog() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::OPTIONAL_LOG) != 0;
    }

    bool EnableGCStatsPrint() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::GC_STATS_PRINT) != 0;
    }

    bool EnableParallelGC() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::PARALLEL_GC) != 0;
    }

    bool EnableConcurrentMark() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CONCURRENT_MARK) != 0;
    }

    bool EnableExceptionBacktrace() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::EXCEPTION_BACKTRACE) != 0;
    }

    bool EnableConcurrentSweep() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CONCURRENT_SWEEP) != 0;
    }

    bool EnableThreadCheck() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::THREAD_CHECK) != 0;
    }

    bool EnableIdleGC() const
    {
        return false;
    }

    bool EnableGCTracer() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_GC_TRACER) != 0;
    }

    bool EnableGlobalObjectLeakCheck() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::GLOBAL_OBJECT_LEAK_CHECK) != 0;
    }

    bool EnableGlobalPrimitiveLeakCheck() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::GLOBAL_PRIMITIVE_LEAK_CHECK) != 0;
    }

    bool EnableGlobalLeakCheck() const
    {
        return EnableGlobalObjectLeakCheck() || EnableGlobalPrimitiveLeakCheck();
    }

    bool EnableCpuProfilerColdStartMainThread() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CPU_PROFILER_COLD_START_MAIN_THREAD) != 0;
    }

    bool EnableCpuProfilerColdStartWorkerThread() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CPU_PROFILER_COLD_START_WORKER_THREAD) != 0;
    }

    bool EnableCpuProfilerAnyTimeMainThread() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CPU_PROFILER_ANY_TIME_MAIN_THREAD) != 0;
    }

    bool EnableCpuProfilerAnyTimeWorkerThread() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::CPU_PROFILER_ANY_TIME_WORKER_THREAD) != 0;
    }

    bool EnableCpuProfilerVMTag() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_CPU_PROFILER_VM_TAG) != 0;
    }

    bool IsStartGlobalLeakCheck() const
    {
        return startGlobalLeakCheck_;
    }

    void SwitchStartGlobalLeakCheck()
    {
        startGlobalLeakCheck_ = !startGlobalLeakCheck_;
    }

    bool EnableSnapshotSerialize() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_SNAPSHOT_SERIALIZE) != 0;
    }

    bool EnableSnapshotDeserialize() const
    {
        if (WIN_OR_MAC_OR_IOS_PLATFORM) {
            return false;
        }

        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_SNAPSHOT_DESERIALIZE) != 0;
    }

    bool EnableHeapVerify() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_HEAP_VERIFY) != 0;
    }

    bool EnableMicroJobTrace() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_MICROJOB_TRACE) != 0;
    }

    bool EnableInitOldSocketSession() const
    {
        return (static_cast<uint32_t>(arkProperties_) & ArkProperties::ENABLE_INIT_OLD_SOCKET_SESSION) != 0;
    }

    void DisableReportModuleResolvingFailure()
    {
        reportModuleResolvingFailure_ = false;
    }

    bool EnableReportModuleResolvingFailure() const
    {
        return reportModuleResolvingFailure_;
    }

    bool WasSetMaxNonmovableSpaceCapacity() const
    {
        return WasOptionSet(OPTION_MAX_UNMOVABLE_SPACE);
    }

    size_t MaxNonmovableSpaceCapacity() const
    {
        return maxNonmovableSpaceCapacity_;
    }

    void SetMaxNonmovableSpaceCapacity(uint32_t value)
    {
        maxNonmovableSpaceCapacity_ = value;
    }

    void SetEnableAsmInterpreter(bool value)
    {
        enableAsmInterpreter_ = value;
    }

    bool GetEnableAsmInterpreter() const
    {
        return enableAsmInterpreter_;
    }

    void SetEnableBuiltinsLazy(bool value)
    {
        enableBuiltinsLazy_ = value;
    }

    bool GetEnableBuiltinsLazy() const
    {
        return enableBuiltinsLazy_;
    }

    void SetAsmOpcodeDisableRange(std::string value)
    {
        asmOpcodeDisableRange_ = std::move(value);
    }

    void ParseAsmInterOption()
    {
        asmInterParsedOption_.enableAsm = enableAsmInterpreter_;
        std::string strAsmOpcodeDisableRange = asmOpcodeDisableRange_;
        if (strAsmOpcodeDisableRange.empty()) {
            return;
        }

        // asm interpreter handle disable range
        size_t pos = strAsmOpcodeDisableRange.find(",");
        if (pos != std::string::npos) {
            std::string strStart = strAsmOpcodeDisableRange.substr(0, pos);
            std::string strEnd = strAsmOpcodeDisableRange.substr(pos + 1);
            int start = strStart.empty() ? 0 : std::stoi(strStart);
            int end = strEnd.empty() ? kungfu::BYTECODE_STUB_END_ID : std::stoi(strEnd);
            if (start >= 0 && start < kungfu::BytecodeStubCSigns::NUM_OF_ALL_NORMAL_STUBS &&
                end >= 0 && end < kungfu::BytecodeStubCSigns::NUM_OF_ALL_NORMAL_STUBS &&
                start <= end) {
                asmInterParsedOption_.handleStart = start;
                asmInterParsedOption_.handleEnd = end;
            }
        }
    }

    AsmInterParsedOption GetAsmInterParsedOption() const
    {
        return asmInterParsedOption_;
    }

    std::string GetCompilerLogOption() const
    {
        return compilerLogOpt_;
    }

    void SetCompilerLogOption(std::string value)
    {
        compilerLogOpt_ = std::move(value);
    }

    bool WasSetCompilerLogOption() const
    {
        return WasOptionSet(OPTION_COMPILER_LOG_OPT) &&
            GetCompilerLogOption().find("none") == std::string::npos;
    }

    std::string GetMethodsListForLog() const
    {
        return compilerLogMethods_;
    }

    void SetMethodsListForLog(std::string value)
    {
        compilerLogMethods_ = std::move(value);
    }

    bool WasSetMethodsListForLog() const
    {
        return WasOptionSet(OPTION_COMPILER_LOG_METHODS)  &&
            GetCompilerLogOption().find("none") == std::string::npos &&
            GetCompilerLogOption().find("all") == std::string::npos;
    }

    void SetCompilerLogSnapshot(bool value)
    {
        compilerLogSnapshot_ = value;
    }

    bool IsEnableCompilerLogSnapshot() const
    {
        return compilerLogSnapshot_;
    }

    bool WasSetCompilerLogSnapshot() const
    {
        return WasOptionSet(OPTION_COMPILER_LOG_SNAPSHOT);
    }

    void SetCompilerLogTime(bool value)
    {
        compilerLogTime_ = value;
    }

    bool IsEnableCompilerLogTime() const
    {
        return compilerLogTime_;
    }

    bool WasSetCompilerLogTime() const
    {
        return WasOptionSet(OPTION_COMPILER_LOG_TIME);
    }

    uint64_t GetSerializerBufferSizeLimit() const
    {
        return serializerBufferSizeLimit_;
    }

    void SetSerializerBufferSizeLimit(uint64_t value)
    {
        serializerBufferSizeLimit_ = value;
    }

    uint32_t GetHeapSizeLimit() const
    {
        return heapSizeLimit_;
    }

    void SetHeapSizeLimit(uint32_t value)
    {
        heapSizeLimit_ = value;
    }

    bool WasSetHeapSizeLimit() const
    {
        return WasOptionSet(OPTION_HEAP_SIZE_LIMIT);
    }

    void SetIsWorker(bool isWorker)
    {
        isWorker_ = isWorker;
    }

    void SetIsRestrictedWorker(bool isRestrictedWorker)
    {
        isRestrictedWorker_ = isRestrictedWorker;
    }

    bool IsWorker() const
    {
        return isWorker_;
    }

    bool IsRestrictedWorker() const
    {
        return isRestrictedWorker_;
    }

    bool EnableIC() const
    {
        return enableIC_;
    }

    void SetEnableIC(bool value)
    {
        enableIC_ = value;
    }

    bool WasSetEnableIC() const
    {
        return WasOptionSet(OPTION_ENABLE_IC);
    }

    std::string GetIcuDataPath() const
    {
        return icuDataPath_;
    }

    void SetIcuDataPath(std::string value)
    {
        icuDataPath_ = std::move(value);
    }

    bool WasSetIcuDataPath() const
    {
        return WasOptionSet(OPTION_ICU_DATA_PATH);
    }

    bool IsStartupTime() const
    {
        return startupTime_;
    }

    void SetStartupTime(bool value)
    {
        startupTime_ = value;
    }

    bool WasSetStartupTime() const
    {
        return WasOptionSet(OPTION_STARTUP_TIME);
    }

    void SetTraceBc(bool value)
    {
        traceBc_ = value;
    }

    bool IsTraceBC() const
    {
        return traceBc_;
    }

    bool WasSetTraceBc() const
    {
        return WasOptionSet(OPTION_COMPILER_TRACE_BC);
    }

    std::string GetLogLevel() const
    {
        return logLevel_;
    }

    void SetLogLevel(std::string value)
    {
        logLevel_ = std::move(value);
    }

    bool WasSetLogLevel() const
    {
        return WasOptionSet(OPTION_LOG_LEVEL);
    }

    arg_list_t GetLogComponents() const
    {
        return logComponents_;
    }

    void SetLogComponents(arg_list_t value)
    {
        logComponents_ = std::move(value);
    }

    bool WasSetLogComponents() const
    {
        return WasOptionSet(OPTION_LOG_COMPONENTS);
    }

    arg_list_t GetLogDebug() const
    {
        return logDebug_;
    }

    void SetLogDebug(arg_list_t value)
    {
        logDebug_ = std::move(value);
    }

    bool WasSetLogDebug() const
    {
        return WasOptionSet(OPTION_LOG_DEBUG);
    }

    arg_list_t GetLogInfo() const
    {
        return logInfo_;
    }

    void SetLogInfo(arg_list_t value)
    {
        logInfo_ = std::move(value);
    }

    bool WasSetLogInfo() const
    {
        return WasOptionSet(OPTION_LOG_INFO);
    }

    arg_list_t GetLogWarning() const
    {
        return logWarning_;
    }

    void SetLogWarning(arg_list_t value)
    {
        logWarning_ = std::move(value);
    }

    bool WasSetLogWarning() const
    {
        return WasOptionSet(OPTION_LOG_WARNING);
    }

    arg_list_t GetLogError() const
    {
        return logError_;
    }

    void SetLogError(arg_list_t value)
    {
        logError_ = std::move(value);
    }

    bool WasSetLogError() const
    {
        return WasOptionSet(OPTION_LOG_ERROR);
    }

    arg_list_t GetLogFatal() const
    {
        return logFatal_;
    }

    void SetLogFatal(arg_list_t value)
    {
        logFatal_ = std::move(value);
    }

    bool WasSetLogFatal() const
    {
        return WasOptionSet(OPTION_LOG_FATAL);
    }

    size_t GetMaxAotMethodSize() const
    {
        return maxAotMethodSize_;
    }

    void SetMaxAotMethodSize(uint32_t value)
    {
        maxAotMethodSize_ = value;
    }

    double GetTypeThreshold() const
    {
        return typeThreshold_;
    }

    void SetTypeThreshold(double threshold)
    {
        typeThreshold_ = threshold;
    }

    std::string GetEntryPoint() const
    {
        return entryPoint_;
    }

    void SetEntryPoint(std::string value)
    {
        entryPoint_ = std::move(value);
    }

    bool WasSetEntryPoint() const
    {
        return WasOptionSet(OPTION_ENTRY_POINT);
    }

    bool GetMergeAbc() const
    {
        return mergeAbc_;
    }

    void SetMergeAbc(bool value)
    {
        mergeAbc_ = value;
    }

    void SetEnableContext(bool value)
    {
        enableContext_ = value;
    }

    bool IsEnableContext() const
    {
        return enableContext_;
    }

    void SetEnablePrintExecuteTime(bool value)
    {
        enablePrintExecuteTime_ = value;
    }

    bool IsEnablePrintExecuteTime() const
    {
        return enablePrintExecuteTime_;
    }

    void SetEnableElementsKind(bool value)
    {
        enableElementsKind_ = value;
    }

    bool IsEnableElementsKind() const
    {
        return enableElementsKind_;
    }

    void SetEnablePGOProfiler(bool value)
    {
        enablePGOProfiler_ = value;
    }

    bool IsEnablePGOProfiler() const
    {
        return enablePGOProfiler_;
    }

    uint32_t GetPGOHotnessThreshold() const
    {
        return pgoHotnessThreshold_;
    }

    void SetPGOHotnessThreshold(uint32_t threshold)
    {
        pgoHotnessThreshold_ = threshold;
    }

    uint32_t GetPGOSaveMinInterval() const
    {
        return pgoSaveMinInterval_;
    }

    void SetPGOSaveMinInterval(uint32_t value)
    {
        pgoSaveMinInterval_ = value;
    }

    std::string GetPGOProfilerPath() const
    {
        return pgoProfilerPath_;
    }

    void SetPGOProfilerPath(const std::string& value)
    {
        pgoProfilerPath_ = panda::os::file::File::GetExtendedFilePath(value);
    }

    bool IsPGOProfilerPathEmpty() const
    {
        return pgoProfilerPath_.empty();
    }

    void SetEnableTypeLowering(bool value)
    {
        enableTypeLowering_ = value;
    }

    bool IsEnableArrayBoundsCheckElimination() const
    {
        return enableArrayBoundsCheckElimination_;
    }

    void SetEnableArrayBoundsCheckElimination(bool value)
    {
        enableArrayBoundsCheckElimination_ = value;
    }

    bool IsEnableTypeLowering() const
    {
        return enableTypeLowering_;
    }

    void SetEnableEarlyElimination(bool value)
    {
        enableEarlyElimination_ = value;
    }

    bool IsEnableEarlyElimination() const
    {
        return enableEarlyElimination_;
    }

    void SetEnableLaterElimination(bool value)
    {
        enableLaterElimination_ = value;
    }

    bool IsEnableLaterElimination() const
    {
        return enableLaterElimination_;
    }

    void SetEnableInstrcutionCombine(bool value)
    {
        enableInstrcutionCombine = value;
    }

    bool IsEnableInstrcutionCombine() const
    {
        return enableInstrcutionCombine;
    }

    void SetEnableValueNumbering(bool value)
    {
        enableValueNumbering_ = value;
    }

    bool IsEnableValueNumbering() const
    {
        return enableValueNumbering_;
    }


    void SetEnableJIT(bool value)
    {
        enableFastJIT_ = value;
    }

    bool IsEnableJIT() const
    {
        return enableFastJIT_;
    }

    void SetEnableAPPJIT(bool value)
    {
        enableAPPJIT_ = value;
    }

    bool IsEnableAPPJIT() const
    {
        return enableAPPJIT_;
    }

    void SetEnableOSR(bool value)
    {
        enableOSR_ = value;
    }

    bool IsEnableOSR() const
    {
        return enableOSR_;
    }

    void SetJitHotnessThreshold(uint16_t value)
    {
        jitHotnessThreshold_ = value;
    }

    uint16_t GetJitHotnessThreshold() const
    {
        return jitHotnessThreshold_;
    }

    void SetOsrHotnessThreshold(uint16_t value)
    {
        osrHotnessThreshold_ = value;
    }

    uint16_t GetOsrHotnessThreshold() const
    {
        return osrHotnessThreshold_;
    }

    void SetForceJitCompileMain(bool value)
    {
        forceJitCompileMain_ = value;
    }

    bool IsEnableForceJitCompileMain()
    {
        return forceJitCompileMain_;
    }

    void SetEnableBaselineJIT(bool value)
    {
        enableBaselineJIT_ = value;
    }

    bool IsEnableBaselineJIT() const
    {
        return enableBaselineJIT_;
    }

    void SetBaselineJitHotnessThreshold(uint16_t value)
    {
        baselineJitHotnessThreshold_ = value;
    }

    uint16_t GetBaselineJitHotnessThreshold() const
    {
        return baselineJitHotnessThreshold_;
    }

    void SetForceBaselineCompileMain(bool value)
    {
        forceBaselineCompileMain_ = value;
    }

    bool IsEnableForceBaselineCompileMain()
    {
        return forceBaselineCompileMain_;
    }

    void SetEnableNewValueNumbering(bool value)
    {
        enableNewValueNumbering_ = value;
    }

    bool IsEnableNewValueNumbering() const
    {
        return enableNewValueNumbering_;
    }

    void SetEnableOptString(bool value)
    {
        enableOptString_ = value;
    }

    bool IsEnableOptString() const
    {
        return enableOptString_;
    }

    void SetEnableOptInlining(bool value)
    {
        enableOptInlining_ = value;
    }

    bool IsEnableOptInlining() const
    {
        return enableOptInlining_;
    }

    void SetEnableOptPGOType(bool value)
    {
        enableOptPGOType_ = value;
    }

    bool IsEnableOptPGOType() const
    {
        return enableOptPGOType_;
    }

    void SetEnableOptTrackField(bool value)
    {
        enableOptTrackField_ = value;
    }

    bool IsEnableOptTrackField() const
    {
        return enableOptTrackField_;
    }

    uint32_t GetCompilerModuleMethods() const
    {
        return compilerModuleMethods_;
    }

    void SetCompilerModuleMethods(uint32_t compilerModuleMethods)
    {
        compilerModuleMethods_ = compilerModuleMethods;
    }

    void SetTraceDeopt(bool value)
    {
        traceDeopt_ = value;
    }

    bool GetTraceDeopt() const
    {
        return traceDeopt_;
    }

    void SetDeoptThreshold(uint8_t value)
    {
        deoptThreshold_ = value;
    }

    uint32_t GetDeoptThreshold() const
    {
        return deoptThreshold_;
    }

    void SetStressDeopt(bool value)
    {
        stressDeopt_ = value;
    }

    bool GetStressDeopt() const
    {
        return stressDeopt_;
    }

    void SetDeviceState(bool value)
    {
        deviceIsScreenOff_ = value;
    }

    bool GetDeviceState() const
    {
        return deviceIsScreenOff_;
    }

    bool WasSetDeviceState() const
    {
        return WasOptionSet(OPTION_COMPILER_DEVICE_STATE);
    }

    void SetOptCodeProfiler(bool value)
    {
        optCodeProfiler_ = value;
    }

    bool GetOptCodeProfiler() const
    {
        return optCodeProfiler_;
    }

    void SetVerifyVTable(bool value)
    {
        verifyVTable_ = value;
    }

    bool GetVerifyVTable() const
    {
        return verifyVTable_;
    }

    std::string GetCompilerSelectMethods() const
    {
        return compilerSelectMethods_;
    }

    void SetCompilerSelectMethods(std::string value)
    {
        compilerSelectMethods_ = std::move(value);
    }

    std::string GetCompilerSkipMethods() const
    {
        return compilerSkipMethods_;
    }

    void SetCompilerSkipMethods(std::string value)
    {
        compilerSkipMethods_ = std::move(value);
    }

    void SetTraceInline(bool value)
    {
        traceInline_ = value;
    }

    bool GetTraceInline() const
    {
        return traceInline_;
    }

    void SetTraceValueNumbering(bool value)
    {
        traceValueNumbering_ = value;
    }

    bool GetTraceValueNumbering() const
    {
        return traceValueNumbering_;
    }

    void SetTraceJIT(bool value)
    {
        traceJIT_ = value;
    }

    bool GetTraceJIT() const
    {
        return traceJIT_;
    }

    void SetTraceInstructionCombine(bool value)
    {
        traceInstructionCombine_ = value;
    }

    bool GetTraceInstructionCombine() const
    {
        return traceInstructionCombine_;
    }

    void SetMaxInlineBytecodes(size_t value)
    {
        maxInlineBytecodes_ = value;
    }

    size_t GetMaxInlineBytecodes()
    {
        return maxInlineBytecodes_;
    }

    void SetCompilerFrameworkAbcPath(std::string frameworkAbcPath)
    {
        frameworkAbcPath_ = std::move(frameworkAbcPath);
    }

    std::string GetCompilerFrameworkAbcPath() const
    {
        return frameworkAbcPath_;
    }

    bool WasSetCompilerFrameworkAbcPath() const
    {
        return WasOptionSet(OPTION_COMPILER_FRAMEWORK_ABC_PATH);
    }

    void SetTargetCompilerMode(std::string mode)
    {
        targetCompilerMode_ = std::move(mode);
    }

    std::string GetTargetCompilerMode() const
    {
        return targetCompilerMode_;
    }

    bool IsTargetCompilerMode() const
    {
        return IsPartialCompilerMode() || IsFullCompilerMode();
    }

    bool IsPartialCompilerMode() const
    {
        return targetCompilerMode_ == "partial";
    }

    bool IsFullCompilerMode() const
    {
        return targetCompilerMode_ == "full";
    }

    void SetHapPath(std::string path)
    {
        hapPath_ = std::move(path);
    }

    std::string GetHapPath() const
    {
        return hapPath_;
    }

    void SetHapAbcOffset(uint32_t offset)
    {
        hapAbcOffset_ = offset;
    }

    uint32_t GetHapAbcOffset() const
    {
        return hapAbcOffset_;
    }

    void SetHapAbcSize(uint32_t size)
    {
        hapAbcSize_ = size;
    }

    uint32_t GetHapAbcSize() const
    {
        return hapAbcSize_;
    }

    void SetCompilerNoCheck(bool value)
    {
        compilerNoCheck_ = value;
    }

    bool IsCompilerNoCheck() const
    {
        return compilerNoCheck_;
    }

    void SetOptionsForTargetCompilation();

    void SetFastAOTCompileMode(bool value)
    {
        fastAOTCompileMode_ = value;
    }

    bool GetFastAOTCompileMode() const
    {
        return fastAOTCompileMode_;
    }

    void SetEnableOptLoopPeeling(bool value)
    {
        enableOptLoopPeeling_ = value;
    }

    bool IsEnableOptLoopPeeling() const
    {
        return enableOptLoopPeeling_;
    }

    void SetEnableOptLoopInvariantCodeMotion(bool value)
    {
        enableOptLoopInvariantCodeMotion_ = value;
    }

    bool IsEnableOptLoopInvariantCodeMotion() const
    {
        return enableOptLoopInvariantCodeMotion_;
    }

    bool IsEnableOptConstantFolding() const
    {
        return enableOptConstantFolding_;
    }

    void SetEnableOptConstantFolding(bool value)
    {
        enableOptConstantFolding_ = value;
    }

    void SetEnableOptOnHeapCheck(bool value)
    {
        enableOptOnHeapCheck_ = value;
    }

    bool IsEnableOptOnHeapCheck() const
    {
        return enableOptOnHeapCheck_;
    }

    bool IsEnableLexenvSpecialization() const
    {
        return enableLexenvSpecialization_;
    }

    void SetEnableLexenvSpecialization(bool value)
    {
        enableLexenvSpecialization_ = value;
    }

    bool IsEnableNativeInline() const
    {
        return enableNativeInline_;
    }

    void SetEnableNativeInline(bool value)
    {
        enableNativeInline_ = value;
    }

    bool IsEnableLoweringBuiltin() const
    {
        return enableLoweringBuiltin_;
    }

    void SetEnableLoweringBuiltin(bool value)
    {
        enableLoweringBuiltin_ = value;
    }

    void SetCompilerEnableLiteCG(bool value)
    {
        enableLiteCG_ = value;
    }

    bool IsCompilerEnableLiteCG() const
    {
        return enableLiteCG_;
    }

    void SetTypedOpProfiler(bool value)
    {
        enableTypedOpProfiler_ = value;
    }

    bool GetTypedOpProfiler() const
    {
        return enableTypedOpProfiler_;
    }

    bool IsEnableBranchProfiling() const
    {
        return enableBranchProfiling_;
    }

    void SetEnableBranchProfiling(bool value)
    {
        enableBranchProfiling_ = value;
    }

    void SetTestAssert(bool value)
    {
        testAssert_ = value;
    }

    bool GetTestAssert() const
    {
        return testAssert_;
    }

    void SetCompilerMethodsRange(arg_list_t *argListStr)
    {
        compileMethodsRange_.first = std::stoull((*argListStr)[0]);
        compileMethodsRange_.second = std::stoull((*argListStr)[1]);
    }

    const std::pair<uint32_t, uint32_t> &GetCompilerMethodsRange() const
    {
        return compileMethodsRange_;
    }

    void SetCompilerCodegenOptions(arg_list_t argListStr)
    {
        compileCodegenOption_ = std::move(argListStr);
    }

    const arg_list_t &GetCompilerCodegenOptions() const
    {
        return compileCodegenOption_;
    }

    void SetOptCodeRange(std::string value)
    {
        optBCRange_ = std::move(value);
    }

    std::string GetOptCodeRange() const
    {
        return optBCRange_;
    }

    void SetEnableEscapeAnalysis(bool value)
    {
        enableEscapeAnalysis_ = value;
    }

    bool IsEnableEscapeAnalysis() const
    {
        return enableEscapeAnalysis_;
    }

    void SetEnableTraceEscapeAnalysis(bool value)
    {
        traceEscapeAnalysis_ = value;
    }

    bool GetTraceEscapeAnalysis() const
    {
        return traceEscapeAnalysis_;
    }

    void SetEnableInductionVariableAnalysis(bool value)
    {
        enableInductionVariableAnalysis_ = value;
    }

    bool IsEnableInductionVariableAnalysis() const
    {
        return enableInductionVariableAnalysis_;
    }

    void SetEnableTraceInductionVariableAnalysis(bool value)
    {
        traceInductionVariableAnalysis_ = value;
    }

    bool GetTraceInductionVariableAnalysis() const
    {
        return traceInductionVariableAnalysis_;
    }

    void SetEnableMemoryAnalysis(bool value)
    {
        enableMemoryAnalysis_ = value;
    }

    bool IsEnableMemoryAnalysis() const
    {
        return enableMemoryAnalysis_;
    }

    void SetCheckPgoVersion(bool value)
    {
        checkPgoVersion_ = value;
    }

    bool IsCheckPgoVersion() const
    {
        return checkPgoVersion_;
    }

    void SetEnableJITPGO(bool value)
    {
        enableJITPGO_ = value;
    }

    bool IsEnableJITPGO() const
    {
        return enableJITPGO_;
    }

    void SetEnableProfileDump(bool value)
    {
        enableProfileDump_ = value;
    }

    bool IsEnableProfileDump() const
    {
        return enableProfileDump_;
    }

    void SetEnableAOTPGO(bool value)
    {
        enableAOTPGO_ = value;
    }

    bool IsEnableAOTPGO() const
    {
        return enableAOTPGO_;
    }

private:
    static bool StartsWith(const std::string &haystack, const std::string &needle)
    {
        return std::equal(needle.begin(), needle.end(), haystack.begin());
    }

    void WasSet(int option)
    {
        if (option < OPTION_SPLIT_ONE) {
            wasSetPartOne_ |= (1ULL << static_cast<uint64_t>(option));
        } else {
            wasSetPartTwo_ |= (1ULL << static_cast<uint64_t>(option - OPTION_SPLIT_ONE));
        }
    }

    bool WasOptionSet(int option) const
    {
        if (option < OPTION_SPLIT_ONE) {
            return ((1ULL << static_cast<uint64_t>(option)) & wasSetPartOne_) != 0;
        }

        return ((1ULL << static_cast<uint64_t>(option - OPTION_SPLIT_ONE)) & wasSetPartTwo_) != 0;
    }

    bool ParseBoolParam(bool* argBool);
    bool ParseDoubleParam(const std::string &option, double* argDouble);
    bool ParseIntParam(const std::string &option, int* argInt);
    bool ParseUint32Param(const std::string &option, uint32_t *argUInt32);
    bool ParseUint64Param(const std::string &option, uint64_t *argUInt64);
    void ParseListArgParam(const std::string &option, arg_list_t *argListStr, std::string delimiter);

    bool enableArkTools_ {true};
    std::string stubFile_ {"stub.an"};
    std::string compilerPkgInfo_ {};
    std::string compilerExternalPkgInfo_ {};
    bool compilerEnableExternalPkg_ {true};
    bool enableForceGc_ {true};
    bool forceFullGc_ {true};
    uint32_t forceSharedGc_ {1};
    int arkProperties_ = GetDefaultProperties();
    std::string arkBundleName_ = {""};
    size_t heapSize_ = {0};
    uint32_t gcThreadNum_ {7}; // 7: default thread num
    uint32_t longPauseTime_ {40}; // 40: default pause time
    std::string aotOutputFile_ {""};
    std::string targetTriple_ {TARGET_X64};
    uint32_t asmOptLevel_ {2};
    uint32_t relocationMode_ {2}; // 2: default relocation mode
    uint32_t maxNonmovableSpaceCapacity_ {4_MB};
    bool enableAsmInterpreter_ {true};
    bool enableBuiltinsLazy_ {true};
    std::string asmOpcodeDisableRange_ {""};
    AsmInterParsedOption asmInterParsedOption_;
    uint64_t serializerBufferSizeLimit_ {2_GB};
    uint32_t heapSizeLimit_ {512_MB};
    bool enableIC_ {true};
    std::string icuDataPath_ {"default"};
    bool startupTime_ {false};
    std::string compilerLogOpt_ {"none"};
    std::string compilerLogMethods_ {"none"};
    bool compilerLogSnapshot_ {false};
    bool compilerLogTime_ {false};
    bool enableRuntimeStat_ {false};
    bool isWorker_ {false};
    bool isRestrictedWorker_ {false};
    bool traceBc_ {false};
    std::string logLevel_ {"error"};
    arg_list_t logDebug_ {{"all"}};
    arg_list_t logInfo_ {{"all"}};
    arg_list_t logWarning_ {{"all"}};
    arg_list_t logError_ {{"all"}};
    arg_list_t logFatal_ {{"all"}};
    arg_list_t logComponents_ {{"all"}};
    bool enableAOT_ {false};
    uint32_t maxAotMethodSize_ {32_KB};
    double typeThreshold_ {-1};
    std::string entryPoint_ {"_GLOBAL::func_main_0"};
    bool mergeAbc_ {false};
    bool enableArrayBoundsCheckElimination_ {false};
    bool enableTypeLowering_ {true};
    bool enableEarlyElimination_ {true};
    bool enableLaterElimination_ {true};
    bool enableValueNumbering_ {true};
    bool enableOptString_ {true};
    bool enableElementsKind_ {false};
    bool enableInstrcutionCombine {true};
    bool enableNewValueNumbering_ {true};
    bool enableOptInlining_ {true};
    bool enableOptPGOType_ {true};
    bool enableFastJIT_{false};
    bool enableAPPJIT_{false};
    bool enableOSR_{false};
    uint16_t jitHotnessThreshold_ {2};
    uint16_t osrHotnessThreshold_ {2};
    bool forceJitCompileMain_{false};
    bool enableBaselineJIT_{false};
    uint16_t baselineJitHotnessThreshold_{1};
    bool forceBaselineCompileMain_ {false};
    bool enableOptTrackField_ {true};
    uint32_t compilerModuleMethods_ {100};
    uint64_t wasSetPartOne_ {0};
    uint64_t wasSetPartTwo_ {0};
    bool enableContext_ {false};
    bool enablePrintExecuteTime_ {false};
    bool enablePGOProfiler_ {false};
    bool enableJITPGO_ {true};
    bool enableAOTPGO_ {true};
    bool enableProfileDump_ {true};
    bool reportModuleResolvingFailure_ {true};
    uint32_t pgoHotnessThreshold_ {1};
    std::string pgoProfilerPath_ {""};
    uint32_t pgoSaveMinInterval_ {30};
    bool traceDeopt_ {false};
    uint8_t deoptThreshold_ {10};
    bool stressDeopt_ {false};
    bool deviceIsScreenOff_ {true};
    bool optCodeProfiler_ {false};
    bool startGlobalLeakCheck_ {false};
    bool verifyVTable_ {false};
    std::string compilerSelectMethods_ {""};
    std::string compilerSkipMethods_ {""};
    bool traceInline_ {false};
    bool traceJIT_{false};
    bool traceValueNumbering_{false};
    bool traceInstructionCombine_{false};
    size_t maxInlineBytecodes_ {45};
    std::string targetCompilerMode_ {""};
    std::string frameworkAbcPath_ {""};
    std::string hapPath_ {""};
    uint32_t hapAbcOffset_ {0};
    uint32_t hapAbcSize_ {0};
    std::string optBCRange_ {""};
    bool compilerNoCheck_ {false};
    bool fastAOTCompileMode_ {false};
    bool enableOptLoopPeeling_ {true};
    bool enableOptConstantFolding_ {true};
    bool enableOptOnHeapCheck_ {true};
    bool enableOptLoopInvariantCodeMotion_ {false};
    bool enableLexenvSpecialization_ {false};
    bool enableNativeInline_ {true};
    bool enableLoweringBuiltin_ {true};
    bool enableLiteCG_ {false};
    bool enableTypedOpProfiler_ {false};
    bool enableBranchProfiling_ {true};
    bool testAssert_ {false};
    std::pair<uint32_t, uint32_t> compileMethodsRange_ {0, UINT32_MAX};
    arg_list_t compileCodegenOption_ {{""}};
    bool enableEscapeAnalysis_ {false};
    bool traceEscapeAnalysis_ {false};
    bool enableInductionVariableAnalysis_ {false};
    bool traceInductionVariableAnalysis_ {false};
    bool enableMemoryAnalysis_ {true};
    bool checkPgoVersion_ {false};
};
}  // namespace panda::ecmascript

#endif  // ECMASCRIPT_JS_RUNTIME_OPTIONS_H_