/*
 * Copyright (c) 2021-2025 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.
 */
// Autogenerated file -- DO NOT EDIT!

#ifndef PANDA_COMPILER_OPTIONS_GEN_H
#define PANDA_COMPILER_OPTIONS_GEN_H

#include "libarkbase/utils/pandargs.h"
#include "platforms/target_defaults/default_target_options.h"
#include "libarkbase/macros.h"

#include <optional>
#include <string>
#include <unordered_set>
#include <vector>

namespace ark::compiler {
// NOLINTBEGIN(readability-identifier-naming,readability-magic-numbers)
class PANDA_PUBLIC_API Options {
public:
    class Error {
    public:
        explicit Error(std::string msg) : msg_(std::move(msg)) {}

        std::string GetMessage() {
            return msg_;
        }
    private:
        std::string msg_;
    };

    explicit Options(const std::string &exe_path) :
        exe_dir_(GetExeDir(exe_path))
    {}

    // NOLINTBEGIN(readability-function-size)
    void AddOptions(PandArgParser *parser) {
        parser->Add(&compiler_non_optimizing_);
        parser->Add(&compiler_regex_);
        parser->Add(&compiler_regex_with_signature_);
        parser->Add(&compiler_visualizer_dump_);
        parser->Add(&compiler_dump_);
        parser->Add(&compiler_disasm_dump_);
        parser->Add(&compiler_emit_asm_);
        parser->Add(&compiler_enable_tracing_);
        parser->Add(&compiler_enable_tlab_events_);
        parser->Add(&compiler_support_init_object_inst_);
        parser->Add(&compiler_log_);
        parser->Add(&compiler_check_graph_);
        parser->Add(&compiler_check_final_);
        parser->Add(&compiler_encode_intrinsics_);
        parser->Add(&compiler_lowering_);
        parser->Add(&compiler_lower_boxed_boolean_);
        parser->Add(&compiler_code_sink_);
        parser->Add(&compiler_balance_expressions_);
        parser->Add(&compiler_branch_elimination_);
        parser->Add(&compiler_optimize_string_concat_);
        parser->Add(&compiler_simplify_string_builder_);
        parser->Add(&compiler_reserve_string_builder_buffer_);
        parser->Add(&compiler_checks_elimination_);
        parser->Add(&compiler_enable_replacing_checks_on_deoptimization_);
        parser->Add(&compiler_deoptimize_elimination_);
        parser->Add(&compiler_save_state_elimination_);
        parser->Add(&compiler_safepoint_elimination_limit_);
        parser->Add(&compiler_implicit_null_check_);
        parser->Add(&compiler_licm_);
        parser->Add(&compiler_licm_hoist_limit_);
        parser->Add(&compiler_licm_conditions_);
        parser->Add(&compiler_loop_unswitch_);
        parser->Add(&compiler_loop_unswitch_max_level_);
        parser->Add(&compiler_loop_unswitch_max_insts_);
        parser->Add(&compiler_loop_idioms_);
        parser->Add(&compiler_loop_peeling_);
        parser->Add(&compiler_loop_unroll_);
        parser->Add(&compiler_loop_unroll_factor_);
        parser->Add(&compiler_loop_unroll_inst_limit_);
        parser->Add(&compiler_unroll_loop_with_calls_);
        parser->Add(&compiler_unroll_with_side_exits_);
        parser->Add(&compiler_unroll_unknown_trip_count_);
        parser->Add(&compiler_lse_);
        parser->Add(&compiler_cse_);
        parser->Add(&compiler_vn_);
        parser->Add(&compiler_memory_coalescing_);
        parser->Add(&compiler_memory_coalescing_objects_);
        parser->Add(&compiler_memory_coalescing_aligned_);
        parser->Add(&compiler_optimize_native_calls_);
        parser->Add(&compiler_print_stats_);
        parser->Add(&compiler_dump_stats_csv_);
        parser->Add(&compiler_enable_ir_stats_);
        parser->Add(&compiler_dump_jit_stats_csv_);
        parser->Add(&compiler_use_safepoint_);
        parser->Add(&compiler_defer_preheader_transform_);
        parser->Add(&compiler_inlining_);
        parser->Add(&compiler_inline_external_methods_);
        parser->Add(&compiler_inline_external_methods_aot_);
        parser->Add(&compiler_inlining_blacklist_);
        parser->Add(&compiler_inlining_max_insts_);
        parser->Add(&compiler_inlining_max_depth_);
        parser->Add(&compiler_inlining_recursive_calls_limit_);
        parser->Add(&compiler_inlining_insts_bc_ratio_);
        parser->Add(&compiler_inlining_max_bc_size_);
        parser->Add(&compiler_inlining_always_inline_bc_size_);
        parser->Add(&compiler_inline_simple_only_);
        parser->Add(&compiler_inlining_skip_throw_blocks_);
        parser->Add(&compiler_inlining_skip_always_throw_methods_);
        parser->Add(&compiler_no_virtual_inlining_);
        parser->Add(&compiler_no_cha_inlining_);
        parser->Add(&compiler_no_pic_inlining_);
        parser->Add(&compiler_reset_local_allocator_);
        parser->Add(&compiler_scheduling_);
        parser->Add(&compiler_sched_latency_);
        parser->Add(&compiler_sched_latency_long_);
        parser->Add(&compiler_if_conversion_);
        parser->Add(&compiler_if_conversion_limit_);
        parser->Add(&compiler_if_conversion_incrase_limit_threshold_);
        parser->Add(&compiler_cross_arch_);
        parser->Add(&compiler_enable_events_);
        parser->Add(&compiler_events_path_);
        parser->Add(&compiler_save_only_live_registers_);
        parser->Add(&compiler_ignore_failures_);
        parser->Add(&compiler_allow_backend_failures_);
        parser->Add(&compiler_max_gen_code_size_);
        parser->Add(&compiler_max_bytecode_size_);
        parser->Add(&compiler_max_vregs_num_);
        parser->Add(&compiler_compact_prologue_);
        parser->Add(&compiler_js_filter_intrinsics_);
        parser->Add(&compiler_reg_acc_alloc_);
        parser->Add(&compiler_regalloc_reg_mask_);
        parser->Add(&compiler_verify_regalloc_);
        parser->Add(&compiler_select_optimization_);
        parser->Add(&compiler_move_constants_);
        parser->Add(&compiler_adjust_refs_);
        parser->Add(&compiler_aot_load_string_plt_);
        parser->Add(&compiler_remat_const_);
        parser->Add(&compiler_unfold_const_array_max_size_);
        parser->Add(&compiler_spill_fill_pair_);
        parser->Add(&compiler_frame_size_);
        parser->Add(&compiler_cpu_features_);
        parser->Add(&compiler_emit_debug_info_);
        parser->Add(&compiler_aot_ra_);
        parser->Add(&compiler_freq_based_branch_reorder_);
        parser->Add(&compiler_freq_based_branch_reorder_threshold_);
        parser->Add(&compiler_inline_full_intrinsics_);
        parser->Add(&compiler_safe_points_require_reg_map_);
        parser->Add(&compiler_scalar_replacement_);
        parser->Add(&compiler_peepholes_);
        parser->Add(&compiler_if_merging_);
        parser->Add(&compiler_redundant_loop_elimination_);
        parser->Add(&compiler_optimize_memory_barriers_);
        parser->Add(&compiler_string_flat_check_);
        parser->Add(&compiler_profile_);
        parser->Add(&compiler_force_unresolved_);
        parser->Add(&compiler_enable_fast_interop_);
        parser->Add(&compiler_interop_intrinsic_optimization_);
        parser->Add(&compiler_interop_scope_object_limit_);
        parser->Add(&compiler_interop_try_single_scope_);
        parser->Add(&compiler_inst_graph_coloring_limit_);
        parser->Add(&compiler_enforce_safepoint_placement_);
        parser->Add(&compiler_safepoint_distance_limit_);
    }
    // NOLINTEND(readability-function-size)

    bool IsCompilerNonOptimizing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_non_optimizing_.GetValue();
    }

    void SetCompilerNonOptimizing(bool value) {
        compiler_non_optimizing_.SetValue(value);
    }

    bool WasSetCompilerNonOptimizing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_non_optimizing_.WasSet();
    }
    const std::string &GetCompilerRegex([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regex_.GetValue();
    }

    void SetCompilerRegex(std::string value) {
        compiler_regex_.SetValue(std::move(value));
    }

    bool WasSetCompilerRegex([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regex_.WasSet();
    }
    const std::string &GetCompilerRegexWithSignature([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regex_with_signature_.GetValue();
    }

    void SetCompilerRegexWithSignature(std::string value) {
        compiler_regex_with_signature_.SetValue(std::move(value));
    }

    bool WasSetCompilerRegexWithSignature([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regex_with_signature_.WasSet();
    }
    bool IsCompilerVisualizerDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_visualizer_dump_.GetValue();
    }

    void SetCompilerVisualizerDump(bool value) {
        compiler_visualizer_dump_.SetValue(value);
    }

    bool WasSetCompilerVisualizerDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_visualizer_dump_.WasSet();
    }
    bool IsCompilerDumpFinal([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_final_.GetValue();
    }

    void SetCompilerDumpFinal(bool value) {
        compiler_dump_final_.SetValue(value);
    }

    bool WasSetCompilerDumpFinal([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_final_.WasSet();
    }
    bool IsCompilerDumpCompact([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_compact_.GetValue();
    }

    void SetCompilerDumpCompact(bool value) {
        compiler_dump_compact_.SetValue(value);
    }

    bool WasSetCompilerDumpCompact([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_compact_.WasSet();
    }
    bool IsCompilerDumpNoChecks([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_no_checks_.GetValue();
    }

    void SetCompilerDumpNoChecks(bool value) {
        compiler_dump_no_checks_.SetValue(value);
    }

    bool WasSetCompilerDumpNoChecks([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_no_checks_.WasSet();
    }
    bool IsCompilerDumpLifeIntervals([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_life_intervals_.GetValue();
    }

    void SetCompilerDumpLifeIntervals(bool value) {
        compiler_dump_life_intervals_.SetValue(value);
    }

    bool WasSetCompilerDumpLifeIntervals([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_life_intervals_.WasSet();
    }
    const std::string &GetCompilerDumpFolder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_folder_.GetValue();
    }

    void SetCompilerDumpFolder(std::string value) {
        compiler_dump_folder_.SetValue(std::move(value));
    }

    bool WasSetCompilerDumpFolder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_folder_.WasSet();
    }
    bool IsCompilerDumpBytecode([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_bytecode_.GetValue();
    }

    void SetCompilerDumpBytecode(bool value) {
        compiler_dump_bytecode_.SetValue(value);
    }

    bool WasSetCompilerDumpBytecode([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_bytecode_.WasSet();
    }
    bool IsCompilerDumpPeepholes([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_peepholes_.GetValue();
    }

    void SetCompilerDumpPeepholes(bool value) {
        compiler_dump_peepholes_.SetValue(value);
    }

    bool WasSetCompilerDumpPeepholes([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_peepholes_.WasSet();
    }
    bool IsCompilerDumpSourceLine([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_source_line_.GetValue();
    }

    void SetCompilerDumpSourceLine(bool value) {
        compiler_dump_source_line_.SetValue(value);
    }

    bool WasSetCompilerDumpSourceLine([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_source_line_.WasSet();
    }
    bool IsCompilerDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_.GetValue();
    }

    void SetCompilerDump(bool value) {
        compiler_dump_.SetValue(value);
    }

    bool WasSetCompilerDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_.WasSet();
    }
    bool IsCompilerDisasmDumpSingleFile([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_single_file_.GetValue();
    }

    void SetCompilerDisasmDumpSingleFile(bool value) {
        compiler_disasm_dump_single_file_.SetValue(value);
    }

    bool WasSetCompilerDisasmDumpSingleFile([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_single_file_.WasSet();
    }
    bool IsCompilerDisasmDumpStdout([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_stdout_.GetValue();
    }

    void SetCompilerDisasmDumpStdout(bool value) {
        compiler_disasm_dump_stdout_.SetValue(value);
    }

    bool WasSetCompilerDisasmDumpStdout([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_stdout_.WasSet();
    }
    bool IsCompilerDisasmDumpCode([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_code_.GetValue();
    }

    void SetCompilerDisasmDumpCode(bool value) {
        compiler_disasm_dump_code_.SetValue(value);
    }

    bool WasSetCompilerDisasmDumpCode([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_code_.WasSet();
    }
    bool IsCompilerDisasmDumpCodeInfo([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_code_info_.GetValue();
    }

    void SetCompilerDisasmDumpCodeInfo(bool value) {
        compiler_disasm_dump_code_info_.SetValue(value);
    }

    bool WasSetCompilerDisasmDumpCodeInfo([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_code_info_.WasSet();
    }
    const std::string &GetCompilerDisasmDumpFileName([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_file_name_.GetValue();
    }

    void SetCompilerDisasmDumpFileName(std::string value) {
        compiler_disasm_dump_file_name_.SetValue(std::move(value));
    }

    bool WasSetCompilerDisasmDumpFileName([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_file_name_.WasSet();
    }
    bool IsCompilerDisasmDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_.GetValue();
    }

    void SetCompilerDisasmDump(bool value) {
        compiler_disasm_dump_.SetValue(value);
    }

    bool WasSetCompilerDisasmDump([[maybe_unused]] std::string_view lang = "") const {
        return compiler_disasm_dump_.WasSet();
    }
    bool IsCompilerEmitAsm([[maybe_unused]] std::string_view lang = "") const {
        return compiler_emit_asm_.GetValue();
    }

    void SetCompilerEmitAsm(bool value) {
        compiler_emit_asm_.SetValue(value);
    }

    bool WasSetCompilerEmitAsm([[maybe_unused]] std::string_view lang = "") const {
        return compiler_emit_asm_.WasSet();
    }
    bool IsCompilerEnableTracing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_tracing_.GetValue();
    }

    void SetCompilerEnableTracing(bool value) {
        compiler_enable_tracing_.SetValue(value);
    }

    bool WasSetCompilerEnableTracing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_tracing_.WasSet();
    }
    bool IsCompilerEnableTlabEvents([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_tlab_events_.GetValue();
    }

    void SetCompilerEnableTlabEvents(bool value) {
        compiler_enable_tlab_events_.SetValue(value);
    }

    bool WasSetCompilerEnableTlabEvents([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_tlab_events_.WasSet();
    }
    bool IsCompilerSupportInitObjectInst([[maybe_unused]] std::string_view lang = "") const {
        return compiler_support_init_object_inst_.GetValue();
    }

    void SetCompilerSupportInitObjectInst(bool value) {
        compiler_support_init_object_inst_.SetValue(value);
    }

    bool WasSetCompilerSupportInitObjectInst([[maybe_unused]] std::string_view lang = "") const {
        return compiler_support_init_object_inst_.WasSet();
    }
    const arg_list_t &GetCompilerLog([[maybe_unused]] std::string_view lang = "") const {
        return compiler_log_.GetValue();
    }

    void SetCompilerLog(arg_list_t value) {
        compiler_log_.SetValue(std::move(value));
    }

    bool WasSetCompilerLog([[maybe_unused]] std::string_view lang = "") const {
        return compiler_log_.WasSet();
    }
    bool IsCompilerCheckGraph([[maybe_unused]] std::string_view lang = "") const {
        return compiler_check_graph_.GetValue();
    }

    void SetCompilerCheckGraph(bool value) {
        compiler_check_graph_.SetValue(value);
    }

    bool WasSetCompilerCheckGraph([[maybe_unused]] std::string_view lang = "") const {
        return compiler_check_graph_.WasSet();
    }
    bool IsCompilerCheckFinal([[maybe_unused]] std::string_view lang = "") const {
        return compiler_check_final_.GetValue();
    }

    void SetCompilerCheckFinal(bool value) {
        compiler_check_final_.SetValue(value);
    }

    bool WasSetCompilerCheckFinal([[maybe_unused]] std::string_view lang = "") const {
        return compiler_check_final_.WasSet();
    }
    bool IsCompilerEncodeIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_encode_intrinsics_.GetValue();
    }

    void SetCompilerEncodeIntrinsics(bool value) {
        compiler_encode_intrinsics_.SetValue(value);
    }

    bool WasSetCompilerEncodeIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_encode_intrinsics_.WasSet();
    }
    bool IsCompilerLowering([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lowering_.GetValue();
    }

    void SetCompilerLowering(bool value) {
        compiler_lowering_.SetValue(value);
    }

    bool WasSetCompilerLowering([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lowering_.WasSet();
    }
    bool IsCompilerLowerBoxedBoolean([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lower_boxed_boolean_.GetValue();
    }

    void SetCompilerLowerBoxedBoolean(bool value) {
        compiler_lower_boxed_boolean_.SetValue(value);
    }

    bool WasSetCompilerLowerBoxedBoolean([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lower_boxed_boolean_.WasSet();
    }
    bool IsCompilerCodeSink([[maybe_unused]] std::string_view lang = "") const {
        return compiler_code_sink_.GetValue();
    }

    void SetCompilerCodeSink(bool value) {
        compiler_code_sink_.SetValue(value);
    }

    bool WasSetCompilerCodeSink([[maybe_unused]] std::string_view lang = "") const {
        return compiler_code_sink_.WasSet();
    }
    bool IsCompilerBalanceExpressions([[maybe_unused]] std::string_view lang = "") const {
        return compiler_balance_expressions_.GetValue();
    }

    void SetCompilerBalanceExpressions(bool value) {
        compiler_balance_expressions_.SetValue(value);
    }

    bool WasSetCompilerBalanceExpressions([[maybe_unused]] std::string_view lang = "") const {
        return compiler_balance_expressions_.WasSet();
    }
    bool IsCompilerBranchElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_branch_elimination_.GetValue();
    }

    void SetCompilerBranchElimination(bool value) {
        compiler_branch_elimination_.SetValue(value);
    }

    bool WasSetCompilerBranchElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_branch_elimination_.WasSet();
    }
    bool IsCompilerOptimizeStringConcat([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_string_concat_.GetValue();
    }

    void SetCompilerOptimizeStringConcat(bool value) {
        compiler_optimize_string_concat_.SetValue(value);
    }

    bool WasSetCompilerOptimizeStringConcat([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_string_concat_.WasSet();
    }
    bool IsCompilerSimplifyStringBuilder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_simplify_string_builder_.GetValue();
    }

    void SetCompilerSimplifyStringBuilder(bool value) {
        compiler_simplify_string_builder_.SetValue(value);
    }

    bool WasSetCompilerSimplifyStringBuilder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_simplify_string_builder_.WasSet();
    }
    bool IsCompilerReserveStringBuilderBuffer([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reserve_string_builder_buffer_.GetValue();
    }

    void SetCompilerReserveStringBuilderBuffer(bool value) {
        compiler_reserve_string_builder_buffer_.SetValue(value);
    }

    bool WasSetCompilerReserveStringBuilderBuffer([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reserve_string_builder_buffer_.WasSet();
    }
    bool IsCompilerChecksElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_checks_elimination_.GetValue();
    }

    void SetCompilerChecksElimination(bool value) {
        compiler_checks_elimination_.SetValue(value);
    }

    bool WasSetCompilerChecksElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_checks_elimination_.WasSet();
    }
    bool IsCompilerEnableReplacingChecksOnDeoptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_replacing_checks_on_deoptimization_.GetValue();
    }

    void SetCompilerEnableReplacingChecksOnDeoptimization(bool value) {
        compiler_enable_replacing_checks_on_deoptimization_.SetValue(value);
    }

    bool WasSetCompilerEnableReplacingChecksOnDeoptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_replacing_checks_on_deoptimization_.WasSet();
    }
    bool IsCompilerDeoptimizeElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_deoptimize_elimination_.GetValue();
    }

    void SetCompilerDeoptimizeElimination(bool value) {
        compiler_deoptimize_elimination_.SetValue(value);
    }

    bool WasSetCompilerDeoptimizeElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_deoptimize_elimination_.WasSet();
    }
    bool IsCompilerSaveStateElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_save_state_elimination_.GetValue();
    }

    void SetCompilerSaveStateElimination(bool value) {
        compiler_save_state_elimination_.SetValue(value);
    }

    bool WasSetCompilerSaveStateElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_save_state_elimination_.WasSet();
    }
    uint64_t GetCompilerSafepointEliminationLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safepoint_elimination_limit_.GetValue();
    }

    void SetCompilerSafepointEliminationLimit(uint64_t value) {
        compiler_safepoint_elimination_limit_.SetValue(value);
    }

    bool WasSetCompilerSafepointEliminationLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safepoint_elimination_limit_.WasSet();
    }
    bool IsCompilerImplicitNullCheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_implicit_null_check_.GetValue();
    }

    void SetCompilerImplicitNullCheck(bool value) {
        compiler_implicit_null_check_.SetValue(value);
    }

    bool WasSetCompilerImplicitNullCheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_implicit_null_check_.WasSet();
    }
    bool IsCompilerLicm([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_.GetValue();
    }

    void SetCompilerLicm(bool value) {
        compiler_licm_.SetValue(value);
    }

    bool WasSetCompilerLicm([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_.WasSet();
    }
    uint32_t GetCompilerLicmHoistLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_hoist_limit_.GetValue();
    }

    void SetCompilerLicmHoistLimit(uint32_t value) {
        compiler_licm_hoist_limit_.SetValue(value);
    }

    bool WasSetCompilerLicmHoistLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_hoist_limit_.WasSet();
    }
    bool IsCompilerLicmConditions([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_conditions_.GetValue();
    }

    void SetCompilerLicmConditions(bool value) {
        compiler_licm_conditions_.SetValue(value);
    }

    bool WasSetCompilerLicmConditions([[maybe_unused]] std::string_view lang = "") const {
        return compiler_licm_conditions_.WasSet();
    }
    bool IsCompilerLoopUnswitch([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_.GetValue();
    }

    void SetCompilerLoopUnswitch(bool value) {
        compiler_loop_unswitch_.SetValue(value);
    }

    bool WasSetCompilerLoopUnswitch([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_.WasSet();
    }
    uint32_t GetCompilerLoopUnswitchMaxLevel([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_max_level_.GetValue();
    }

    void SetCompilerLoopUnswitchMaxLevel(uint32_t value) {
        compiler_loop_unswitch_max_level_.SetValue(value);
    }

    bool WasSetCompilerLoopUnswitchMaxLevel([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_max_level_.WasSet();
    }
    uint32_t GetCompilerLoopUnswitchMaxInsts([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_max_insts_.GetValue();
    }

    void SetCompilerLoopUnswitchMaxInsts(uint32_t value) {
        compiler_loop_unswitch_max_insts_.SetValue(value);
    }

    bool WasSetCompilerLoopUnswitchMaxInsts([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unswitch_max_insts_.WasSet();
    }
    bool IsCompilerLoopIdioms([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_idioms_.GetValue();
    }

    void SetCompilerLoopIdioms(bool value) {
        compiler_loop_idioms_.SetValue(value);
    }

    bool WasSetCompilerLoopIdioms([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_idioms_.WasSet();
    }
    bool IsCompilerLoopPeeling([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_peeling_.GetValue();
    }

    void SetCompilerLoopPeeling(bool value) {
        compiler_loop_peeling_.SetValue(value);
    }

    bool WasSetCompilerLoopPeeling([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_peeling_.WasSet();
    }
    bool IsCompilerLoopUnroll([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_.GetValue();
    }

    void SetCompilerLoopUnroll(bool value) {
        compiler_loop_unroll_.SetValue(value);
    }

    bool WasSetCompilerLoopUnroll([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_.WasSet();
    }
    uint32_t GetCompilerLoopUnrollFactor([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_factor_.GetValue();
    }

    void SetCompilerLoopUnrollFactor(uint32_t value) {
        compiler_loop_unroll_factor_.SetValue(value);
    }

    bool WasSetCompilerLoopUnrollFactor([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_factor_.WasSet();
    }
    uint32_t GetCompilerLoopUnrollInstLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_inst_limit_.GetValue();
    }

    void SetCompilerLoopUnrollInstLimit(uint32_t value) {
        compiler_loop_unroll_inst_limit_.SetValue(value);
    }

    bool WasSetCompilerLoopUnrollInstLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_loop_unroll_inst_limit_.WasSet();
    }
    bool IsCompilerUnrollLoopWithCalls([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_loop_with_calls_.GetValue();
    }

    void SetCompilerUnrollLoopWithCalls(bool value) {
        compiler_unroll_loop_with_calls_.SetValue(value);
    }

    bool WasSetCompilerUnrollLoopWithCalls([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_loop_with_calls_.WasSet();
    }
    bool IsCompilerUnrollWithSideExits([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_with_side_exits_.GetValue();
    }

    void SetCompilerUnrollWithSideExits(bool value) {
        compiler_unroll_with_side_exits_.SetValue(value);
    }

    bool WasSetCompilerUnrollWithSideExits([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_with_side_exits_.WasSet();
    }
    bool IsCompilerUnrollUnknownTripCount([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_unknown_trip_count_.GetValue();
    }

    void SetCompilerUnrollUnknownTripCount(bool value) {
        compiler_unroll_unknown_trip_count_.SetValue(value);
    }

    bool WasSetCompilerUnrollUnknownTripCount([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unroll_unknown_trip_count_.WasSet();
    }
    bool IsCompilerLse([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lse_.GetValue();
    }

    void SetCompilerLse(bool value) {
        compiler_lse_.SetValue(value);
    }

    bool WasSetCompilerLse([[maybe_unused]] std::string_view lang = "") const {
        return compiler_lse_.WasSet();
    }
    bool IsCompilerCse([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cse_.GetValue();
    }

    void SetCompilerCse(bool value) {
        compiler_cse_.SetValue(value);
    }

    bool WasSetCompilerCse([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cse_.WasSet();
    }
    bool IsCompilerVn([[maybe_unused]] std::string_view lang = "") const {
        return compiler_vn_.GetValue();
    }

    void SetCompilerVn(bool value) {
        compiler_vn_.SetValue(value);
    }

    bool WasSetCompilerVn([[maybe_unused]] std::string_view lang = "") const {
        return compiler_vn_.WasSet();
    }
    bool IsCompilerMemoryCoalescing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_.GetValue();
    }

    void SetCompilerMemoryCoalescing(bool value) {
        compiler_memory_coalescing_.SetValue(value);
    }

    bool WasSetCompilerMemoryCoalescing([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_.WasSet();
    }
    bool IsCompilerMemoryCoalescingObjects([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_objects_.GetValue();
    }

    void SetCompilerMemoryCoalescingObjects(bool value) {
        compiler_memory_coalescing_objects_.SetValue(value);
    }

    bool WasSetCompilerMemoryCoalescingObjects([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_objects_.WasSet();
    }
    bool IsCompilerMemoryCoalescingAligned([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_aligned_.GetValue();
    }

    void SetCompilerMemoryCoalescingAligned(bool value) {
        compiler_memory_coalescing_aligned_.SetValue(value);
    }

    bool WasSetCompilerMemoryCoalescingAligned([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_coalescing_aligned_.WasSet();
    }
    bool IsCompilerOptimizeNativeCalls([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_native_calls_.GetValue();
    }

    void SetCompilerOptimizeNativeCalls(bool value) {
        compiler_optimize_native_calls_.SetValue(value);
    }

    bool WasSetCompilerOptimizeNativeCalls([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_native_calls_.WasSet();
    }
    bool IsCompilerPrintStats([[maybe_unused]] std::string_view lang = "") const {
        return compiler_print_stats_.GetValue();
    }

    void SetCompilerPrintStats(bool value) {
        compiler_print_stats_.SetValue(value);
    }

    bool WasSetCompilerPrintStats([[maybe_unused]] std::string_view lang = "") const {
        return compiler_print_stats_.WasSet();
    }
    const std::string &GetCompilerDumpStatsCsv([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_stats_csv_.GetValue();
    }

    void SetCompilerDumpStatsCsv(std::string value) {
        compiler_dump_stats_csv_.SetValue(std::move(value));
    }

    bool WasSetCompilerDumpStatsCsv([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_stats_csv_.WasSet();
    }
    bool IsCompilerEnableIrStats([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_ir_stats_.GetValue();
    }

    void SetCompilerEnableIrStats(bool value) {
        compiler_enable_ir_stats_.SetValue(value);
    }

    bool WasSetCompilerEnableIrStats([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_ir_stats_.WasSet();
    }
    const std::string &GetCompilerDumpJitStatsCsv([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_jit_stats_csv_.GetValue();
    }

    void SetCompilerDumpJitStatsCsv(std::string value) {
        compiler_dump_jit_stats_csv_.SetValue(std::move(value));
    }

    bool WasSetCompilerDumpJitStatsCsv([[maybe_unused]] std::string_view lang = "") const {
        return compiler_dump_jit_stats_csv_.WasSet();
    }
    bool IsCompilerUseSafepoint([[maybe_unused]] std::string_view lang = "") const {
        return compiler_use_safepoint_.GetValue();
    }

    void SetCompilerUseSafepoint(bool value) {
        compiler_use_safepoint_.SetValue(value);
    }

    bool WasSetCompilerUseSafepoint([[maybe_unused]] std::string_view lang = "") const {
        return compiler_use_safepoint_.WasSet();
    }
    bool IsCompilerDeferPreheaderTransform([[maybe_unused]] std::string_view lang = "") const {
        return compiler_defer_preheader_transform_.GetValue();
    }

    void SetCompilerDeferPreheaderTransform(bool value) {
        compiler_defer_preheader_transform_.SetValue(value);
    }

    bool WasSetCompilerDeferPreheaderTransform([[maybe_unused]] std::string_view lang = "") const {
        return compiler_defer_preheader_transform_.WasSet();
    }
    bool IsCompilerInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_.GetValue();
    }

    void SetCompilerInlining(bool value) {
        compiler_inlining_.SetValue(value);
    }

    bool WasSetCompilerInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_.WasSet();
    }
    bool IsCompilerInlineExternalMethods([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_external_methods_.GetValue();
    }

    void SetCompilerInlineExternalMethods(bool value) {
        compiler_inline_external_methods_.SetValue(value);
    }

    bool WasSetCompilerInlineExternalMethods([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_external_methods_.WasSet();
    }
    bool IsCompilerInlineExternalMethodsAot([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_external_methods_aot_.GetValue();
    }

    void SetCompilerInlineExternalMethodsAot(bool value) {
        compiler_inline_external_methods_aot_.SetValue(value);
    }

    bool WasSetCompilerInlineExternalMethodsAot([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_external_methods_aot_.WasSet();
    }
    const arg_list_t &GetCompilerInliningBlacklist([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_blacklist_.GetValue();
    }

    void SetCompilerInliningBlacklist(arg_list_t value) {
        compiler_inlining_blacklist_.SetValue(std::move(value));
    }

    bool WasSetCompilerInliningBlacklist([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_blacklist_.WasSet();
    }
    uint32_t GetCompilerInliningMaxInsts([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_insts_.GetValue();
    }

    void SetCompilerInliningMaxInsts(uint32_t value) {
        compiler_inlining_max_insts_.SetValue(value);
    }

    bool WasSetCompilerInliningMaxInsts([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_insts_.WasSet();
    }
    uint32_t GetCompilerInliningMaxDepth([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_depth_.GetValue();
    }

    void SetCompilerInliningMaxDepth(uint32_t value) {
        compiler_inlining_max_depth_.SetValue(value);
    }

    bool WasSetCompilerInliningMaxDepth([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_depth_.WasSet();
    }
    uint32_t GetCompilerInliningRecursiveCallsLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_recursive_calls_limit_.GetValue();
    }

    void SetCompilerInliningRecursiveCallsLimit(uint32_t value) {
        compiler_inlining_recursive_calls_limit_.SetValue(value);
    }

    bool WasSetCompilerInliningRecursiveCallsLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_recursive_calls_limit_.WasSet();
    }
    double GetCompilerInliningInstsBcRatio([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_insts_bc_ratio_.GetValue();
    }

    void SetCompilerInliningInstsBcRatio(double value) {
        compiler_inlining_insts_bc_ratio_.SetValue(value);
    }

    bool WasSetCompilerInliningInstsBcRatio([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_insts_bc_ratio_.WasSet();
    }
    uint32_t GetCompilerInliningMaxBcSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_bc_size_.GetValue();
    }

    void SetCompilerInliningMaxBcSize(uint32_t value) {
        compiler_inlining_max_bc_size_.SetValue(value);
    }

    bool WasSetCompilerInliningMaxBcSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_max_bc_size_.WasSet();
    }
    uint32_t GetCompilerInliningAlwaysInlineBcSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_always_inline_bc_size_.GetValue();
    }

    void SetCompilerInliningAlwaysInlineBcSize(uint32_t value) {
        compiler_inlining_always_inline_bc_size_.SetValue(value);
    }

    bool WasSetCompilerInliningAlwaysInlineBcSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_always_inline_bc_size_.WasSet();
    }
    bool IsCompilerInlineSimpleOnly([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_simple_only_.GetValue();
    }

    void SetCompilerInlineSimpleOnly(bool value) {
        compiler_inline_simple_only_.SetValue(value);
    }

    bool WasSetCompilerInlineSimpleOnly([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_simple_only_.WasSet();
    }
    bool IsCompilerInliningSkipThrowBlocks([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_skip_throw_blocks_.GetValue();
    }

    void SetCompilerInliningSkipThrowBlocks(bool value) {
        compiler_inlining_skip_throw_blocks_.SetValue(value);
    }

    bool WasSetCompilerInliningSkipThrowBlocks([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_skip_throw_blocks_.WasSet();
    }
    bool IsCompilerInliningSkipAlwaysThrowMethods([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_skip_always_throw_methods_.GetValue();
    }

    void SetCompilerInliningSkipAlwaysThrowMethods(bool value) {
        compiler_inlining_skip_always_throw_methods_.SetValue(value);
    }

    bool WasSetCompilerInliningSkipAlwaysThrowMethods([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inlining_skip_always_throw_methods_.WasSet();
    }
    bool IsCompilerNoVirtualInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_virtual_inlining_.GetValue();
    }

    void SetCompilerNoVirtualInlining(bool value) {
        compiler_no_virtual_inlining_.SetValue(value);
    }

    bool WasSetCompilerNoVirtualInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_virtual_inlining_.WasSet();
    }
    bool IsCompilerNoChaInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_cha_inlining_.GetValue();
    }

    void SetCompilerNoChaInlining(bool value) {
        compiler_no_cha_inlining_.SetValue(value);
    }

    bool WasSetCompilerNoChaInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_cha_inlining_.WasSet();
    }
    bool IsCompilerNoPicInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_pic_inlining_.GetValue();
    }

    void SetCompilerNoPicInlining(bool value) {
        compiler_no_pic_inlining_.SetValue(value);
    }

    bool WasSetCompilerNoPicInlining([[maybe_unused]] std::string_view lang = "") const {
        return compiler_no_pic_inlining_.WasSet();
    }
    bool IsCompilerResetLocalAllocator([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reset_local_allocator_.GetValue();
    }

    void SetCompilerResetLocalAllocator(bool value) {
        compiler_reset_local_allocator_.SetValue(value);
    }

    bool WasSetCompilerResetLocalAllocator([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reset_local_allocator_.WasSet();
    }
    bool IsCompilerScheduling([[maybe_unused]] std::string_view lang = "") const {
        return compiler_scheduling_.GetValue();
    }

    void SetCompilerScheduling(bool value) {
        compiler_scheduling_.SetValue(value);
    }

    bool WasSetCompilerScheduling([[maybe_unused]] std::string_view lang = "") const {
        return compiler_scheduling_.WasSet();
    }
    uint32_t GetCompilerSchedLatency([[maybe_unused]] std::string_view lang = "") const {
        return compiler_sched_latency_.GetValue();
    }

    void SetCompilerSchedLatency(uint32_t value) {
        compiler_sched_latency_.SetValue(value);
    }

    bool WasSetCompilerSchedLatency([[maybe_unused]] std::string_view lang = "") const {
        return compiler_sched_latency_.WasSet();
    }
    uint32_t GetCompilerSchedLatencyLong([[maybe_unused]] std::string_view lang = "") const {
        return compiler_sched_latency_long_.GetValue();
    }

    void SetCompilerSchedLatencyLong(uint32_t value) {
        compiler_sched_latency_long_.SetValue(value);
    }

    bool WasSetCompilerSchedLatencyLong([[maybe_unused]] std::string_view lang = "") const {
        return compiler_sched_latency_long_.WasSet();
    }
    bool IsCompilerIfConversion([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_.GetValue();
    }

    void SetCompilerIfConversion(bool value) {
        compiler_if_conversion_.SetValue(value);
    }

    bool WasSetCompilerIfConversion([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_.WasSet();
    }
    uint32_t GetCompilerIfConversionLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_limit_.GetValue();
    }

    void SetCompilerIfConversionLimit(uint32_t value) {
        compiler_if_conversion_limit_.SetValue(value);
    }

    bool WasSetCompilerIfConversionLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_limit_.WasSet();
    }
    uint32_t GetCompilerIfConversionIncraseLimitThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_incrase_limit_threshold_.GetValue();
    }

    void SetCompilerIfConversionIncraseLimitThreshold(uint32_t value) {
        compiler_if_conversion_incrase_limit_threshold_.SetValue(value);
    }

    bool WasSetCompilerIfConversionIncraseLimitThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_conversion_incrase_limit_threshold_.WasSet();
    }
    const std::string &GetCompilerCrossArch([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cross_arch_.GetValue();
    }

    void SetCompilerCrossArch(std::string value) {
        compiler_cross_arch_.SetValue(std::move(value));
    }

    bool WasSetCompilerCrossArch([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cross_arch_.WasSet();
    }
    bool IsCompilerEnableEvents([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_events_.GetValue();
    }

    void SetCompilerEnableEvents(bool value) {
        compiler_enable_events_.SetValue(value);
    }

    bool WasSetCompilerEnableEvents([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_events_.WasSet();
    }
    const std::string &GetCompilerEventsPath([[maybe_unused]] std::string_view lang = "") const {
        return compiler_events_path_.GetValue();
    }

    void SetCompilerEventsPath(std::string value) {
        compiler_events_path_.SetValue(std::move(value));
    }

    bool WasSetCompilerEventsPath([[maybe_unused]] std::string_view lang = "") const {
        return compiler_events_path_.WasSet();
    }
    bool IsCompilerSaveOnlyLiveRegisters([[maybe_unused]] std::string_view lang = "") const {
        return compiler_save_only_live_registers_.GetValue();
    }

    void SetCompilerSaveOnlyLiveRegisters(bool value) {
        compiler_save_only_live_registers_.SetValue(value);
    }

    bool WasSetCompilerSaveOnlyLiveRegisters([[maybe_unused]] std::string_view lang = "") const {
        return compiler_save_only_live_registers_.WasSet();
    }
    bool IsCompilerIgnoreFailures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_ignore_failures_.GetValue();
    }

    void SetCompilerIgnoreFailures(bool value) {
        compiler_ignore_failures_.SetValue(value);
    }

    bool WasSetCompilerIgnoreFailures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_ignore_failures_.WasSet();
    }
    bool IsCompilerAllowBackendFailures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_allow_backend_failures_.GetValue();
    }

    void SetCompilerAllowBackendFailures(bool value) {
        compiler_allow_backend_failures_.SetValue(value);
    }

    bool WasSetCompilerAllowBackendFailures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_allow_backend_failures_.WasSet();
    }
    uint32_t GetCompilerMaxGenCodeSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_gen_code_size_.GetValue();
    }

    void SetCompilerMaxGenCodeSize(uint32_t value) {
        compiler_max_gen_code_size_.SetValue(value);
    }

    bool WasSetCompilerMaxGenCodeSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_gen_code_size_.WasSet();
    }
    uint32_t GetCompilerMaxBytecodeSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_bytecode_size_.GetValue();
    }

    void SetCompilerMaxBytecodeSize(uint32_t value) {
        compiler_max_bytecode_size_.SetValue(value);
    }

    bool WasSetCompilerMaxBytecodeSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_bytecode_size_.WasSet();
    }
    uint32_t GetCompilerMaxVregsNum([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_vregs_num_.GetValue();
    }

    void SetCompilerMaxVregsNum(uint32_t value) {
        compiler_max_vregs_num_.SetValue(value);
    }

    bool WasSetCompilerMaxVregsNum([[maybe_unused]] std::string_view lang = "") const {
        return compiler_max_vregs_num_.WasSet();
    }
    bool IsCompilerCompactPrologue([[maybe_unused]] std::string_view lang = "") const {
        return compiler_compact_prologue_.GetValue();
    }

    void SetCompilerCompactPrologue(bool value) {
        compiler_compact_prologue_.SetValue(value);
    }

    bool WasSetCompilerCompactPrologue([[maybe_unused]] std::string_view lang = "") const {
        return compiler_compact_prologue_.WasSet();
    }
    bool IsCompilerJsFilterIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_js_filter_intrinsics_.GetValue();
    }

    void SetCompilerJsFilterIntrinsics(bool value) {
        compiler_js_filter_intrinsics_.SetValue(value);
    }

    bool WasSetCompilerJsFilterIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_js_filter_intrinsics_.WasSet();
    }
    bool IsCompilerRegAccAlloc([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reg_acc_alloc_.GetValue();
    }

    void SetCompilerRegAccAlloc(bool value) {
        compiler_reg_acc_alloc_.SetValue(value);
    }

    bool WasSetCompilerRegAccAlloc([[maybe_unused]] std::string_view lang = "") const {
        return compiler_reg_acc_alloc_.WasSet();
    }
    uint64_t GetCompilerRegallocRegMask([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regalloc_reg_mask_.GetValue();
    }

    void SetCompilerRegallocRegMask(uint64_t value) {
        compiler_regalloc_reg_mask_.SetValue(value);
    }

    bool WasSetCompilerRegallocRegMask([[maybe_unused]] std::string_view lang = "") const {
        return compiler_regalloc_reg_mask_.WasSet();
    }
    bool IsCompilerVerifyRegalloc([[maybe_unused]] std::string_view lang = "") const {
        return compiler_verify_regalloc_.GetValue();
    }

    void SetCompilerVerifyRegalloc(bool value) {
        compiler_verify_regalloc_.SetValue(value);
    }

    bool WasSetCompilerVerifyRegalloc([[maybe_unused]] std::string_view lang = "") const {
        return compiler_verify_regalloc_.WasSet();
    }
    bool IsCompilerSelectOptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_select_optimization_.GetValue();
    }

    void SetCompilerSelectOptimization(bool value) {
        compiler_select_optimization_.SetValue(value);
    }

    bool WasSetCompilerSelectOptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_select_optimization_.WasSet();
    }
    bool IsCompilerMoveConstants([[maybe_unused]] std::string_view lang = "") const {
        return compiler_move_constants_.GetValue();
    }

    void SetCompilerMoveConstants(bool value) {
        compiler_move_constants_.SetValue(value);
    }

    bool WasSetCompilerMoveConstants([[maybe_unused]] std::string_view lang = "") const {
        return compiler_move_constants_.WasSet();
    }
    bool IsCompilerAdjustRefs([[maybe_unused]] std::string_view lang = "") const {
        return compiler_adjust_refs_.GetValue();
    }

    void SetCompilerAdjustRefs(bool value) {
        compiler_adjust_refs_.SetValue(value);
    }

    bool WasSetCompilerAdjustRefs([[maybe_unused]] std::string_view lang = "") const {
        return compiler_adjust_refs_.WasSet();
    }
    bool IsCompilerAotLoadStringPlt([[maybe_unused]] std::string_view lang = "") const {
        return compiler_aot_load_string_plt_.GetValue();
    }

    void SetCompilerAotLoadStringPlt(bool value) {
        compiler_aot_load_string_plt_.SetValue(value);
    }

    bool WasSetCompilerAotLoadStringPlt([[maybe_unused]] std::string_view lang = "") const {
        return compiler_aot_load_string_plt_.WasSet();
    }
    bool IsCompilerRematConst([[maybe_unused]] std::string_view lang = "") const {
        return compiler_remat_const_.GetValue();
    }

    void SetCompilerRematConst(bool value) {
        compiler_remat_const_.SetValue(value);
    }

    bool WasSetCompilerRematConst([[maybe_unused]] std::string_view lang = "") const {
        return compiler_remat_const_.WasSet();
    }
    uint32_t GetCompilerUnfoldConstArrayMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unfold_const_array_max_size_.GetValue();
    }

    void SetCompilerUnfoldConstArrayMaxSize(uint32_t value) {
        compiler_unfold_const_array_max_size_.SetValue(value);
    }

    bool WasSetCompilerUnfoldConstArrayMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_unfold_const_array_max_size_.WasSet();
    }
    bool IsCompilerSpillFillPair([[maybe_unused]] std::string_view lang = "") const {
        return compiler_spill_fill_pair_.GetValue();
    }

    void SetCompilerSpillFillPair(bool value) {
        compiler_spill_fill_pair_.SetValue(value);
    }

    bool WasSetCompilerSpillFillPair([[maybe_unused]] std::string_view lang = "") const {
        return compiler_spill_fill_pair_.WasSet();
    }
    const std::string &GetCompilerFrameSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_frame_size_.GetValue();
    }

    void SetCompilerFrameSize(std::string value) {
        compiler_frame_size_.SetValue(std::move(value));
    }

    bool WasSetCompilerFrameSize([[maybe_unused]] std::string_view lang = "") const {
        return compiler_frame_size_.WasSet();
    }
    const arg_list_t &GetCompilerCpuFeatures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cpu_features_.GetValue();
    }

    void SetCompilerCpuFeatures(arg_list_t value) {
        compiler_cpu_features_.SetValue(std::move(value));
    }

    bool WasSetCompilerCpuFeatures([[maybe_unused]] std::string_view lang = "") const {
        return compiler_cpu_features_.WasSet();
    }
    bool IsCompilerEmitDebugInfo([[maybe_unused]] std::string_view lang = "") const {
        return compiler_emit_debug_info_.GetValue();
    }

    void SetCompilerEmitDebugInfo(bool value) {
        compiler_emit_debug_info_.SetValue(value);
    }

    bool WasSetCompilerEmitDebugInfo([[maybe_unused]] std::string_view lang = "") const {
        return compiler_emit_debug_info_.WasSet();
    }
    bool IsCompilerAotRa([[maybe_unused]] std::string_view lang = "") const {
        return compiler_aot_ra_.GetValue();
    }

    void SetCompilerAotRa(bool value) {
        compiler_aot_ra_.SetValue(value);
    }

    bool WasSetCompilerAotRa([[maybe_unused]] std::string_view lang = "") const {
        return compiler_aot_ra_.WasSet();
    }
    bool IsCompilerFreqBasedBranchReorder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_freq_based_branch_reorder_.GetValue();
    }

    void SetCompilerFreqBasedBranchReorder(bool value) {
        compiler_freq_based_branch_reorder_.SetValue(value);
    }

    bool WasSetCompilerFreqBasedBranchReorder([[maybe_unused]] std::string_view lang = "") const {
        return compiler_freq_based_branch_reorder_.WasSet();
    }
    uint32_t GetCompilerFreqBasedBranchReorderThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_freq_based_branch_reorder_threshold_.GetValue();
    }

    void SetCompilerFreqBasedBranchReorderThreshold(uint32_t value) {
        compiler_freq_based_branch_reorder_threshold_.SetValue(value);
    }

    bool WasSetCompilerFreqBasedBranchReorderThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_freq_based_branch_reorder_threshold_.WasSet();
    }
    bool IsCompilerInlineFullIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_full_intrinsics_.GetValue();
    }

    void SetCompilerInlineFullIntrinsics(bool value) {
        compiler_inline_full_intrinsics_.SetValue(value);
    }

    bool WasSetCompilerInlineFullIntrinsics([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inline_full_intrinsics_.WasSet();
    }
    bool IsCompilerSafePointsRequireRegMap([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safe_points_require_reg_map_.GetValue();
    }

    void SetCompilerSafePointsRequireRegMap(bool value) {
        compiler_safe_points_require_reg_map_.SetValue(value);
    }

    bool WasSetCompilerSafePointsRequireRegMap([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safe_points_require_reg_map_.WasSet();
    }
    bool IsCompilerScalarReplacement([[maybe_unused]] std::string_view lang = "") const {
        return compiler_scalar_replacement_.GetValue();
    }

    void SetCompilerScalarReplacement(bool value) {
        compiler_scalar_replacement_.SetValue(value);
    }

    bool WasSetCompilerScalarReplacement([[maybe_unused]] std::string_view lang = "") const {
        return compiler_scalar_replacement_.WasSet();
    }
    bool IsCompilerPeepholes([[maybe_unused]] std::string_view lang = "") const {
        return compiler_peepholes_.GetValue();
    }

    void SetCompilerPeepholes(bool value) {
        compiler_peepholes_.SetValue(value);
    }

    bool WasSetCompilerPeepholes([[maybe_unused]] std::string_view lang = "") const {
        return compiler_peepholes_.WasSet();
    }
    bool IsCompilerIfMerging([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_merging_.GetValue();
    }

    void SetCompilerIfMerging(bool value) {
        compiler_if_merging_.SetValue(value);
    }

    bool WasSetCompilerIfMerging([[maybe_unused]] std::string_view lang = "") const {
        return compiler_if_merging_.WasSet();
    }
    bool IsCompilerRedundantLoopElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_redundant_loop_elimination_.GetValue();
    }

    void SetCompilerRedundantLoopElimination(bool value) {
        compiler_redundant_loop_elimination_.SetValue(value);
    }

    bool WasSetCompilerRedundantLoopElimination([[maybe_unused]] std::string_view lang = "") const {
        return compiler_redundant_loop_elimination_.WasSet();
    }
    bool IsCompilerOptimizeMemoryBarriers([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_memory_barriers_.GetValue();
    }

    void SetCompilerOptimizeMemoryBarriers(bool value) {
        compiler_optimize_memory_barriers_.SetValue(value);
    }

    bool WasSetCompilerOptimizeMemoryBarriers([[maybe_unused]] std::string_view lang = "") const {
        return compiler_optimize_memory_barriers_.WasSet();
    }
    bool IsCompilerStringFlatCheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_string_flat_check_.GetValue();
    }

    void SetCompilerStringFlatCheck(bool value) {
        compiler_string_flat_check_.SetValue(value);
    }

    bool WasSetCompilerStringFlatCheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_string_flat_check_.WasSet();
    }
    const std::string &GetCompilerProfile([[maybe_unused]] std::string_view lang = "") const {
        return compiler_profile_.GetValue();
    }

    void SetCompilerProfile(std::string value) {
        compiler_profile_.SetValue(std::move(value));
    }

    bool WasSetCompilerProfile([[maybe_unused]] std::string_view lang = "") const {
        return compiler_profile_.WasSet();
    }
    bool IsCompilerForceUnresolved([[maybe_unused]] std::string_view lang = "") const {
        return compiler_force_unresolved_.GetValue();
    }

    void SetCompilerForceUnresolved(bool value) {
        compiler_force_unresolved_.SetValue(value);
    }

    bool WasSetCompilerForceUnresolved([[maybe_unused]] std::string_view lang = "") const {
        return compiler_force_unresolved_.WasSet();
    }
    bool IsCompilerEnableFastInterop([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_fast_interop_.GetValue();
    }

    void SetCompilerEnableFastInterop(bool value) {
        compiler_enable_fast_interop_.SetValue(value);
    }

    bool WasSetCompilerEnableFastInterop([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_fast_interop_.WasSet();
    }
    bool IsCompilerInteropIntrinsicOptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_intrinsic_optimization_.GetValue();
    }

    void SetCompilerInteropIntrinsicOptimization(bool value) {
        compiler_interop_intrinsic_optimization_.SetValue(value);
    }

    bool WasSetCompilerInteropIntrinsicOptimization([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_intrinsic_optimization_.WasSet();
    }
    uint32_t GetCompilerInteropScopeObjectLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_scope_object_limit_.GetValue();
    }

    void SetCompilerInteropScopeObjectLimit(uint32_t value) {
        compiler_interop_scope_object_limit_.SetValue(value);
    }

    bool WasSetCompilerInteropScopeObjectLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_scope_object_limit_.WasSet();
    }
    bool IsCompilerInteropTrySingleScope([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_try_single_scope_.GetValue();
    }

    void SetCompilerInteropTrySingleScope(bool value) {
        compiler_interop_try_single_scope_.SetValue(value);
    }

    bool WasSetCompilerInteropTrySingleScope([[maybe_unused]] std::string_view lang = "") const {
        return compiler_interop_try_single_scope_.WasSet();
    }
    uint32_t GetCompilerInstGraphColoringLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inst_graph_coloring_limit_.GetValue();
    }

    void SetCompilerInstGraphColoringLimit(uint32_t value) {
        compiler_inst_graph_coloring_limit_.SetValue(value);
    }

    bool WasSetCompilerInstGraphColoringLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_inst_graph_coloring_limit_.WasSet();
    }
    bool IsCompilerEnforceSafepointPlacement([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enforce_safepoint_placement_.GetValue();
    }

    void SetCompilerEnforceSafepointPlacement(bool value) {
        compiler_enforce_safepoint_placement_.SetValue(value);
    }

    bool WasSetCompilerEnforceSafepointPlacement([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enforce_safepoint_placement_.WasSet();
    }
    uint32_t GetCompilerSafepointDistanceLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safepoint_distance_limit_.GetValue();
    }

    void SetCompilerSafepointDistanceLimit(uint32_t value) {
        compiler_safepoint_distance_limit_.SetValue(value);
    }

    bool WasSetCompilerSafepointDistanceLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_safepoint_distance_limit_.WasSet();
    }
// NOLINTNEXTLINE(readability-function-size)
    std::optional<Error> Validate() const {
        {
            std::unordered_set<std::string> possible_values{R"(none)", R"(all)", R"(alias-analysis)", R"(balance-expr)", R"(branch-elim)", R"(checks-elim)", R"(codegen)", R"(code-sink)", R"(cse-opt)", R"(graph-cloner)", R"(deoptimize-elim)", R"(cleanup)", R"(if-merging)", R"(ifconversion)", R"(inlining)", R"(ir-builder)", R"(licm-opt)", R"(licm-cond-opt)", R"(loop-unswitch)", R"(liveness-analyzer)", R"(loop-transform)", R"(lowering)", R"(lower-boxed-boolean)", R"(lse-opt)", R"(memory-coalescing)", R"(monitor-analysis)", R"(optimize-string-concat)", R"(peephole)", R"(rle-opt)", R"(regalloc)", R"(select-opt)", R"(split-resolver)", R"(scheduler)", R"(simplify-sb)", R"(reserve-sb-buffer)", R"(savestate-opt)", R"(try-catch-resolving)", R"(type-propagation)", R"(vn-opt)", R"(bridges-ss)", R"(pm)", R"(pea)", R"(pea_ext)", R"(interop-intrinsic-opt)", R"(native-call-opt)"};
            const auto &values = compiler_log_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-log: invalid value: '" + value + \
                                 R"('. Possible values: ["none", "all", "alias-analysis", "balance-expr", "branch-elim", "checks-elim", "codegen", "code-sink", "cse-opt", "graph-cloner", "deoptimize-elim", "cleanup", "if-merging", "ifconversion", "inlining", "ir-builder", "licm-opt", "licm-cond-opt", "loop-unswitch", "liveness-analyzer", "loop-transform", "lowering", "lower-boxed-boolean", "lse-opt", "memory-coalescing", "monitor-analysis", "optimize-string-concat", "peephole", "rle-opt", "regalloc", "select-opt", "split-resolver", "scheduler", "simplify-sb", "reserve-sb-buffer", "savestate-opt", "try-catch-resolving", "type-propagation", "vn-opt", "bridges-ss", "pm", "pea", "pea_ext", "interop-intrinsic-opt", "native-call-opt"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(arm)", R"(arm64)", R"(x86)", R"(x86_64)"};
            std::vector<std::string> values{compiler_cross_arch_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-cross-arch: invalid value: '" + value + \
                                 R"('. Possible values: ["arm", "arm64", "x86", "x86_64"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(default)", R"(large)"};
            std::vector<std::string> values{compiler_frame_size_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-frame-size: invalid value: '" + value + \
                                 R"('. Possible values: ["default", "large"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(none)", R"(crc32)", R"(sse42)", R"(jscvt)", R"(atomics)"};
            const auto &values = compiler_cpu_features_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-cpu-features: invalid value: '" + value + \
                                 R"('. Possible values: ["none", "crc32", "sse42", "jscvt", "atomics"])");
                }
            }
        }
        return {};
    }

private:

    static std::string GetExeDir(const std::string &exe_path) {
#ifdef PANDA_TARGET_WINDOWS
        const char preferred_separator = '\\';
#else
        const char preferred_separator = '/';
#endif
        auto pos = exe_path.find_last_of(preferred_separator);
        if (pos == std::string::npos) {
            return ".";
        }
        return exe_path.substr(0, pos);
    }

    static constexpr uint64_t COMPILER_SAFEPOINT_ELIMINATION_LIMIT_DEFAULT = 50;

    static constexpr uint32_t COMPILER_LICM_HOIST_LIMIT_DEFAULT = 200;

    static constexpr uint32_t COMPILER_LOOP_UNSWITCH_MAX_LEVEL_DEFAULT = 3;

    static constexpr uint32_t COMPILER_LOOP_UNSWITCH_MAX_INSTS_DEFAULT = 100;

    static constexpr uint32_t COMPILER_LOOP_UNROLL_FACTOR_DEFAULT = 6;

    static constexpr uint32_t COMPILER_LOOP_UNROLL_INST_LIMIT_DEFAULT = 100;

    static constexpr uint32_t COMPILER_INLINING_MAX_INSTS_DEFAULT = 512;

    static constexpr uint32_t COMPILER_INLINING_MAX_DEPTH_DEFAULT = 12;

    static constexpr uint32_t COMPILER_INLINING_RECURSIVE_CALLS_LIMIT_DEFAULT = 4;

    static constexpr double COMPILER_INLINING_INSTS_BC_RATIO_DEFAULT = 0.4;

    static constexpr uint32_t COMPILER_INLINING_MAX_BC_SIZE_DEFAULT = 200;

    static constexpr uint32_t COMPILER_INLINING_ALWAYS_INLINE_BC_SIZE_DEFAULT = 12;

    static constexpr uint32_t COMPILER_SCHED_LATENCY_DEFAULT = 2;

    static constexpr uint32_t COMPILER_SCHED_LATENCY_LONG_DEFAULT = 7;

    static constexpr uint32_t COMPILER_IF_CONVERSION_LIMIT_DEFAULT = 2;

    static constexpr uint32_t COMPILER_IF_CONVERSION_INCRASE_LIMIT_THRESHOLD_DEFAULT = 40;

    static constexpr uint32_t COMPILER_MAX_GEN_CODE_SIZE_DEFAULT = 66060288;

    static constexpr uint32_t COMPILER_MAX_BYTECODE_SIZE_DEFAULT = 30000;

    static constexpr uint32_t COMPILER_MAX_VREGS_NUM_DEFAULT = 8188;

    static constexpr uint64_t COMPILER_REGALLOC_REG_MASK_DEFAULT = 0;

    static constexpr uint32_t COMPILER_UNFOLD_CONST_ARRAY_MAX_SIZE_DEFAULT = 20;

    static constexpr uint32_t COMPILER_FREQ_BASED_BRANCH_REORDER_THRESHOLD_DEFAULT = 80;

    static constexpr uint32_t COMPILER_INTEROP_SCOPE_OBJECT_LIMIT_DEFAULT = 256;

    static constexpr uint32_t COMPILER_INST_GRAPH_COLORING_LIMIT_DEFAULT = 5000;

    static constexpr uint32_t COMPILER_SAFEPOINT_DISTANCE_LIMIT_DEFAULT = 50;

    std::string exe_dir_;
    PandArg<bool> compiler_non_optimizing_{"compiler-non-optimizing", false, R"(Skip all optimizations. Default: false)"};
    PandArg<std::string> compiler_regex_{"compiler-regex", R"(.*)", R"(A regular expression that specifies methods to compile (ECMA-262 grammar). A method matches if its qualified name (e.g. 'Foo::bar') is fully matched.
. Default: ".*")"};
    PandArg<std::string> compiler_regex_with_signature_{"compiler-regex-with-signature", R"(.*)", R"(A regular expression that specifies methods to compile (ECMA-262 grammar). A method matches if its full signature (e.g. 'void Foo::bar(i32)') is fully matched.
. Default: ".*")"};
    PandArg<bool> compiler_visualizer_dump_{"compiler-visualizer-dump", false, R"(Enable visualizer dump ir. Default: false)"};
    PandArg<bool> compiler_dump_final_{"final", false, R"(Dump ir only after last (codegen) pass. Default: false)"};
    PandArg<bool> compiler_dump_compact_{"compact", false, R"(Suppress dumping of some data (bc, SaveState instructions, etc). Default: false)"};
    PandArg<bool> compiler_dump_no_checks_{"no-checks", false, R"(Dump data-flow inputs instead of check instructions. Default: false)"};
    PandArg<bool> compiler_dump_life_intervals_{"life-intervals", false, R"(Dump life intervals from regalloc. Default: false)"};
    PandArg<std::string> compiler_dump_folder_{"folder", R"(./ir_dump)", R"(Set folder for dump ir. Default: "./ir_dump")"};
    PandArg<bool> compiler_dump_bytecode_{"bytecode", false, R"(Enable printing byte code instruction after ir instruction in dump ir. Default: false)"};
    PandArg<bool> compiler_dump_peepholes_{"peepholes", false, R"(Enable dumps each time peephole applies. Default: false)"};
    PandArg<bool> compiler_dump_source_line_{"source-line", false, R"(Dump source line after instruction. Default: false)"};
    PandArgCompound compiler_dump_{"compiler-dump", R"(Enable dump ir. Default: "false")", {&compiler_dump_final_, &compiler_dump_compact_, &compiler_dump_no_checks_, &compiler_dump_life_intervals_, &compiler_dump_folder_, &compiler_dump_bytecode_, &compiler_dump_peepholes_, &compiler_dump_source_line_}};
    PandArg<bool> compiler_disasm_dump_single_file_{"single-file", false, R"(Dump disasm files into single file, which is "disasm.txt". Default: false)"};
    PandArg<bool> compiler_disasm_dump_stdout_{"stdout", false, R"(Dump to the standard output. Default: false)"};
    PandArg<bool> compiler_disasm_dump_code_{"code", true, R"(Dump generated assembly code. Default is true. Default: true)"};
    PandArg<bool> compiler_disasm_dump_code_info_{"code-info", false, R"(Dump code info. Default: false)"};
    PandArg<std::string> compiler_disasm_dump_file_name_{"file-name", R"(disasm.txt)", R"(File name to dump. Used only when 'single-file' is set. Default: "disasm.txt")"};
    PandArgCompound compiler_disasm_dump_{"compiler-disasm-dump", R"(Enable dump disasm to text files. Default: "false")", {&compiler_disasm_dump_single_file_, &compiler_disasm_dump_stdout_, &compiler_disasm_dump_code_, &compiler_disasm_dump_code_info_, &compiler_disasm_dump_file_name_}};
    PandArg<bool> compiler_emit_asm_{"compiler-emit-asm", false, R"(Enable dump assembly to disasm.txt file (do not emit binary). Default: false)"};
    PandArg<bool> compiler_enable_tracing_{"compiler-enable-tracing", false, R"(Enable tracing for passes. Default: false)"};
    PandArg<bool> compiler_enable_tlab_events_{"compiler-enable-tlab-events", false, R"(Enable events for tlab allocation. Default: false)"};
    PandArg<bool> compiler_support_init_object_inst_{"compiler-support-init-object-inst", false, R"(Compiler don't create InitObject  and GraphChecker checks this. The options are needed for bytecode optimizer. Default: false)"};
    PandArg<arg_list_t> compiler_log_{"compiler-log", {R"(none)"}, R"(Set log compiler components. Possible values: ["none", "all", "alias-analysis", "balance-expr", "branch-elim", "checks-elim", "codegen", "code-sink", "cse-opt", "graph-cloner", "deoptimize-elim", "cleanup", "if-merging", "ifconversion", "inlining", "ir-builder", "licm-opt", "licm-cond-opt", "loop-unswitch", "liveness-analyzer", "loop-transform", "lowering", "lower-boxed-boolean", "lse-opt", "memory-coalescing", "monitor-analysis", "optimize-string-concat", "peephole", "rle-opt", "regalloc", "select-opt", "split-resolver", "scheduler", "simplify-sb", "reserve-sb-buffer", "savestate-opt", "try-catch-resolving", "type-propagation", "vn-opt", "bridges-ss", "pm", "pea", "pea_ext", "interop-intrinsic-opt", "native-call-opt"]. Default: ["none"])", ","};
    PandArg<bool> compiler_check_graph_{"compiler-check-graph", true, R"(Enable Graph checking after each optimization. Default: true)"};
    PandArg<bool> compiler_check_final_{"compiler-check-final", false, R"(Enable Graph checking only after last optimization(Codegen). Default: false)"};
    PandArg<bool> compiler_encode_intrinsics_{"compiler-encode-intrinsics", true, R"(If false, we always call C implementation of an intrinsic. Default: true)"};
    PandArg<bool> compiler_lowering_{"compiler-lowering", true, R"(Enable Lowering Pass. Default: true)"};
    PandArg<bool> compiler_lower_boxed_boolean_{"compiler-lower-boxed-boolean", true, R"(Enable LowerBoxedBoolean Pass. Default: true)"};
    PandArg<bool> compiler_code_sink_{"compiler-code-sink", true, R"(Enable Code Sink Pass. Default: true)"};
    PandArg<bool> compiler_balance_expressions_{"compiler-balance-expressions", true, R"(Enable Balance Expressions Pass. Default: true)"};
    PandArg<bool> compiler_branch_elimination_{"compiler-branch-elimination", true, R"(Enable Branch Elimination Pass. Default: true)"};
    PandArg<bool> compiler_optimize_string_concat_{"compiler-optimize-string-concat", true, R"(Enable Optimize String.concat Pass. Default: true)"};
    PandArg<bool> compiler_simplify_string_builder_{"compiler-simplify-string-builder", true, R"(Enable Simplify StringBuilder Pass. Default: true)"};
    PandArg<bool> compiler_reserve_string_builder_buffer_{"compiler-reserve-string-builder-buffer", true, R"(Enable Reserve StringBuilder Buffer Pass. Default: true)"};
    PandArg<bool> compiler_checks_elimination_{"compiler-checks-elimination", true, R"(Enable Checks Elimination Pass. Default: true)"};
    PandArg<bool> compiler_enable_replacing_checks_on_deoptimization_{"compiler-enable-replacing-checks-on-deoptimization", true, R"(Enable replacing checks on deoptimization in checks elimination. Default: true)"};
    PandArg<bool> compiler_deoptimize_elimination_{"compiler-deoptimize-elimination", true, R"(Enable Deoptimize Elimination Pass. Default: true)"};
    PandArg<bool> compiler_save_state_elimination_{"compiler-save-state-elimination", true, R"(Enable SaveState Elimination Pass. Default: true)"};
    PandArg<uint64_t> compiler_safepoint_elimination_limit_{"compiler-safepoint-elimination-limit", COMPILER_SAFEPOINT_ELIMINATION_LIMIT_DEFAULT, R"(Set the instructions limit in deoptimize elimination for removing safe points. Default: 50)"};
    PandArg<bool> compiler_implicit_null_check_{"compiler-implicit-null-check", true, R"(Apply Implicit Null Check. Default: true)"};
    PandArg<bool> compiler_licm_{"compiler-licm", true, R"(Enable LICM Pass. Default: true)"};
    PandArg<uint32_t> compiler_licm_hoist_limit_{"compiler-licm-hoist-limit", COMPILER_LICM_HOIST_LIMIT_DEFAULT, R"(Set the instructions limit which are hoisted by LICM. Default: 200)"};
    PandArg<bool> compiler_licm_conditions_{"compiler-licm-conditions", true, R"(Enable LICM conditions Pass. Default: true)"};
    PandArg<bool> compiler_loop_unswitch_{"compiler-loop-unswitch", true, R"(Enable Loop unswitch Pass. Default: true)"};
    PandArg<uint32_t> compiler_loop_unswitch_max_level_{"compiler-loop-unswitch-max-level", COMPILER_LOOP_UNSWITCH_MAX_LEVEL_DEFAULT, R"(Max loop unswitch level. Default: 3)"};
    PandArg<uint32_t> compiler_loop_unswitch_max_insts_{"compiler-loop-unswitch-max-insts", COMPILER_LOOP_UNSWITCH_MAX_INSTS_DEFAULT, R"(Max loop unswitch instructions. Default: 100)"};
    PandArg<bool> compiler_loop_idioms_{"compiler-loop-idioms", true, R"(Enable Loop idioms Pass. Default: true)"};
    PandArg<bool> compiler_loop_peeling_{"compiler-loop-peeling", true, R"(Enable Loop peeling Pass. Default: true)"};
    PandArg<bool> compiler_loop_unroll_{"compiler-loop-unroll", true, R"(Enable Loop unroll Pass. Default: true)"};
    PandArg<uint32_t> compiler_loop_unroll_factor_{"compiler-loop-unroll-factor", COMPILER_LOOP_UNROLL_FACTOR_DEFAULT, R"(Set loop unrolling factor. Default: 6)"};
    PandArg<uint32_t> compiler_loop_unroll_inst_limit_{"compiler-loop-unroll-inst-limit", COMPILER_LOOP_UNROLL_INST_LIMIT_DEFAULT, R"(Set the instructions limit for the unrolling loop body. Default: 100)"};
    PandArg<bool> compiler_unroll_loop_with_calls_{"compiler-unroll-loop-with-calls", false, R"(Enable unroll for loops containing method calls. Default: false)"};
    PandArg<bool> compiler_unroll_with_side_exits_{"compiler-unroll-with-side-exits", true, R"(Enable unroll with side exits for not countable loop. Default: true)"};
    PandArg<bool> compiler_unroll_unknown_trip_count_{"compiler-unroll-unknown-trip-count", true, R"(Enable unroll for loops for which trip count is not known in advance. Default: true)"};
    PandArg<bool> compiler_lse_{"compiler-lse", true, R"(Enable Load-Store Elimination Pass. Default: true)"};
    PandArg<bool> compiler_cse_{"compiler-cse", false, R"(Enable CSE Pass. Default: false)"};
    PandArg<bool> compiler_vn_{"compiler-vn", true, R"(Enable Value Numbering Pass. Default: true)"};
    PandArg<bool> compiler_memory_coalescing_{"compiler-memory-coalescing", true, R"(Enable Memory Coalescing Pass. Default: true)"};
    PandArg<bool> compiler_memory_coalescing_objects_{"compiler-memory-coalescing-objects", true, R"(Apply Memory Coalescing to objects accesses. Default: true)"};
    PandArg<bool> compiler_memory_coalescing_aligned_{"compiler-memory-coalescing-aligned", false, R"(Apply Memory Coalescing only to aligned accesses. Default: false)"};
    PandArg<bool> compiler_optimize_native_calls_{"compiler-optimize-native-calls", true, R"(Optimize Native API methods (insert call without asm bridge). Default: true)"};
    PandArg<bool> compiler_print_stats_{"compiler-print-stats", false, R"(Print optimizations statistics. Default: false)"};
    PandArg<std::string> compiler_dump_stats_csv_{"compiler-dump-stats-csv", R"()", R"(Dump optimizations statistics in csv file. Default: "")"};
    PandArg<bool> compiler_enable_ir_stats_{"compiler-enable-ir-stats", false, R"(Enable collecting ir stats on compiler statistic. Default: false)"};
    PandArg<std::string> compiler_dump_jit_stats_csv_{"compiler-dump-jit-stats-csv", R"()", R"(Dump JIT compilation statistics in csv file. Default: "")"};
    PandArg<bool> compiler_use_safepoint_{"compiler-use-safepoint", true, R"(Build SafePoint instructions. Default: true)"};
    PandArg<bool> compiler_defer_preheader_transform_{"compiler-defer-preheader-transform", true, R"(Defer processing of loop preheader in peepholer and branch elimination until past unrolling. Default: true)"};
    PandArg<bool> compiler_inlining_{"compiler-inlining", true, R"(Enable inlining optimization. Default: true)"};
    PandArg<bool> compiler_inline_external_methods_{"compiler-inline-external-methods", true, R"(Enable inlining external methods in JIT mode. Default: true)"};
    PandArg<bool> compiler_inline_external_methods_aot_{"compiler-inline-external-methods-aot", true, R"(Enable inlining external methods in AOT mode. Default: true)"};
    PandArg<arg_list_t> compiler_inlining_blacklist_{"compiler-inlining-blacklist", {}, R"(Method names that should not be inlined. Default: [])", ","};
    PandArg<uint32_t> compiler_inlining_max_insts_{"compiler-inlining-max-insts", COMPILER_INLINING_MAX_INSTS_DEFAULT, R"(Maximum number of the IR instructions to be inlined, including instructions of the current graph. Default: 512)"};
    PandArg<uint32_t> compiler_inlining_max_depth_{"compiler-inlining-max-depth", COMPILER_INLINING_MAX_DEPTH_DEFAULT, R"(Maximum depth of the inlining. Default: 12)"};
    PandArg<uint32_t> compiler_inlining_recursive_calls_limit_{"compiler-inlining-recursive-calls-limit", COMPILER_INLINING_RECURSIVE_CALLS_LIMIT_DEFAULT, R"(Maximum count of recursive calls in inlined call stack. Default: 4)"};
    PandArg<double> compiler_inlining_insts_bc_ratio_{"compiler-inlining-insts-bc-ratio", COMPILER_INLINING_INSTS_BC_RATIO_DEFAULT, R"(Ratio of IR insts count to 1 byte of bytecode. Used for inlining heuristic. Default: 0.4)"};
    PandArg<uint32_t> compiler_inlining_max_bc_size_{"compiler-inlining-max-bc-size", COMPILER_INLINING_MAX_BC_SIZE_DEFAULT, R"(Maximum bytecode size for inlined functions, in bytes. Average bytecode instruction size is 2.8 bytes. Default: 200)"};
    PandArg<uint32_t> compiler_inlining_always_inline_bc_size_{"compiler-inlining-always-inline-bc-size", COMPILER_INLINING_ALWAYS_INLINE_BC_SIZE_DEFAULT, R"(Always inline methods with bytecode size less or equal than this limit. Default: 12)"};
    PandArg<bool> compiler_inline_simple_only_{"compiler-inline-simple-only", false, R"(Inline only simple methods that don't contain calls to runtime. Default: false)"};
    PandArg<bool> compiler_inlining_skip_throw_blocks_{"compiler-inlining-skip-throw-blocks", true, R"(Don't inline methods inside blocks throwing an exception or performing deoptimization. Default: true)"};
    PandArg<bool> compiler_inlining_skip_always_throw_methods_{"compiler-inlining-skip-always-throw-methods", true, R"(Don't inline methods that always throw an exception. Default: true)"};
    PandArg<bool> compiler_no_virtual_inlining_{"compiler-no-virtual-inlining", false, R"(Disable inlining of the virtual calls. Default: false)"};
    PandArg<bool> compiler_no_cha_inlining_{"compiler-no-cha-inlining", false, R"(Don't use CHA in the inlining. Default: false)"};
    PandArg<bool> compiler_no_pic_inlining_{"compiler-no-pic-inlining", false, R"(Don't use Polymorphic Inline Caches in the inlining. Default: false)"};
    PandArg<bool> compiler_reset_local_allocator_{"compiler-reset-local-allocator", true, R"(Reset local allocator between passes runs. Default: true)"};
    PandArg<bool> compiler_scheduling_{"compiler-scheduling", true, R"(Enable Scheduling Pass. Default: true)"};
    PandArg<uint32_t> compiler_sched_latency_{"compiler-sched-latency", COMPILER_SCHED_LATENCY_DEFAULT, R"(Set default instruction latency. Default: 2)"};
    PandArg<uint32_t> compiler_sched_latency_long_{"compiler-sched-latency-long", COMPILER_SCHED_LATENCY_LONG_DEFAULT, R"(Set loads latency. Default: 7)"};
    PandArg<bool> compiler_if_conversion_{"compiler-if-conversion", true, R"(Enable IfConversion Pass. Default: true)"};
    PandArg<uint32_t> compiler_if_conversion_limit_{"compiler-if-conversion-limit", COMPILER_IF_CONVERSION_LIMIT_DEFAULT, R"(Maximum amount of instructions in basicblock(s) for if-conversion. Default: 2)"};
    PandArg<uint32_t> compiler_if_conversion_incrase_limit_threshold_{"compiler-if-conversion-incrase-limit-threshold", COMPILER_IF_CONVERSION_INCRASE_LIMIT_THRESHOLD_DEFAULT, R"(If the execution of each of the edge branch is greater than threshold in percents, then the limit increases. Default: 40)"};
    PandArg<std::string> compiler_cross_arch_{"compiler-cross-arch", R"(arm64)", R"(On AMD64 enable creation of non-native code for testing purpose. Possible values: ["arm", "arm64", "x86", "x86_64"]. Default: "arm64")"};
    PandArg<bool> compiler_enable_events_{"compiler-enable-events", false, R"(Enable optimizations events dump. Default: false)"};
    PandArg<std::string> compiler_events_path_{"compiler-events-path", R"(./compiler/events.csv)", R"(Set path for optimizations events dump. Default: "./compiler/events.csv")"};
    PandArg<bool> compiler_save_only_live_registers_{"compiler-save-only-live-registers", true, R"(Save and Load only registers that contains live values when making calls. Default: true)"};
    PandArg<bool> compiler_ignore_failures_{"compiler-ignore-failures", true, R"(Ignore failures occurred during compilation. Default: true)"};
    PandArg<bool> compiler_allow_backend_failures_{"compiler-allow-backend-failures", true, R"(Ignore failures occurred during register allocation and code generation. Default: true)"};
    PandArg<uint32_t> compiler_max_gen_code_size_{"compiler-max-gen-code-size", COMPILER_MAX_GEN_CODE_SIZE_DEFAULT, R"(Maximum size of the generated code in code-cache, default 63 M. Default: 66060288)"};
    PandArg<uint32_t> compiler_max_bytecode_size_{"compiler-max-bytecode-size", COMPILER_MAX_BYTECODE_SIZE_DEFAULT, R"(Maximum size of the method's code to be compiled. Default: 30000)"};
    PandArg<uint32_t> compiler_max_vregs_num_{"compiler-max-vregs-num", COMPILER_MAX_VREGS_NUM_DEFAULT, R"(Maximum number of virtual registers in a method. Can't be more than 32764. Default: 8188)"};
    PandArg<bool> compiler_compact_prologue_{"compiler-compact-prologue", true, R"(Omit unused callee-registers save/restore in prologue/epilogue when possible. Default: true)"};
    PandArg<bool> compiler_js_filter_intrinsics_{"compiler-js-filter-intrinsics", true, R"(Enable intrinsics filter in JS Compiler. Default: true)"};
    PandArg<bool> compiler_reg_acc_alloc_{"compiler-reg-acc-alloc", true, R"(Enable accumulator register allocator pass. Default: true)"};
    PandArg<uint64_t> compiler_regalloc_reg_mask_{"compiler-regalloc-reg-mask", COMPILER_REGALLOC_REG_MASK_DEFAULT, R"(Mask of registers, avaliable for regalloc. Default: 0)"};
    PandArg<bool> compiler_verify_regalloc_{"compiler-verify-regalloc", true, R"(Verify register allocation results in debug mode. Default: true)"};
    PandArg<bool> compiler_select_optimization_{"compiler-select-optimization", true, R"(Enable Select instructions optimization pass. Default: true)"};
    PandArg<bool> compiler_move_constants_{"compiler-move-constants", true, R"(Enable move constants from start block closer to usage. Default: true)"};
    PandArg<bool> compiler_adjust_refs_{"compiler-adjust-refs", true, R"(Enable hoisting of array data address. Default: true)"};
    PandArg<bool> compiler_aot_load_string_plt_{"compiler-aot-load-string-plt", true, R"(Replace unconditional ResolveString runtime call with loading string reference from PLT slot for AOT. Default: true)"};
    PandArg<bool> compiler_remat_const_{"compiler-remat-const", true, R"(Rematerialize constants instead of spilling them to the stack. Default: true)"};
    PandArg<uint32_t> compiler_unfold_const_array_max_size_{"compiler-unfold-const-array-max-size", COMPILER_UNFOLD_CONST_ARRAY_MAX_SIZE_DEFAULT, R"(Set the maximum size of the constant array to unfold a single LoadConstArray instruction to the initial instructions set. Default: 20)"};
    PandArg<bool> compiler_spill_fill_pair_{"compiler-spill-fill-pair", true, R"(Store and load values from successive stack slots as pair of values during SpillFill encoding. Default: true)"};
    PandArg<std::string> compiler_frame_size_{"compiler-frame-size", R"(default)", R"(Set virtual frame size. Large frame size is used for AbcKit tool. Default is used for other cases. Possible values: ["default", "large"]. Default: "default")"};
    PandArg<arg_list_t> compiler_cpu_features_{"compiler-cpu-features", {R"(sse42)"}, R"(Set compiler CPU features. Possible values: ["none", "crc32", "sse42", "jscvt", "atomics"]. Default: ["sse42"])", ","};
    PandArg<bool> compiler_emit_debug_info_{"compiler-emit-debug-info", false, R"(Emit DWARF debug info for JIT/AOT code, PANDA_COMPILER_DEBUG_INFO should be set. Default: false)"};
    PandArg<bool> compiler_aot_ra_{"compiler-aot-ra", true, R"(Enable AOT register allocation. Default: true)"};
    PandArg<bool> compiler_freq_based_branch_reorder_{"compiler-freq-based-branch-reorder", true, R"(Enables/disables frequency based branch reorder. Default: true)"};
    PandArg<uint32_t> compiler_freq_based_branch_reorder_threshold_{"compiler-freq-based-branch-reorder-threshold", COMPILER_FREQ_BASED_BRANCH_REORDER_THRESHOLD_DEFAULT, R"(Threshold in percents for frequency based branch reorder. Default: 80)"};
    PandArg<bool> compiler_inline_full_intrinsics_{"compiler-inline-full-intrinsics", false, R"(Inline graph for dynamic insrinsics in IrBuilder. Default: false)"};
    PandArg<bool> compiler_safe_points_require_reg_map_{"compiler-safe-points-require-reg-map", false, R"(Emit virtual registers stack map for safe points. Default: false)"};
    PandArg<bool> compiler_scalar_replacement_{"compiler-scalar-replacement", true, R"(Enable scalar replacement optimization. Default: true)"};
    PandArg<bool> compiler_peepholes_{"compiler-peepholes", true, R"(Enable peepholes optimizations. Default: true)"};
    PandArg<bool> compiler_if_merging_{"compiler-if-merging", true, R"(Enable if-merging optimization. Default: true)"};
    PandArg<bool> compiler_redundant_loop_elimination_{"compiler-redundant-loop-elimination", true, R"(Enable redundant-loop-elimination optimization. Default: true)"};
    PandArg<bool> compiler_optimize_memory_barriers_{"compiler-optimize-memory-barriers", true, R"(Enable optimize-memory-barriers optimization. Default: true)"};
    PandArg<bool> compiler_string_flat_check_{"compiler-string-flat-check", true, R"(Enable StringFlatCheck instructions to ensure flat string is passed as input to specified intrinsics. Default: true)"};
    PandArg<std::string> compiler_profile_{"compiler-profile", R"()", R"(Path to a file with profile information. Default: "")"};
    PandArg<bool> compiler_force_unresolved_{"compiler-force-unresolved", false, R"(Force the compiler to generate method and field resolvers whenever it is possible (Debug mode only). Default: false)"};
    PandArg<bool> compiler_enable_fast_interop_{"compiler-enable-fast-interop", true, R"(Enable fast ArkTS->JS interop. Default: true)"};
    PandArg<bool> compiler_interop_intrinsic_optimization_{"compiler-interop-intrinsic-optimization", true, R"(Enable merging local scopes in fast ArkTS->EcmaScript interop. Default: true)"};
    PandArg<uint32_t> compiler_interop_scope_object_limit_{"compiler-interop-scope-object-limit", COMPILER_INTEROP_SCOPE_OBJECT_LIMIT_DEFAULT, R"(Object limit for merged local scope in ArkTS->EcmaScript interop. Default: 256)"};
    PandArg<bool> compiler_interop_try_single_scope_{"compiler-interop-try-single-scope", false, R"(Try to create single scope for method in ArkTS->EcmaScript interop whenever possible. Default: false)"};
    PandArg<uint32_t> compiler_inst_graph_coloring_limit_{"compiler-inst-graph-coloring-limit", COMPILER_INST_GRAPH_COLORING_LIMIT_DEFAULT, R"(Maximum number of the IR instructions to be chosen for graph coloring algorithm of register allocator. Default: 5000)"};
    PandArg<bool> compiler_enforce_safepoint_placement_{"compiler-enforce-safepoint-placement", false, R"(Inserting safepoints at the beginning of every basic block and after every Nth IR instruction. N is determined by compiler-safepoint-distance-limit option. Default: false)"};
    PandArg<uint32_t> compiler_safepoint_distance_limit_{"compiler-safepoint-distance-limit", COMPILER_SAFEPOINT_DISTANCE_LIMIT_DEFAULT, R"(Distance limit between inserted safepoints. Default: 50)"};
};
// NOLINTEND(readability-identifier-naming,readability-magic-numbers)
}  // namespace ark::compiler

#endif  // PANDA_COMPILER_OPTIONS_GEN_H
