mirror of
https://github.com/bazelbuild/rules_cc
synced 2024-12-02 01:15:34 +00:00
bc665f9271
*** Reason for rollback *** Broke a test *** Original change description *** The auto-configured toolchains provided by Bazel itself have diverged heavily from the version maintained in this repo. There is no need to maintain this duplication until Starlarkification has progressed succiciently for rules_cc to be the source of truth for them. This is particularly relevant for Bzlmod, which currently uses the toolchains defined in rules_cc. As a result, Bazel C++ builds will use subtly different toolchains depending on whether --enable_bzlmod is used or not. This is fixed... *** PiperOrigin-RevId: 501228335 Change-Id: I858dc3ea44df7ae70b5603f6dc2e082b4540c42a
588 lines
21 KiB
Python
588 lines
21 KiB
Python
# pylint: disable=g-bad-file-header
|
|
# Copyright 2016 The Bazel Authors. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Configuring the C++ toolchain on Unix platforms."""
|
|
|
|
load(
|
|
":lib_cc_configure.bzl",
|
|
"auto_configure_fail",
|
|
"auto_configure_warning",
|
|
"auto_configure_warning_maybe",
|
|
"escape_string",
|
|
"get_env_var",
|
|
"get_starlark_list",
|
|
"resolve_labels",
|
|
"split_escaped",
|
|
"which",
|
|
"write_builtin_include_directory_paths",
|
|
)
|
|
|
|
def _uniq(iterable):
|
|
"""Remove duplicates from a list."""
|
|
|
|
unique_elements = {element: None for element in iterable}
|
|
return unique_elements.keys()
|
|
|
|
def _prepare_include_path(repo_ctx, path):
|
|
"""Resolve and sanitize include path before outputting it into the crosstool.
|
|
|
|
Args:
|
|
repo_ctx: repository_ctx object.
|
|
path: an include path to be sanitized.
|
|
|
|
Returns:
|
|
Sanitized include path that can be written to the crosstoot. Resulting path
|
|
is absolute if it is outside the repository and relative otherwise.
|
|
"""
|
|
|
|
repo_root = str(repo_ctx.path("."))
|
|
|
|
# We're on UNIX, so the path delimiter is '/'.
|
|
repo_root += "/"
|
|
path = str(repo_ctx.path(path))
|
|
if path.startswith(repo_root):
|
|
return escape_string(path[len(repo_root):])
|
|
return escape_string(path)
|
|
|
|
def _find_tool(repository_ctx, tool, overriden_tools):
|
|
"""Find a tool for repository, taking overriden tools into account."""
|
|
if tool in overriden_tools:
|
|
return overriden_tools[tool]
|
|
return which(repository_ctx, tool, "/usr/bin/" + tool)
|
|
|
|
def _get_tool_paths(repository_ctx, overriden_tools):
|
|
"""Compute the %-escaped path to the various tools"""
|
|
return dict({
|
|
k: escape_string(_find_tool(repository_ctx, k, overriden_tools))
|
|
for k in [
|
|
"ar",
|
|
"ld",
|
|
"cpp",
|
|
"gcc",
|
|
"dwp",
|
|
"gcov",
|
|
"nm",
|
|
"objcopy",
|
|
"objdump",
|
|
"strip",
|
|
]
|
|
}.items())
|
|
|
|
def _escaped_cplus_include_paths(repository_ctx):
|
|
"""Use ${CPLUS_INCLUDE_PATH} to compute the %-escaped list of flags for cxxflag."""
|
|
if "CPLUS_INCLUDE_PATH" in repository_ctx.os.environ:
|
|
result = []
|
|
for p in repository_ctx.os.environ["CPLUS_INCLUDE_PATH"].split(":"):
|
|
p = escape_string(str(repository_ctx.path(p))) # Normalize the path
|
|
result.append("-I" + p)
|
|
return result
|
|
else:
|
|
return []
|
|
|
|
_INC_DIR_MARKER_BEGIN = "#include <...>"
|
|
|
|
# OSX add " (framework directory)" at the end of line, strip it.
|
|
_OSX_FRAMEWORK_SUFFIX = " (framework directory)"
|
|
_OSX_FRAMEWORK_SUFFIX_LEN = len(_OSX_FRAMEWORK_SUFFIX)
|
|
|
|
def _cxx_inc_convert(path):
|
|
"""Convert path returned by cc -E xc++ in a complete path. Doesn't %-escape the path!"""
|
|
path = path.strip()
|
|
if path.endswith(_OSX_FRAMEWORK_SUFFIX):
|
|
path = path[:-_OSX_FRAMEWORK_SUFFIX_LEN].strip()
|
|
return path
|
|
|
|
def get_escaped_cxx_inc_directories(repository_ctx, cc, lang_flag, additional_flags = []):
|
|
"""Compute the list of default %-escaped C++ include directories.
|
|
|
|
Args:
|
|
repository_ctx: The repository context.
|
|
cc: path to the C compiler.
|
|
lang_flag: value for the language flag (c, c++).
|
|
additional_flags: additional flags to pass to cc.
|
|
Returns:
|
|
a list of escaped system include directories.
|
|
"""
|
|
result = repository_ctx.execute([cc, "-E", lang_flag, "-", "-v"] + additional_flags)
|
|
index1 = result.stderr.find(_INC_DIR_MARKER_BEGIN)
|
|
if index1 == -1:
|
|
return []
|
|
index1 = result.stderr.find("\n", index1)
|
|
if index1 == -1:
|
|
return []
|
|
index2 = result.stderr.rfind("\n ")
|
|
if index2 == -1 or index2 < index1:
|
|
return []
|
|
index2 = result.stderr.find("\n", index2 + 1)
|
|
if index2 == -1:
|
|
inc_dirs = result.stderr[index1 + 1:]
|
|
else:
|
|
inc_dirs = result.stderr[index1 + 1:index2].strip()
|
|
|
|
inc_directories = [
|
|
_prepare_include_path(repository_ctx, _cxx_inc_convert(p))
|
|
for p in inc_dirs.split("\n")
|
|
]
|
|
|
|
if _is_compiler_option_supported(repository_ctx, cc, "-print-resource-dir"):
|
|
resource_dir = repository_ctx.execute(
|
|
[cc, "-print-resource-dir"],
|
|
).stdout.strip() + "/share"
|
|
inc_directories.append(_prepare_include_path(repository_ctx, resource_dir))
|
|
|
|
return inc_directories
|
|
|
|
def _is_compiler_option_supported(repository_ctx, cc, option):
|
|
"""Checks that `option` is supported by the C compiler. Doesn't %-escape the option."""
|
|
result = repository_ctx.execute([
|
|
cc,
|
|
option,
|
|
"-o",
|
|
"/dev/null",
|
|
"-c",
|
|
str(repository_ctx.path("tools/cpp/empty.cc")),
|
|
])
|
|
return result.stderr.find(option) == -1
|
|
|
|
def _is_linker_option_supported(repository_ctx, cc, option, pattern):
|
|
"""Checks that `option` is supported by the C linker. Doesn't %-escape the option."""
|
|
result = repository_ctx.execute([
|
|
cc,
|
|
option,
|
|
"-o",
|
|
"/dev/null",
|
|
str(repository_ctx.path("tools/cpp/empty.cc")),
|
|
])
|
|
return result.stderr.find(pattern) == -1
|
|
|
|
def _find_gold_linker_path(repository_ctx, cc):
|
|
"""Checks if `gold` is supported by the C compiler.
|
|
|
|
Args:
|
|
repository_ctx: repository_ctx.
|
|
cc: path to the C compiler.
|
|
|
|
Returns:
|
|
String to put as value to -fuse-ld= flag, or None if gold couldn't be found.
|
|
"""
|
|
result = repository_ctx.execute([
|
|
cc,
|
|
str(repository_ctx.path("tools/cpp/empty.cc")),
|
|
"-o",
|
|
"/dev/null",
|
|
# Some macos clang versions don't fail when setting -fuse-ld=gold, adding
|
|
# these lines to force it to. This also means that we will not detect
|
|
# gold when only a very old (year 2010 and older) is present.
|
|
"-Wl,--start-lib",
|
|
"-Wl,--end-lib",
|
|
"-fuse-ld=gold",
|
|
"-v",
|
|
])
|
|
if result.return_code != 0:
|
|
return None
|
|
|
|
for line in result.stderr.splitlines():
|
|
if line.find("gold") == -1:
|
|
continue
|
|
for flag in line.split(" "):
|
|
if flag.find("gold") == -1:
|
|
continue
|
|
if flag.find("--enable-gold") > -1 or flag.find("--with-plugin-ld") > -1:
|
|
# skip build configuration options of gcc itself
|
|
# TODO(hlopko): Add redhat-like worker on the CI (#9392)
|
|
continue
|
|
|
|
# flag is '-fuse-ld=gold' for GCC or "/usr/lib/ld.gold" for Clang
|
|
# strip space, single quote, and double quotes
|
|
flag = flag.strip(" \"'")
|
|
|
|
# remove -fuse-ld= from GCC output so we have only the flag value part
|
|
flag = flag.replace("-fuse-ld=", "")
|
|
return flag
|
|
auto_configure_warning(
|
|
"CC with -fuse-ld=gold returned 0, but its -v output " +
|
|
"didn't contain 'gold', falling back to the default linker.",
|
|
)
|
|
return None
|
|
|
|
def _add_compiler_option_if_supported(repository_ctx, cc, option):
|
|
"""Returns `[option]` if supported, `[]` otherwise. Doesn't %-escape the option."""
|
|
return [option] if _is_compiler_option_supported(repository_ctx, cc, option) else []
|
|
|
|
def _add_linker_option_if_supported(repository_ctx, cc, option, pattern):
|
|
"""Returns `[option]` if supported, `[]` otherwise. Doesn't %-escape the option."""
|
|
return [option] if _is_linker_option_supported(repository_ctx, cc, option, pattern) else []
|
|
|
|
def _get_no_canonical_prefixes_opt(repository_ctx, cc):
|
|
# If the compiler sometimes rewrites paths in the .d files without symlinks
|
|
# (ie when they're shorter), it confuses Bazel's logic for verifying all
|
|
# #included header files are listed as inputs to the action.
|
|
|
|
# The '-fno-canonical-system-headers' should be enough, but clang does not
|
|
# support it, so we also try '-no-canonical-prefixes' if first option does
|
|
# not work.
|
|
opt = _add_compiler_option_if_supported(
|
|
repository_ctx,
|
|
cc,
|
|
"-fno-canonical-system-headers",
|
|
)
|
|
if len(opt) == 0:
|
|
return _add_compiler_option_if_supported(
|
|
repository_ctx,
|
|
cc,
|
|
"-no-canonical-prefixes",
|
|
)
|
|
return opt
|
|
|
|
def get_env(repository_ctx):
|
|
"""Convert the environment in a list of export if in Homebrew. Doesn't %-escape the result!
|
|
|
|
Args:
|
|
repository_ctx: The repository context.
|
|
Returns:
|
|
empty string or a list of exports in case we're running with homebrew. Don't ask me why.
|
|
"""
|
|
env = repository_ctx.os.environ
|
|
if "HOMEBREW_RUBY_PATH" in env:
|
|
return "\n".join([
|
|
"export %s='%s'" % (k, env[k].replace("'", "'\\''"))
|
|
for k in env
|
|
if k != "_" and k.find(".") == -1
|
|
])
|
|
else:
|
|
return ""
|
|
|
|
def _coverage_flags(repository_ctx, darwin):
|
|
use_llvm_cov = "1" == get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_USE_LLVM_NATIVE_COVERAGE",
|
|
default = "0",
|
|
enable_warning = False,
|
|
)
|
|
if darwin or use_llvm_cov:
|
|
compile_flags = '"-fprofile-instr-generate", "-fcoverage-mapping"'
|
|
link_flags = '"-fprofile-instr-generate"'
|
|
else:
|
|
# gcc requires --coverage being passed for compilation and linking
|
|
# https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options
|
|
compile_flags = '"--coverage"'
|
|
link_flags = '"--coverage"'
|
|
return compile_flags, link_flags
|
|
|
|
def _find_generic(repository_ctx, name, env_name, overriden_tools, warn = False, silent = False):
|
|
"""Find a generic C++ toolchain tool. Doesn't %-escape the result."""
|
|
|
|
if name in overriden_tools:
|
|
return overriden_tools[name]
|
|
|
|
result = name
|
|
env_value = repository_ctx.os.environ.get(env_name)
|
|
env_value_with_paren = ""
|
|
if env_value != None:
|
|
env_value = env_value.strip()
|
|
if env_value:
|
|
result = env_value
|
|
env_value_with_paren = " (%s)" % env_value
|
|
if result.startswith("/"):
|
|
# Absolute path, maybe we should make this suported by our which function.
|
|
return result
|
|
result = repository_ctx.which(result)
|
|
if result == None:
|
|
msg = ("Cannot find %s or %s%s; either correct your path or set the %s" +
|
|
" environment variable") % (name, env_name, env_value_with_paren, env_name)
|
|
if warn:
|
|
if not silent:
|
|
auto_configure_warning(msg)
|
|
else:
|
|
auto_configure_fail(msg)
|
|
return result
|
|
|
|
def find_cc(repository_ctx, overriden_tools):
|
|
return _find_generic(repository_ctx, "gcc", "CC", overriden_tools)
|
|
|
|
def configure_unix_toolchain(repository_ctx, cpu_value, overriden_tools):
|
|
"""Configure C++ toolchain on Unix platforms.
|
|
|
|
Args:
|
|
repository_ctx: The repository context.
|
|
cpu_value: current cpu name.
|
|
overriden_tools: overriden tools.
|
|
"""
|
|
paths = resolve_labels(repository_ctx, [
|
|
"@rules_cc//cc/private/toolchain:BUILD.tpl",
|
|
"@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl",
|
|
"@rules_cc//cc/private/toolchain:unix_cc_toolchain_config.bzl",
|
|
"@rules_cc//cc/private/toolchain:linux_cc_wrapper.sh.tpl",
|
|
"@rules_cc//cc/private/toolchain:osx_cc_wrapper.sh.tpl",
|
|
])
|
|
|
|
repository_ctx.symlink(
|
|
paths["@rules_cc//cc/private/toolchain:unix_cc_toolchain_config.bzl"],
|
|
"cc_toolchain_config.bzl",
|
|
)
|
|
|
|
repository_ctx.symlink(
|
|
paths["@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"],
|
|
"armeabi_cc_toolchain_config.bzl",
|
|
)
|
|
|
|
repository_ctx.file("tools/cpp/empty.cc", "int main() {}")
|
|
darwin = cpu_value == "darwin"
|
|
|
|
cc = _find_generic(repository_ctx, "gcc", "CC", overriden_tools)
|
|
overriden_tools = dict(overriden_tools)
|
|
overriden_tools["gcc"] = cc
|
|
overriden_tools["gcov"] = _find_generic(
|
|
repository_ctx,
|
|
"gcov",
|
|
"GCOV",
|
|
overriden_tools,
|
|
warn = True,
|
|
silent = True,
|
|
)
|
|
if darwin:
|
|
overriden_tools["gcc"] = "cc_wrapper.sh"
|
|
overriden_tools["ar"] = "/usr/bin/libtool"
|
|
auto_configure_warning_maybe(repository_ctx, "CC used: " + str(cc))
|
|
tool_paths = _get_tool_paths(repository_ctx, overriden_tools)
|
|
cc_toolchain_identifier = escape_string(get_env_var(
|
|
repository_ctx,
|
|
"CC_TOOLCHAIN_NAME",
|
|
"local",
|
|
False,
|
|
))
|
|
|
|
cc_wrapper_src = (
|
|
"@rules_cc//cc/private/toolchain:osx_cc_wrapper.sh.tpl" if darwin else "@rules_cc//cc/private/toolchain:linux_cc_wrapper.sh.tpl"
|
|
)
|
|
repository_ctx.template(
|
|
"cc_wrapper.sh",
|
|
paths[cc_wrapper_src],
|
|
{
|
|
"%{cc}": escape_string(str(cc)),
|
|
"%{env}": escape_string(get_env(repository_ctx)),
|
|
},
|
|
)
|
|
|
|
cxx_opts = split_escaped(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_CXXOPTS",
|
|
"-std=c++0x",
|
|
False,
|
|
), ":")
|
|
|
|
bazel_linklibs = "-lstdc++:-lm"
|
|
bazel_linkopts = ""
|
|
link_opts = split_escaped(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_LINKOPTS",
|
|
bazel_linkopts,
|
|
False,
|
|
), ":")
|
|
link_libs = split_escaped(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_LINKLIBS",
|
|
bazel_linklibs,
|
|
False,
|
|
), ":")
|
|
gold_linker_path = _find_gold_linker_path(repository_ctx, cc)
|
|
cc_path = repository_ctx.path(cc)
|
|
if not str(cc_path).startswith(str(repository_ctx.path(".")) + "/"):
|
|
# cc is outside the repository, set -B
|
|
bin_search_flag = ["-B" + escape_string(str(cc_path.dirname))]
|
|
else:
|
|
# cc is inside the repository, don't set -B.
|
|
bin_search_flag = []
|
|
|
|
coverage_compile_flags, coverage_link_flags = _coverage_flags(repository_ctx, darwin)
|
|
builtin_include_directories = _uniq(
|
|
get_escaped_cxx_inc_directories(repository_ctx, cc, "-xc") +
|
|
get_escaped_cxx_inc_directories(repository_ctx, cc, "-xc++", cxx_opts) +
|
|
get_escaped_cxx_inc_directories(
|
|
repository_ctx,
|
|
cc,
|
|
"-xc",
|
|
_get_no_canonical_prefixes_opt(repository_ctx, cc),
|
|
) +
|
|
get_escaped_cxx_inc_directories(
|
|
repository_ctx,
|
|
cc,
|
|
"-xc++",
|
|
cxx_opts + _get_no_canonical_prefixes_opt(repository_ctx, cc),
|
|
),
|
|
)
|
|
|
|
write_builtin_include_directory_paths(repository_ctx, cc, builtin_include_directories)
|
|
repository_ctx.template(
|
|
"BUILD",
|
|
paths["@rules_cc//cc/private/toolchain:BUILD.tpl"],
|
|
{
|
|
"%{abi_libc_version}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"ABI_LIBC_VERSION",
|
|
"local",
|
|
False,
|
|
)),
|
|
"%{abi_version}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"ABI_VERSION",
|
|
"local",
|
|
False,
|
|
)),
|
|
"%{cc_compiler_deps}": get_starlark_list([":builtin_include_directory_paths"] + (
|
|
[":cc_wrapper"] if darwin else []
|
|
)),
|
|
"%{cc_toolchain_identifier}": cc_toolchain_identifier,
|
|
"%{compile_flags}": get_starlark_list(
|
|
[
|
|
# Security hardening requires optimization.
|
|
# We need to undef it as some distributions now have it enabled by default.
|
|
"-U_FORTIFY_SOURCE",
|
|
"-fstack-protector",
|
|
# All warnings are enabled. Maybe enable -Werror as well?
|
|
"-Wall",
|
|
# Enable a few more warnings that aren't part of -Wall.
|
|
] + (
|
|
_add_compiler_option_if_supported(repository_ctx, cc, "-Wthread-safety") +
|
|
_add_compiler_option_if_supported(repository_ctx, cc, "-Wself-assign")
|
|
) + (
|
|
# Disable problematic warnings.
|
|
_add_compiler_option_if_supported(repository_ctx, cc, "-Wunused-but-set-parameter") +
|
|
# has false positives
|
|
_add_compiler_option_if_supported(repository_ctx, cc, "-Wno-free-nonheap-object") +
|
|
# Enable coloring even if there's no attached terminal. Bazel removes the
|
|
# escape sequences if --nocolor is specified.
|
|
_add_compiler_option_if_supported(repository_ctx, cc, "-fcolor-diagnostics")
|
|
) + [
|
|
# Keep stack frames for debugging, even in opt mode.
|
|
"-fno-omit-frame-pointer",
|
|
],
|
|
),
|
|
"%{compiler}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_COMPILER",
|
|
"compiler",
|
|
False,
|
|
)),
|
|
"%{coverage_compile_flags}": coverage_compile_flags,
|
|
"%{coverage_link_flags}": coverage_link_flags,
|
|
"%{cxx_builtin_include_directories}": get_starlark_list(builtin_include_directories),
|
|
"%{cxx_flags}": get_starlark_list(cxx_opts + _escaped_cplus_include_paths(repository_ctx)),
|
|
"%{dbg_compile_flags}": get_starlark_list(["-g"]),
|
|
"%{host_system_name}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_HOST_SYSTEM",
|
|
"local",
|
|
False,
|
|
)),
|
|
"%{link_flags}": get_starlark_list((
|
|
["-fuse-ld=" + gold_linker_path] if gold_linker_path else []
|
|
) + _add_linker_option_if_supported(
|
|
repository_ctx,
|
|
cc,
|
|
"-Wl,-no-as-needed",
|
|
"-no-as-needed",
|
|
) + _add_linker_option_if_supported(
|
|
repository_ctx,
|
|
cc,
|
|
"-Wl,-z,relro,-z,now",
|
|
"-z",
|
|
) + (
|
|
[
|
|
"-undefined",
|
|
"dynamic_lookup",
|
|
"-headerpad_max_install_names",
|
|
] if darwin else bin_search_flag + [
|
|
# Gold linker only? Can we enable this by default?
|
|
# "-Wl,--warn-execstack",
|
|
# "-Wl,--detect-odr-violations"
|
|
] + _add_compiler_option_if_supported(
|
|
# Have gcc return the exit code from ld.
|
|
repository_ctx,
|
|
cc,
|
|
"-pass-exit-codes",
|
|
)
|
|
) + link_opts),
|
|
"%{link_libs}": get_starlark_list(link_libs),
|
|
"%{name}": cpu_value,
|
|
"%{opt_compile_flags}": get_starlark_list(
|
|
[
|
|
# No debug symbols.
|
|
# Maybe we should enable https://gcc.gnu.org/wiki/DebugFission for opt or
|
|
# even generally? However, that can't happen here, as it requires special
|
|
# handling in Bazel.
|
|
"-g0",
|
|
|
|
# Conservative choice for -O
|
|
# -O3 can increase binary size and even slow down the resulting binaries.
|
|
# Profile first and / or use FDO if you need better performance than this.
|
|
"-O2",
|
|
|
|
# Security hardening on by default.
|
|
# Conservative choice; -D_FORTIFY_SOURCE=2 may be unsafe in some cases.
|
|
"-D_FORTIFY_SOURCE=1",
|
|
|
|
# Disable assertions
|
|
"-DNDEBUG",
|
|
|
|
# Removal of unused code and data at link time (can this increase binary
|
|
# size in some cases?).
|
|
"-ffunction-sections",
|
|
"-fdata-sections",
|
|
],
|
|
),
|
|
"%{opt_link_flags}": get_starlark_list(
|
|
[] if darwin else _add_linker_option_if_supported(
|
|
repository_ctx,
|
|
cc,
|
|
"-Wl,--gc-sections",
|
|
"-gc-sections",
|
|
),
|
|
),
|
|
"%{supports_param_files}": "0" if darwin else "1",
|
|
"%{supports_start_end_lib}": "True" if gold_linker_path else "False",
|
|
"%{target_cpu}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_TARGET_CPU",
|
|
cpu_value,
|
|
False,
|
|
)),
|
|
"%{target_libc}": "macosx" if darwin else escape_string(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_TARGET_LIBC",
|
|
"local",
|
|
False,
|
|
)),
|
|
"%{target_system_name}": escape_string(get_env_var(
|
|
repository_ctx,
|
|
"BAZEL_TARGET_SYSTEM",
|
|
"local",
|
|
False,
|
|
)),
|
|
"%{tool_paths}": ",\n ".join(
|
|
['"%s": "%s"' % (k, v) for k, v in tool_paths.items()],
|
|
),
|
|
"%{unfiltered_compile_flags}": get_starlark_list(
|
|
_get_no_canonical_prefixes_opt(repository_ctx, cc) + [
|
|
# Make C++ compilation deterministic. Use linkstamping instead of these
|
|
# compiler symbols.
|
|
"-Wno-builtin-macro-redefined",
|
|
"-D__DATE__=\\\"redacted\\\"",
|
|
"-D__TIMESTAMP__=\\\"redacted\\\"",
|
|
"-D__TIME__=\\\"redacted\\\"",
|
|
],
|
|
),
|
|
},
|
|
)
|