# Copyright 2017 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

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

declare_args() {
  # Use in-tree libc++ (buildtools/third_party/libc++ and
  # buildtools/third_party/libc++abi) instead of the system C++ library for C++
  # standard library support.
  # Don't check in changes that set this to false for more platforms; doing so
  # is not supported.
  use_custom_libcxx = is_fuchsia || is_android || is_apple || is_linux ||
                      is_chromeos || (is_win && is_clang)

  # Use libc++ instead of stdlibc++ when using the host_cpu toolchain, even if
  # use_custom_libcxx is false. This is useful for cross-compiles where a custom
  # toolchain for the target_cpu has been set as the default toolchain, but
  # use_custom_libcxx should still be true when building for the host.  The
  # expected usage is to set use_custom_libcxx=false and
  # use_custom_libcxx_for_host=true in the passed in buildargs.
  use_custom_libcxx_for_host = false

  # Builds libcxx Natvis into the symbols for type visualization.
  # Set to false to workaround http://crbug.com/966676 and
  # http://crbug.com/966687.
  libcxx_natvis_include = true

  # When set, enables libc++ debug mode with iterator debugging.
  #
  # Iterator debugging is generally useful for catching bugs. But it can
  # introduce extra locking to check the state of an iterator against the state
  # of the current object. For iterator- and thread-heavy code, this can
  # significantly slow execution - two orders of magnitude slowdown has been
  # seen (crbug.com/903553) and iterator debugging also slows builds by making
  # generation of snapshot_blob.bin take ~40-60 s longer. Therefore this
  # defaults to off.
  enable_iterator_debugging = false

  # Use Clang header modules for libc++.
  # This is experimental only (see crbug.com/543704).
  # For details on the current state of modules in Chromium see
  # https://chromium.googlesource.com/chromium/src/+/main/docs/modules.md
  use_libcxx_modules = false
}

assert(!use_libcxx_modules || !use_remoteexec,
       "Implicit Clang header modules don't work with remote execution.")

use_custom_libcxx =
    use_custom_libcxx || (use_custom_libcxx_for_host && !is_a_target_toolchain)
use_custom_libcxx = use_custom_libcxx && !is_nacl

declare_args() {
  # WARNING: Setting this to a non-default value is highly discouraged.
  # If true, libc++ will be built as a shared library; otherwise libc++ will be
  # linked statically. Setting this to something other than the default is
  # unsupported and can be broken by libc++ rolls. Note that if this is set to
  # true, you must also set libcxx_abi_unstable=false, which is bad for
  # performance and memory use.
  libcxx_is_shared = use_custom_libcxx && is_component_build

  # In case the C++ standard library implementation used is libstdc++, then
  # enable its own hardening checks. As we cannot determine in GN if libstdc++
  # is used or not, by default enable it for Linux without the custom libc++.
  use_safe_libstdcxx = is_linux && !use_custom_libcxx
}

# The saigo libc++ is distinct from the custom hermetic libc++. However, since
# the Chrome team controls the saigo toolchain, it is safe to unconditionally
# enable libc++ hardening there as well.
use_safe_libcxx = (use_custom_libcxx && enable_safe_libcxx) || is_nacl_saigo

# libc++abi needs to be exported from executables to be picked up by shared
# libraries on certain instrumented builds.
export_libcxxabi_from_executables =
    use_custom_libcxx && !is_apple && !is_win && !is_component_build &&
    (is_asan || is_ubsan_vptr)

# On Android, many shared libraries get loaded from the context of a JRE.  In
# this case, there's no "main executable" to export libc++abi from.  We could
# export libc++abi from each "toplevel" shared library instead, but that would
# require adding an explicit dependency for each one, and might introduce
# subtle, hard-to-fix problems down the line if the dependency is missing.
#
# export_libcxxabi_from_executables was added to avoid having an RPATH set in
# static sanitizer builds just for executables to find libc++.  But on Android,
# the Bionic dynamic loader doesn't even look at RPATH; instead, LD_LIBRARY_PATH
# is set for tests. Because of this, we make libc++ a shared library on android
# since it should get loaded properly.
if (is_android && export_libcxxabi_from_executables) {
  export_libcxxabi_from_executables = false
  libcxx_is_shared = true
}

libcxx_prefix = "//third_party/libc++/src"
libcxxabi_prefix = "//third_party/libc++abi/src"
libcxx_module_prefix = "$root_gen_dir/libcxx"

assert(!(is_ios && libcxx_is_shared),
       "Can't build libc++ as a shared library on iOS.")