// Copyright 2012 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

// This file defines all of the flags. It is separated into different section,

// for Debug, Release, Logging and Profiling, etc. To add a new flag, find the

// correct section, and use one of the DEFINE_ macros, without a trailing ';'.

//

// This include does not have a guard, because it is a template-style include,

// which can be included multiple times in different modes. It expects to have

// a mode defined before it's included. The modes are FLAG_MODE_... below:

//

// PRESUBMIT_INTENTIONALLY_MISSING_INCLUDE_GUARD

#define DEFINE_IMPLICATION(whenflag, thenflag) \

DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true)

// A weak implication will be overwritten by a normal implication or by an

// explicit flag.

#define DEFINE_WEAK_IMPLICATION(whenflag, thenflag) \

DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, true)

#define DEFINE_WEAK_NEG_IMPLICATION(whenflag, thenflag) \

DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, false)

#define DEFINE_NEG_IMPLICATION(whenflag, thenflag) \

DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false)

#define DEFINE_NEG_NEG_IMPLICATION(whenflag, thenflag) \

DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, false)

// With FLAG_MODE_DECLARE we declare the fields in the {FlagValues} struct.

// Read-only flags are static constants instead of fields.

#if defined(FLAG_MODE_DECLARE)

#define FLAG_FULL(ftype, ctype, nam, def, cmt) FlagValue<ctype> nam{def};

#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \

static constexpr FlagValue<ctype> nam{def};

// We need to define all of our default values so that the Flag structure can

// access them by pointer. These are just used internally inside of one .cc,

// for MODE_META, so there is no impact on the flags interface.

#elif defined(FLAG_MODE_DEFINE_DEFAULTS)

#define FLAG_FULL(ftype, ctype, nam, def, cmt) \

static constexpr ctype FLAGDEFAULT_##nam{def};

#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \

static constexpr ctype FLAGDEFAULT_##nam{def};

// We want to write entries into our meta data table, for internal parsing and

// printing / etc in the flag parser code.

#elif defined(FLAG_MODE_META)

#define FLAG_FULL(ftype, ctype, nam, def, cmt) \

{Flag::TYPE_##ftype, #nam, &v8_flags.nam, &FLAGDEFAULT_##nam, cmt, false},

// Readonly flags don't pass the value pointer since the struct expects a

// mutable value. That's okay since the value always equals the default.

#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \

{Flag::TYPE_##ftype, #nam, nullptr, &FLAGDEFAULT_##nam, cmt, false},

#define FLAG_ALIAS(ftype, ctype, alias, nam) \

{Flag::TYPE_##ftype, #alias, &v8_flags.nam, &FLAGDEFAULT_##nam, \

"alias for --" #nam, false}, // NOLINT(whitespace/indent)

// We produce the code to set flags when it is implied by another flag.

#elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)

#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \

changed |= TriggerImplication(v8_flags.whenflag, #whenflag, \

&v8_flags.thenflag, #thenflag, value, false);

// A weak implication will be overwritten by a normal implication or by an

// explicit flag.

#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) \

changed |= TriggerImplication(v8_flags.whenflag, #whenflag, \

&v8_flags.thenflag, #thenflag, value, true);

#define DEFINE_GENERIC_IMPLICATION(whenflag, statement) \

if (v8_flags.whenflag) statement;

#define DEFINE_REQUIREMENT(statement) CHECK(statement);

#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \

changed |= TriggerImplication(!v8_flags.whenflag, "!" #whenflag, \

&v8_flags.thenflag, #thenflag, value, false);

#define DEFINE_NEG_VALUE_VALUE_IMPLICATION(whenflag, whenvalue, thenflag, \

thenvalue) \

changed |= \

TriggerImplication(v8_flags.whenflag != whenvalue, #whenflag, \

&v8_flags.thenflag, #thenflag, thenvalue, false);

#define DEFINE_MIN_VALUE_IMPLICATION(flag, min_value) \

changed |= TriggerImplication(v8_flags.flag < min_value, #flag, \

&v8_flags.flag, #flag, min_value, false);

#define DEFINE_DISABLE_FLAG_IMPLICATION(whenflag, thenflag) \

if (v8_flags.whenflag && v8_flags.thenflag) { \

PrintF(stderr, "Warning: disabling flag --" #thenflag \

" due to conflicting flags\n"); \

} \

DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false)

// We apply a generic macro to the flags.

#elif defined(FLAG_MODE_APPLY)

#define FLAG_FULL FLAG_MODE_APPLY

#else

#error No mode supplied when including flags.defs

#endif

// Dummy defines for modes where it is not relevant.

#ifndef FLAG_FULL

#define FLAG_FULL(ftype, ctype, nam, def, cmt)

#endif

#ifndef FLAG_READONLY

#define FLAG_READONLY(ftype, ctype, nam, def, cmt)

#endif

#ifndef FLAG_ALIAS

#define FLAG_ALIAS(ftype, ctype, alias, nam)

#endif

#ifndef DEFINE_VALUE_IMPLICATION

#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value)

#endif

#ifndef DEFINE_WEAK_VALUE_IMPLICATION

#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value)

#endif

#ifndef DEFINE_GENERIC_IMPLICATION

#define DEFINE_GENERIC_IMPLICATION(whenflag, statement)

#endif

#ifndef DEFINE_NEG_VALUE_IMPLICATION

#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value)

#endif

#ifndef DEFINE_NEG_VALUE_VALUE_IMPLICATION

#define DEFINE_NEG_VALUE_VALUE_IMPLICATION(whenflag, whenvalue, thenflag, \

thenvalue)

#endif

#ifndef DEFINE_MIN_VALUE_IMPLICATION

#define DEFINE_MIN_VALUE_IMPLICATION(flag, min_value)

#endif

#ifndef DEFINE_DISABLE_FLAG_IMPLICATION

#define DEFINE_DISABLE_FLAG_IMPLICATION(whenflag, thenflag)

#endif

#ifndef DEFINE_REQUIREMENT

#define DEFINE_REQUIREMENT(statement)

#endif

#ifndef DEBUG_BOOL

#error DEBUG_BOOL must be defined at this point.

#endif // DEBUG_BOOL

#if V8_ENABLE_SPARKPLUG

#define ENABLE_SPARKPLUG_BY_DEFAULT true

#else

#define ENABLE_SPARKPLUG_BY_DEFAULT false

#endif

// Supported ARM configurations are:

// "armv6": ARMv6 + VFPv2

// "armv7": ARMv7 + VFPv3-D32 + NEON

// "armv7+sudiv": ARMv7 + VFPv4-D32 + NEON + SUDIV

// "armv8": ARMv8 (including all of the above)

#if !defined(ARM_TEST_NO_FEATURE_PROBE) || \

(defined(CAN_USE_ARMV8_INSTRUCTIONS) && \

defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \

defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS))

#define ARM_ARCH_DEFAULT "armv8"

#elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_SUDIV) && \

defined(CAN_USE_NEON) && defined(CAN_USE_VFP3_INSTRUCTIONS)

#define ARM_ARCH_DEFAULT "armv7+sudiv"

#elif defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(CAN_USE_NEON) && \

defined(CAN_USE_VFP3_INSTRUCTIONS)

#define ARM_ARCH_DEFAULT "armv7"

#else

#define ARM_ARCH_DEFAULT "armv6"

#endif

#ifdef V8_OS_WIN

#define ENABLE_LOG_COLOUR false

#else

#define ENABLE_LOG_COLOUR true

#endif

#define DEFINE_BOOL(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)

#define DEFINE_BOOL_READONLY(nam, def, cmt) \

FLAG_READONLY(BOOL, bool, nam, def, cmt)

#define DEFINE_MAYBE_BOOL(nam, cmt) \

FLAG(MAYBE_BOOL, std::optional<bool>, nam, std::nullopt, cmt)

#define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt)

#define DEFINE_UINT(nam, def, cmt) FLAG(UINT, unsigned int, nam, def, cmt)

#define DEFINE_UINT_READONLY(nam, def, cmt) \

FLAG_READONLY(UINT, unsigned int, nam, def, cmt)

#define DEFINE_UINT64(nam, def, cmt) FLAG(UINT64, uint64_t, nam, def, cmt)

#define DEFINE_FLOAT(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)

#define DEFINE_SIZE_T(nam, def, cmt) FLAG(SIZE_T, size_t, nam, def, cmt)

#define DEFINE_STRING(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt)

#define DEFINE_ALIAS_BOOL(alias, nam) FLAG_ALIAS(BOOL, bool, alias, nam)

#define DEFINE_ALIAS_INT(alias, nam) FLAG_ALIAS(INT, int, alias, nam)

#define DEFINE_ALIAS_FLOAT(alias, nam) FLAG_ALIAS(FLOAT, double, alias, nam)

#define DEFINE_ALIAS_SIZE_T(alias, nam) FLAG_ALIAS(SIZE_T, size_t, alias, nam)

#define DEFINE_ALIAS_STRING(alias, nam) \

FLAG_ALIAS(STRING, const char*, alias, nam)

#ifdef DEBUG

#define DEFINE_DEBUG_BOOL DEFINE_BOOL

#else

#define DEFINE_DEBUG_BOOL DEFINE_BOOL_READONLY

#endif

//

// Flags in all modes.

//

#define FLAG FLAG_FULL

// Experimental features.

// Features that are still considered experimental and which are not ready for

// fuzz testing should be defined using this macro. The feature will then imply

// --experimental, which will indicate to the user that they are running an

// experimental configuration of V8. Experimental features are always disabled

// by default. When these features mature, the flag should first turn into a

// regular feature flag (still disabled by default) and then ideally be staged

// behind (for example) --future before being enabled by default.

DEFINE_BOOL(experimental, false,

"Indicates that V8 is running with experimental features enabled. "

"This flag is typically not set explicitly but instead enabled as "

"an implication of other flags which enable experimental features.")

#define DEFINE_EXPERIMENTAL_FEATURE(nam, cmt) \

FLAG(BOOL, bool, nam, false, cmt " (experimental)") \

DEFINE_IMPLICATION(nam, experimental)

// ATTENTION: This is set to true by default in d8. But for API compatibility,

// it generally defaults to false.

DEFINE_BOOL(abort_on_contradictory_flags, false,

"Disallow flags or implications overriding each other.")

// This implication is also hard-coded into the flags processing to make sure it

// becomes active before we even process subsequent flags.

DEFINE_NEG_IMPLICATION(fuzzing, abort_on_contradictory_flags)

// As abort_on_contradictory_flags, but it will simply exit with return code 0.

DEFINE_BOOL(exit_on_contradictory_flags, false,

"Exit with return code 0 on contradictory flags.")

// We rely on abort_on_contradictory_flags to turn on the analysis.

DEFINE_WEAK_IMPLICATION(exit_on_contradictory_flags,

abort_on_contradictory_flags)

// This is not really a flag, it affects the interpretation of the next flag but

// doesn't become permanently true when specified. This only works for flags

// defined in this file, but not for d8 flags defined in src/d8/d8.cc.

DEFINE_BOOL(allow_overwriting_for_next_flag, false,

"temporary disable flag contradiction to allow overwriting just "

"the next flag")

// Flags for language modes and experimental language features.

DEFINE_BOOL(use_strict, false, "enforce strict mode")

DEFINE_BOOL(trace_temporal, false, "trace temporal code")

DEFINE_BOOL(harmony, false, "enable all completed harmony features")

DEFINE_BOOL(harmony_shipping, true, "enable all shipped harmony features")

DEFINE_BOOL(js_staging, false, "enable all completed JavaScript features")

DEFINE_BOOL(js_shipping, true, "enable all shipped JavaScript features")

// Update bootstrapper.cc whenever adding a new feature flag.

// Features that are still work in progress (behind individual flags).

//

// The "harmony" naming is now outdated and will no longer be used for new JS

// features. Use the JAVASCRIPT macros instead.

//

// TODO(v8:14214): Remove --harmony flags once transition is complete.

#define HARMONY_INPROGRESS_BASE(V) \

V(harmony_temporal, "Temporal") \

V(harmony_shadow_realm, "harmony ShadowRealm") \

V(harmony_struct, "harmony structs, shared structs, and shared arrays")

#define JAVASCRIPT_INPROGRESS_FEATURES_BASE(V) \

V(js_decorators, "decorators") \

V(js_source_phase_imports, "source phase imports") \

V(js_base_64, "Uint8Array to/from base64 and hex")

#ifdef V8_INTL_SUPPORT

#define HARMONY_INPROGRESS(V) \

HARMONY_INPROGRESS_BASE(V) \

V(harmony_intl_best_fit_matcher, "Intl BestFitMatcher")

#define JAVASCRIPT_INPROGRESS_FEATURES(V) JAVASCRIPT_INPROGRESS_FEATURES_BASE(V)

#else

#define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)

#define JAVASCRIPT_INPROGRESS_FEATURES(V) JAVASCRIPT_INPROGRESS_FEATURES_BASE(V)

#endif

// Features that are complete (but still behind the --harmony flag).

#define HARMONY_STAGED_BASE(V)

#define JAVASCRIPT_STAGED_FEATURES_BASE(V)

#ifdef V8_INTL_SUPPORT

#define HARMONY_STAGED(V) \

HARMONY_STAGED_BASE(V) \

V(harmony_remove_intl_locale_info_getters, \

"Remove Obsoleted Intl Locale Info getters")

#define JAVASCRIPT_STAGED_FEATURES(V) JAVASCRIPT_STAGED_FEATURES_BASE(V)

#else

#define HARMONY_STAGED(V) HARMONY_STAGED_BASE(V)

#define JAVASCRIPT_STAGED_FEATURES(V) JAVASCRIPT_STAGED_FEATURES_BASE(V)

#endif

// Features that are shipping (turned on by default, but internal flag remains).

#define HARMONY_SHIPPING_BASE(V) \

V(harmony_import_attributes, "harmony import attributes")

#define JAVASCRIPT_SHIPPING_FEATURES_BASE(V) \

V(js_regexp_duplicate_named_groups, "RegExp duplicate named groups") \

V(js_regexp_modifiers, "RegExp modifiers") \

V(js_promise_try, "Promise.try") \

V(js_atomics_pause, "Atomics.pause") \

V(js_error_iserror, "Error.isError") \

V(js_regexp_escape, "RegExp.escape") \

V(js_explicit_resource_management, "explicit resource management") \

V(js_float16array, \

"Float16Array, Math.f16round, DataView.getFloat16, DataView.setFloat16")

#ifdef V8_INTL_SUPPORT

#define HARMONY_SHIPPING(V) HARMONY_SHIPPING_BASE(V)

#define JAVASCRIPT_SHIPPING_FEATURES(V) JAVASCRIPT_SHIPPING_FEATURES_BASE(V)

#else

#define HARMONY_SHIPPING(V) HARMONY_SHIPPING_BASE(V)

#define JAVASCRIPT_SHIPPING_FEATURES(V) JAVASCRIPT_SHIPPING_FEATURES_BASE(V)

#endif

// Once a shipping feature has proved stable in the wild, it will be dropped

// from HARMONY_SHIPPING, all occurrences of the FLAG_ variable are removed,

// and associated tests are moved from the harmony directory to the appropriate

// esN directory.

//

// In-progress features are not code complete and are considered experimental,

// i.e. not ready for fuzz testing.

#define FLAG_INPROGRESS_FEATURES(id, description) \

DEFINE_BOOL(id, false, \

"enable " #description " (in progress / experimental)") \

DEFINE_IMPLICATION(id, experimental)

HARMONY_INPROGRESS(FLAG_INPROGRESS_FEATURES)

JAVASCRIPT_INPROGRESS_FEATURES(FLAG_INPROGRESS_FEATURES)

#undef FLAG_INPROGRESS_FEATURES

#define FLAG_STAGED_FEATURES(id, description) \

DEFINE_BOOL(id, false, "enable " #description) \

DEFINE_IMPLICATION(harmony, id) \

DEFINE_IMPLICATION(js_staging, id)

HARMONY_STAGED(FLAG_STAGED_FEATURES)

JAVASCRIPT_STAGED_FEATURES(FLAG_STAGED_FEATURES)

DEFINE_IMPLICATION(harmony, js_staging)

#undef FLAG_STAGED_FEATURES

#define FLAG_SHIPPING_FEATURES(id, description) \

DEFINE_BOOL(id, true, "enable " #description) \

DEFINE_NEG_NEG_IMPLICATION(harmony_shipping, id) \

DEFINE_NEG_NEG_IMPLICATION(js_shipping, id)

HARMONY_SHIPPING(FLAG_SHIPPING_FEATURES)

JAVASCRIPT_SHIPPING_FEATURES(FLAG_SHIPPING_FEATURES)

DEFINE_NEG_NEG_IMPLICATION(harmony_shipping, js_shipping)

#undef FLAG_SHIPPING_FEATURES

DEFINE_BOOL(builtin_subclassing, true,

"subclassing support in built-in methods")

// If the following flag is set to `true`, the SharedArrayBuffer constructor is

// enabled per context depending on the callback set via

// `SetSharedArrayBufferConstructorEnabledCallback`. If no callback is set, the

// SharedArrayBuffer constructor is disabled.

DEFINE_BOOL(enable_sharedarraybuffer_per_context, false,

"enable the SharedArrayBuffer constructor per context")

#ifdef V8_INTL_SUPPORT

DEFINE_BOOL(icu_timezone_data, true, "get information about timezones from ICU")

#endif

#ifdef V8_ENABLE_DOUBLE_CONST_STORE_CHECK

#define V8_ENABLE_DOUBLE_CONST_STORE_CHECK_BOOL true

#else

#define V8_ENABLE_DOUBLE_CONST_STORE_CHECK_BOOL false

#endif

#ifdef V8_ENABLE_LAZY_SOURCE_POSITIONS

#define V8_LAZY_SOURCE_POSITIONS_BOOL true

#else

#define V8_LAZY_SOURCE_POSITIONS_BOOL false

#endif

DEFINE_BOOL(stress_snapshot, false,

"disables sharing of the read-only heap for testing")

// Incremental marking is incompatible with the stress_snapshot mode;

// specifically, serialization may clear bytecode arrays from shared function

// infos which the MarkCompactCollector (running concurrently) may still need.

// See also https://crbug.com/v8/10882.

//

// Note: This is not an issue in production because we don't clear SFI's

// there (that only happens in mksnapshot and in --stress-snapshot mode).

DEFINE_NEG_IMPLICATION(stress_snapshot, incremental_marking)

#ifdef V8_LITE_MODE

#define V8_LITE_MODE_BOOL true

#else

#define V8_LITE_MODE_BOOL false

#endif

DEFINE_BOOL(lite_mode, V8_LITE_MODE_BOOL,

"enables trade-off of performance for memory savings")

// Lite mode implies other flags to trade-off performance for memory.

DEFINE_IMPLICATION(lite_mode, jitless)

DEFINE_IMPLICATION(lite_mode, optimize_for_size)

#ifdef V8_ALLOCATION_FOLDING

#define V8_ALLOCATION_FOLDING_BOOL true

#else

#define V8_ALLOCATION_FOLDING_BOOL false

#endif

DEFINE_BOOL_READONLY(enable_allocation_folding, V8_ALLOCATION_FOLDING_BOOL,

"Use allocation folding globally")

DEFINE_NEG_NEG_IMPLICATION(enable_allocation_folding, turbo_allocation_folding)

#ifdef V8_DISABLE_WRITE_BARRIERS

#define V8_DISABLE_WRITE_BARRIERS_BOOL true

#else

#define V8_DISABLE_WRITE_BARRIERS_BOOL false

#endif

DEFINE_BOOL_READONLY(disable_write_barriers, V8_DISABLE_WRITE_BARRIERS_BOOL,

"disable write barriers when GC is non-incremental "

"and heap contains single generation.")

// Disable incremental marking barriers

DEFINE_NEG_IMPLICATION(disable_write_barriers, incremental_marking)

DEFINE_NEG_IMPLICATION(disable_write_barriers, concurrent_marking)

DEFINE_NEG_IMPLICATION(disable_write_barriers, cppheap_incremental_marking)

DEFINE_NEG_IMPLICATION(disable_write_barriers, cppheap_concurrent_marking)

#ifdef V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS

#define V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS_BOOL true

#else

#define V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS_BOOL false

#endif

DEFINE_BOOL_READONLY(enable_unconditional_write_barriers,

V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS_BOOL,

"always use full write barriers")

#ifdef V8_ENABLE_SINGLE_GENERATION

#define V8_SINGLE_GENERATION_BOOL true

#else

#define V8_SINGLE_GENERATION_BOOL false

#endif

DEFINE_BOOL_READONLY(

single_generation, V8_SINGLE_GENERATION_BOOL,

"allocate all objects from young generation to old generation")

#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING

#define V8_ENABLE_CONSERVATIVE_STACK_SCANNING_BOOL true

#else

#define V8_ENABLE_CONSERVATIVE_STACK_SCANNING_BOOL false

#endif

DEFINE_BOOL_READONLY(conservative_stack_scanning,

V8_ENABLE_CONSERVATIVE_STACK_SCANNING_BOOL,

"use conservative stack scanning")

DEFINE_IMPLICATION(conservative_stack_scanning,

scavenger_conservative_object_pinning)

DEFINE_NEG_IMPLICATION(conservative_stack_scanning, compact_with_stack)

#ifdef V8_ENABLE_DIRECT_HANDLE

#define V8_ENABLE_DIRECT_HANDLE_BOOL true

#else

#define V8_ENABLE_DIRECT_HANDLE_BOOL false

#endif

DEFINE_BOOL_READONLY(direct_handle, V8_ENABLE_DIRECT_HANDLE_BOOL,

"use direct handles with conservative stack scanning")

// Do not use direct handles without conservative stack scanning, as this would

// break the correctness of the GC.

DEFINE_NEG_NEG_IMPLICATION(conservative_stack_scanning, direct_handle)

DEFINE_EXPERIMENTAL_FEATURE(scavenger_conservative_object_pinning,

"Objects reachable from the native stack during "

"scavenge will be pinned and "

"won't move.")

DEFINE_IMPLICATION(scavenger_conservative_object_pinning, separate_gc_phases)

DEFINE_BOOL(

stress_scavenger_conservative_object_pinning, false,

"Treat some precise references as conservative references to stress "

"test object pinning in Scavenger")

DEFINE_IMPLICATION(stress_scavenger_conservative_object_pinning,

scavenger_conservative_object_pinning)

DEFINE_NEG_IMPLICATION(stress_scavenger_conservative_object_pinning,

minor_gc_task)

DEFINE_VALUE_IMPLICATION(stress_scavenger_conservative_object_pinning,

scavenger_max_new_space_capacity_mb, 1u)

DEFINE_BOOL(stress_scavenger_conservative_object_pinning_random, false,

"Enables random stressing of object pinning in Scavenger, such "

"that each GC would randomly pick a subset of the precise "

"references to treat conservatively")

DEFINE_IMPLICATION(stress_scavenger_conservative_object_pinning_random,

stress_scavenger_conservative_object_pinning)

DEFINE_BOOL(scavenger_precise_object_pinning, false,

"Objects reachable from handles during scavenge "

"will be pinned and won't move.")

DEFINE_IMPLICATION(scavenger_precise_object_pinning, separate_gc_phases)

DEFINE_BOOL(

precise_object_pinning, false,

"Objects reachable from handles during GC will be pinned and won't move.")

DEFINE_IMPLICATION(precise_object_pinning, scavenger_precise_object_pinning)

DEFINE_BOOL(scavenger_promote_quarantined_pages, true,

"Quarantined pages in the intermediate generation will be promoted "

"to old space")

#ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK

#define V8_ENABLE_LOCAL_OFF_STACK_CHECK_BOOL true

#else

#define V8_ENABLE_LOCAL_OFF_STACK_CHECK_BOOL false

#endif

DEFINE_BOOL_READONLY(local_off_stack_check,

V8_ENABLE_LOCAL_OFF_STACK_CHECK_BOOL,

"check for off-stack allocation of v8::Local")

#ifdef V8_ENABLE_FUTURE

#define FUTURE_BOOL true

#else

#define FUTURE_BOOL false

#endif

DEFINE_BOOL(future, FUTURE_BOOL,

"Implies all staged features that we want to ship in the "

"not-too-far future")

DEFINE_BOOL(force_emit_interrupt_budget_checks, false,

"force emit tier-up logic from all non-turbofan code, even if it "

"is the top enabled tier")

#ifdef V8_ENABLE_MAGLEV

DEFINE_BOOL(maglev, true, "enable the maglev optimizing compiler")

#if !ENABLE_MAGLEV

// Enable Maglev on Future for platforms in which it's not enabled by default

// (eg, Android).

DEFINE_WEAK_IMPLICATION(future, maglev)

#endif

DEFINE_EXPERIMENTAL_FEATURE(

maglev_future,

"enable maglev features that we want to ship in the not-too-far future")

DEFINE_IMPLICATION(maglev_future, maglev)

DEFINE_BOOL(

optimize_on_next_call_optimizes_to_maglev, false,

"make OptimizeFunctionOnNextCall optimize to maglev instead of turbofan")

// We stress maglev by setting a very low interrupt budget for maglev. This

// way, we still gather *some* feedback before compiling optimized code.

DEFINE_BOOL(stress_maglev, false, "trigger maglev compilation earlier")

DEFINE_IMPLICATION(stress_maglev, maglev)

DEFINE_WEAK_VALUE_IMPLICATION(stress_maglev, invocation_count_for_maglev, 4)

#else

DEFINE_BOOL_READONLY(maglev, false, "enable the maglev optimizing compiler")

DEFINE_BOOL_READONLY(

maglev_future, false,

"enable maglev features that we want to ship in the not-too-far future")

DEFINE_BOOL_READONLY(stress_maglev, false, "trigger maglev compilation earlier")

DEFINE_BOOL_READONLY(

optimize_on_next_call_optimizes_to_maglev, false,

"make OptimizeFunctionOnNextCall optimize to maglev instead of turbofan")

#endif // V8_ENABLE_MAGLEV

DEFINE_BOOL(maglev_inlining, true,

"enable inlining in the maglev optimizing compiler")

DEFINE_BOOL(maglev_loop_peeling, true,

"enable loop peeling in the maglev optimizing compiler")

DEFINE_BOOL(maglev_optimistic_peeled_loops, true,

"enable aggressive optimizations for loops (loop SPeeling) in the "

"maglev optimizing compiler")

DEFINE_INT(maglev_loop_peeling_max_size, 400,

"max loop size for loop peeling in the maglev optimizing compiler")

DEFINE_INT(

maglev_loop_peeling_max_size_cumulative, 900,

"max cumulative size for loop peeling in the maglev optimizing compiler")

DEFINE_BOOL(maglev_deopt_data_on_background, true,

"Generate deopt data on background thread")

DEFINE_BOOL(maglev_build_code_on_background, true,

"Generate code on background thread")

DEFINE_WEAK_IMPLICATION(maglev_build_code_on_background,

maglev_deopt_data_on_background)

DEFINE_BOOL(maglev_destroy_on_background, true,

"Destroy compilation jobs on background thread")

DEFINE_BOOL(maglev_inline_api_calls, false,

"Inline CallApiCallback builtin into generated code")

DEFINE_BOOL(maglev_cons_string_elision, false,

"Native support for cons strings and their elision in maglev.")

DEFINE_BOOL(maglev_pretenure_store_values, false,

"Recursively pretenure values which are stored into pretenured "

"allocation sites.")

DEFINE_EXPERIMENTAL_FEATURE(maglev_licm, "loop invariant code motion")

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_speculative_hoist_phi_untagging)

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_inline_api_calls)

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_escape_analysis)

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_licm)

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_cons_string_elision)

DEFINE_WEAK_IMPLICATION(maglev_future, maglev_pretenure_store_values)

// This might be too big of a hammer but we must prohibit moving the C++

// trampolines while we are executing a C++ code.

DEFINE_NEG_IMPLICATION(maglev_inline_api_calls, compact_code_space_with_stack)

DEFINE_UINT(

concurrent_maglev_max_threads, 2,

"max number of threads that concurrent Maglev can use (0 for unbounded)")

DEFINE_BOOL(concurrent_maglev_high_priority_threads, false,

"use high priority compiler threads for concurrent Maglev")

DEFINE_INT(

max_maglev_inline_depth, 1,

"max depth of functions that Maglev will inline excl. small functions")

DEFINE_INT(

max_maglev_hard_inline_depth, 10,

"max depth of functions that Maglev will inline incl. small functions")

DEFINE_INT(max_maglev_inlined_bytecode_size, 460,

"maximum size of bytecode for a single inlining")

DEFINE_INT(max_maglev_inlined_bytecode_size_cumulative, 920,

"maximum cumulative size of bytecode considered for inlining excl. "

"small functions")

DEFINE_INT(max_maglev_inlined_bytecode_size_small, 27,

"maximum size of bytecode considered for small function inlining")

DEFINE_FLOAT(min_maglev_inlining_frequency, 0.10,

"minimum frequency for inlining")

DEFINE_WEAK_VALUE_IMPLICATION(turbofan, max_maglev_inline_depth, 1)

DEFINE_WEAK_VALUE_IMPLICATION(turbofan, max_maglev_inlined_bytecode_size, 100)

DEFINE_WEAK_VALUE_IMPLICATION(turbofan,

max_maglev_inlined_bytecode_size_cumulative, 920)

DEFINE_WEAK_VALUE_IMPLICATION(turbofan, min_maglev_inlining_frequency, 0.95)

DEFINE_BOOL(maglev_reuse_stack_slots, true,

"reuse stack slots in the maglev optimizing compiler")

DEFINE_BOOL(maglev_untagged_phis, true,

"enable phi untagging in the maglev optimizing compiler")

DEFINE_BOOL(maglev_hoist_osr_value_phi_untagging, true,

"enable phi untagging to hoist untagging of osr values")

DEFINE_EXPERIMENTAL_FEATURE(

maglev_speculative_hoist_phi_untagging,

"enable phi untagging to hoist untagging of loop phi inputs (could "

"still cause deopt loops)")

DEFINE_BOOL(maglev_cse, true, "common subexpression elimination")

DEFINE_EXPERIMENTAL_FEATURE(maglev_non_eager_inlining,

"enable Maglev non-eager inlining")

DEFINE_EXPERIMENTAL_FEATURE(turbolev_non_eager_inlining,

"enable Turbolev non-eager inlining")

DEFINE_WEAK_IMPLICATION(turbolev_future, turbolev_non_eager_inlining)

DEFINE_BOOL(maglev_inlining_following_eager_order, false,

"enable Maglev non-eager inlining using the same order as eager "

"inlining (for testing)")

DEFINE_IMPLICATION(maglev_inlining_following_eager_order,

maglev_non_eager_inlining)

DEFINE_STRING(maglev_filter, "*", "optimization filter for the maglev compiler")

DEFINE_STRING(maglev_print_filter, "*",

"filter for maglev's tracing/printing options")

DEFINE_BOOL(maglev_assert, false, "insert extra assertion in maglev code")

DEFINE_DEBUG_BOOL(maglev_assert_stack_size, true,

"insert stack size checks before every IR node")

DEFINE_BOOL(maglev_break_on_entry, false, "insert an int3 on maglev entries")

DEFINE_BOOL(maglev_print_feedback, true,

"print feedback vector for maglev compiled code")

DEFINE_BOOL(maglev_print_inlined, true,

"print bytecode / feedback vectors also for inlined code")

DEFINE_BOOL(print_maglev_code, false, "print maglev code")

DEFINE_BOOL(trace_maglev_graph_building, false, "trace maglev graph building")

DEFINE_BOOL(trace_maglev_loop_speeling, false, "trace maglev loop SPeeling")

DEFINE_WEAK_IMPLICATION(trace_maglev_graph_building, trace_maglev_loop_speeling)

DEFINE_BOOL(trace_maglev_inlining, false, "trace maglev inlining")

DEFINE_BOOL(trace_maglev_inlining_verbose, false,

"trace maglev inlining (verbose)")

DEFINE_IMPLICATION(trace_maglev_inlining_verbose, trace_maglev_inlining)

#ifdef V8_ENABLE_MAGLEV_GRAPH_PRINTER

DEFINE_BOOL(print_maglev_deopt_verbose, false, "print verbose deopt info")

DEFINE_WEAK_IMPLICATION(trace_deopt_verbose, print_maglev_deopt_verbose)

DEFINE_BOOL(print_maglev_graph, false, "print the final maglev graph")

DEFINE_BOOL(print_maglev_graphs, false, "print maglev graph across all phases")

DEFINE_BOOL(trace_maglev_phi_untagging, false, "trace maglev phi untagging")

DEFINE_BOOL(trace_maglev_regalloc, false, "trace maglev register allocation")

#else

DEFINE_BOOL_READONLY(print_maglev_deopt_verbose, false,

"print verbose deopt info")

DEFINE_BOOL_READONLY(print_maglev_graph, false, "print the final maglev graph")

DEFINE_BOOL_READONLY(print_maglev_graphs, false,

"print maglev graph across all phases")

DEFINE_BOOL_READONLY(trace_maglev_phi_untagging, false,

"trace maglev phi untagging")

DEFINE_BOOL_READONLY(trace_maglev_regalloc, false,

"trace maglev register allocation")

#endif // V8_ENABLE_MAGLEV_GRAPH_PRINTER

DEFINE_BOOL(maglev_stats, false, "print Maglev statistics")

DEFINE_BOOL(maglev_stats_nvp, false,

"print Maglev statistics in machine-readable format")

// TODO(v8:7700): Remove once stable.

DEFINE_BOOL(maglev_function_context_specialization, true,

"enable function context specialization in maglev")

DEFINE_BOOL(maglev_skip_migration_check_for_polymorphic_access, false,

"skip generating a migration check when some maps of polymorphic "

"property access are migration targets")

#ifdef V8_ENABLE_SPARKPLUG

DEFINE_WEAK_IMPLICATION(future, flush_baseline_code)

#endif

#ifdef V8_TARGET_ARCH_64_BIT

DEFINE_BOOL(additive_safe_int_feedback, false,

"Enable the use of AdditiveSafeInteger feedback")

DEFINE_WEAK_IMPLICATION(future, additive_safe_int_feedback)

#else

DEFINE_BOOL_READONLY(additive_safe_int_feedback, false,

"Enable the use of AdditiveSafeInteger feedback")

#endif // V8_TARGET_ARCH_64_BIT

DEFINE_BOOL(

enable_enumerated_keyed_access_bytecode, true,

"enable generating GetEnumeratedKeyedProperty bytecode for keyed access")

DEFINE_BOOL_READONLY(dict_property_const_tracking,

V8_DICT_PROPERTY_CONST_TRACKING_BOOL,

"Use const tracking on dictionary properties")

DEFINE_BOOL(const_tracking_let, true,

"Use const tracking on top-level `let` variables")

DEFINE_BOOL(script_context_mutable_heap_number, true,

"Use mutable heap numbers in script contexts")

#if defined(V8_31BIT_SMIS_ON_64BIT_ARCH) || defined(V8_TARGET_ARCH_32_BIT)

#define SUPPORT_SCRIPT_CONTEXT_MUTABLE_HEAP_INT32

DEFINE_BOOL(script_context_mutable_heap_int32, true,

"Use mutable heap int32 number in script contexts")

DEFINE_WEAK_IMPLICATION(script_context_mutable_heap_int32,

script_context_mutable_heap_number)

#else

DEFINE_BOOL_READONLY(script_context_mutable_heap_int32, false,

"Use mutable heap int32 number in script contexts")

#endif

DEFINE_BOOL(empty_context_extension_dep, true,

"Use compilation dependency to avoid dynamic checks for "

"non-empty context extensions")

DEFINE_BOOL(json_stringify_fast_path, false, "Enable JSON.stringify fast-path")

DEFINE_WEAK_IMPLICATION(future, json_stringify_fast_path)

#ifdef V8_ENABLE_EXTENSIBLE_RO_SNAPSHOT

DEFINE_BOOL(extensible_ro_snapshot, true,

"Whether custom embedder snapshots may extend ReadOnlySpace")

#else

DEFINE_BOOL_READONLY(

extensible_ro_snapshot, false,

"Whether custom embedder snapshots may extend ReadOnlySpace")

#endif // V8_ENABLE_EXTENSIBLE_RO_SNAPSHOT

DEFINE_UINT(max_opt, 999,

"Set the maximal optimisation tier: "

"> 3 == any, 0 == ignition/interpreter, 1 == sparkplug/baseline, "

"2 == maglev, 3 == turbofan")

#ifdef V8_ENABLE_TURBOFAN

DEFINE_WEAK_VALUE_IMPLICATION(max_opt < 3, turbofan, false)

#endif // V8_ENABLE_TURBOFAN

#ifdef V8_ENABLE_MAGLEV

DEFINE_WEAK_VALUE_IMPLICATION(max_opt < 2, maglev, false)

#endif // V8_ENABLE_MAGLEV

#ifdef V8_ENABLE_SPARKPLUG

DEFINE_WEAK_VALUE_IMPLICATION(max_opt < 1, sparkplug, false)

#endif // V8_ENABLE_SPARKPLUG

// Flags to override efficiency and battery saver mode settings for debugging

// and testing.

DEFINE_MAYBE_BOOL(efficiency_mode,

"Forces efficiency mode on or off, disregarding any dynamic "

"signals. Efficiency mode is optimized for situations with "

"no latency requirements and uses fewer threads.")

DEFINE_MAYBE_BOOL(

battery_saver_mode,

"Forces battery saver mode on or off, disregarding any dynamic signals. "

"Battery saver tries to conserve overall cpu cycles spent.")

DEFINE_MAYBE_BOOL(

memory_saver_mode,

"Forces memory saver mode on or off, disregarding any dynamic signals. "

"Memory saver tries to keep memory footprint low at the expense of extra "

"cpu cycles.")

// Flags to experiment with the new efficiency mode

DEFINE_BOOL(efficiency_mode_for_tiering_heuristics, true,

"Use efficiency mode in tiering heuristics.")

DEFINE_BOOL(efficiency_mode_disable_turbofan, false,

"Defer tier-up to turbofan while in efficiency mode.")

DEFINE_INT(efficiency_mode_delay_turbofan, 15000,

"Delay tier-up to turbofan to a certain invocation count while in "

"efficiency mode.")

// Flag to select wasm trace mark type

DEFINE_STRING(

wasm_trace_native, nullptr,

"Select which native code sequence to use for wasm trace instruction: "

"default or cpuid")

#ifdef V8_JITLESS

#define V8_JITLESS_BOOL true

DEFINE_BOOL_READONLY(jitless, true,

"Disable runtime allocation of executable memory.")

#else

#define V8_JITLESS_BOOL false

DEFINE_BOOL(jitless, V8_LITE_MODE_BOOL,

"Disable runtime allocation of executable memory.")

#endif // V8_JITLESS

// Jitless V8 has a few implications:

// Field type tracking is only used by TurboFan.

DEFINE_NEG_IMPLICATION(jitless, track_field_types)

DEFINE_NEG_IMPLICATION(jitless, script_context_mutable_heap_number)

// No code generation at runtime.

DEFINE_IMPLICATION(jitless, regexp_interpret_all)

DEFINE_NEG_IMPLICATION(jitless, turbofan)

#ifdef V8_ENABLE_SPARKPLUG

DEFINE_NEG_IMPLICATION(jitless, sparkplug)

DEFINE_NEG_IMPLICATION(jitless, always_sparkplug)

#endif // V8_ENABLE_SPARKPLUG

#ifdef V8_ENABLE_MAGLEV

DEFINE_NEG_IMPLICATION(jitless, maglev)

#endif // V8_ENABLE_MAGLEV

// Doesn't work without an executable code space.

DEFINE_NEG_IMPLICATION(jitless, interpreted_frames_native_stack)

DEFINE_BOOL(

disable_optimizing_compilers, false,

"Disable all optimizing compilers while leaving baseline compilers enabled")

// Disable all optimizing JavaScript compilers.

// JavaScript code can execute either in Ignition or Sparkplug.

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, turbofan)

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, turboshaft)

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, maglev)

#if V8_ENABLE_WEBASSEMBLY

// Disable optimizing Wasm compilers. Wasm code must execute with Liftoff.

DEFINE_IMPLICATION(disable_optimizing_compilers, liftoff)

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, wasm_tier_up)

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, wasm_dynamic_tiering)

// Disable translation of asm.js to Wasm

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, validate_asm)

#endif // V8_ENABLE_WEBASSEMBLY

// Field type tracking is only used by TurboFan, so can be disabled.

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers, track_field_types)

DEFINE_NEG_IMPLICATION(disable_optimizing_compilers,

script_context_mutable_heap_number)

DEFINE_BOOL(memory_protection_keys, true,

"protect code memory with PKU if available")

DEFINE_BOOL(assert_types, false,

"generate runtime type assertions to test the typer")

// TODO(tebbi): Support allocating types from background thread.

DEFINE_NEG_IMPLICATION(assert_types, concurrent_recompilation)

DEFINE_NEG_IMPLICATION(assert_types, concurrent_builtin_generation)

DEFINE_EXPERIMENTAL_FEATURE(

turboshaft_assert_types,

"generate runtime type assertions to test the turboshaft type system")

DEFINE_NEG_IMPLICATION(turboshaft_assert_types, concurrent_recompilation)

DEFINE_NEG_IMPLICATION(turboshaft_assert_types, concurrent_builtin_generation)

// Enable verification of SimplifiedLowering in debug builds.

DEFINE_BOOL(verify_simplified_lowering, false,

"verify graph generated by simplified lowering")

DEFINE_BOOL(trace_compilation_dependencies, false, "trace code dependencies")

// Depend on --trace-deopt-verbose for reporting dependency invalidations.

DEFINE_IMPLICATION(trace_compilation_dependencies, trace_deopt_verbose)

#ifdef V8_ALLOCATION_SITE_TRACKING

#define V8_ALLOCATION_SITE_TRACKING_BOOL true

#else

#define V8_ALLOCATION_SITE_TRACKING_BOOL false

#endif

DEFINE_BOOL_READONLY(allocation_site_tracking, V8_ALLOCATION_SITE_TRACKING_BOOL,

"Enable allocation site tracking")

DEFINE_NEG_NEG_IMPLICATION(allocation_site_tracking,

allocation_site_pretenuring)

// Flags for experimental implementation features.

DEFINE_BOOL(allocation_site_pretenuring, true,

"pretenure with allocation sites")

DEFINE_BOOL(page_promotion, true, "promote pages based on utilization")

DEFINE_INT(page_promotion_threshold, 70,

"min percentage of live bytes on a page to enable fast evacuation "

"in full GCs")

DEFINE_INT(minor_ms_page_promotion_threshold, 50,

"min percentage of live bytes on a page to enable fast evacuation "

"in MinorMS")

DEFINE_INT(minor_ms_page_promotion_max_lab_threshold, 30,

"max percentage of labs out of a page to still be considered for "

"page promotion")

DEFINE_UINT(minor_ms_max_page_age, 4,

"max age for a page after which it is force promoted to old space")

DEFINE_UINT(minor_ms_max_new_space_capacity_mb, 72,

"max new space capacity in MBs when using MinorMS. When pointer "

"compression is disabled, twice the capacity is used.")

DEFINE_REQUIREMENT(v8_flags.minor_ms_max_new_space_capacity_mb > 0)

#if defined(ANDROID)

#define DEFAULT_SCAVENGER_MAX_NEW_SPACE_CAPACITY_MB 8

#else

#define DEFAULT_SCAVENGER_MAX_NEW_SPACE_CAPACITY_MB 32

#endif

DEFINE_UINT(scavenger_max_new_space_capacity_mb,

DEFAULT_SCAVENGER_MAX_NEW_SPACE_CAPACITY_MB,

"max new space capacity in MBs when using Scavenger. When pointer "

"compression is disabled, twice the capacity is used.")

DEFINE_REQUIREMENT(v8_flags.scavenger_max_new_space_capacity_mb > 0)

#undef DEFAULT_SCAVENGER_MAX_NEW_SPACE_CAPACITY_MB

DEFINE_BOOL(trace_page_promotions, false, "trace page promotion decisions")

DEFINE_BOOL(trace_pretenuring, false,

"trace pretenuring decisions of HAllocate instructions")

DEFINE_BOOL(trace_pretenuring_statistics, false,

"trace allocation site pretenuring statistics")

DEFINE_BOOL(track_field_types, true, "track field types")

DEFINE_BOOL(trace_block_coverage, false,

"trace collected block coverage information")

DEFINE_BOOL(trace_protector_invalidation, false,

"trace protector cell invalidations")

DEFINE_BOOL(decommit_pooled_pages, true,

"decommit, rather than discard pooled pages")

DEFINE_BOOL(

zero_unused_memory, false,

"Zero unused memory (except for memory which was discarded) on memory "

"reducing GCs.")

#ifdef V8_MINORMS_STRING_SHORTCUTTING

DEFINE_BOOL(minor_ms_shortcut_strings, false,

"short cut strings during marking")

// String shortcutting currently doesn't work with concurrent marking.

DEFINE_NEG_IMPLICATION(minor_ms_shortcut_strings, concurrent_minor_ms_marking)

#else

DEFINE_BOOL_READONLY(minor_ms_shortcut_strings, false,

"short cut strings during marking")

#endif

DEFINE_EXPERIMENTAL_FEATURE(feedback_normalization,

"feed back normalization to constructors")

// TODO(jkummerow): This currently adds too much load on the stub cache.

DEFINE_BOOL_READONLY(internalize_on_the_fly, true,

"internalize string keys for generic keyed ICs on the fly")

// Flags for data representation optimizations

DEFINE_BOOL(unbox_double_arrays, true, "automatically unbox arrays of doubles")

DEFINE_BOOL_READONLY(string_slices, true, "use string slices")

// Tiering: Sparkplug / feedback vector allocation.

DEFINE_INT(invocation_count_for_feedback_allocation, 8,

"invocation count required for allocating feedback vectors")

// Tiering: Maglev.

#if defined(ANDROID)

DEFINE_INT(invocation_count_for_maglev, 1000,

"invocation count required for optimizing with Maglev")

#else

DEFINE_INT(invocation_count_for_maglev, 400,

"invocation count required for optimizing with Maglev")

#endif // ANDROID

DEFINE_INT(invocation_count_for_maglev_osr, 100,

"invocation count required for maglev OSR")

DEFINE_BOOL(osr_from_maglev, false,

"whether we try to OSR to Turbofan from OSR'd Maglev")

DEFINE_FLOAT(

osr_from_maglev_interrupt_scale_factor, 0.8,

"Scale interrupt budget reduction for OSR from Maglev vs. OSR to Maglev")

DEFINE_BOOL(always_osr_from_maglev, false,

"whether we try to OSR to Turbofan from any Maglev")

DEFINE_WEAK_IMPLICATION(always_osr_from_maglev, osr_from_maglev)

// Tiering: Turbofan.

DEFINE_INT(invocation_count_for_turbofan, 3000,

"invocation count required for optimizing with TurboFan")

DEFINE_INT(invocation_count_for_osr, 500, "invocation count required for OSR")

DEFINE_INT(osr_to_tierup, 1,

"number to decrease the invocation budget by when we follow OSR")

DEFINE_INT(minimum_invocations_after_ic_update, 500,

"How long to minimally wait after IC update before tier up")

DEFINE_INT(minimum_invocations_before_optimization, 2,

"Minimum number of invocations we need before non-OSR optimization")