Upload Kmake

deps/v8/gni/Info.plist

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleDisplayName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>${BUNDLE_IDENTIFIER}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UISupportedInterfaceOrientation</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>

deps/v8/gni/OWNERS

@@ -0,0 +1,5 @@
+file:../INFRA_OWNERS
+
+per-file v8.cml=victorgomes@chromium.org
+per-file release_branch_toggle.gni=v8-ci-autoroll-builder@chops-service-accounts.iam.gserviceaccount.com
+per-file release_branch_toggle.gni=vahl@chromium.org

deps/v8/gni/release_branch_toggle.gni

@@ -0,0 +1,7 @@
+# Copyright 2022 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.
+
+declare_args() {
+  v8_is_on_release_branch = true
+}

deps/v8/gni/snapshot_toolchain.gni

@@ -0,0 +1,124 @@
+# Copyright 2015 the V8 project authors. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#     * Neither the name of Google Inc. nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//build/config/v8_target_cpu.gni")
+
+declare_args() {
+  # The v8 snapshot needs to be built by code that is compiled with a
+  # toolchain that matches the bit-width of the target CPU, but runs on
+  # the host.
+  v8_snapshot_toolchain = ""
+}
+
+# Try to infer the appropriate snapshot toolchain for the v8_current_cpu
+# where possible.
+#
+# Assume that v8_target_cpu (and hence v8_current_cpu) has been validated
+# as supported on the current host CPU and OS in v8_target_cpu.gni. The
+# logic below is complicated enough without also needing to do input
+# validation.
+#
+# There are test cases for this code posted as an attachment to
+# https://crbug.com/625353.
+
+if (v8_snapshot_toolchain == "") {
+  if (current_os == host_os && current_cpu == host_cpu) {
+    # This is not a cross-compile, so build the snapshot with the current
+    # toolchain.
+    v8_snapshot_toolchain = current_toolchain
+  } else if (current_os == host_os && current_cpu == "x86" &&
+             host_cpu == "x64") {
+    # This is an x64 -> x86 cross-compile, but x64 hosts can usually run x86
+    # binaries built for the same OS, so build the snapshot with the current
+    # toolchain here, too.
+    v8_snapshot_toolchain = current_toolchain
+  } else if (current_os == host_os && host_cpu == "arm64" &&
+             current_cpu == "arm") {
+    # Trying to compile 32-bit arm on arm64. Good luck!
+    v8_snapshot_toolchain = current_toolchain
+  } else if (host_cpu == "x64" && v8_current_cpu == "mips64") {
+    # We don't support snapshot generation for big-endian targets,
+    # therefore snapshots will need to be built using native mksnapshot
+    # in combination with qemu
+    v8_snapshot_toolchain = current_toolchain
+  } else if (host_cpu == current_cpu) {
+    # Cross-build from same ISA on one OS to another. For example:
+    # * targeting win/x64 on a linux/x64 host
+    # * targeting win/arm64 on a mac/arm64 host
+    v8_snapshot_toolchain = host_toolchain
+  } else if (host_cpu == "arm64" && current_cpu == "x64") {
+    # Cross-build from arm64 to intel (likely on an Apple Silicon mac).
+    v8_snapshot_toolchain =
+        "//build/toolchain/${host_os}:clang_arm64_v8_$v8_current_cpu"
+  } else if (host_cpu == "x64") {
+    # This is a cross-compile from an x64 host to either a non-Intel target
+    # cpu or to 32-bit x86 on a different target OS.
+
+    assert(v8_current_cpu != "x64", "handled by host_cpu == current_cpu branch")
+    if (v8_current_cpu == "x86") {
+      _cpus = v8_current_cpu
+    } else if (v8_current_cpu == "arm64" || v8_current_cpu == "mips64el" ||
+               v8_current_cpu == "riscv64" || v8_current_cpu == "loong64") {
+      if (is_win && v8_current_cpu == "arm64") {
+        # set _cpus to blank for Windows ARM64 so host_toolchain could be
+        # selected as snapshot toolchain later.
+        _cpus = ""
+      } else {
+        _cpus = "x64_v8_${v8_current_cpu}"
+      }
+    } else if (v8_current_cpu == "arm" || v8_current_cpu == "riscv32") {
+      _cpus = "x86_v8_${v8_current_cpu}"
+    } else {
+      # This branch should not be reached; leave _cpus blank so the assert
+      # below will fail.
+      _cpus = ""
+    }
+
+    if (_cpus != "") {
+      v8_snapshot_toolchain = "//build/toolchain/${host_os}:clang_${_cpus}"
+    } else if (is_win && v8_current_cpu == "arm64") {
+      # cross compile Windows arm64 with host toolchain.
+      v8_snapshot_toolchain = host_toolchain
+    }
+  } else if (host_cpu == "arm64" && current_cpu == "arm64" &&
+             host_os == "mac") {
+    # cross compile iOS arm64 with host_toolchain
+    v8_snapshot_toolchain = host_toolchain
+  }
+}
+
+assert(v8_snapshot_toolchain != "",
+       "Do not know how to build a snapshot for $current_toolchain " +
+           "on $host_os $host_cpu")
+
+# 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 == "mips64") {
+  v8_generator_toolchain = "//build/toolchain/linux:clang_x64"
+}

deps/v8/gni/split_static_library.gni

@@ -0,0 +1,78 @@
+# Copyright 2019 the V8 project authors. All rights reserved.
+# Copyright 2016 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/compiler/compiler.gni")
+
+template("split_static_library") {
+  assert(defined(invoker.split_count),
+         "Must define split_count for split_static_library")
+
+  # In many conditions the number of inputs will be 1 (because the
+  # count will be conditional on platform or configuration) and for
+  # some build configurations it's unnecessary to split libraries
+  # since the tooling will never create files of a problematic size.
+  if (invoker.split_count == 1 || use_lld) {
+    static_library(target_name) {
+      forward_variables_from(invoker, "*")
+    }
+  } else {
+    group_name = target_name
+
+    generated_static_libraries = []
+    current_library_index = 0
+    foreach(current_sources, split_list(invoker.sources, invoker.split_count)) {
+      current_name = "${target_name}_$current_library_index"
+      assert(
+          current_sources != [],
+          "Your values for splitting a static library generate one that has no sources.")
+      generated_static_libraries += [ ":$current_name" ]
+
+      static_library(current_name) {
+        # Generated static library shard gets everything but sources (which
+        # we're redefining) and visibility (which is set to be the group
+        # below).
+        forward_variables_from(invoker,
+                               "*",
+                               [
+                                 "check_includes",
+                                 "sources",
+                                 "visibility",
+                               ])
+        sources = current_sources
+        visibility = [ ":$group_name" ]
+
+        # When splitting a target's sources up into a series of static
+        # libraries, those targets will naturally include headers from each
+        # other arbitrarily. We could theoretically generate a web of
+        # dependencies and allow_circular_includes_from between all pairs of
+        # targets, but that's very cumbersome. Typical usage in Chrome is that
+        # only official Windows builds use split static libraries due to the
+        # Visual Studio size limits, and this means we'll still get header
+        # checking coverage for the other configurations.
+        check_includes = false
+
+        # Uniquify the output name if one is specified.
+        if (defined(invoker.output_name)) {
+          output_name = "${invoker.output_name}_$current_library_index"
+        }
+      }
+
+      current_library_index = current_library_index + 1
+    }
+
+    group(group_name) {
+      public_deps = generated_static_libraries
+      forward_variables_from(invoker,
+                             [
+                               "testonly",
+                               "visibility",
+                             ])
+    }
+  }
+}
+
+set_defaults("split_static_library") {
+  configs = default_compiler_configs
+}

deps/v8/gni/v8.cml

@@ -0,0 +1,21 @@
+// Copyright 2022 The V8 project authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+{
+  include: [ "syslog/client.shard.cml" ],
+  program: {
+    runner: "elf",
+    binary: "d8",
+  },
+  use: [
+    {
+      protocol: [
+        "fuchsia.kernel.VmexResource",
+      ],
+    },
+    {
+      storage: "tmp",
+      path: "/tmp",
+    },
+  ],
+}

deps/v8/gni/v8.gni

@@ -0,0 +1,462 @@
+# Copyright 2016 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.
+
+import("//build/config/chrome_build.gni")
+import("//build/config/compiler/pgo/pgo.gni")
+import("//build/config/gclient_args.gni")
+import("//build/config/ios/config.gni")
+import("//build/config/ios/ios_sdk_overrides.gni")
+import("//build/config/sanitizers/sanitizers.gni")
+import("//build/config/v8_target_cpu.gni")
+import("//build_overrides/build.gni")
+import("release_branch_toggle.gni")
+import("split_static_library.gni")
+
+if (is_ios) {
+  import("//build/config/apple/mobile_config.gni")  # For `target_platform`.
+}
+
+declare_args() {
+  # Includes files needed for correctness fuzzing.
+  v8_correctness_fuzzer = false
+
+  # Adds additional compile target for building multiple architectures at once.
+  v8_multi_arch_build = false
+
+  # Indicate if valgrind was fetched as a custom deps to make it available on
+  # swarming.
+  v8_has_valgrind = false
+
+  # Indicate if gcmole was fetched as a hook to make it available on swarming.
+  v8_gcmole = false
+
+  # Turns on compiler optimizations in V8 in Debug build.
+  v8_optimized_debug = true
+
+  # Support for backtrace_symbols on linux.
+  v8_enable_backtrace = ""
+
+  # Use external files for startup data blobs:
+  # the JS builtins sources and the start snapshot.
+  v8_use_external_startup_data = ""
+
+  # Includes profiles to optimize builtins.
+  v8_enable_builtins_optimization = ""
+
+  # Turns on all V8 debug features. Enables running V8 in a pseudo debug mode
+  # within a release Chrome.
+  v8_enable_debugging_features = is_debug
+
+  # Enable ECMAScript Internationalization API. Enabling this feature will
+  # add a dependency on the ICU library.
+  v8_enable_i18n_support = true
+
+  # Use static libraries instead of source_sets.
+  v8_static_library = false
+
+  # Enable monolithic static library for embedders.
+  v8_monolithic = false
+
+  # Expose public symbols for native modules of Node.js and Electron. Default
+  # is false.
+  v8_expose_public_symbols = ""
+
+  # Deprecated for v8_expose_public_symbols.
+  v8_expose_symbols = false
+
+  # Implement tracing using Perfetto (https://perfetto.dev).
+  v8_use_perfetto = false
+
+  # Override global symbol level setting for v8.
+  v8_symbol_level = symbol_level
+
+  # Enable WebAssembly debugging via GDB-remote protocol.
+  v8_enable_wasm_gdb_remote_debugging = 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
+
+  # We use target_os == "ios" here because it isn't equivalent to is_ios
+  # (is_ios is based on host_os).
+  if (target_os == "ios") {
+    if (target_platform == "iphoneos") {
+      # iOS executable code pages is in 17.4 SDK.
+      # TODO(dtapuska): Change this to an assert.
+      v8_enable_lite_mode = ios_deployment_target != "17.4"
+    } else if (target_platform == "tvos") {
+      # tvOS runs in single process mode and is not allowed to use JIT.
+      # TODO(crbug.com/394710095): Enable the v8 lite mode to run v8 with the
+      # jitless mode on tvOS.
+      v8_enable_lite_mode = true
+    }
+  }
+
+  # Enable the Turbofan compiler.
+  # Sets -dV8_ENABLE_TURBOFAN.
+  v8_enable_turbofan = ""
+
+  # Enable the Maglev compiler.
+  # Sets -dV8_ENABLE_MAGLEV
+  v8_enable_maglev = ""
+
+  # Include support for WebAssembly. If disabled, the 'WebAssembly' global
+  # will not be available, and embedder APIs to generate WebAssembly modules
+  # will fail. Also, asm.js will not be translated to WebAssembly and will be
+  # executed as standard JavaScript instead.
+  # Sets -dV8_ENABLE_WEBASSEMBLY.
+  v8_enable_webassembly = ""
+
+  # Enable 256-bit long vector re-vectorization pass in WASM compilation pipeline.
+  v8_enable_wasm_simd256_revec = false
+
+  # Enable runtime call stats.
+  v8_enable_runtime_call_stats = !v8_is_on_release_branch
+
+  # Add fuzzilli fuzzer support.
+  v8_fuzzilli = false
+
+  # Enable FuzzTest
+  v8_enable_fuzztest = !build_with_v8_embedder &&
+                       !(defined(build_with_node) && build_with_node) &&
+                       !(is_win && is_component_build) && is_clang
+
+  # Scan the call stack conservatively during garbage collection.
+  v8_enable_conservative_stack_scanning = false
+
+  # Use direct pointers in handles (v8::internal::Handle and v8::Local).
+  v8_enable_direct_handle = ""
+
+  # Check for off-stack allocated local handles.
+  v8_enable_local_off_stack_check = false
+
+  v8_enable_google_benchmark = false
+
+  cppgc_is_standalone = false
+
+  # Enables certain checks on API level functionality.
+  cppgc_enable_api_checks = is_debug || dcheck_always_on
+
+  # Enable slow checks on API level functionality.
+  cppgc_enable_slow_api_checks = false
+
+  # Enable object names in cppgc for profiling purposes.
+  cppgc_enable_object_names = is_chrome_for_testing
+
+  # Enable young generation in cppgc.
+  cppgc_enable_young_generation = false
+
+  # Enables a slim write barrier that only performs a single check in the fast
+  # path and delegates all further checks to a slow path call. This is fast
+  # in a setting with few slow-path checks, i.e., with disabled young generation
+  # GC.
+  cppgc_enable_slim_write_barrier = true
+
+  # Enable pointer compression in cppgc.
+  cppgc_enable_pointer_compression = false
+
+  # Enable support for larger cages, up to 16GB.
+  # iOS cannot mmap above 8GB, so use the smaller cage.
+  cppgc_enable_larger_cage = !is_ios
+
+  # Enable advanced BigInt algorithms, costing about 10-30 KB binary size
+  # depending on platform. Disabled on Android to save binary size.
+  v8_advanced_bigint_algorithms = !is_android
+
+  # TODO: macros for determining endian type are clang specific.
+  v8_use_libm_trig_functions = is_clang
+
+  # Location of icu.
+  v8_icu_path = "//third_party/icu"
+
+  # Location of zlib.
+  v8_zlib_path = "//third_party/zlib"
+
+  # Enable pointer compression (sets -dV8_COMPRESS_POINTERS).
+  v8_enable_pointer_compression = ""
+  v8_enable_pointer_compression_shared_cage = ""
+  v8_enable_31bit_smis_on_64bit_arch = false
+
+  # Change code emission and runtime features to be CET shadow-stack compliant
+  # (incomplete and experimental).
+  v8_enable_cet_shadow_stack = false
+
+  # Emit CET IBT landing pad instructions in JIT generated code (experimental).
+  v8_enable_cet_ibt = false
+
+  # Use memory sealing to protect various global memory mappings for CFI
+  # (experimental).
+  # TODO(sroettger): enable by default once we have bot support for testing.
+  v8_enable_memory_sealing = false
+
+  # Sets -DV8_ENABLE_ETW_STACK_WALKING. Enables ETW Stack Walking
+  v8_enable_etw_stack_walking = is_win
+}
+
+if (v8_use_external_startup_data == "") {
+  # If not specified as a gn arg, use external startup data by default if
+  # we're not on ios.
+  v8_use_external_startup_data = !is_ios
+}
+
+if (v8_enable_backtrace == "") {
+  v8_enable_backtrace = is_debug && !v8_optimized_debug
+}
+
+# Chromium is configured to use the perfetto client library, v8 should also
+# use perfetto for tracing.
+if (build_with_chromium) {
+  v8_use_perfetto = true
+}
+
+# Includes profiles to optimize builtins if
+#   * it is a Chromium build, and
+#   * Chromium builds with optimization.
+# If no profiles are downloaded during gclient runhooks, optimization fails
+# silently.
+if (v8_enable_builtins_optimization == "") {
+  v8_enable_builtins_optimization = build_with_chromium && chrome_pgo_phase == 2
+}
+
+# TODO(jgruber): Move v8_jitless from BUILD.gn here as these
+# all depend on each other and really should be derived from
+# v8_jitless.
+# WebAssembly is enabled by default, except in lite mode.
+if (v8_enable_webassembly == "") {
+  v8_enable_webassembly = !v8_enable_lite_mode
+}
+assert(!(v8_enable_webassembly && v8_enable_lite_mode),
+       "Webassembly is not available in lite mode.")
+
+if (v8_enable_pointer_compression == "") {
+  v8_enable_pointer_compression =
+      v8_current_cpu == "arm64" || v8_current_cpu == "x64" ||
+      v8_current_cpu == "loong64"
+}
+
+# The Wasm interpreter is currently supported only on arm64 and x64, on
+# Windows, Linux and MacOS.
+is_drumbrake_supported =
+    v8_enable_webassembly && v8_enable_pointer_compression &&
+    (v8_current_cpu == "x64" || v8_current_cpu == "arm64") &&
+    (target_os == "win" || target_os == "linux" || target_os == "mac")
+
+# Turbofan is enabled by default, except in lite mode.
+if (v8_enable_turbofan == "") {
+  v8_enable_turbofan = !v8_enable_lite_mode
+}
+assert(v8_enable_turbofan || !v8_enable_webassembly,
+       "Webassembly is not available when Turbofan is disabled.")
+
+# Direct internal handles and direct locals are enabled by default if
+# conservative stack scanning is enabled.
+if (v8_enable_direct_handle == "") {
+  v8_enable_direct_handle = v8_enable_conservative_stack_scanning
+}
+
+# Points to // in v8 stand-alone or to //v8/ in chromium. We need absolute
+# paths for all configs in templates as they are shared in different
+# subdirectories.
+v8_path_prefix = get_path_info("../", "abspath")
+
+v8_inspector_js_protocol = v8_path_prefix + "/include/js_protocol.pdl"
+
+###############################################################################
+# Templates
+#
+
+# Common configs to remove or add in all v8 targets.
+v8_remove_configs = []
+v8_add_configs = [
+  v8_path_prefix + ":features",
+  v8_path_prefix + ":toolchain",
+  v8_path_prefix + ":strict_warnings",
+]
+
+if (is_debug && !v8_optimized_debug) {
+  v8_remove_configs += [ "//build/config/compiler:default_optimization" ]
+  v8_add_configs += [ "//build/config/compiler:no_optimize" ]
+} else {
+  v8_remove_configs += [ "//build/config/compiler:default_optimization" ]
+
+  # 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_win) && !using_sanitizer) {
+    v8_add_configs += [ "//build/config/compiler:optimize_speed" ]
+  } else {
+    v8_add_configs += [ "//build/config/compiler:optimize_max" ]
+  }
+}
+
+if (!is_debug) {
+  v8_remove_configs += [
+    # Too much performance impact, unclear security benefit.
+    "//build/config/compiler:default_init_stack_vars",
+  ]
+}
+
+if (v8_symbol_level != symbol_level) {
+  v8_remove_configs += [ "//build/config/compiler:default_symbols" ]
+  if (v8_symbol_level == 0) {
+    v8_add_configs += [ "//build/config/compiler:no_symbols" ]
+  } else if (v8_symbol_level == 1) {
+    v8_add_configs += [ "//build/config/compiler:minimal_symbols" ]
+  } else if (v8_symbol_level == 2) {
+    v8_add_configs += [ "//build/config/compiler:symbols" ]
+  } else {
+    assert(false)
+  }
+}
+
+if ((is_posix || is_fuchsia) && (v8_enable_backtrace || v8_monolithic)) {
+  v8_remove_configs += [ "//build/config/gcc:symbol_visibility_hidden" ]
+  v8_add_configs += [ "//build/config/gcc:symbol_visibility_default" ]
+}
+
+# On MIPS gcc_target_rpath and ldso_path might be needed for all builds.
+if (target_cpu == "mips64el" || target_cpu == "mips64") {
+  v8_add_configs += [ "//build/config/gcc:rpath_for_built_shared_libraries" ]
+}
+
+if (!build_with_chromium && is_clang) {
+  v8_remove_configs += [ "//build/config/clang:find_bad_constructs" ]
+}
+
+# All templates should be kept in sync.
+template("v8_source_set") {
+  if (defined(invoker.split_count) && invoker.split_count > 1 &&
+      defined(v8_static_library) && v8_static_library && is_win) {
+    link_target_type = "split_static_library"
+  } else if (defined(v8_static_library) && v8_static_library) {
+    link_target_type = "static_library"
+  } else {
+    link_target_type = "source_set"
+  }
+  target(link_target_type, target_name) {
+    forward_variables_from(invoker,
+                           "*",
+                           [
+                             "configs",
+                             "remove_configs",
+                           ])
+    configs -= v8_remove_configs
+    configs += v8_add_configs
+    if (defined(invoker.remove_configs)) {
+      configs -= invoker.remove_configs
+    }
+    configs += invoker.configs
+  }
+}
+
+template("v8_header_set") {
+  source_set(target_name) {
+    forward_variables_from(invoker, "*", [ "configs" ])
+    configs -= v8_remove_configs
+    configs += v8_add_configs
+    configs += invoker.configs
+  }
+}
+
+template("v8_executable") {
+  if (is_ios) {
+    import("//build/config/ios/rules.gni")
+
+    ios_app_bundle(target_name) {
+      forward_variables_from(invoker,
+                             "*",
+                             [
+                               "configs",
+                               "remove_configs",
+                             ])
+      configs -= v8_remove_configs
+      configs += v8_add_configs
+      if (defined(invoker.remove_configs)) {
+        configs -= invoker.remove_configs
+      }
+      configs += invoker.configs
+      deps += [ v8_path_prefix + ":v8_dump_build_config" ]
+
+      # Provide sensible defaults in case invoker did not define any of those
+      # required variables.
+      if (!defined(info_plist) && !defined(info_plist_target)) {
+        info_plist = v8_path_prefix + "/gni/Info.plist"
+      }
+
+      bundle_identifier = "$ios_app_bundle_id_prefix.chrome.unittests.dev"
+    }
+  } else {
+    executable(target_name) {
+      forward_variables_from(invoker,
+                             "*",
+                             [
+                               "configs",
+                               "remove_configs",
+                             ])
+      configs -= v8_remove_configs
+      configs += v8_add_configs
+      if (defined(invoker.remove_configs)) {
+        configs -= invoker.remove_configs
+      }
+      configs += invoker.configs
+      if (is_linux || is_chromeos) {
+        # For enabling ASLR.
+        ldflags = [ "-pie" ]
+      }
+      deps += [ v8_path_prefix + ":v8_dump_build_config" ]
+
+      if (is_win && !v8_enable_cet_shadow_stack) {
+        configs -= [ "//build/config/compiler:cet_shadow_stack" ]
+      }
+    }
+  }
+}
+
+template("v8_component") {
+  component(target_name) {
+    output_name = target_name
+    forward_variables_from(invoker,
+                           "*",
+                           [
+                             "configs",
+                             "remove_configs",
+                           ])
+    configs -= v8_remove_configs
+    configs += v8_add_configs
+    if (defined(invoker.remove_configs)) {
+      configs -= invoker.remove_configs
+    }
+    configs += invoker.configs
+  }
+}
+
+template("v8_shared_library") {
+  shared_library(target_name) {
+    forward_variables_from(invoker,
+                           "*",
+                           [
+                             "configs",
+                             "remove_configs",
+                           ])
+    configs -= v8_remove_configs
+    configs += v8_add_configs
+    if (defined(invoker.remove_configs)) {
+      configs -= invoker.remove_configs
+    }
+    if (defined(invoker.configs)) {
+      configs += invoker.configs
+    }
+  }
+}
+
+template("v8_static_library") {
+  static_library(target_name) {
+    complete_static_lib = true
+    forward_variables_from(invoker, "*", [ "configs" ])
+    configs -= v8_remove_configs
+    configs -= [ "//build/config/compiler:thin_archive" ]
+    configs += v8_add_configs
+    configs += invoker.configs
+  }
+}