212 lines
8.9 KiB
Plaintext
Executable File
212 lines
8.9 KiB
Plaintext
Executable File
# Copyright 2015 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/sanitizers/sanitizers.gni")
|
|
import("//build/toolchain/toolchain.gni")
|
|
|
|
import("//build/misc/overrides/build.gni")
|
|
|
|
if (is_ohos) {
|
|
import("//build/config/ohos/abi.gni")
|
|
}
|
|
if (is_android) {
|
|
import("//build_plugins/config/aosp/abi.gni")
|
|
}
|
|
if (current_cpu == "arm" || current_cpu == "arm64") {
|
|
import("//build/config/arm.gni")
|
|
}
|
|
|
|
is_ohos_or_android = is_ohos || is_android
|
|
|
|
declare_args() {
|
|
# How many symbols to include in the build. This affects the performance of
|
|
# the build since the symbols are large and dealing with them is slow.
|
|
# 2 means regular build with symbols.
|
|
# 1 means minimal symbols, usually enough for backtraces only. Symbols with
|
|
# internal linkage (static functions or those in anonymous namespaces) may not
|
|
# appear when using this level.
|
|
# 0 means no symbols.
|
|
# -1 means auto-set according to debug/release and platform.
|
|
symbol_level = -1
|
|
|
|
# ohos-only: Strip the debug info of libraries within lib.unstripped to
|
|
# reduce size. As long as symbol_level > 0, this will still allow stacks to be
|
|
# symbolized.
|
|
strip_debug_info = false
|
|
|
|
# Compile in such a way as to enable profiling of the generated code. For
|
|
# example, don't omit the frame pointer and leave in symbols.
|
|
enable_profiling = false
|
|
|
|
# use_debug_fission: whether to use split DWARF debug info
|
|
# files. This can reduce link time significantly, but is incompatible
|
|
# with some utilities such as icecc and ccache. Requires gold and
|
|
# gcc >= 4.8 or clang.
|
|
# http://gcc.gnu.org/wiki/DebugFission
|
|
#
|
|
# This is a placeholder value indicating that the code below should set
|
|
# the default. This is necessary to delay the evaluation of the default
|
|
# value expression until after its input values such as use_gold have
|
|
# been set, e.g. by a toolchain_args() block.
|
|
use_debug_fission = "default"
|
|
|
|
# Enables support for ThinLTO, which links 3x-10x faster than full LTO. See
|
|
# also http://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html
|
|
use_thin_lto = is_cfi || (is_ohos_or_android && is_official_build)
|
|
|
|
# Tell VS to create a PDB that references information in .obj files rather
|
|
# than copying it all. This should improve linker performance. mspdbcmf.exe
|
|
# can be used to convert a fastlink pdb to a normal one.
|
|
is_win_fastlink = false
|
|
|
|
# Whether or not we should turn on incremental WPO. Only affects the VS
|
|
# Windows build.
|
|
use_incremental_wpo = false
|
|
|
|
# Whether or not we should use position independent code.
|
|
use_pic = true
|
|
|
|
# Whether we're using a sample profile collected on an architecture different
|
|
# than the one we're compiling for.
|
|
#
|
|
# It's currently not possible to collect AFDO profiles on anything but
|
|
# x86{,_64}.
|
|
using_mismatched_sample_profile = current_cpu != "x64" && current_cpu != "x86"
|
|
}
|
|
|
|
assert(!is_cfi || use_thin_lto, "CFI requires ThinLTO")
|
|
|
|
# If true, optimize for size. Does not affect windows builds.
|
|
# Linux & Mac favor speed over size.
|
|
optimize_for_size = is_ohos_or_android
|
|
|
|
declare_args() {
|
|
# Whether we should consider the profile we're using to be accurate. Accurate
|
|
# profiles have the benefit of (potentially substantial) binary size
|
|
# reductions, by instructing the compiler to optimize cold and uncovered
|
|
# functions heavily for size. This often comes at the cost of performance.
|
|
sample_profile_is_accurate = optimize_for_size
|
|
}
|
|
|
|
# Determine whether to enable or disable frame pointers, based on the platform
|
|
# and build arguments.
|
|
if (is_mac || is_linux) {
|
|
enable_frame_pointers = true
|
|
} else if (is_win) {
|
|
# 64-bit Windows ABI doesn't support frame pointers.
|
|
if (current_cpu == "x64") {
|
|
enable_frame_pointers = false
|
|
} else {
|
|
enable_frame_pointers = true
|
|
}
|
|
} else if (is_chromeos) {
|
|
# ChromeOS generally prefers frame pointers, to support CWP.
|
|
# However, Clang does not currently generate usable frame pointers in ARM
|
|
# 32-bit builds (https://bugs.llvm.org/show_bug.cgi?id=18505) so disable them
|
|
# there to avoid the unnecessary overhead.
|
|
enable_frame_pointers = current_cpu != "arm"
|
|
} else if (is_ohos_or_android) {
|
|
enable_frame_pointers =
|
|
enable_profiling ||
|
|
# Ensure that stacks from arm64 crash dumps are usable (crbug.com/391706).
|
|
current_cpu == "arm64" ||
|
|
# For x86 ohos, unwind tables are huge without frame pointers
|
|
# (crbug.com/762629). Enabling frame pointers grows the code size slightly
|
|
# but overall shrinks binaries considerably by avoiding huge unwind
|
|
# tables.
|
|
(current_cpu == "x86" && !exclude_unwind_tables && optimize_for_size) ||
|
|
using_sanitizer
|
|
} else {
|
|
# Explicitly ask for frame pointers, otherwise:
|
|
# * Stacks may be missing for sanitizer and profiling builds.
|
|
# * Debug tcmalloc can crash (crbug.com/636489).
|
|
enable_frame_pointers = using_sanitizer || enable_profiling || is_debug
|
|
}
|
|
|
|
# In general assume that if we have frame pointers then we can use them to
|
|
# unwind the stack. However, this requires that they are enabled by default for
|
|
# most translation units, that they are emitted correctly, and that the
|
|
# compiler or platform provides a way to access them.
|
|
can_unwind_with_frame_pointers = enable_frame_pointers
|
|
if (current_cpu == "arm" && arm_use_thumb) {
|
|
# We cannot currently unwind ARM Thumb frame pointers correctly.
|
|
# See https://bugs.llvm.org/show_bug.cgi?id=18505
|
|
can_unwind_with_frame_pointers = false
|
|
} else if (is_win) {
|
|
# Windows 32-bit does provide frame pointers, but the compiler does not
|
|
# provide intrinsics to access them, so we don't use them.
|
|
can_unwind_with_frame_pointers = false
|
|
}
|
|
|
|
assert(!can_unwind_with_frame_pointers || enable_frame_pointers)
|
|
|
|
# Unwinding with CFI table is only possible on static library builds and
|
|
# required only when frame pointers are not enabled.
|
|
can_unwind_with_cfi_table = is_ohos_or_android && !is_component_build &&
|
|
!enable_frame_pointers && current_cpu == "arm"
|
|
|
|
declare_args() {
|
|
# Set to true to use lld, the LLVM linker. This flag may be used on Windows,
|
|
# Linux.
|
|
use_lld =
|
|
is_clang &&
|
|
(is_win || (use_thin_lto && target_os != "chromeos") ||
|
|
(is_linux && current_cpu == "x64" && target_os != "chromeos") ||
|
|
(is_ohos_or_android && (current_cpu != "arm" || arm_version >= 7) &&
|
|
current_cpu != "mipsel" && current_cpu != "mips64el"))
|
|
}
|
|
|
|
declare_args() {
|
|
# Whether to use the gold linker from binutils instead of lld or bfd.
|
|
use_gold =
|
|
!use_lld &&
|
|
!(is_linux && (current_cpu == "arm" || current_cpu == "mipsel")) &&
|
|
((is_linux &&
|
|
(current_cpu == "x64" || current_cpu == "x86" || current_cpu == "arm" ||
|
|
current_cpu == "mipsel" || current_cpu == "mips64el")) ||
|
|
(is_ohos_or_android && (current_cpu == "x86" || current_cpu == "x64" ||
|
|
current_cpu == "arm" || current_cpu == "arm64")))
|
|
}
|
|
|
|
# If it wasn't manually set, set to an appropriate default.
|
|
assert(symbol_level >= -1 && symbol_level <= 2, "Invalid symbol_level")
|
|
if (symbol_level == -1) {
|
|
if (is_ohos_or_android && use_order_profiling) {
|
|
# With instrumentation enabled, debug info puts libchrome.so over 4gb, which
|
|
# causes the linker to produce an invalid ELF. http://crbug.com/574476
|
|
symbol_level = 0
|
|
} else if ((is_ohos && !is_component_build &&
|
|
!(ohos_64bit_target_cpu && !build_app_secondary_abi)) ||
|
|
(is_android && !is_component_build &&
|
|
!(aosp_64bit_target_cpu && !build_app_secondary_abi))) {
|
|
# Reduce symbol level when it will cause invalid elf files to be created
|
|
# (due to file size). https://crbug.com/648948.
|
|
symbol_level = 1
|
|
} else if ((!is_nacl && !is_linux) || is_debug || is_official_build) {
|
|
# Linux builds slower by having symbols as part of the target binary,
|
|
# whereas Mac and Windows have them separate, so in Release Linux, default
|
|
# them off, but keep them on for Official builds and Chromecast builds.
|
|
symbol_level = 2
|
|
} else if (using_sanitizer) {
|
|
# Sanitizers need line table info for stack traces. They don't need type
|
|
# info or variable info, so we can leave that out to speed up the build.
|
|
# Sanitizers also require symbols for filename suppressions to work.
|
|
symbol_level = 1
|
|
} else {
|
|
symbol_level = 0
|
|
}
|
|
}
|
|
|
|
# Assert that the configuration isn't going to hit https://crbug.com/648948.
|
|
# An exception is made when target_os == "chromeos" as we only use the ohos
|
|
# toolchain there to build relatively small binaries.
|
|
assert(ignore_elf32_limitations || !is_ohos_or_android ||
|
|
target_os == "chromeos" ||
|
|
(ohos_64bit_target_cpu && !build_app_secondary_abi) ||
|
|
is_component_build || symbol_level < 2,
|
|
"ohos 32-bit non-component builds cannot have symbol_level=2 " +
|
|
"due to 4GiB file size limit, see https://crbug.com/648948. " +
|
|
"If you really want to try this out, " +
|
|
"set ignore_elf32_limitations=true.")
|