mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2025-03-14 04:56:10 +03:00
260 lines
7.5 KiB
Plaintext
260 lines
7.5 KiB
Plaintext
# Copyright 2013 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/pch.gni")
|
|
import("//build/config/rust.gni")
|
|
import("clang.gni")
|
|
|
|
if (is_ios) {
|
|
import("//build/config/ios/config.gni") # For `target_environment`
|
|
}
|
|
|
|
# Helper function for adding cflags to use a clang plugin.
|
|
# - `plugin` is the name of the plugin.
|
|
# - `plugin_arguments` is a list of arguments to pass to the plugin.
|
|
template("clang_plugin") {
|
|
config(target_name) {
|
|
forward_variables_from(invoker,
|
|
[
|
|
"cflags",
|
|
"configs",
|
|
])
|
|
if (!defined(cflags)) {
|
|
cflags = []
|
|
}
|
|
|
|
if (defined(invoker.plugin)) {
|
|
cflags += [
|
|
"-Xclang",
|
|
"-add-plugin",
|
|
"-Xclang",
|
|
invoker.plugin,
|
|
]
|
|
}
|
|
|
|
if (defined(invoker.plugin_arguments)) {
|
|
foreach(flag, invoker.plugin_arguments) {
|
|
cflags += [
|
|
"-Xclang",
|
|
"-plugin-arg-${invoker.plugin}",
|
|
"-Xclang",
|
|
flag,
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
clang_plugin("raw_ptr_check") {
|
|
if (clang_use_chrome_plugins || clang_use_raw_ptr_plugin) {
|
|
# The plugin is built directly into clang, so there's no need to load it
|
|
# dynamically.
|
|
plugin = "raw-ptr-plugin"
|
|
plugin_arguments = [
|
|
"check-raw-ptr-to-stack-allocated",
|
|
"disable-check-raw-ptr-to-stack-allocated-error",
|
|
|
|
# TODO(crbug.com/40944547): Remove when raw_ptr check has been enabled
|
|
# for the dawn repo.
|
|
"raw-ptr-exclude-path=" +
|
|
rebase_path("//third_party/dawn/", root_build_dir),
|
|
]
|
|
|
|
if (enable_check_raw_ptr_fields) {
|
|
plugin_arguments += [
|
|
"check-raw-ptr-fields",
|
|
"check-span-fields",
|
|
]
|
|
}
|
|
|
|
if (enable_check_raw_ref_fields) {
|
|
plugin_arguments += [ "check-raw-ref-fields" ]
|
|
}
|
|
}
|
|
}
|
|
|
|
clang_plugin("find_bad_constructs") {
|
|
if (clang_use_chrome_plugins) {
|
|
# The plugin is built directly into clang, so there's no need to load it
|
|
# dynamically.
|
|
plugin = "find-bad-constructs"
|
|
plugin_arguments = [
|
|
"span-ctor-from-string-literal",
|
|
"raw-ref-template-as-trivial-member",
|
|
"raw-span-template-as-trivial-member",
|
|
"check-stack-allocated",
|
|
]
|
|
|
|
if (is_linux || is_chromeos || is_android || is_fuchsia) {
|
|
plugin_arguments += [ "check-ipc" ]
|
|
}
|
|
|
|
configs = [ ":raw_ptr_check" ]
|
|
}
|
|
}
|
|
|
|
# A plugin for incrementally applying the -Wunsafe-buffer-usage warning.
|
|
#
|
|
# To use the plugin, the project must specify a path as
|
|
# `clang_unsafe_buffers_paths` in the `//.gn` file. This path points to a text
|
|
# file that controls where the warning is checked.
|
|
#
|
|
# See //build/config/unsafe_buffers_paths.txt for an example file, this it the
|
|
# file used by Chromium.
|
|
#
|
|
# This build configuration is not supported when `enable_precompiled_headers`
|
|
# is on because the pragmas that enable and disable unsafe-buffers warnings are
|
|
# not serialized to precompiled header files, and thus we get warnings that we
|
|
# should not.
|
|
clang_plugin("unsafe_buffers") {
|
|
if (clang_use_chrome_plugins && clang_unsafe_buffers_paths != "" &&
|
|
!enable_precompiled_headers) {
|
|
cflags = [ "-DUNSAFE_BUFFERS_BUILD" ]
|
|
plugin = "unsafe-buffers"
|
|
plugin_arguments =
|
|
[ rebase_path(clang_unsafe_buffers_paths, root_build_dir) ]
|
|
}
|
|
}
|
|
|
|
# Enables some extra Clang-specific warnings. Some third-party code won't
|
|
# compile with these so may want to remove this config.
|
|
config("extra_warnings") {
|
|
cflags = [
|
|
"-Wheader-hygiene",
|
|
|
|
# Warns when a const char[] is converted to bool.
|
|
"-Wstring-conversion",
|
|
|
|
"-Wtautological-overlap-compare",
|
|
]
|
|
}
|
|
|
|
group("llvm-symbolizer_data") {
|
|
if (is_win) {
|
|
data = [ "$clang_base_path/bin/llvm-symbolizer.exe" ]
|
|
} else {
|
|
data = [ "$clang_base_path/bin/llvm-symbolizer" ]
|
|
}
|
|
}
|
|
|
|
template("clang_lib") {
|
|
if (!defined(invoker.libname)) {
|
|
not_needed(invoker, "*")
|
|
config(target_name) {
|
|
}
|
|
} else {
|
|
config(target_name) {
|
|
_dir = ""
|
|
_libname = invoker.libname
|
|
_prefix = "lib"
|
|
_suffix = ""
|
|
_ext = "a"
|
|
if (is_win) {
|
|
_dir = "windows"
|
|
_prefix = ""
|
|
_ext = "lib"
|
|
if (current_cpu == "x64") {
|
|
_suffix = "-x86_64"
|
|
} else if (current_cpu == "x86") {
|
|
_suffix = "-i386"
|
|
} else if (current_cpu == "arm64") {
|
|
_suffix = "-aarch64"
|
|
} else {
|
|
assert(false) # Unhandled cpu type
|
|
}
|
|
} else if (is_apple) {
|
|
_dir = "darwin"
|
|
} else if (is_linux || is_chromeos) {
|
|
if (current_cpu == "x64") {
|
|
_dir = "x86_64-unknown-linux-gnu"
|
|
} else if (current_cpu == "x86") {
|
|
_dir = "i386-unknown-linux-gnu"
|
|
} else if (current_cpu == "arm") {
|
|
_dir = "armv7-unknown-linux-gnueabihf"
|
|
} else if (current_cpu == "arm64") {
|
|
_dir = "aarch64-unknown-linux-gnu"
|
|
} else {
|
|
assert(false) # Unhandled cpu type
|
|
}
|
|
} else if (is_fuchsia) {
|
|
if (current_cpu == "x64") {
|
|
_dir = "x86_64-unknown-fuchsia"
|
|
} else if (current_cpu == "arm64") {
|
|
_dir = "aarch64-unknown-fuchsia"
|
|
} else {
|
|
assert(false) # Unhandled cpu type
|
|
}
|
|
} else if (is_android) {
|
|
_dir = "linux"
|
|
if (current_cpu == "x64") {
|
|
_suffix = "-x86_64-android"
|
|
} else if (current_cpu == "x86") {
|
|
_suffix = "-i686-android"
|
|
} else if (current_cpu == "arm") {
|
|
_suffix = "-arm-android"
|
|
} else if (current_cpu == "arm64") {
|
|
_suffix = "-aarch64-android"
|
|
} else if (current_cpu == "riscv64") {
|
|
_suffix = "-riscv64-android"
|
|
} else {
|
|
assert(false) # Unhandled cpu type
|
|
}
|
|
} else {
|
|
assert(false) # Unhandled target platform
|
|
}
|
|
|
|
_clang_lib_dir = "$clang_base_path/lib/clang/$clang_version/lib"
|
|
_lib_file = "${_prefix}clang_rt.${_libname}${_suffix}.${_ext}"
|
|
libs = [ "$_clang_lib_dir/$_dir/$_lib_file" ]
|
|
}
|
|
}
|
|
}
|
|
|
|
# Adds a dependency on the Clang runtime library clang_rt.builtins.
|
|
clang_lib("compiler_builtins") {
|
|
if (true) {
|
|
# NaiveProxy doesn't use Rust and never links clang_rt.builtins.
|
|
# Don't define libname which makes this target do nothing.
|
|
} else if (is_mac) {
|
|
libname = "osx"
|
|
} else if (is_ios) {
|
|
if (target_environment == "simulator") {
|
|
libname = "iossim"
|
|
} else if (target_environment == "catalyst") {
|
|
libname = "osx"
|
|
} else {
|
|
libname = "ios"
|
|
}
|
|
} else {
|
|
libname = "builtins"
|
|
}
|
|
}
|
|
|
|
# Adds a dependency on the Clang runtime library clang_rt.profile.
|
|
clang_lib("compiler_profile") {
|
|
if (!toolchain_has_rust) {
|
|
# This is only used when `toolchain_has_rust` to support Rust linking.
|
|
#
|
|
# Don't define libname which makes this target do nothing.
|
|
} else if (is_mac) {
|
|
libname = "profile_osx"
|
|
} else if (is_ios) {
|
|
if (target_environment == "simulator") {
|
|
libname = "profile_iossim"
|
|
} else if (target_environment == "catalyst") {
|
|
# We don't enable clang coverage on iOS device builds, and the library is
|
|
# not part of the Clang package tarball as a result.
|
|
#
|
|
# Don't define libname which makes this target do nothing.
|
|
} else {
|
|
# We don't enable clang coverage on iOS device builds, and the library is
|
|
# not part of the Clang package tarball as a result.
|
|
#
|
|
# Don't define libname which makes this target do nothing.
|
|
}
|
|
} else {
|
|
libname = "profile"
|
|
}
|
|
}
|