# Copyright 2014 The Chromium Authors. All rights reserved.

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

# found in the LICENSE file.

import("//build/config/android/config.gni")

import("//build/config/arm.gni")

import("//build/config/coverage/coverage.gni")

import("//build/config/dcheck_always_on.gni")

import("//build/config/host_byteorder.gni")

import("//build/config/mips.gni")

import("//build/config/riscv.gni")

import("//build/config/rust.gni")

import("//build/config/sanitizers/sanitizers.gni")

import("//build_overrides/build.gni")

import("//third_party/icu/config.gni")

import("gni/snapshot_toolchain.gni")

import("gni/v8.gni")

if (is_clang) {

import("//build/config/clang/clang.gni")

}

if (is_ios) {

import("//build/config/apple/mobile_config.gni") # For `target_platform`.

}

# For faster Windows builds. See https://crbug.com/v8/8475.

emit_builtins_as_inline_asm = is_win && is_clang

declare_args() {

# Print to stdout on Android.

v8_android_log_stdout = false

# Dynamically set an additional dependency from v8/custom_deps.

v8_custom_deps = ""

# Sets -DV8_ENABLE_FUTURE.

v8_enable_future = false

# Sets -DENABLE_SYSTEM_INSTRUMENTATION. Enables OS-dependent event tracing

v8_enable_system_instrumentation = (is_win || is_mac) && !v8_use_perfetto

# Sets the GUID for the ETW provider

v8_etw_guid = ""

# Sets -DVERIFY_HEAP.

v8_enable_verify_heap = ""

# Sets -DVERIFY_WRITE_BARRIERS.

v8_enable_verify_write_barriers = ""

# Sets -DVERIFY_PREDICTABLE

v8_enable_verify_predictable = false

# Enable compiler warnings when using V8_DEPRECATED apis.

v8_deprecation_warnings = true

# Enable compiler warnings when using V8_DEPRECATE_SOON apis.

v8_imminent_deprecation_warnings = true

# Embeds the given script into the snapshot.

v8_embed_script = ""

# Allows the embedder to add a custom suffix to the version string.

v8_embedder_string = ""

# Sets -DENABLE_DISASSEMBLER.

v8_enable_disassembler = ""

# Sets the number of internal fields on promise objects.

v8_promise_internal_field_count = 0

# Sets the number of internal fields on array buffer objects.

v8_array_buffer_internal_field_count = 0

# Sets the number of internal fields on array buffer view objects.

v8_array_buffer_view_internal_field_count = 0

# Sets -DENABLE_GDB_JIT_INTERFACE.

v8_enable_gdbjit = ""

# Sets -DENABLE_VTUNE_JIT_INTERFACE.

v8_enable_vtunejit = false

# Sets -DENABLE_VTUNE_TRACEMARK.

v8_enable_vtunetracemark = false

# Sets -DENABLE_HUGEPAGE

v8_enable_hugepage = false

# Sets -DV8_ENABLE_PRIVATE_MAPPING_FORK_OPTIMIZATION.

#

# This flag speeds up the performance of fork/execve on Linux systems for

# embedders which use it (like Node.js). It works by marking the pages that

# V8 allocates as MADV_DONTFORK. Without MADV_DONTFORK, the Linux kernel

# spends a long time manipulating page mappings on fork and exec which the

# child process doesn't generally need to access.

#

# See v8:7381 for more details.

v8_enable_private_mapping_fork_optimization = false

# Sets the default for v8_enable_local_handle_zapping and

# v8_enable_global_handle_zapping.

v8_enable_handle_zapping = is_asan || is_debug

# Sets -DENABLE_LOCAL_HANDLE_ZAPPING, which is more expensive than just

# the global handles. By default it is enabled if v8_enable_handle_zapping

# is enabled.

v8_enable_local_handle_zapping = ""

# Sets -DENABLE_GLOBAL_HANDLE_ZAPPING. By default it is enabled if

# v8_enable_handle_zapping is enabled.

v8_enable_global_handle_zapping = ""

# Enable slow dchecks.

v8_enable_slow_dchecks = false

# Enable fast mksnapshot runs.

v8_enable_fast_mksnapshot = false

# Enable using multiple threads to build builtins in mksnapshot.

v8_enable_concurrent_mksnapshot = true

# Optimize code for Torque executable, even during a debug build.

v8_enable_fast_torque = ""

# Enable the registration of unwinding info for Windows x64 and ARM64.

v8_win64_unwinding_info = true

# Enable code comments for builtins in the snapshot (impacts performance).

# This also enables v8_code_comments.

v8_enable_snapshot_code_comments = false

# Allow runtime-enabled code comments (with --code-comments). Enabled by

# default in debug builds.

# Sets -DV8_CODE_COMMENTS

v8_code_comments = ""

# Allow runtime-enabled debug code (with --debug-code). Enabled by default in

# debug builds.

# Sets -DV8_ENABLE_DEBUG_CODE

v8_enable_debug_code = ""

# Enable native counters from the snapshot (impacts performance, sets

# -DV8_SNAPSHOT_NATIVE_CODE_COUNTERS).

# This option will generate extra code in the snapshot to increment counters,

# as per the --native-code-counters flag.

v8_enable_snapshot_native_code_counters = ""

# Use pre-generated static root pointer values from static-roots.h.

v8_enable_static_roots = ""

# Mode used by gen-static-roots.py to have a heap layout which is identical

# to when v8_enable_static_roots is enabled.

v8_enable_static_roots_generation = false

# Enable code-generation-time checking of types in the CodeStubAssembler.

v8_enable_verify_csa = false

# Sets -DOBJECT_PRINT.

v8_enable_object_print = ""

# Sets -DALWAYS_MAGLEV_GRAPH_LABELLER.

v8_always_enable_maglev_graph_labeller = ""

# Sets -DV8_TRACE_MAPS.

v8_enable_trace_maps = ""

# Sets -DV8_ENABLE_CHECKS.

v8_enable_v8_checks = ""

# Sets -DV8_ENABLE_MEMORY_ACCOUNTING_CHECKS

v8_enable_memory_accounting_checks = ""

# Sets -DV8_TRACE_UNOPTIMIZED.

v8_enable_trace_unoptimized = ""

v8_enable_trace_ignition = false

v8_enable_trace_baseline_exec = false

# Sets -DV8_TRACE_FEEDBACK_UPDATES.

v8_enable_trace_feedback_updates = false

# Sets -DV8_ATOMIC_OBJECT_FIELD_WRITES and turns all field write operations

# into relaxed atomic operations.

v8_enable_atomic_object_field_writes = ""

# Controls the default value of v8_enable_concurrent_marking_state. See the

# default setting code below.

v8_enable_concurrent_marking = true

# Sets -DV8_IGNITION_DISPATCH_COUNTING.

# Enables counting frequencies of bytecode dispatches. After building in this

# configuration, subsequent runs of d8 can output frequencies for each pair

# of (current, next) bytecode instructions executed if you specify

# --trace-ignition-dispatches-output-file, or can generate a JS object with

# those frequencies if you run with --expose-ignition-statistics and call the

# extension function getIgnitionDispatchCounters().

v8_enable_ignition_dispatch_counting = false

# Enable frame elision for builtins.

v8_enable_builtins_frame_elision = true

# Runs mksnapshot with --turbo-profiling. After building in this

# configuration, any subsequent run of d8 will output information about usage

# of basic blocks in builtins.

v8_enable_builtins_profiling = false

# Runs mksnapshot with --turbo-profiling-verbose. After building in this

# configuration, any subsequent run of d8 will output information about usage

# of basic blocks in builtins, including the schedule and disassembly of all

# used builtins.

v8_enable_builtins_profiling_verbose = false

# This build flag is used to input a builtin pgo file containing raw

# execution counts (as opposed to branch hints), which are embedded into

# the `--trace-turbo` .json file from `mksnapshot`.

v8_log_builtins_block_count_input = ""

# This build flag is used to control whether reorder builtins according to

# the call graph with C3 algorithm based builtin PGO profiling.

v8_enable_builtins_reordering = true

# Provides the given V8 log file as an input to mksnapshot, where it can be

# used for profile-guided optimization of builtins.

#

# To do profile-guided optimizations of builtins:

# 1. Build with v8_enable_builtins_profiling = true

# 2. Run your chosen workload with the --turbo-profiling-output flag.

# For Chrome, the invocation might look like this:

# chrome --no-sandbox --disable-extensions

# --js-flags="--turbo-profiling-output=v8.builtins.pgo"

# "http://localhost/test-suite"

# 3. Run tools/builtins-pgo/get_hints.py to produce the branch hints,

# selecting min_count and threshold_ratio as you wish.

# 4. Optionally repeat steps 2-3 for additional workloads, and use

# tools/builtins-pgo/combine_hints.py to combine the hints produced in

# step 3 into a single file.

# 5. Build again with v8_builtins_profiling_log_file set to the file created

# in step 3 or 4.

v8_builtins_profiling_log_file = "default"

# Enable gearbox (instruction set extension) for builtins, the gearbox

# feature only supports x64 arch yet.

# Sets -DV8_BUILTINS_GEARBOX

v8_enable_builtins_gearbox = false

# Enables various testing features.

v8_enable_test_features = ""

# Enable short builtins call instruction sequences by un-embedding builtins.

# Sets -DV8_SHORT_BUILTIN_CALLS

v8_enable_short_builtin_calls = ""

# Enable support for external code range relative to the pointer compression

# cage.

# Sets -DV8_EXTERNAL_CODE_SPACE

v8_enable_external_code_space = ""

# With post mortem support enabled, metadata is embedded into libv8 that

# describes various parameters of the VM for use by debuggers. See

# tools/gen-postmortem-metadata.py for details.

v8_postmortem_support = false

# Use Siphash as added protection against hash flooding attacks.

v8_use_siphash = false

# Switches off inlining in V8.

v8_no_inline = false

# Override OS page size when generating snapshot

v8_os_page_size = "0"

# Similar to vfp but on MIPS.

v8_can_use_fpu_instructions = true

# Similar to the ARM hard float ABI but on MIPS.

v8_use_mips_abi_hardfloat = true

# Controls the threshold for on-heap/off-heap Typed Arrays.

v8_typed_array_max_size_in_heap = 64

v8_enable_gdbjit = ((v8_current_cpu == "x86" || v8_current_cpu == "x64") &&

(is_linux || is_chromeos || is_mac)) ||

(v8_current_cpu == "ppc64" && (is_linux || is_chromeos))

# Check that each header can be included in isolation (requires also

# setting the "check_v8_header_includes" gclient variable to run a

# specific hook).

v8_check_header_includes = false

# Enable lazy source positions by default.

v8_enable_lazy_source_positions = true

# Disable write barriers when GCs are non-incremental and

# heap has single generation.

v8_disable_write_barriers = false

# Ensure that write barriers are always used.

# Useful for debugging purposes.

v8_enable_unconditional_write_barriers = false

# Redirect allocation in young generation so that there will be

# only one single generation.

v8_enable_single_generation = ""

# Use token threaded dispatch for the regular expression interpreter.

# Use switch-based dispatch if this is false

v8_enable_regexp_interpreter_threaded_dispatch = true

# Enforce equality of builtins hashes from compatible architectures.

v8_verify_builtins_compatibility = false

# Check mksnapshot determinism by running it multiple times.

v8_verify_deterministic_mksnapshot = false

# Enable additional targets necessary for verification of torque

# file generation

v8_verify_torque_generation_invariance = false

# Generate comments describing the Torque intermediate representation.

v8_annotate_torque_ir = false

# Enable snapshot compression (enabled by default for desktop) devices.

v8_enable_snapshot_compression =

target_os == "android" || target_os == "chromeos" ||

target_os == "fuchsia"

# Enable control-flow integrity features, such as pointer authentication for

# ARM64. Enable it by default for simulator builds and when native code

# supports it as well. On Mac, control-flow integrity does not work so we

# avoid enabling it when using the simulator.

v8_control_flow_integrity = v8_current_cpu == "arm64" &&

((v8_target_is_simulator && target_os != "mac") ||

arm_control_flow_integrity != "none")

# Enable heap reservation of size 4GB. Only possible for 64bit archs.

cppgc_enable_caged_heap =

v8_current_cpu == "x64" || v8_current_cpu == "arm64" ||

v8_current_cpu == "loong64" || v8_current_cpu == "riscv64"

# Enables additional heap verification phases and checks.

cppgc_enable_verify_heap = ""

# Enable allocations during prefinalizer invocations.

cppgc_allow_allocations_in_prefinalizers = false

# Enable the V8 sandbox.

# Sets -DV8_ENABLE_SANDBOX.

v8_enable_sandbox = ""

# Enable experimental hardware support for the V8 sandbox if available.

# Sets -DV8_ENABLE_SANDBOX_HARDWARE_SUPPORT

v8_enable_sandbox_hardware_support = false

# Enable leaptiering

v8_enable_leaptiering = true

# Enable the memory corruption API. Useful for testing the sandbox.

# The memory corruption API is only exposed to JavaScript if sandbox testing

# mode is enabled at runtime, for example via --sandbox-fuzzing.

# WARNING This will enable builtins that (by design) cause memory corruption.

# Sets -DV8_ENABLE_MEMORY_CORRUPTION_API

v8_enable_memory_corruption_api = false

# Experimental feature for collecting per-class zone memory stats.

# Requires use_rtti = true

v8_enable_precise_zone_stats = false

# Set this if V8 monolithic static library is going to be linked into

# another shared library.

v8_monolithic_for_shared_library = false

# Experimental feature that uses SwissNameDictionary instead of NameDictionary

# as the backing store for all dictionary mode objects.

v8_enable_swiss_name_dictionary = false

# If enabled then macro definitions that are used in externally visible

# header files are placed in a separate header file v8-gn.h.

v8_generate_external_defines_header = false

# Experimental feature for tracking constness of properties in non-global

# dictionaries. Enabling this also always keeps prototypes in dict mode,

# meaning that they are not switched to fast mode.

# Sets -DV8_DICT_PROPERTY_CONST_TRACKING

v8_dict_property_const_tracking = false

# Enable map packing & unpacking (sets -DV8_MAP_PACKING).

v8_enable_map_packing = false

# Allow for JS promise hooks (instead of just C++).

v8_enable_javascript_promise_hooks = false

# Allow embedder data to be saved on continuations. Used to support

# TaskAttribution and `scheduler.yield()`.

# The flag enables disabling the feature, to test this data's overhead.

v8_enable_continuation_preserved_embedder_data = true

# Enable allocation folding globally (sets -DV8_ALLOCATION_FOLDING).

# When it's disabled, the --turbo-allocation-folding runtime flag will be ignored.

v8_enable_allocation_folding = true

# Enable runtime verification of heap snapshots produced for devtools.

v8_enable_heap_snapshot_verify = ""

# Enable global allocation site tracking.

v8_allocation_site_tracking = true

# TODO(cbruni, v8:12302): Remove once API is migrated

# Enable legacy mode for ScriptOrModule's lifetime. By default it's a

# temporary object, if enabled it will be kept alive by the parent Script.

# This is only used by nodejs.

v8_scriptormodule_legacy_lifetime = false

# Enables pointer compression for 8GB heaps.

# Sets -DV8_COMPRESS_POINTERS_8GB.

v8_enable_pointer_compression_8gb = ""

# Compile V8 using zlib as dependency.

# Sets -DV8_USE_ZLIB

v8_use_zlib = true

# Make ValueDeserializer crash if the data to deserialize is invalid.

v8_value_deserializer_hard_fail = false

# Enable jitless mode, including compile-time optimizations. Note that even

# when this is set to 'false', one can run V8 in jitless mode at runtime by

# passing the `--jitless` flag; but then you miss out on compile-time

# optimizations.

v8_jitless = v8_enable_lite_mode

# Enable Sparkplug

# Sets -DV8_ENABLE_SPARKPLUG.

v8_enable_sparkplug = ""

# Enable Maglev's graph printer.

# Sets -DV8_ENABLE_MAGLEV_GRAPH_PRINTER.

v8_enable_maglev_graph_printer = !build_with_chromium

# Enable slow tracing, e.g., tracing on every instruction or Turbofan node.

# Sets -DV8_ENABLE_SLOW_TRACING.

v8_enable_slow_tracing = is_debug

# Enable jump table switch for built-in.

v8_enable_builtin_jump_table_switch =

v8_current_cpu == "x64" || v8_current_cpu == "arm64"

v8_shortcut_strings_in_minor_ms = false

# Whether custom embedder snapshots may extend (= allocate new objects in)

# ReadOnlySpace.

v8_enable_extensible_ro_snapshot = true

# Black allocate objects on separate pages.

v8_enable_black_allocated_pages = ""

# Use sticky mark-bits for separating object generations.

v8_enable_sticky_mark_bits = false

# Use the experimental TSA-based definition for some builtins.

v8_enable_experimental_tsa_builtins = false

# Use the experimental encoding of undefined in double values.

v8_enable_experimental_undefined_double = false

v8_dcheck_always_on = dcheck_always_on

# Remote builds require an explicit dependency on icudat, but

# this breaks locally building V8 with ICU support when the file

# isn't present, which some embedders rely on. This option controls

# the explicit dependency and allows the build to complete.

v8_depend_on_icu_data_file = icu_use_data_file

# Experimental testing mode where various limits are artificially set lower.

v8_lower_limits_mode = false

# Enables the use of partition_alloc as the default allocator for standalone

# V8. This should be used for benchmarking and testing purposes to more

# closely mimic in-browser behavior.

#

# Currently used in d8.

# TODO(399144247,400141120,392817524): Temporarily disabled again because of

# performance regressions in multi-threaded, Zone-allocation heavy workloads,

# e.g., JetStream startup or Wasm eager compilation.

v8_enable_partition_alloc =

false && !build_with_v8_embedder &&

!(defined(build_with_node) && build_with_node) &&

(v8_target_cpu != "ppc64" && v8_target_cpu != "s390x")

# V8 uses Chrome's blink-gc clang plugin for checking V8's internal cppgc

# usages. The plugin is not exhaustive but covers most common known pitfalls.

use_cppgc_clang_plugin = true

# Deinterleaving load support.

v8_enable_wasm_deinterleaved_mem_ops = false

# Expose F.p.caller and .arguments as own properties.

v8_function_arguments_caller_are_own_props = false

# Use a hard-coded secret value when hashing.

v8_use_default_hasher_secret = true

}

# Derived defaults.

if (cppgc_enable_verify_heap == "") {

cppgc_enable_verify_heap = v8_enable_debugging_features || v8_dcheck_always_on

}

if (v8_enable_verify_heap == "") {

v8_enable_verify_heap = v8_enable_debugging_features

}

if (v8_enable_verify_write_barriers == "") {

v8_enable_verify_write_barriers =

v8_enable_debugging_features && !v8_disable_write_barriers

}

if (v8_enable_object_print == "") {

v8_enable_object_print = v8_enable_debugging_features

}

if (v8_always_enable_maglev_graph_labeller == "") {

v8_always_enable_maglev_graph_labeller = v8_enable_debugging_features

}

if (v8_enable_disassembler == "") {

v8_enable_disassembler = v8_enable_debugging_features

}

if (v8_enable_trace_maps == "") {

v8_enable_trace_maps = v8_enable_debugging_features

}

if (v8_enable_test_features == "") {

v8_enable_test_features = v8_enable_debugging_features || v8_dcheck_always_on

}

if (v8_enable_v8_checks == "") {

v8_enable_v8_checks = v8_enable_debugging_features

}

if (v8_enable_memory_accounting_checks == "") {

v8_enable_memory_accounting_checks =

v8_enable_debugging_features || v8_dcheck_always_on

}

if (v8_enable_heap_snapshot_verify == "") {

v8_enable_heap_snapshot_verify =

v8_enable_debugging_features || v8_dcheck_always_on

}

if (v8_enable_snapshot_code_comments) {

assert(v8_code_comments == true || v8_code_comments == "",

"v8_enable_snapshot_code_comments conflicts with v8_code_comments.")

v8_code_comments = true

} else if (v8_code_comments == "") {

v8_code_comments = v8_enable_debugging_features

}

if (v8_enable_debug_code == "") {

v8_enable_debug_code = v8_enable_debugging_features || v8_dcheck_always_on

}

if (v8_enable_snapshot_native_code_counters == "") {

v8_enable_snapshot_native_code_counters = v8_enable_debugging_features

}

if (v8_enable_drumbrake && v8_enable_webassembly) {

assert(

is_drumbrake_supported,

"DrumBrake is only available on x64, arm64 on Windows, Linux and MacOS.")

}

if (v8_enable_black_allocated_pages == "") {

v8_enable_black_allocated_pages = !v8_enable_sticky_mark_bits

}

# Toggle certain build flags for correctness fuzzing when building the

# clang_x64_fuzzer_experiments toolchain. We'll correctness-compare the

# default build with the experiments build.

if (v8_multi_arch_build &&

rebase_path(get_label_info(":d8", "root_out_dir"), root_build_dir) ==

"clang_x64_fuzzer_experiments") {

v8_enable_pointer_compression = !v8_enable_pointer_compression

v8_enable_experimental_undefined_double =

!v8_enable_experimental_undefined_double

v8_lower_limits_mode = !v8_lower_limits_mode

}

# Ensure the sandbox is on/off in the same way as pointer compression for

# correctness fuzzing builds.

if (v8_multi_arch_build) {

v8_enable_sandbox = v8_enable_pointer_compression

}

if (v8_enable_pointer_compression_shared_cage == "") {

v8_enable_pointer_compression_shared_cage = v8_enable_pointer_compression

}

if (v8_enable_pointer_compression_8gb == "") {

v8_enable_pointer_compression_8gb = false

}

if (v8_enable_local_handle_zapping == "") {

v8_enable_local_handle_zapping = v8_enable_handle_zapping

}

if (v8_enable_global_handle_zapping == "") {

v8_enable_global_handle_zapping = v8_enable_handle_zapping

}

if (v8_enable_fast_torque == "") {

v8_enable_fast_torque = v8_enable_fast_mksnapshot

}

if (v8_enable_concurrent_mksnapshot == "") {

v8_enable_concurrent_mksnapshot = v8_enable_fast_mksnapshot

}

if (v8_enable_short_builtin_calls == "") {

v8_enable_short_builtin_calls =

v8_current_cpu == "x64" || v8_current_cpu == "arm64" ||

v8_current_cpu == "loong64" || v8_current_cpu == "riscv64"

}

if (v8_enable_external_code_space == "") {

v8_enable_external_code_space =

v8_enable_pointer_compression &&

v8_enable_pointer_compression_shared_cage &&

(v8_current_cpu == "x64" || v8_current_cpu == "arm64" ||

v8_current_cpu == "loong64")

}

if (v8_enable_sparkplug == "") {

v8_enable_sparkplug = !v8_jitless

}

if (v8_enable_maglev == "") {

v8_enable_maglev = v8_enable_turbofan &&

(v8_current_cpu == "arm" || v8_current_cpu == "x64" ||

v8_current_cpu == "arm64" || v8_current_cpu == "s390x" ||

v8_current_cpu == "riscv64")

}

assert(v8_enable_turbofan || !v8_enable_maglev,

"Maglev is not available when Turbofan is disabled.")

is_wasm_interpreter_mode_enabled =

!v8_enable_sparkplug && !v8_enable_maglev && !v8_enable_turbofan &&

v8_enable_webassembly && v8_enable_drumbrake

assert(

!v8_jitless || (!v8_enable_sparkplug && !v8_enable_maglev &&

!v8_enable_turbofan && !v8_enable_webassembly) ||

is_wasm_interpreter_mode_enabled,

"Sparkplug, Maglev, Turbofan and Wasm are not available in jitless mode. But, if the Wasm interpreter mode is on, Wasm can work in jitless mode")

if (v8_enable_single_generation == "") {

v8_enable_single_generation = v8_disable_write_barriers

}

if (v8_enable_atomic_object_field_writes == "") {

v8_enable_atomic_object_field_writes = v8_enable_concurrent_marking

}

if (v8_enable_single_generation) {

v8_allocation_site_tracking = false

}

assert(!v8_enable_concurrent_marking || v8_enable_atomic_object_field_writes,

"Concurrent marking requires atomic object field writes.")

if (v8_enable_trace_unoptimized == "") {

v8_enable_trace_unoptimized =

v8_enable_trace_ignition || v8_enable_trace_baseline_exec

}

assert(!v8_enable_trace_ignition || v8_enable_trace_unoptimized,

"Ignition tracing requires unoptimized tracing to be enabled.")

assert(!v8_enable_trace_baseline_exec || v8_enable_trace_unoptimized,

"Baseline tracing requires unoptimized tracing to be enabled.")

assert(

v8_enable_debugging_features == true || v8_dcheck_always_on ||

!v8_enable_slow_dchecks,

"v8_enable_slow_dchecks requires v8_enable_debugging_features or dcheck_always_on.")

if (v8_enable_short_builtin_calls &&

(!v8_enable_pointer_compression && v8_current_cpu != "x64")) {

# Disable short calls when pointer compression is not enabled, except x64,

# where short builtin calls can still be enabled if the code range is

# guaranteed to be close enough to embedded builtins.

v8_enable_short_builtin_calls = false

}

if (v8_enable_sandbox == "") {

# TODO(saelo, v8:11880) remove dependency on v8_enable_external_code_space

# once that is enabled everywhere by default.

# TODO(chromium:1325784) the sandbox is not currently supported in Chromium

# on Fuchsia.

v8_enable_sandbox = v8_enable_pointer_compression_shared_cage &&

v8_enable_external_code_space && target_os != "fuchsia"

}

if (v8_enable_static_roots == "") {

# Static roots are only valid for builds with pointer compression and a

# shared read-only heap.

v8_enable_static_roots =

v8_enable_pointer_compression && v8_enable_external_code_space

}

assert(!v8_enable_static_roots ||

(v8_enable_pointer_compression && v8_enable_external_code_space),

"Trying to enable static roots in a configuration that is not supported")

assert(

!(v8_enable_static_roots && v8_enable_static_roots_generation),

"Static root values must be generated in a build that does not rely on static roots itself")

if (v8_builtins_profiling_log_file == "default") {

v8_builtins_profiling_log_file = ""

# The existing profile can be used only when

# * `v8_enable_builtins_optimization` - this switch enables builtins PGO,

# * `!v8_enable_builtins_profiling` - don't use the profiles when generating

# a new one,

# * `!is_debug && !dcheck_always_on` - these modes add more checks to

# the builtins control flow which makes the builtins code different,

# * `v8_enable_pointer_compression` - it changes the objects layouts,

# * `v8_enable_sandbox && v8_enable_external_code_space` because they affect

# the way how external pointer values are accessed,

# * `v8_enable_webassembly` because it changes the set of opcodes which

# affects graphs hashes.

if (v8_enable_builtins_optimization && !v8_enable_builtins_profiling &&

!is_debug && !v8_dcheck_always_on && v8_enable_webassembly) {

# This is about function arguments evaluation order on the machine building

# mksnapshot, which makes node IDs not predictable for subgraphs like

# Op1(Op2(), Op3()) and as a result different graph hashes.

# Clang uses left-to-right order everywhere except Windows, otherwise the

# order is right-to-left.

# TODO(crbug.com/v8/13647): Remove once this issue is fixed in CSA.

if (!is_clang || host_os == "win") {

pgo_profile_suffix = "-rl"

} else {

pgo_profile_suffix = ""

}

if ((v8_current_cpu == "x64" || v8_current_cpu == "arm64") &&

v8_enable_pointer_compression && v8_enable_external_code_space &&

v8_enable_sandbox) {

# Note, currently x64 profile can be applied to arm64 but not the other

# way round.

v8_builtins_profiling_log_file =

"tools/builtins-pgo/profiles/x64" + pgo_profile_suffix + ".profile"

} else if (v8_current_cpu == "x86" || v8_current_cpu == "arm") {

# Note, x86 profile can be applied to arm but not the other way round.

v8_builtins_profiling_log_file =

"tools/builtins-pgo/profiles/x86" + pgo_profile_suffix + ".profile"

}

}

}

if (v8_enable_webassembly && !v8_target_is_simulator &&

v8_current_cpu == "x64") {

v8_enable_wasm_simd256_revec = true

}

if (v8_enable_webassembly && v8_current_cpu == "arm64") {

v8_enable_wasm_deinterleaved_mem_ops = true

}

assert(!v8_disable_write_barriers || v8_enable_single_generation,

"Disabling write barriers works only with single generation")

assert(!v8_enable_verify_write_barriers || !v8_disable_write_barriers,

"Write barriers need to be enabled for verification")

assert(v8_current_cpu == "arm64" || !v8_control_flow_integrity,

"Control-flow integrity is only supported on arm64")

assert(!v8_enable_map_packing || !v8_enable_pointer_compression,

"Map packing does not support pointer compression")

assert(!v8_enable_map_packing || v8_current_cpu == "x64",

"Map packing is only supported on x64")

assert(!v8_enable_external_code_space || v8_enable_pointer_compression,

"External code space feature requires pointer compression")

assert(!v8_enable_pointer_compression_8gb || v8_enable_pointer_compression,

"Pointer compression for 8GB cages requires pointer compression")

assert(!v8_enable_sandbox || v8_enable_external_code_space,

"The sandbox requires the external code space")

assert(

v8_enable_leaptiering,

"non-leaptiering is deprecated (see https://groups.google.com/g/v8-dev/c/PYk2_GGP2Wk)")

assert(!v8_enable_memory_corruption_api || v8_enable_sandbox,

"The Memory Corruption API requires the sandbox")

assert(!v8_enable_sandbox_hardware_support || v8_enable_sandbox,

"The sandbox must be enabled to enable sandbox hardware support")

assert(

!v8_enable_pointer_compression_shared_cage || v8_enable_pointer_compression,

"Can't share a pointer compression cage if pointers aren't compressed")

assert(

!v8_enable_pointer_compression_shared_cage || v8_current_cpu == "x64" ||

v8_current_cpu == "arm64" || v8_current_cpu == "riscv64" ||

v8_current_cpu == "ppc64" || v8_current_cpu == "s390x" ||

v8_current_cpu == "loong64",

"Sharing a pointer compression cage is only supported on x64, arm64, ppc64, s390x, riscv64 and loong64")

assert(!v8_enable_unconditional_write_barriers || !v8_disable_write_barriers,

"Write barriers can't be both enabled and disabled")

assert(!cppgc_enable_caged_heap || v8_current_cpu == "x64" ||

v8_current_cpu == "arm64" || v8_current_cpu == "loong64" ||

v8_current_cpu == "riscv64",

"CppGC caged heap requires 64bit platforms")

assert(!cppgc_enable_young_generation || cppgc_enable_caged_heap,

"Young generation in CppGC requires caged heap")

assert(!cppgc_enable_pointer_compression || cppgc_enable_caged_heap,

"Pointer compression in CppGC requires caged heap")

if (v8_enable_single_generation == true) {

assert(

v8_enable_unconditional_write_barriers || v8_disable_write_barriers,

"Requires unconditional write barriers or none (which disables incremental marking)")

}

assert(!v8_enable_snapshot_compression || v8_use_zlib,

"Snapshot compression requires zlib")

assert(!v8_enable_cet_shadow_stack ||

(v8_target_cpu == "x64" && target_os == "win"),

"CET shadow stack is supported only on x64 Windows")

if (v8_enable_sticky_mark_bits) {

# To support sticky mark bits, pretenured allocations must be allocated from

# a separate free-list and the atomic pause (or the sweeper) must fix up the

# mark bits.

assert(!v8_enable_black_allocated_pages,

"Black allocated pages are not yet supported with sticky mark bits")

}

if (v8_expose_public_symbols == "") {

v8_expose_public_symbols = v8_expose_symbols

}

assert(

!build_with_chromium || !v8_enable_partition_alloc,

"V8 using partition_alloc from Chromium is not implemented at the moment")

v8_random_seed = "314159265"

v8_toolset_for_shell = "host"

is_DEBUG_defined = v8_enable_debugging_features || v8_dcheck_always_on

###############################################################################

# Configurations

#

config("internal_config_base") {

# Only targets in this file and its subdirs can depend on this.

visibility = [ "./*" ]

configs = [ ":v8_tracing_config" ]

include_dirs = [

".",

"include",

"$target_gen_dir",

"$target_gen_dir/include",

]

}

config("internal_config") {

defines = []

# Only targets in this file and its subdirs can depend on this.

visibility = [ "./*" ]

configs = [

"//build/config/compiler:wexit_time_destructors",

":internal_config_base",

":v8_header_features",

":cppgc_header_features",

]

if (is_component_build) {

defines += [ "BUILDING_V8_SHARED_PRIVATE" ]

} else if (v8_expose_public_symbols) {

defines += [ "BUILDING_V8_SHARED" ]

}

if (v8_current_cpu == "riscv64" || v8_current_cpu == "riscv32") {

if (!is_clang) {

libs = [ "atomic" ]

}

}

}

# Should be applied to all targets that write trace events.

config("v8_tracing_config") {

if (v8_use_perfetto) {

include_dirs = [

"//third_party/perfetto/include",

"$root_gen_dir/third_party/perfetto",

"$root_gen_dir/third_party/perfetto/build_config",

]

}

}

# This config should be applied to code using the libplatform.

config("libplatform_config") {

include_dirs = [ "include" ]

if (is_component_build) {

defines = [ "USING_V8_PLATFORM_SHARED" ]

}

}

# This config should be applied to code using the libbase.

config("libbase_config") {

if (is_component_build) {

defines = [ "USING_V8_BASE_SHARED" ]

}

libs = []

if (is_android && current_toolchain != host_toolchain) {

libs += [ "log" ]

}

}

config("zoslib_config") {

if (current_os == "zos") {

configs = [ "//third_party/zoslib:zoslib_config" ]

}

}

# Standalone cppgc cannot be built within chrome or with perfetto.

assert(!cppgc_is_standalone || !build_with_chromium)

assert(!cppgc_is_standalone || !v8_use_perfetto)

# This config should be applied to code using the cppgc_base.

config("cppgc_base_config") {

defines = []

if (cppgc_is_standalone) {

defines += [ "CPPGC_IS_STANDALONE" ]

}

}

# This config is only applied to v8_headers and is the basis for external_config

# but without setting the USING_V8_SHARED define, which means v8_headers can be

# used inside v8 itself.

config("headers_config") {

defines = []

configs = [

":v8_header_features",

":cppgc_header_features",

]

include_dirs = [ "include" ]

}

# This config should only be applied to code using V8 and not any V8 code

# itself.

config("external_config") {

configs = [ ":headers_config" ]

defines = []

if (is_component_build) {

defines += [

"USING_V8_SHARED",

"USING_V8_SHARED_PRIVATE",

]

}

if (current_cpu == "riscv64" || current_cpu == "riscv32") {

if (!is_clang) {

libs = [ "atomic" ]

}

}

}

# This config should only be applied to code that needs to be explicitly

# aware of whether we are using startup data or not.

config("external_startup_data") {

if (v8_use_external_startup_data) {

defines = [ "V8_USE_EXTERNAL_STARTUP_DATA" ]

}

}

# List of defines that can appear in externally visible header files and that

# are controlled by args.gn.

# Make sure the |v8_generate_features_json| action is also updated when adding

# or removing defines below.

external_v8_defines = [

"V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT=${v8_array_buffer_internal_field_count}",

"V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT=${v8_array_buffer_view_internal_field_count}",

"V8_PROMISE_INTERNAL_FIELD_COUNT=${v8_promise_internal_field_count}",

"V8_USE_DEFAULT_HASHER_SECRET=${v8_use_default_hasher_secret}",

"V8_ENABLE_CHECKS",

"V8_ENABLE_MEMORY_ACCOUNTING_CHECKS",

"V8_COMPRESS_POINTERS",

"V8_COMPRESS_POINTERS_IN_SHARED_CAGE",

"V8_31BIT_SMIS_ON_64BIT_ARCH",

"V8_COMPRESS_ZONES",

"V8_ENABLE_SANDBOX",

"V8_DEPRECATION_WARNINGS",

"V8_IMMINENT_DEPRECATION_WARNINGS",

"V8_USE_PERFETTO",

"V8_MAP_PACKING",

"V8_IS_TSAN",

"V8_ENABLE_DIRECT_HANDLE",

"V8_MINORMS_STRING_SHORTCUTTING",

"V8_HAVE_TARGET_OS",

"V8_TARGET_OS_ANDROID",

"V8_TARGET_OS_FUCHSIA",

"V8_TARGET_OS_IOS",

"V8_TARGET_OS_LINUX",

"V8_TARGET_OS_MACOS",

"V8_TARGET_OS_WIN",

"V8_TARGET_OS_CHROMEOS",

]

enabled_external_v8_defines = [

"V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT=${v8_array_buffer_internal_field_count}",

"V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT=${v8_array_buffer_view_internal_field_count}",

"V8_PROMISE_INTERNAL_FIELD_COUNT=${v8_promise_internal_field_count}",

"V8_USE_DEFAULT_HASHER_SECRET=${v8_use_default_hasher_secret}",