# 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/dcheck_always_on.gni")

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

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

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

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

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

if (is_android) {

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

}

import("gni/snapshot_toolchain.gni")

import("gni/v8.gni")

# Specifies if the target build is a simulator build. Comparing target cpu

# with v8 target cpu to not affect simulator builds for making cross-compile

# snapshots.

is_target_simulator = (target_cpu != v8_target_cpu && !v8_multi_arch_build) ||

(current_cpu != v8_current_cpu && v8_multi_arch_build)

# 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 = ""

# Turns on all V8 debug features. Enables running V8 in a pseudo debug mode

# within a release Chrome.

v8_enable_debugging_features = is_debug

# Sets -DV8_ENABLE_FUTURE.

v8_enable_future = false

# Lite mode disables a number of performance optimizations to reduce memory

# at the cost of performance.

# Sets --DV8_LITE_MODE.

v8_enable_lite_mode = false

# Sets -DVERIFY_HEAP.

v8_enable_verify_heap = ""

# 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 -dENABLE_GDB_JIT_INTERFACE.

v8_enable_gdbjit = ""

# Sets -dENABLE_VTUNE_JIT_INTERFACE.

v8_enable_vtunejit = false

# Sets -dENABLE_HANDLE_ZAPPING.

v8_enable_handle_zapping = true

# Enable slow dchecks.

v8_enable_slow_dchecks = false

# Enable fast mksnapshot runs.

v8_enable_fast_mksnapshot = false

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

v8_enable_fast_torque = ""

# Enable embedded builtins.

v8_enable_embedded_builtins = true

# Enable the registration of unwinding info for Windows/x64.

v8_win64_unwinding_info = true

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

v8_enable_snapshot_code_comments = false

# 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 = ""

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

v8_enable_verify_csa = false

# Enable pointer compression (sets -dV8_COMPRESS_POINTERS).

v8_enable_pointer_compression = false

v8_enable_31bit_smis_on_64bit_arch = false

# Sets -dOBJECT_PRINT.

v8_enable_object_print = ""

# Sets -dV8_TRACE_MAPS.

v8_enable_trace_maps = ""

# Sets -dV8_ENABLE_CHECKS.

v8_enable_v8_checks = ""

# Sets -dV8_TRACE_IGNITION.

v8_enable_trace_ignition = false

# Sets -dV8_TRACE_FEEDBACK_UPDATES.

v8_enable_trace_feedback_updates = false

# Sets -dV8_CONCURRENT_MARKING

v8_enable_concurrent_marking = true

# Enables various testing features.

v8_enable_test_features = ""

# 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

# List of extra files to snapshot. They will be snapshotted in order so

# if files export symbols used by later files, they should go first.

#

# This default is used by cctests. Projects using V8 will want to override.

v8_extra_library_files = [ "//test/cctest/test-extra.js" ]

v8_enable_gdbjit =

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

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

# Temporary flag to allow embedders to update their microtasks scopes

# while rolling in a new version of V8.

v8_check_microtasks_scopes_consistency = ""

# Enable mitigations for executing untrusted code.

# Disabled by default on ia32 due to conflicting requirements with embedded

# builtins. Enabled by default on Android since it doesn't support

# site-isolation in Chrome and on simulator builds which test code generation

# on these platforms.

v8_untrusted_code_mitigations =

v8_current_cpu != "x86" && (is_android || is_target_simulator)

# Enable minor mark compact.

v8_enable_minor_mc = true

# 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 sharing read-only space across isolates.

# Sets -DV8_SHARED_RO_HEAP.

v8_enable_shared_ro_heap = ""

}

# We reuse the snapshot toolchain for building torque and other generators to

# avoid building v8_libbase on the host more than once. On mips with big endian,

# the snapshot toolchain is the target toolchain and, hence, can't be used.

v8_generator_toolchain = v8_snapshot_toolchain

if (host_cpu == "x64" &&

(v8_current_cpu == "mips" || v8_current_cpu == "mips64")) {

v8_generator_toolchain = "//build/toolchain/linux:clang_x64"

}

# Derived defaults.

if (v8_enable_verify_heap == "") {

v8_enable_verify_heap = v8_enable_debugging_features

}

if (v8_enable_object_print == "") {

v8_enable_object_print = 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 || dcheck_always_on

}

if (v8_enable_v8_checks == "") {

v8_enable_v8_checks = v8_enable_debugging_features

}

if (v8_check_microtasks_scopes_consistency == "") {

v8_check_microtasks_scopes_consistency =

v8_enable_debugging_features || dcheck_always_on

}

if (v8_enable_snapshot_native_code_counters == "") {

v8_enable_snapshot_native_code_counters = v8_enable_debugging_features

}

if (v8_enable_shared_ro_heap == "") {

v8_enable_shared_ro_heap = v8_enable_lite_mode

}

if (v8_enable_fast_torque == "") {

v8_enable_fast_torque = v8_enable_fast_mksnapshot

}

assert(v8_current_cpu != "x86" || !v8_untrusted_code_mitigations,

"Untrusted code mitigations are unsupported on ia32")

assert(!v8_enable_lite_mode || v8_enable_embedded_builtins,

"Lite mode requires embedded builtins")

assert(!v8_enable_lite_mode || v8_use_snapshot,

"Lite mode requires a snapshot build")

assert(

!v8_enable_pointer_compression || !v8_enable_shared_ro_heap,

"Pointer compression is not supported with shared read-only heap enabled")

v8_random_seed = "314159265"

v8_toolset_for_shell = "host"

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

# Configurations

#

config("internal_config_base") {

visibility = [ ":*" ] # Only targets in this file can depend on this.

include_dirs = [

".",

"$target_gen_dir",

]

}

config("internal_config") {

defines = []

visibility = [ ":*" ] # Only targets in this file can depend on this.

configs = [

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

":internal_config_base",

":v8_header_features",

]

if (is_component_build) {

defines += [ "BUILDING_V8_SHARED" ]

}

}

# 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" ]

}

}

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

config("libsampler_config") {

include_dirs = [ "include" ]

}

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

# itself.

config("external_config") {

defines = []

configs = [ ":v8_header_features" ]

if (is_component_build) {

defines += [ "USING_V8_SHARED" ]

}

include_dirs = [

"include",

"$target_gen_dir/include",

]

}

# 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" ]

}

}

# Put defines that are used in public headers here; public headers are

# defined in "v8_headers" and are included by embedders of V8.

config("v8_header_features") {

visibility = [ ":*" ]

defines = []

if (v8_enable_v8_checks) {

defines += [ "V8_ENABLE_CHECKS" ] # Used in "include/v8.h".

}

if (v8_enable_pointer_compression) {

defines += [ "V8_COMPRESS_POINTERS" ]

}

if (v8_enable_pointer_compression || v8_enable_31bit_smis_on_64bit_arch) {

defines += [ "V8_31BIT_SMIS_ON_64BIT_ARCH" ]

}

if (v8_deprecation_warnings) {

defines += [ "V8_DEPRECATION_WARNINGS" ]

}

if (v8_imminent_deprecation_warnings) {

defines += [ "V8_IMMINENT_DEPRECATION_WARNINGS" ]

}

}

# Put defines here that are only used in our internal files and NEVER in

# external headers that embedders (such as chromium and node) might include.

config("features") {

visibility = [ ":*" ] # Only targets in this file can depend on this.

defines = []

configs = [ ":v8_header_features" ]

if (v8_embedder_string != "") {

defines += [ "V8_EMBEDDER_STRING=\"$v8_embedder_string\"" ]

}

if (v8_enable_disassembler) {

defines += [ "ENABLE_DISASSEMBLER" ]

}

if (v8_promise_internal_field_count != 0) {

defines +=

[ "V8_PROMISE_INTERNAL_FIELD_COUNT=${v8_promise_internal_field_count}" ]

}

defines +=

[ "V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=${v8_typed_array_max_size_in_heap}" ]

if (v8_enable_raw_heap_snapshots) {

defines += [ "V8_ENABLE_RAW_HEAP_SNAPSHOTS" ]

}

if (v8_enable_future) {

defines += [ "V8_ENABLE_FUTURE" ]

}

if (v8_enable_lite_mode) {

defines += [ "V8_LITE_MODE" ]

# TODO(v8:7777): Remove the define once the --jitless runtime flag does

# everything we need.

defines += [ "V8_JITLESS_MODE" ]

}

if (v8_enable_gdbjit) {

defines += [ "ENABLE_GDB_JIT_INTERFACE" ]

}

if (v8_enable_vtunejit) {

defines += [ "ENABLE_VTUNE_JIT_INTERFACE" ]

}

if (v8_enable_minor_mc) {

defines += [ "ENABLE_MINOR_MC" ]

}

if (v8_enable_object_print) {

defines += [ "OBJECT_PRINT" ]

}

if (v8_enable_verify_heap) {

defines += [ "VERIFY_HEAP" ]

}

if (v8_enable_verify_predictable) {

defines += [ "VERIFY_PREDICTABLE" ]

}

if (v8_enable_trace_maps) {

defines += [ "V8_TRACE_MAPS" ]

}

if (v8_enable_trace_ignition) {

defines += [ "V8_TRACE_IGNITION" ]

}

if (v8_enable_trace_feedback_updates) {

defines += [ "V8_TRACE_FEEDBACK_UPDATES" ]

}

if (v8_enable_test_features) {

defines += [ "V8_ENABLE_ALLOCATION_TIMEOUT" ]

defines += [ "V8_ENABLE_FORCE_SLOW_PATH" ]

}

if (v8_enable_i18n_support) {

defines += [ "V8_INTL_SUPPORT" ]

}

if (v8_enable_handle_zapping) {

defines += [ "ENABLE_HANDLE_ZAPPING" ]

}

if (v8_use_snapshot) {

defines += [ "V8_USE_SNAPSHOT" ]

if (v8_enable_snapshot_native_code_counters) {

defines += [ "V8_SNAPSHOT_NATIVE_CODE_COUNTERS" ]

}

}

if (v8_use_external_startup_data) {

defines += [ "V8_USE_EXTERNAL_STARTUP_DATA" ]

}

if (v8_enable_concurrent_marking) {

defines += [ "V8_CONCURRENT_MARKING" ]

}

if (v8_check_microtasks_scopes_consistency) {

defines += [ "V8_CHECK_MICROTASKS_SCOPES_CONSISTENCY" ]

}

if (v8_enable_embedded_builtins) {

defines += [ "V8_EMBEDDED_BUILTINS" ]

}

if (v8_use_multi_snapshots) {

defines += [ "V8_MULTI_SNAPSHOTS" ]

}

if (v8_use_siphash) {

defines += [ "V8_USE_SIPHASH" ]

}

if (v8_enable_shared_ro_heap) {

defines += [ "V8_SHARED_RO_HEAP" ]

}

if (v8_use_perfetto) {

defines += [ "V8_USE_PERFETTO" ]

}

if (v8_win64_unwinding_info) {

defines += [ "V8_WIN64_UNWINDING_INFO" ]

}

}

config("toolchain") {

visibility = [ ":*" ] # Only targets in this file can depend on this.

defines = []

cflags = []

ldflags = []

if (v8_current_cpu == "arm") {

defines += [ "V8_TARGET_ARCH_ARM" ]

if (arm_version >= 7) {

defines += [ "CAN_USE_ARMV7_INSTRUCTIONS" ]

}

if (arm_fpu == "vfpv3-d16") {

defines += [ "CAN_USE_VFP3_INSTRUCTIONS" ]

} else if (arm_fpu == "vfpv3") {

defines += [

"CAN_USE_VFP3_INSTRUCTIONS",

"CAN_USE_VFP32DREGS",

]

} else if (arm_fpu == "neon") {

defines += [

"CAN_USE_VFP3_INSTRUCTIONS",

"CAN_USE_VFP32DREGS",

"CAN_USE_NEON",

]

}

# TODO(jochen): Add support for arm_test_noprobe.

if (current_cpu != "arm") {

# These defines ares used for the ARM simulator.

if (arm_float_abi == "hard") {

defines += [ "USE_EABI_HARDFLOAT=1" ]

} else if (arm_float_abi == "softfp") {

defines += [ "USE_EABI_HARDFLOAT=0" ]

}

}

}

if (v8_current_cpu == "arm64") {

defines += [ "V8_TARGET_ARCH_ARM64" ]

}

# Mips64el/mipsel simulators.

if (is_target_simulator &&

(v8_current_cpu == "mipsel" || v8_current_cpu == "mips64el")) {

defines += [ "_MIPS_TARGET_SIMULATOR" ]

}

if (v8_current_cpu == "mipsel" || v8_current_cpu == "mips") {

defines += [ "V8_TARGET_ARCH_MIPS" ]

if (v8_can_use_fpu_instructions) {

defines += [ "CAN_USE_FPU_INSTRUCTIONS" ]

}

if (v8_use_mips_abi_hardfloat) {

defines += [

"__mips_hard_float=1",

"CAN_USE_FPU_INSTRUCTIONS",

]

} else {

defines += [ "__mips_soft_float=1" ]

}

if (mips_arch_variant == "r6") {

defines += [

"_MIPS_ARCH_MIPS32R6",

"FPU_MODE_FP64",

]

if (mips_use_msa) {

defines += [ "_MIPS_MSA" ]

}

} else if (mips_arch_variant == "r2") {

defines += [ "_MIPS_ARCH_MIPS32R2" ]

if (mips_fpu_mode == "fp64") {

defines += [ "FPU_MODE_FP64" ]

} else if (mips_fpu_mode == "fpxx") {

defines += [ "FPU_MODE_FPXX" ]

} else if (mips_fpu_mode == "fp32") {

defines += [ "FPU_MODE_FP32" ]

}

} else if (mips_arch_variant == "r1") {

defines += [ "FPU_MODE_FP32" ]

}

# TODO(jochen): Add support for mips_arch_variant rx and loongson.

}

if (v8_current_cpu == "mips64el" || v8_current_cpu == "mips64") {

defines += [ "V8_TARGET_ARCH_MIPS64" ]

if (v8_can_use_fpu_instructions) {

defines += [ "CAN_USE_FPU_INSTRUCTIONS" ]

}

if (host_byteorder == "little") {

defines += [ "V8_TARGET_ARCH_MIPS64_LE" ]

} else if (host_byteorder == "big") {

defines += [ "V8_TARGET_ARCH_MIPS64_BE" ]

}

if (v8_use_mips_abi_hardfloat) {

defines += [

"__mips_hard_float=1",

"CAN_USE_FPU_INSTRUCTIONS",

]

} else {

defines += [ "__mips_soft_float=1" ]

}

if (mips_arch_variant == "r6") {

defines += [ "_MIPS_ARCH_MIPS64R6" ]

if (mips_use_msa) {

defines += [ "_MIPS_MSA" ]

}

} else if (mips_arch_variant == "r2") {

defines += [ "_MIPS_ARCH_MIPS64R2" ]

}

}

if (v8_current_cpu == "s390" || v8_current_cpu == "s390x") {

defines += [ "V8_TARGET_ARCH_S390" ]

if (v8_current_cpu == "s390x") {

defines += [ "V8_TARGET_ARCH_S390X" ]

}

if (host_byteorder == "little") {

defines += [ "V8_TARGET_ARCH_S390_LE_SIM" ]

} else {

cflags += [ "-march=z196" ]

}

}

if (v8_current_cpu == "ppc" || v8_current_cpu == "ppc64") {

defines += [ "V8_TARGET_ARCH_PPC" ]

if (v8_current_cpu == "ppc64") {

defines += [ "V8_TARGET_ARCH_PPC64" ]

}

if (host_byteorder == "little") {

defines += [ "V8_TARGET_ARCH_PPC_LE" ]

} else if (host_byteorder == "big") {

defines += [ "V8_TARGET_ARCH_PPC_BE" ]

if (current_os == "aix") {

cflags += [

# Work around AIX ceil, trunc and round oddities.

"-mcpu=power5+",

"-mfprnd",

# Work around AIX assembler popcntb bug.

"-mno-popcntb",

]

}

}

}

if (v8_current_cpu == "x86") {

defines += [ "V8_TARGET_ARCH_IA32" ]

if (is_win) {

# Ensure no surprising artifacts from 80bit double math with x86.

cflags += [ "/arch:SSE2" ]

}

}

if (v8_current_cpu == "x64") {

defines += [ "V8_TARGET_ARCH_X64" ]

if (is_win) {

# Increase the initial stack size. The default is 1MB, this is 2MB. This

# applies only to executables and shared libraries produced by V8 since

# ldflags are not pushed to dependants.

ldflags += [ "/STACK:2097152" ]

}

}

if (is_android && v8_android_log_stdout) {

defines += [ "V8_ANDROID_LOG_STDOUT" ]

}

# TODO(jochen): Support v8_enable_prof on Windows.

# TODO(jochen): Add support for compiling with simulators.

if (v8_enable_debugging_features) {

if (is_linux && v8_enable_backtrace) {

ldflags += [ "-rdynamic" ]

}

defines += [ "DEBUG" ]

if (v8_enable_slow_dchecks) {

defines += [ "ENABLE_SLOW_DCHECKS" ]

}

} else if (dcheck_always_on) {

defines += [ "DEBUG" ]

}

if (v8_enable_verify_csa) {

defines += [ "ENABLE_VERIFY_CSA" ]

}

if (!v8_untrusted_code_mitigations) {

defines += [ "DISABLE_UNTRUSTED_CODE_MITIGATIONS" ]

}

if (v8_no_inline) {

if (is_win) {

cflags += [ "/Ob0" ]

} else {

cflags += [

"-fno-inline-functions",

"-fno-inline",

]

}

}

if (is_clang) {

cflags += [ "-Wmissing-field-initializers" ]

if (v8_current_cpu != "mips" && v8_current_cpu != "mipsel") {

# We exclude MIPS because the IsMipsArchVariant macro causes trouble.

cflags += [ "-Wunreachable-code" ]

}

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

v8_current_cpu == "mips64el") {

cflags += [ "-Wshorten-64-to-32" ]

}

}

if (is_win) {

cflags += [

"/wd4245", # Conversion with signed/unsigned mismatch.

"/wd4267", # Conversion with possible loss of data.

"/wd4324", # Padding structure due to alignment.

"/wd4701", # Potentially uninitialized local variable.

"/wd4702", # Unreachable code.

"/wd4703", # Potentially uninitialized local pointer variable.

"/wd4709", # Comma operator within array index expr (bugged).

"/wd4714", # Function marked forceinline not inlined.

# MSVC assumes that control can get past an exhaustive switch and then

# warns if there's no return there (see https://crbug.com/v8/7658)

"/wd4715", # Not all control paths return a value.

"/wd4718", # Recursive call has no side-effect.

"/wd4723", # https://crbug.com/v8/7771

"/wd4724", # https://crbug.com/v8/7771

"/wd4800", # Forcing value to bool.

]

}

if (!is_clang && !is_win) {

cflags += [

# Disable gcc warnings for optimizations based on the assumption that

# signed overflow does not occur. Generates false positives (see

# http://crbug.com/v8/6341).

"-Wno-strict-overflow",

# GCC assumes that control can get past an exhaustive switch and then

# warns if there's no return there (see https://crbug.com/v8/7658).

"-Wno-return-type",

]

}

# Chromium uses a hand-picked subset of UBSan coverage. We want everything.

if (is_ubsan) {

cflags += [ "-fsanitize=undefined" ]

}

}

# For code that is hot during mksnapshot. In fast-mksnapshot builds, we

# optimize some files even in debug builds to speed up mksnapshot times.

config("always_optimize") {

configs = [ ":internal_config" ]

# TODO(crbug.com/621335) Rework this so that we don't have the confusion

# between "optimize_speed" and "optimize_max".

if (((is_posix && !is_android) || is_fuchsia) && !using_sanitizer) {

configs += [ "//build/config/compiler:optimize_speed" ]

} else {

configs += [ "//build/config/compiler:optimize_max" ]

}

}

# Configs for code coverage with gcov. Separate configs for cflags and ldflags

# to selectively influde cflags in non-test targets only.

config("v8_gcov_coverage_cflags") {

cflags = [

"-fprofile-arcs",

"-ftest-coverage",

]

}

config("v8_gcov_coverage_ldflags") {

ldflags = [ "-fprofile-arcs" ]

}

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

# Actions

#

# Only for Windows clang builds. Converts the embedded.S file produced by

# mksnapshot into an embedded.cc file with corresponding inline assembly.

template("asm_to_inline_asm") {

name = target_name

if (name == "default") {

suffix = ""

} else {

suffix = "_$name"

}

action("asm_to_inline_asm_" + name) {

visibility = [ ":*" ] # Only targets in this file can depend on this.

assert(emit_builtins_as_inline_asm)

script = "tools/snapshot/asm_to_inline_asm.py"

deps = [

":run_mksnapshot_" + name,

]

sources = [

"$target_gen_dir/embedded${suffix}.S",

]

outputs = [

"$target_gen_dir/embedded${suffix}.cc",

]

args = invoker.args

args += [

rebase_path("$target_gen_dir/embedded${suffix}.S", root_build_dir),

rebase_path("$target_gen_dir/embedded${suffix}.cc", root_build_dir),

]

}

}

action("js2c_extras") {

visibility = [ ":*" ] # Only targets in this file can depend on this.

script = "tools/js2c.py"

sources = v8_extra_library_files

outputs = [

"$target_gen_dir/extras-libraries.cc",

]

args = [

rebase_path("$target_gen_dir/extras-libraries.cc", root_build_dir),

"EXTRAS",

] + rebase_path(sources, root_build_dir)

if (v8_use_external_startup_data) {

outputs += [ "$target_gen_dir/libraries_extras.bin" ]

args += [

"--startup_blob",

rebase_path("$target_gen_dir/libraries_extras.bin", root_build_dir),

]

}

}

if (is_android && enable_java_templates) {

android_assets("v8_external_startup_data_assets") {

if (v8_use_external_startup_data) {

# We don't support side-by-side snapshots on Android within Chromium.

assert(!v8_use_multi_snapshots)

deps = [

"//v8",

]

sources = [

"$root_out_dir/natives_blob.bin",

]

renaming_sources = [ "$root_out_dir/snapshot_blob.bin" ]

if (current_cpu == "arm" || current_cpu == "x86" ||

current_cpu == "mipsel") {

renaming_destinations = [ "snapshot_blob_32.bin" ]

} else {

renaming_destinations = [ "snapshot_blob_64.bin" ]

}

disable_compression = true

}

}

}

if (v8_use_external_startup_data) {

action("natives_blob") {

visibility = [ ":*" ] # Only targets in this file can depend on this.

deps = [

":js2c_extras",

]

# NOSORT

sources = [

"$target_gen_dir/libraries_extras.bin",

]

outputs = [

"$root_out_dir/natives_blob.bin",

]

data = [

"$root_out_dir/natives_blob.bin",

]

script = "tools/concatenate-files.py"

args = rebase_path(sources + outputs, root_build_dir)

}

}

action("postmortem-metadata") {

# Only targets in this file and the top-level visibility target can

# depend on this.

visibility = [

":*",

"//:gn_visibility",

]

script = "tools/gen-postmortem-metadata.py"

# NOSORT

sources = [

"src/objects/objects.h",

"src/objects/objects-inl.h",

"src/objects/allocation-site-inl.h",

"src/objects/allocation-site.h",

"src/objects/cell-inl.h",

"src/objects/cell.h",

"src/objects/code-inl.h",

"src/objects/code.h",

"src/objects/data-handler.h",

"src/objects/data-handler-inl.h",

"src/objects/feedback-cell.h",

"src/objects/feedback-cell-inl.h",

"src/objects/fixed-array-inl.h",

"src/objects/fixed-array.h",

"src/objects/heap-number-inl.h",

"src/objects/heap-number.h",

"src/objects/heap-object-inl.h",

"src/objects/heap-object.h",

"src/objects/instance-type.h",

"src/objects/js-array-inl.h",

"src/objects/js-array.h",

"src/objects/js-array-buffer-inl.h",

"src/objects/js-array-buffer.h",

"src/objects/js-objects-inl.h",

"src/objects/js-objects.h",

"src/objects/js-promise-inl.h",

"src/objects/js-promise.h",

"src/objects/js-regexp-inl.h",

"src/objects/js-regexp.h",

"src/objects/js-regexp-string-iterator-inl.h",

"src/objects/js-regexp-string-iterator.h",

"src/objects/map.h",

"src/objects/map.cc",

"src/objects/map-inl.h",

"src/objects/js-objects.cc",

"src/objects/name.h",

"src/objects/name-inl.h",

"src/objects/oddball-inl.h",

"src/objects/oddball.h",

"src/objects/scope-info.h",

"src/objects/script.h",

"src/objects/script-inl.h",

"src/objects/shared-function-info.h",

"src/objects/shared-function-info-inl.h",

"src/objects/string.cc",

"src/objects/string.h",

"src/objects/string-comparator.cc",

"src/objects/string-comparator.h",

"src/objects/string-inl.h",

"src/objects/struct.h",

"src/objects/struct-inl.h",

]

outputs = [

"$target_gen_dir/debug-support.cc",

]

args = rebase_path(outputs, root_build_dir) +

rebase_path(sources, root_build_dir)

}

torque_files = [

"src/builtins/arguments.tq",

"src/builtins/array-copywithin.tq",

"src/builtins/array-every.tq",

"src/builtins/array-filter.tq",

"src/builtins/array-find.tq",

"src/builtins/array-findindex.tq",

"src/builtins/array-foreach.tq",

"src/builtins/array-join.tq",

"src/builtins/array-lastindexof.tq",

"src/builtins/array-map.tq",

"src/builtins/array-of.tq",

"src/builtins/array-reduce-right.tq",

"src/builtins/array-reduce.tq",

"src/builtins/array-reverse.tq",

"src/builtins/array-shift.tq",

"src/builtins/array-slice.tq",

"src/builtins/array-some.tq",

"src/builtins/array-splice.tq",

"src/builtins/array-unshift.tq",

"src/builtins/array.tq",

"src/builtins/base.tq",

"src/builtins/boolean.tq",

"src/builtins/collections.tq",

"src/builtins/data-view.tq",

"src/builtins/extras-utils.tq",

"src/builtins/frames.tq",

"src/builtins/growable-fixed-array.tq",

"src/builtins/internal-coverage.tq",

"src/builtins/iterator.tq",

"src/builtins/math.tq",

"src/builtins/object-fromentries.tq",

"src/builtins/proxy-constructor.tq",

"src/builtins/proxy-get-property.tq",

"src/builtins/proxy-has-property.tq",

"src/builtins/proxy-revocable.tq",

"src/builtins/proxy-revoke.tq",

"src/builtins/proxy-set-property.tq",

"src/builtins/proxy.tq",

"src/builtins/regexp-replace.tq",

"src/builtins/regexp.tq",

"src/builtins/string.tq",

"src/builtins/string-endswith.tq",

"src/builtins/string-html.tq",

"src/builtins/string-iterator.tq",

"src/builtins/string-repeat.tq",

"src/builtins/string-slice.tq",

"src/builtins/string-startswith.tq",

"src/builtins/string-substring.tq",

"src/builtins/typed-array-createtypedarray.tq",

"src/builtins/typed-array-every.tq",

"src/builtins/typed-array-filter.tq",

"src/builtins/typed-array-find.tq",

"src/builtins/typed-array-findindex.tq",

"src/builtins/typed-array-foreach.tq",

"src/builtins/typed-array-reduce.tq",

"src/builtins/typed-array-reduceright.tq",

"src/builtins/typed-array-slice.tq",

"src/builtins/typed-array-some.tq",

"src/builtins/typed-array-subarray.tq",

"src/builtins/typed-array.tq",

"src/objects/intl-objects.tq",

"test/torque/test-torque.tq",

"third_party/v8/builtins/array-sort.tq",

]

if (!v8_enable_i18n_support) {

torque_files -= [ "src/objects/intl-objects.tq" ]

}

torque_namespaces = [

"arguments",

"array",

"array-copywithin",

"array-filter",

"array-find",

"array-findindex",

"array-foreach",

"array-join",

"array-map",