stamp = 1: Always stamp the build information into the binary, even in
- --nostamp builds. This
+ --nostamp builds. This
setting should be avoided, since it potentially kills remote caching for the
binary and any downstream actions that depend on it.
stamp = -1: Embedding of build information is controlled by the
- --[no]stamp flag.
+ --[no]stamp flag.
Stamped binaries are not rebuilt unless their dependencies change.
diff --git a/cc/private/rules_impl/cc_binary_impl.bzl b/cc/private/rules_impl/cc_binary_impl.bzl index a329ae28d..152f5f6f0 100644 --- a/cc/private/rules_impl/cc_binary_impl.bzl +++ b/cc/private/rules_impl/cc_binary_impl.bzl @@ -120,7 +120,7 @@ def _add_transitive_info_providers(ctx, cc_toolchain, cpp_config, feature_config cc_toolchain, feature_configuration, ctx, - False, # generate_hidden_top_level_group + generate_hidden_top_level_group = False, ) cc_info = CcInfo( compilation_context = compilation_context, @@ -178,21 +178,6 @@ def _collect_runfiles(ctx, feature_configuration, cc_toolchain, linking_context, return (builder.merge(ctx.runfiles(files = builder_artifacts, transitive_files = depset(builder_transitive_artifacts))), runtime_objects_for_coverage) -def _create_dynamic_libraries_copy_actions(ctx, binary, dynamic_libraries_for_runtime): - result = [] - for lib in dynamic_libraries_for_runtime: - # If the binary and the DLL are not in the same directory, copy the DLL - # to the binary's directory. - if lib.dirname != binary.dirname: - copy = ctx.actions.declare_file(lib.basename, sibling = binary) - ctx.actions.symlink(output = copy, target_file = lib, progress_message = "Copying Execution Dynamic Library") - result.append(copy) - else: - # If the library is already in the same directory as the binary, we don't need to copy it, - # but we still add it to the result. - result.append(lib) - return depset(result) - def _get_dynamic_library_for_runtime_or_none(library_to_link, link_statically): if library_to_link.dynamic_library == None: return None @@ -718,10 +703,15 @@ def cc_binary_impl(ctx, additional_linkopts, force_linkstatic = False): dwp_exec_group = "cpp_dwp", ) explicit_dwp_file = dwp_file + materialize_dwo_files = False if not cc_helper.should_create_per_object_debug_info(feature_configuration, cpp_config): explicit_dwp_file = None elif cc_helper.should_create_test_dwp_for_statically_linked_test(ctx.attr._is_test, linking_mode, cpp_config): files_to_build_list.append(dwp_file) + elif is_dbg_build: + # If fission is enabled, and this is a debug build, and we are not creating a DWP file, + # materialize DWO files into their own output_group. + materialize_dwo_files = True # If the binary is linked dynamically and COPY_DYNAMIC_LIBRARIES_TO_BINARY is enabled, collect # all the dynamic libraries we need at runtime. Then copy these libraries next to the binary. @@ -731,7 +721,7 @@ def cc_binary_impl(ctx, additional_linkopts, force_linkstatic = False): libraries = [] for linker_input in linker_inputs: libraries.extend(linker_input.libraries) - copied_runtime_dynamic_libraries = _create_dynamic_libraries_copy_actions(ctx, binary, _get_dynamic_libraries_for_runtime(is_static_mode, libraries)) + copied_runtime_dynamic_libraries = cc_helper.create_dynamic_libraries_copy_actions(ctx, binary, _get_dynamic_libraries_for_runtime(is_static_mode, libraries)) # TODO(b/198254254)(bazel-team): Do we need to put original shared libraries (along with # mangled symlinks) into the RunfilesSupport object? It does not seem @@ -785,6 +775,13 @@ def cc_binary_impl(ctx, additional_linkopts, force_linkstatic = False): if linkmap: output_groups["linkmap"] = depset([linkmap]) + if materialize_dwo_files and dwo_files: + output_groups["dwo_files"] = dwo_files + else: + # Some configurations always request dwo_files. + # If we do not create them, set an empty depset to avoid a warning. + output_groups["dwo_files"] = depset() + if cc_linking_outputs_binary_library != None: # For consistency and readability. library_to_link = cc_linking_outputs_binary_library @@ -818,12 +815,14 @@ def cc_binary_impl(ctx, additional_linkopts, force_linkstatic = False): runfiles = runfiles, executable = binary, ) + + # TODO(https://github.com/bazelbuild/bazel/issues/32085): Use Bazel's type. result = [ cc_info, instrumented_files_provider, debug_package_info, OutputGroupInfo(**output_groups), - ] + ] # type: list[ProviderInstance] if cc_launcher_info != None: result.append(cc_launcher_info) return binary_info, result diff --git a/cc/private/rules_impl/cc_library.bzl b/cc/private/rules_impl/cc_library.bzl index 0bbb93094..5b8e7bb43 100755 --- a/cc/private/rules_impl/cc_library.bzl +++ b/cc/private/rules_impl/cc_library.bzl @@ -394,7 +394,7 @@ themalloc
attribute of cc_binary). Dependency
linkopts take precedence over dependent linkopts (i.e. dependency linkopts
appear later in the command line). Linkopts specified in
---linkopt
+--linkopt
take precedence over rule linkopts.
diff --git a/cc/private/rules_impl/cc_shared_library.bzl b/cc/private/rules_impl/cc_shared_library.bzl index 7df94c7f8..8566333d2 100644 --- a/cc/private/rules_impl/cc_shared_library.bzl +++ b/cc/private/rules_impl/cc_shared_library.bzl @@ -79,31 +79,8 @@ graph_structure_aspect = aspect( implementation = _graph_structure_aspect_impl, ) -def _cc_shared_library_initializer(**kwargs): - """Converts labels in exports_filter into canonical form relative to the current repository. - - This conversion can only be done in a macro as it requires access to the repository mapping of - the repository containing the cc_shared_library target. This mapping is automatically - applied to label attributes, but exports_filter is a list of strings attribute. - """ - if "exports_filter" not in kwargs: - return kwargs - - raw_exports_filter = kwargs["exports_filter"] - if type(raw_exports_filter) != type([]): - # TODO: Also canonicalize labels in selects once macros can operate on them. - # https://github.com/bazelbuild/bazel/issues/14157 - return kwargs - - canonical_exports_filter = [ - str(native.package_relative_label(s)) - for s in raw_exports_filter - ] - return kwargs | {"exports_filter": canonical_exports_filter} - cc_shared_library = rule( implementation = proxy, - initializer = _cc_shared_library_initializer, doc = """
It produces a shared library.
diff --git a/cc/private/rules_impl/cc_shared_library_impl.bzl b/cc/private/rules_impl/cc_shared_library_impl.bzl index b241381c4..58212ae28 100644 --- a/cc/private/rules_impl/cc_shared_library_impl.bzl +++ b/cc/private/rules_impl/cc_shared_library_impl.bzl @@ -17,7 +17,7 @@ load("@bazel_skylib//lib:paths.bzl", "paths") load("//cc:find_cc_toolchain.bzl", "find_cc_toolchain") load("//cc/common:cc_common.bzl", "cc_common") -load("//cc/common:cc_helper.bzl", "cc_helper") +load("//cc/common:cc_helper.bzl", "artifact_category", "cc_helper") load("//cc/common:cc_info.bzl", "CcInfo") load("//cc/common:cc_shared_library_info.bzl", "CcSharedLibraryInfo") load("//cc/common:feature_names.bzl", "feature_names") @@ -293,9 +293,9 @@ def _check_if_target_under_path(value, pattern): return pattern.package == value.package and pattern.name == value.name -def _check_if_target_should_be_exported_with_filter(target, current_label, exports_filter): +def _check_if_target_should_be_exported_with_filter(ctx, target, exports_filter): for export_filter in exports_filter: - export_filter_label = current_label.relative(export_filter) + export_filter_label = ctx.package_relative_label(export_filter) if _check_if_target_under_path(target, export_filter_label): return True @@ -478,8 +478,8 @@ def _filter_inputs( linker_input, ) if _check_if_target_should_be_exported_with_filter( + ctx, linker_input.owner, - ctx.label, ctx.attr.exports_filter, ): exports[owner] = True @@ -690,12 +690,21 @@ def _cc_shared_library_impl(ctx): if library.objects != None: object_files.extend(library.objects) - generated_def_file = None + # The LIBRARY statement of the DEF file determines the DLL name that the import library + # refers to, so it has to match the actual output file. + if main_output: + dll_name = main_output.basename + else: + dll_name = paths.basename(cc_common.get_artifact_name_for_category( + cc_toolchain = cc_toolchain, + category = artifact_category.DYNAMIC_LIBRARY, + output_name = ctx.label.name, + )) generated_def_file = cc_helper.generate_def_file( ctx, ctx.file._def_parser, object_files, - ctx.label.name, + dll_name, cc_toolchain, feature_configuration, ) @@ -736,6 +745,25 @@ def _cc_shared_library_impl(ctx): for dep in ctx.attr.dynamic_deps: runfiles = runfiles.merge(dep[DefaultInfo].data_runfiles) + if feature_configuration.is_enabled(feature_names.COPY_DYNAMIC_LIBRARIES_TO_BINARY): + libraries_to_copy = [] + copy_linking_contexts = [linking_context] + runtimes_linking_contexts + copy_linking_contexts.append(_create_linker_context([ + dep.linker_input + for dep in merged_cc_shared_library_infos_list + ])) + for context in copy_linking_contexts: + libraries_to_copy.extend(cc_helper.get_dynamic_libraries_for_runtime( + context, + linking_statically = True, + )) + copied_runtime_libraries = cc_helper.create_dynamic_libraries_copy_actions( + ctx, + linking_outputs.library_to_link.dynamic_library, + libraries_to_copy, + ) + runfiles = runfiles.merge(ctx.runfiles(transitive_files = copied_runtime_libraries)) + precompiled_only_dynamic_libraries_runfiles = [] for precompiled_dynamic_library in precompiled_only_dynamic_libraries: # precompiled_dynamic_library.dynamic_library could be None if the library to link just contains diff --git a/cc/private/rules_impl/cc_static_library.bzl b/cc/private/rules_impl/cc_static_library.bzl index 041da2afb..7579307b6 100644 --- a/cc/private/rules_impl/cc_static_library.bzl +++ b/cc/private/rules_impl/cc_static_library.bzl @@ -40,8 +40,8 @@ def _flatten_and_get_objects(linker_inputs): for linker_input in linker_inputs.to_list(): for lib in linker_input.libraries: if lib._contains_objects: - transitive_objects.append(depset(lib.pic_objects)) - transitive_objects.append(depset(lib.objects)) + # Select on variant per library, preferring PIC. + transitive_objects.append(depset(lib.pic_objects or lib.objects)) return depset(transitive = transitive_objects, order = "topological") diff --git a/cc/private/rules_impl/cc_toolchain.bzl b/cc/private/rules_impl/cc_toolchain.bzl index ab55e6b35..7a622b536 100644 --- a/cc/private/rules_impl/cc_toolchain.bzl +++ b/cc/private/rules_impl/cc_toolchain.bzl @@ -356,12 +356,12 @@ The label of the rule providingcc_toolchain_config_info.""",
default = configuration_field(fragment = "cpp", name = "libc_top"),
),
"_interface_library_builder": attr.label(
- default = "@bazel_tools//tools/cpp:interface_library_builder",
+ default = "//cc/private/toolchain:interface_library_builder",
allow_single_file = True,
cfg = "exec",
),
"_link_dynamic_library_tool": attr.label(
- default = "@bazel_tools//tools/cpp:link_dynamic_library",
+ default = "//cc/private/toolchain:link_dynamic_library",
allow_single_file = True,
cfg = "exec",
),
diff --git a/cc/private/rules_impl/cc_toolchain_provider_helper.bzl b/cc/private/rules_impl/cc_toolchain_provider_helper.bzl
index 8d042e291..b0dea3f7f 100644
--- a/cc/private/rules_impl/cc_toolchain_provider_helper.bzl
+++ b/cc/private/rules_impl/cc_toolchain_provider_helper.bzl
@@ -58,17 +58,22 @@ def _additional_make_variables(toolchain_make_vars):
make_vars.pop("CC_FLAGS", None)
return make_vars
-def _compute_tool_paths(toolchain_config_info, crosstool_top_path):
+def _compute_tool_paths(toolchain_config_info, crosstool_top_path, output_directory_prefix):
tool_paths_collector = {}
for tool in toolchain_config_info.tool_paths:
path_str = tool.path
if not paths.is_normalized(path_str):
fail("The include path '" + path_str + "' is not normalized.")
- tool_paths_collector[tool.name] = get_relative_path(crosstool_top_path, path_str)
+ if path_str.startswith(output_directory_prefix):
+ # The path of a file generated by the build, e.g. a compiler wrapper built in the
+ # exec configuration, is already relative to the execution root.
+ tool_paths_collector[tool.name] = path_str
+ else:
+ tool_paths_collector[tool.name] = get_relative_path(crosstool_top_path, path_str)
return tool_paths_collector
-def _resolve_include_dir(target_label, s, sysroot, crosstool_path):
+def _resolve_include_dir(ctx, s, sysroot, crosstool_path):
""" Resolve the given include directory.
If it starts with %sysroot%/, that part is replaced with the actual sysroot.
@@ -97,7 +102,7 @@ def _resolve_include_dir(target_label, s, sysroot, crosstool_path):
# This is necessary to avoid the hard work of parsing,
# and use an already existing API.
- dummy_label = target_label.relative(package + ":dummy_target")
+ dummy_label = ctx.package_relative_label(package + ":dummy_target")
repo_prefix = dummy_label.workspace_root
path_prefix = get_relative_path(repo_prefix, dummy_label.package)
path_start_index = package_end_index + len(_PACKAGE_END)
@@ -150,7 +155,14 @@ def get_cc_toolchain_provider(ctx, attributes):
attributes.cc_toolchain_label.package,
ctx.configuration.is_sibling_repository_layout(),
)
- tool_paths = _compute_tool_paths(toolchain_config_info, tools_directory)
+ bin_dir_path = ctx.bin_dir.path
+ tool_paths = _compute_tool_paths(
+ toolchain_config_info,
+ tools_directory,
+ # The first segment of the bin directory path, e.g. "bazel-out/", is shared by the output
+ # directories of all configurations.
+ bin_dir_path[:bin_dir_path.find("/") + 1],
+ )
toolchain_features = cc_common.cc_toolchain_features(toolchain_config_info = toolchain_config_info, tools_directory = tools_directory)
# action_is_enabled only returns true for action_configs that are in
@@ -222,7 +234,7 @@ def get_cc_toolchain_provider(ctx, attributes):
builtin_include_directories = []
for s in toolchain_config_info.cxx_builtin_include_directories:
- builtin_include_directories.append(_resolve_include_dir(ctx.label, s, sysroot, tools_directory))
+ builtin_include_directories.append(_resolve_include_dir(ctx, s, sysroot, tools_directory))
build_variables_dict = _get_cc_toolchain_vars(ctx.fragments.cpp, sysroot)
build_variables = cc_common.cc_toolchain_variables(vars = build_variables_dict)
diff --git a/cc/private/rules_impl/failing_cc_proto_library.bzl b/cc/private/rules_impl/failing_cc_proto_library.bzl
index 263c8a022..499c8d2cc 100644
--- a/cc/private/rules_impl/failing_cc_proto_library.bzl
+++ b/cc/private/rules_impl/failing_cc_proto_library.bzl
@@ -23,6 +23,7 @@ CC_PROTO_LIBRARY_DEPRECATION = (
)
def _impl(_ctx):
+ # type: (...) -> Never
fail(CC_PROTO_LIBRARY_DEPRECATION)
cc_proto_library = rule(
diff --git a/cc/private/rules_impl/fdo/fdo_prefetch_hints.bzl b/cc/private/rules_impl/fdo/fdo_prefetch_hints.bzl
index 6696b7b3d..c6e693073 100644
--- a/cc/private/rules_impl/fdo/fdo_prefetch_hints.bzl
+++ b/cc/private/rules_impl/fdo/fdo_prefetch_hints.bzl
@@ -20,6 +20,7 @@ FdoPrefetchHintsInfo = provider(
)
def _impl(ctx):
+ # type: (...) -> FdoPrefetchHintsInfo
return FdoPrefetchHintsInfo(artifact = ctx.file.profile)
fdo_prefetch_hints = rule(
diff --git a/cc/private/rules_impl/fdo/fdo_profile.bzl b/cc/private/rules_impl/fdo/fdo_profile.bzl
index d16e94dac..f2bfe2937 100644
--- a/cc/private/rules_impl/fdo/fdo_profile.bzl
+++ b/cc/private/rules_impl/fdo/fdo_profile.bzl
@@ -26,6 +26,7 @@ FdoProfileInfo = provider(
)
def _impl(ctx):
+ # type: (...) -> FdoProfileInfo
return FdoProfileInfo(
artifact = ctx.file.profile,
proto_profile_artifact = ctx.file.proto_profile,
diff --git a/cc/private/rules_impl/fdo/memprof_profile.bzl b/cc/private/rules_impl/fdo/memprof_profile.bzl
index 46248613c..3eb12f01a 100644
--- a/cc/private/rules_impl/fdo/memprof_profile.bzl
+++ b/cc/private/rules_impl/fdo/memprof_profile.bzl
@@ -20,6 +20,7 @@ MemProfProfileInfo = provider(
)
def _impl(ctx):
+ # type: (...) -> MemProfProfileInfo
return MemProfProfileInfo(
artifact = ctx.file.profile,
changelist = ctx.attr.changelist,
diff --git a/cc/private/rules_impl/fdo/propeller_optimize.bzl b/cc/private/rules_impl/fdo/propeller_optimize.bzl
index 3e3e8ce62..833aa535c 100644
--- a/cc/private/rules_impl/fdo/propeller_optimize.bzl
+++ b/cc/private/rules_impl/fdo/propeller_optimize.bzl
@@ -20,6 +20,7 @@ PropellerOptimizeInfo = provider(
)
def _impl(ctx):
+ # type: (...) -> PropellerOptimizeInfo
return PropellerOptimizeInfo(
cc_profile = ctx.file.cc_profile,
ld_profile = ctx.file.ld_profile,
diff --git a/cc/private/rules_impl/native_cc_common.bzl b/cc/private/rules_impl/native_cc_common.bzl
index 00bc8a5dc..75f18abcf 100644
--- a/cc/private/rules_impl/native_cc_common.bzl
+++ b/cc/private/rules_impl/native_cc_common.bzl
@@ -14,5 +14,7 @@
#
"""Native implementation of cc_common."""
+# Bazel's API metadata omits private members such as empty_variables and
+# legacy_cc_flags_make_variable_do_not_use.
# buildifier: disable=native-cc-common
-native_cc_common = cc_common
+native_cc_common = cc_common # ty: ignore[non-static-type]
diff --git a/cc/private/rules_impl/objc_compilation_artifacts_info.bzl b/cc/private/rules_impl/objc_compilation_artifacts_info.bzl
index bdb0e77ea..0b72d049f 100644
--- a/cc/private/rules_impl/objc_compilation_artifacts_info.bzl
+++ b/cc/private/rules_impl/objc_compilation_artifacts_info.bzl
@@ -53,12 +53,13 @@ def _compilation_artifacts_init(
# Note: the condition under which we set an archive artifact needs to match the condition for
# which we create the archive in compilation_support.bzl. In particular, if srcs are all
# headers, we don't generate an archive.
+ # TODO(https://github.com/bazelbuild/rules_cc/pull/967): handle omitted sources and artifacts.
if (
non_arc_srcs or
- [s for s in srcs if s.is_directory or
+ [s for s in srcs if s.is_directory or # ty: ignore[not-iterable]
s.extension in COMPILABLE_OR_PRECOMPILED_SRC_EXTENSIONS]
):
- archive = intermediate_artifacts.archive()
+ archive = intermediate_artifacts.archive() # ty: ignore[unresolved-attribute]
else:
archive = None
return {
diff --git a/cc/private/rules_impl/objc_compilation_artifacts_info.bzli b/cc/private/rules_impl/objc_compilation_artifacts_info.bzli
new file mode 100644
index 000000000..2d7748db4
--- /dev/null
+++ b/cc/private/rules_impl/objc_compilation_artifacts_info.bzli
@@ -0,0 +1,47 @@
+# Copyright 2024 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.
+
+"""Types for Objective-C compilation artifacts."""
+
+type _Files = list[File] | tuple[File, ...]
+type _ArchiveFactory = struct[{"archive": Callable[[], File]}, ...]
+# TODO(https://github.com/bazelbuild/bazel/issues/31770): annotate the Objective-C artifact dictionary
+# in Starlark once Bazel supports dictionaries with named, typed keys.
+type _Result = dict[{
+ "srcs": _Files | None,
+ "non_arc_srcs": _Files | None,
+ "additional_hdrs": _Files | None,
+ "archive": File | None,
+}]
+
+def _compilation_artifacts_init(
+ ctx: ctx[object, object] | None = ...,
+ srcs: _Files | None = ...,
+ non_arc_srcs: _Files | None = ...,
+ hdrs: _Files | None = ...,
+ intermediate_artifacts: _ArchiveFactory | None = ...,
+) -> _Result: ...
+
+def CompilationArtifactsInfo(
+ ctx: ctx[object, object] | None = ...,
+ srcs: _Files | None = ...,
+ non_arc_srcs: _Files | None = ...,
+ hdrs: _Files | None = ...,
+ intermediate_artifacts: _ArchiveFactory | None = ...,
+) -> record[{
+ "srcs": _Files | None,
+ "non_arc_srcs": _Files | None,
+ "additional_hdrs": _Files | None,
+ "archive": File | None,
+}]: ...
diff --git a/cc/private/rules_impl/objc_compilation_context_info.bzli b/cc/private/rules_impl/objc_compilation_context_info.bzli
new file mode 100644
index 000000000..9a417c6ce
--- /dev/null
+++ b/cc/private/rules_impl/objc_compilation_context_info.bzli
@@ -0,0 +1,35 @@
+"""Inputs and fields of the Objective-C compilation context provider."""
+
+class _StrictIncludes(Protocol):
+ @property
+ def strict_include(self) -> depset[str]: ...
+
+# TODO(https://github.com/bazelbuild/bazel/issues/31770): annotate the Objective-C provider initializer result
+# in Starlark once Bazel supports dictionaries with named, typed keys.
+type _Fields = dict[{
+ "defines": Sequence[str],
+ "public_hdrs": Sequence[File],
+ "public_textual_hdrs": Collection[File],
+ "private_hdrs": Collection[File],
+ "includes": Sequence[str],
+ "system_includes": Sequence[str],
+ "quote_includes": Sequence[str],
+ "direct_cc_compilation_contexts": Collection[CompilationContext],
+ "cc_compilation_contexts": list[CompilationContext],
+ "implementation_cc_compilation_contexts": Sequence[CompilationContext],
+ "strict_dependency_includes": list[str],
+}]
+
+def _objc_compilation_context_info_init(
+ defines: Sequence[str] = ...,
+ public_hdrs: Sequence[File] = ...,
+ public_textual_hdrs: Collection[File] = ...,
+ private_hdrs: Collection[File] = ...,
+ includes: Sequence[str] = ...,
+ system_includes: Sequence[str] = ...,
+ quote_includes: Sequence[str] = ...,
+ direct_cc_compilation_contexts: Collection[CompilationContext] = ...,
+ cc_compilation_contexts: list[CompilationContext] = ...,
+ implementation_cc_compilation_contexts: Sequence[CompilationContext] = ...,
+ providers: Collection[_StrictIncludes] = ...,
+) -> _Fields: ...
diff --git a/cc/private/rules_impl/objc_compilation_support.bzl b/cc/private/rules_impl/objc_compilation_support.bzl
index 624ee8bfd..46bcd8439 100644
--- a/cc/private/rules_impl/objc_compilation_support.bzl
+++ b/cc/private/rules_impl/objc_compilation_support.bzl
@@ -22,8 +22,6 @@ load(":objc_common.bzl", "objc_common")
load(":objc_compilation_artifacts_info.bzl", "CompilationArtifactsInfo")
load(":objc_intermediate_artifacts.bzl", "create_intermediate_artifacts")
-XcodeVersionInfo = apple_common.XcodeVersionConfig
-
def _build_variable_extensions(ctx, arc_enabled):
extensions = {}
if hasattr(ctx.attr, "pch") and ctx.attr.pch != None:
@@ -282,13 +280,7 @@ def _get_non_arc_srcs(ctx):
if DefaultInfo in src:
for artifact in src[DefaultInfo].files.to_list():
artifact_label_map[artifact] = src.label
- return _map_to_list(artifact_label_map)
-
-def _map_to_list(m):
- result = []
- for k, v in m.items():
- result.append((k, v))
- return result
+ return artifact_label_map.items()
def _cc_compile_and_link(
srcs,
diff --git a/cc/private/toolchain/BUILD b/cc/private/toolchain/BUILD
index abd4e6b9d..753bdab3d 100644
--- a/cc/private/toolchain/BUILD
+++ b/cc/private/toolchain/BUILD
@@ -21,6 +21,11 @@ package(default_visibility = ["//visibility:public"])
licenses(["notice"]) # Apache 2.0
+exports_files([
+ "lib_cc_configure.bzli",
+ "unix_cc_configure.bzli",
+])
+
# It is frequently necessary to constrain platforms based on the cc compiler type.
constraint_setting(name = "cc_compiler")
@@ -58,6 +63,12 @@ cc_library(
name = "malloc",
)
+filegroup(
+ name = "grep-includes",
+ srcs = ["empty.cc"],
+ deprecation = "grep-includes is always empty, you must provide your own.",
+)
+
filegroup(
name = "empty",
srcs = [],
diff --git a/cc/private/toolchain/cc_configure.bzl b/cc/private/toolchain/cc_configure.bzl
index c2bf06aaa..fa28a5d81 100644
--- a/cc/private/toolchain/cc_configure.bzl
+++ b/cc/private/toolchain/cc_configure.bzl
@@ -14,15 +14,14 @@
"""Rules for configuring the C++ toolchain (experimental)."""
load("@bazel_features//:features.bzl", "bazel_features")
-load(
- ":lib_cc_configure.bzl",
- "get_cpu_value",
- "resolve_labels",
-)
+load(":lib_cc_configure.bzl", "copy_file", "get_cpu_value")
load(":unix_cc_configure.bzl", "configure_unix_toolchain")
load(":windows_cc_configure.bzl", "configure_windows_toolchain")
def _should_disable_toolchain(repository_ctx):
+ # type: (repository_ctx) -> bool
+ # TODO(https://github.com/bazelbuild/bazel/issues/32020): make this an
+ # annotation when supported Bazel versions expose a repository context type.
"""Returns true if the toolchain should be disabled based on environment variables."""
env = repository_ctx.os.environ
if env.get("BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN") == "1":
@@ -39,6 +38,7 @@ def _should_disable_toolchain(repository_ctx):
return False
def cc_autoconf_toolchains_impl(repository_ctx):
+ # type: (repository_ctx) -> repo_metadata | None
"""Generate BUILD file with 'toolchain' targets for the local host C++ toolchain.
Args:
@@ -52,13 +52,10 @@ def cc_autoconf_toolchains_impl(repository_ctx):
build_path = "@rules_cc//cc/private/toolchain:BUILD.windows_toolchains.tpl"
else:
build_path = "@rules_cc//cc/private/toolchain:BUILD.toolchains.tpl"
- paths = resolve_labels(repository_ctx, [
- build_path,
- ])
repository_ctx.template(
"BUILD",
- paths[build_path],
+ Label(build_path),
{"%{name}": get_cpu_value(repository_ctx)},
)
else:
@@ -78,6 +75,7 @@ cc_autoconf_toolchains = repository_rule(
)
def cc_autoconf_impl(repository_ctx, overriden_tools = dict()):
+ # type: (repository_ctx, Mapping[str, str | path]) -> repo_metadata | None
"""Generate BUILD file with 'cc_toolchain' targets for the local host C++ toolchain.
Args:
@@ -89,28 +87,18 @@ def cc_autoconf_impl(repository_ctx, overriden_tools = dict()):
"""
cpu_value = get_cpu_value(repository_ctx)
if _should_disable_toolchain(repository_ctx):
- paths = resolve_labels(repository_ctx, [
- "@rules_cc//cc/private/toolchain:BUILD.empty.tpl",
- "@rules_cc//cc/private/toolchain:empty_cc_toolchain_config.bzl",
- ])
- repository_ctx.symlink(paths["@rules_cc//cc/private/toolchain:empty_cc_toolchain_config.bzl"], "cc_toolchain_config.bzl")
- repository_ctx.template("BUILD", paths["@rules_cc//cc/private/toolchain:BUILD.empty.tpl"], {
+ copy_file(repository_ctx, Label("@rules_cc//cc/private/toolchain:empty_cc_toolchain_config.bzl"), "cc_toolchain_config.bzl")
+ repository_ctx.template("BUILD", Label("@rules_cc//cc/private/toolchain:BUILD.empty.tpl"), {
"%{cpu}": get_cpu_value(repository_ctx),
})
elif cpu_value == "freebsd" or cpu_value == "openbsd":
- paths = resolve_labels(repository_ctx, [
- "@rules_cc//cc/private/toolchain:BUILD.static.bsd",
- "@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl",
- "@rules_cc//cc/private/toolchain:bsd_cc_toolchain_config.bzl",
- ])
-
# This is defaulting to a static crosstool. We should eventually
# autoconfigure this platform too. Theoretically, FreeBSD and OpenBSD
# should be straightforward to add but we cannot run them in a Docker
# container so skipping until we have proper tests for these platforms.
- repository_ctx.symlink(paths["@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"], "armeabi_cc_toolchain_config.bzl")
- repository_ctx.symlink(paths["@rules_cc//cc/private/toolchain:bsd_cc_toolchain_config.bzl"], "cc_toolchain_config.bzl")
- repository_ctx.symlink(paths["@rules_cc//cc/private/toolchain:BUILD.static.bsd"], "BUILD")
+ copy_file(repository_ctx, Label("@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"), "armeabi_cc_toolchain_config.bzl")
+ copy_file(repository_ctx, Label("@rules_cc//cc/private/toolchain:bsd_cc_toolchain_config.bzl"), "cc_toolchain_config.bzl")
+ copy_file(repository_ctx, Label("@rules_cc//cc/private/toolchain:BUILD.static.bsd"), "BUILD")
elif cpu_value in ["x64_windows", "arm64_windows"]:
# TODO(ibiryukov): overriden_tools are only supported in configure_unix_toolchain.
# We might want to add that to Windows too(at least for msys toolchain).
@@ -180,6 +168,7 @@ cc_autoconf = repository_rule(
# buildifier: disable=unnamed-macro
def cc_configure():
+ # type: () -> None
"""A C++ configuration rules that generate the crosstool file."""
cc_autoconf_toolchains(name = "local_config_cc_toolchains")
cc_autoconf(name = "local_config_cc")
diff --git a/cc/private/toolchain/lib_cc_configure.bzl b/cc/private/toolchain/lib_cc_configure.bzl
index 464700387..241adae99 100644
--- a/cc/private/toolchain/lib_cc_configure.bzl
+++ b/cc/private/toolchain/lib_cc_configure.bzl
@@ -17,16 +17,8 @@
def resolve_labels(repository_ctx, labels):
"""Resolves a collection of labels to their paths.
- Label resolution can cause the evaluation of Starlark functions to restart.
- For functions with side-effects (like the auto-configuration functions, which
- inspect the system and touch the file system), such restarts are costly.
- We cannot avoid the restarts, but we can minimize their penalty by resolving
- all labels upfront.
-
- Among other things, doing less work on restarts can cut analysis times by
- several seconds and may also prevent tickling kernel conditions that cause
- build failures. See https://github.com/bazelbuild/bazel/issues/5196 for
- more details.
+ Deprecated: This function is no longer used by rules_cc and will be removed
+ in the future. Pass labels to repository_ctx methods directly instead.
Args:
repository_ctx: The context with which to resolve the labels.
@@ -37,14 +29,35 @@ def resolve_labels(repository_ctx, labels):
"""
return dict([(label, repository_ctx.path(Label(label))) for label in labels])
+def copy_file(repository_ctx, src, dest):
+ # type: (repository_ctx, Label, str) -> None
+ """Copies a file into the repository.
+
+ Unlike repository_ctx.symlink, this doesn't require the repository
+ containing the file to be present on disk.
+
+ Args:
+ repository_ctx: The repository context.
+ src: The Label of the file to copy.
+ dest: The path of the copy relative to the repository root.
+ """
+ repository_ctx.template(dest, src, executable = False)
+
+def escape_percent(value):
+ # type: (str) -> str
+ """Escape percent signs in a known string for the Crosstool."""
+ return value.replace("%", "%%")
+
def escape_string(arg):
+ # type: (object) -> str | None
"""Escape percent sign (%) in the string so it can appear in the Crosstool."""
if arg != None:
- return str(arg).replace("%", "%%")
+ return escape_percent(str(arg))
else:
return None
def split_escaped(string, delimiter):
+ # type: (str, str) -> list[str]
"""Split string on the delimiter unless %-escaped.
Examples:
@@ -75,7 +88,7 @@ def split_escaped(string, delimiter):
i = 0
result = []
- accumulator = []
+ accumulator = [] # type: list[str]
length = len(string)
delimiter_length = len(delimiter)
@@ -106,12 +119,14 @@ def split_escaped(string, delimiter):
return result
def auto_configure_fail(msg):
+ # type: (object) -> Never
"""Output failure message when auto configuration fails."""
red = "\033[0;31m"
no_color = "\033[0m"
fail("\n%sAuto-Configuration Error:%s %s\n" % (red, no_color, msg))
def auto_configure_warning(msg):
+ # type: (object) -> None
"""Output warning message during auto configuration."""
yellow = "\033[1;33m"
no_color = "\033[0m"
@@ -137,8 +152,7 @@ def get_env_var(repository_ctx, name, default = None, enable_warning = True):
if enable_warning:
auto_configure_warning("'%s' environment variable is not set, using '%s' as default" % (name, default))
return default
- auto_configure_fail("'%s' environment variable is not set" % name)
- return None
+ return auto_configure_fail("'%s' environment variable is not set" % name)
def which(repository_ctx, cmd, default = None):
"""A wrapper around repository_ctx.which() to provide a fallback value. Doesn't %-escape the value!
@@ -170,8 +184,7 @@ def which_cmd(repository_ctx, cmd, default = None):
if default != None:
auto_configure_warning("Cannot find %s in PATH, using '%s' as default.\nPATH=%s" % (cmd, default, path))
return default
- auto_configure_fail("Cannot find %s in PATH, please make sure %s is installed and add its directory in PATH.\nPATH=%s" % (cmd, cmd, path))
- return str(result)
+ return auto_configure_fail("Cannot find %s in PATH, please make sure %s is installed and add its directory in PATH.\nPATH=%s" % (cmd, cmd, path))
def execute(
repository_ctx,
@@ -223,6 +236,9 @@ def execute(
return stripped_stdout
def get_cpu_value(repository_ctx):
+ # type: (repository_ctx) -> str
+ # TODO(https://github.com/bazelbuild/bazel/issues/32020): make this an
+ # annotation when supported Bazel versions expose a repository context type.
"""Compute the cpu_value based on the OS name. Doesn't %-escape the result!
Args:
@@ -262,26 +278,31 @@ def get_cpu_value(repository_ctx):
return "k8" if arch in ["amd64", "x86_64", "x64"] else "piii"
def is_cc_configure_debug(repository_ctx):
+ # type: (repository_ctx) -> bool
"""Returns True if CC_CONFIGURE_DEBUG is set to 1."""
env = repository_ctx.os.environ
return "CC_CONFIGURE_DEBUG" in env and env["CC_CONFIGURE_DEBUG"] == "1"
def build_flags(flags):
+ # type: (Collection[str]) -> str
"""Convert `flags` to a string of flag fields."""
return "\n".join([" flag: '" + flag + "'" for flag in flags])
def get_starlark_list(values):
+ # type: (Collection[str]) -> str
"""Convert a list of string into a string that can be passed to a rule attribute."""
if not values:
return ""
return "\"" + "\",\n \"".join(values) + "\""
def auto_configure_warning_maybe(repository_ctx, msg):
+ # type: (repository_ctx, object) -> None
"""Output warning message when CC_CONFIGURE_DEBUG is enabled."""
if is_cc_configure_debug(repository_ctx):
auto_configure_warning(msg)
def write_builtin_include_directory_paths(repository_ctx, cc, directories, file_suffix = ""):
+ # type: (repository_ctx, object, Collection[str], str) -> None
"""Generate output file named 'builtin_include_directory_paths' in the root of the repository."""
if get_env_var(repository_ctx, "BAZEL_IGNORE_SYSTEM_HEADERS_VERSIONS", "0", False) == "1":
repository_ctx.file(
diff --git a/cc/private/toolchain/lib_cc_configure.bzli b/cc/private/toolchain/lib_cc_configure.bzli
new file mode 100644
index 000000000..621ec3f45
--- /dev/null
+++ b/cc/private/toolchain/lib_cc_configure.bzli
@@ -0,0 +1,47 @@
+"""Type contracts for C++ toolchain configuration helpers."""
+
+# TODO(https://github.com/bazelbuild/starlark/pull/362): Move get_env_var and which into source when the supported syntax
+# can bind a type parameter for the caller’s default. Comments cannot bind T.
+
+def resolve_labels[T: str | Label](repository_ctx: repository_ctx, labels: Collection[T]) -> dict[T, path]: ...
+
+def get_env_var[T = Never](
+ repository_ctx: repository_ctx,
+ name: str,
+ default: T | None = ...,
+ enable_warning: bool = ...,
+) -> str | T: ...
+
+def which[T = Never](
+ repository_ctx: repository_ctx,
+ cmd: str,
+ default: T | None = ...,
+) -> str | T | None: ...
+
+def which_cmd[T = Never](
+ repository_ctx: repository_ctx,
+ cmd: str,
+ default: T | None = ...,
+) -> str | T: ...
+
+class _EnvironmentSchema[V](TypedDict, extra_items=ReadOnly[V]): ...
+
+type _Environment[K: str, V] = dict[K, V] | _EnvironmentSchema[V]
+
+# The wrapper forwards its environment to Bazel. Derive the accepted value
+# type from the repository context, since it varies across Bazel releases.
+class _Executable[K: str, V](Protocol):
+ def execute(
+ self,
+ __arguments: Sequence[str | Label | path],
+ *,
+ environment: _Environment[K, V] = ...,
+ ) -> exec_result: ...
+
+def execute[K: str = str, V = str](
+ repository_ctx: Intersection[repository_ctx, _Executable[K, V]],
+ command: Sequence[str | Label | path],
+ environment: _Environment[K, V] | None = ...,
+ expect_failure: bool = ...,
+ expect_empty_output: bool = ...,
+) -> str: ...
diff --git a/cc/private/toolchain/unix_cc_configure.bzl b/cc/private/toolchain/unix_cc_configure.bzl
index 65ac6ce9d..89615b709 100644
--- a/cc/private/toolchain/unix_cc_configure.bzl
+++ b/cc/private/toolchain/unix_cc_configure.bzl
@@ -17,13 +17,12 @@
load(
":lib_cc_configure.bzl",
"auto_configure_fail",
- "auto_configure_warning",
"auto_configure_warning_maybe",
- "escape_string",
+ "copy_file",
+ "escape_percent",
"execute",
"get_env_var",
"get_starlark_list",
- "resolve_labels",
"split_escaped",
"which",
"write_builtin_include_directory_paths",
@@ -32,11 +31,16 @@ load(
def _uniq(iterable):
"""Remove duplicates from a list."""
- unique_elements = {element: None for element in iterable}
- return unique_elements.keys()
+ return {element: None for element in iterable}.keys()
-def _generate_system_module_map(repository_ctx, dirs, script_path):
- return execute(repository_ctx, [script_path] + dirs)
+def _generate_system_module_map(repository_ctx, dirs):
+ # type: (repository_ctx, list[str]) -> str
+ # The script has to be present on disk to be run.
+ script = "generate_system_module_map.sh"
+ repository_ctx.template(script, Label("@rules_cc//cc/private/toolchain:generate_system_module_map.sh"))
+ module_map = execute(repository_ctx, [repository_ctx.path(script)] + dirs)
+ repository_ctx.delete(script)
+ return module_map
def _prepare_include_path(repo_ctx, path):
"""Resolve include path before outputting it into the crosstool.
@@ -78,7 +82,7 @@ def _get_target_libc(repository_ctx, cc, darwin, compile_opts):
return "macosx"
libc = get_env_var(repository_ctx, "BAZEL_TARGET_LIBC", "", False)
if libc:
- return escape_string(libc)
+ return escape_percent(libc)
# Preprocessing any standard library header defines macros that identify
# most implementations.
@@ -115,33 +119,38 @@ def _find_tool(repository_ctx, tool, overridden_tools):
return overridden_tools[tool]
return which(repository_ctx, tool, "/usr/bin/" + tool)
+# TODO(https://github.com/bazelbuild/bazel/issues/32020): use a source annotation once Bazel exposes these context and metadata types.
def _get_tool_paths(repository_ctx, overridden_tools):
+ # type: (repository_ctx, Mapping[str, str | path | None]) -> dict[str, str]
"""Compute the %-escaped path to the various tools"""
- return dict({
- k: escape_string(_find_tool(repository_ctx, k, overridden_tools))
- for k in [
- "ar",
- "ld",
- "llvm-cov",
- "llvm-profdata",
- "cpp",
- "gcc",
- "dwp",
- "gcov",
- "nm",
- "objcopy",
- "objdump",
- "strip",
- "c++filt",
- ]
- }.items())
+ paths = {}
+ for name in [
+ "ar",
+ "ld",
+ "llvm-cov",
+ "llvm-profdata",
+ "cpp",
+ "gcc",
+ "dwp",
+ "gcov",
+ "nm",
+ "objcopy",
+ "objdump",
+ "strip",
+ "c++filt",
+ ]:
+ tool = _find_tool(repository_ctx, name, overridden_tools)
+ if tool != None:
+ paths[name] = escape_percent(str(tool))
+ return paths
def _escaped_cplus_include_paths(repository_ctx):
+ # type: (repository_ctx) -> list[str]
"""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
+ p = escape_percent(str(repository_ctx.path(p))) # Normalize the path
result.append("-I" + p)
return result
else:
@@ -154,6 +163,7 @@ _OSX_FRAMEWORK_SUFFIX = " (framework directory)"
_OSX_FRAMEWORK_SUFFIX_LEN = len(_OSX_FRAMEWORK_SUFFIX)
def _cxx_inc_convert(path):
+ # type: (str) -> str
"""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):
@@ -216,7 +226,7 @@ def _is_linker_option_supported(repository_ctx, cc, force_linker_flags, option,
def _is_oso_prefix_supported(repository_ctx, ld):
return repository_ctx.execute([ld, "-v", "-oso_prefix", "."]).return_code == 0
-def _find_linker_path(repository_ctx, cc, linker, is_clang):
+def _find_linker(repository_ctx, cc, linker, is_clang):
"""Checks if a given linker is supported by the C compiler.
Args:
@@ -226,7 +236,8 @@ def _find_linker_path(repository_ctx, cc, linker, is_clang):
is_clang: whether the compiler is known to be clang
Returns:
- String to put as value to -fuse-ld= flag, or None if linker couldn't be found.
+ A struct with the linker name or path and the flags that select it, or
+ None if the linker couldn't be found.
"""
result = repository_ctx.execute([
cc,
@@ -245,7 +256,7 @@ def _find_linker_path(repository_ctx, cc, linker, is_clang):
return None
if not is_clang:
- return linker
+ return struct(path = linker, flags = ["-fuse-ld=" + linker])
# Extract linker path from:
# /usr/bin/clang ...
@@ -254,9 +265,22 @@ def _find_linker_path(repository_ctx, cc, linker, is_clang):
# https://github.com/llvm/llvm-project/blob/85c78274358717e4d5d019a801decba5c1add484/clang/lib/Driver/Job.cpp#L207-L209
invocations = [line for line in result.stderr.splitlines() if line.startswith(" \"")]
if not invocations:
- return linker
+ return struct(path = linker, flags = ["-fuse-ld=" + linker])
linker_command = invocations[-1]
- return linker_command.strip().split(" ")[0].strip("\"'")
+ linker_path = linker_command.strip().split(" ")[0].strip("\"'")
+
+ # Clang uses the -fuse-ld= value as the linker flavor. --ld-path= (Clang 12+)
+ # specifies the path without losing the flavor.
+ flags = ["-fuse-ld=" + linker, "--ld-path=" + linker_path]
+ result = repository_ctx.execute([
+ cc,
+ str(repository_ctx.path("tools/cpp/empty.cc")),
+ "-o",
+ "/dev/null",
+ ] + flags)
+ if result.return_code != 0:
+ return struct(path = linker_path, flags = ["-fuse-ld=" + linker_path])
+ return struct(path = linker_path, flags = flags)
def _add_compiler_option_if_supported(repository_ctx, cc, option):
"""Returns `[option]` if supported, `[]` otherwise. Doesn't %-escape the option."""
@@ -288,6 +312,7 @@ def _get_no_canonical_prefixes_opt(repository_ctx, cc):
return opt
def get_env(repository_ctx):
+ # type: (repository_ctx) -> str
"""Convert the environment in a list of export if in Homebrew. Doesn't %-escape the result!
Args:
@@ -306,6 +331,7 @@ def get_env(repository_ctx):
return ""
def _coverage_flags(repository_ctx, darwin):
+ # type: (repository_ctx, bool) -> tuple[str, str]
use_llvm_cov = "1" == get_env_var(
repository_ctx,
"BAZEL_USE_LLVM_NATIVE_COVERAGE",
@@ -346,8 +372,8 @@ def _get_compiler_name(repository_ctx, cc):
return "gcc"
return "compiler"
-def _find_generic(repository_ctx, name, env_name, overridden_tools, warn = False, silent = False):
- """Find a generic C++ toolchain tool. Doesn't %-escape the result."""
+def _find_generic(repository_ctx, name, env_name, overridden_tools, on_missing = auto_configure_fail):
+ """Return the tool without %-escaping it, or call on_missing with the lookup error."""
if name in overridden_tools:
return overridden_tools[name]
@@ -367,14 +393,17 @@ def _find_generic(repository_ctx, name, env_name, overridden_tools, warn = False
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 on_missing(msg)
return result
+def _allow_missing_tool(_message):
+ # type: (str) -> None
+ return None
+
def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
+ # type: (repository_ctx, str, Mapping[str, str | path]) -> None
+ # TODO(https://github.com/bazelbuild/bazel/issues/32020): make this an
+ # annotation when supported Bazel versions expose a repository context type.
"""Configure C++ toolchain on Unix platforms.
Args:
@@ -382,25 +411,15 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
cpu_value: The CPU value.
overridden_tools: A dictionary of overridden tools.
"""
- paths = resolve_labels(repository_ctx, [
- "@rules_cc//cc/private/toolchain:BUILD.tpl",
- "@rules_cc//cc/private/toolchain:generate_system_module_map.sh",
- "@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:validate_static_library.sh.tpl",
- "@rules_cc//cc/private/toolchain:osx_cc_wrapper.sh.tpl",
- "@rules_cc//cc/private/toolchain:clang_deps_scanner_wrapper.sh.tpl",
- "@rules_cc//cc/private/toolchain:gcc_deps_scanner_wrapper.sh.tpl",
- ])
-
- repository_ctx.symlink(
- paths["@rules_cc//cc/private/toolchain:unix_cc_toolchain_config.bzl"],
+ copy_file(
+ repository_ctx,
+ Label("@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"],
+ copy_file(
+ repository_ctx,
+ Label("@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"),
"armeabi_cc_toolchain_config.bzl",
)
@@ -412,62 +431,37 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
cc = _find_generic(repository_ctx, "gcc", "CC", overridden_tools)
is_clang = _is_clang(repository_ctx, cc)
- overridden_tools = dict(overridden_tools)
- overridden_tools["gcc"] = cc
- overridden_tools["gcov"] = _find_generic(
- repository_ctx,
- "gcov",
- "GCOV",
- overridden_tools,
- warn = True,
- silent = True,
- )
- overridden_tools["llvm-cov"] = _find_generic(
- repository_ctx,
- "llvm-cov",
- "BAZEL_LLVM_COV",
- overridden_tools,
- warn = True,
- silent = True,
- )
- overridden_tools["llvm-profdata"] = _find_generic(
- repository_ctx,
- "llvm-profdata",
- "BAZEL_LLVM_PROFDATA",
- overridden_tools,
- warn = True,
- silent = True,
- )
- overridden_tools["ar"] = _find_generic(
- repository_ctx,
- "ar",
- "AR",
- overridden_tools,
- warn = True,
- silent = True,
- )
+ optional_tools = {
+ name: _find_generic(repository_ctx, name, env, overridden_tools, on_missing = _allow_missing_tool)
+ for name, env in [
+ ("gcov", "GCOV"),
+ ("llvm-cov", "BAZEL_LLVM_COV"),
+ ("llvm-profdata", "BAZEL_LLVM_PROFDATA"),
+ ("ar", "AR"),
+ ]
+ }
+ tool_overrides = dict(overridden_tools) | {"gcc": cc} | optional_tools
libtool = _find_generic(
repository_ctx,
"libtool",
"LIBTOOL",
- overridden_tools,
- warn = not darwin,
- silent = True,
+ tool_overrides,
+ on_missing = auto_configure_fail if darwin else _allow_missing_tool,
)
if darwin:
- overridden_tools["gcc"] = "cc_wrapper.sh"
+ tool_overrides["gcc"] = "cc_wrapper.sh"
xcrun = repository_ctx.which("xcrun")
if xcrun:
for tool_name in ["llvm-cov", "llvm-profdata"]:
- if overridden_tools.get(tool_name) == None:
+ if tool_overrides.get(tool_name) == None:
xcrun_result = repository_ctx.execute([xcrun, "--find", tool_name])
if xcrun_result.return_code == 0:
- overridden_tools[tool_name] = xcrun_result.stdout.strip()
+ tool_overrides[tool_name] = xcrun_result.stdout.strip()
auto_configure_warning_maybe(repository_ctx, "CC used: " + str(cc))
- tool_paths = _get_tool_paths(repository_ctx, overridden_tools)
+ tool_paths = _get_tool_paths(repository_ctx, tool_overrides)
if libtool:
- tool_paths["libtool"] = escape_string(libtool)
+ tool_paths["libtool"] = escape_percent(str(libtool))
tool_paths["cpp-module-deps-scanner"] = "deps_scanner_wrapper.sh"
toolchain_features = []
@@ -477,7 +471,7 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
# The parse_header tool needs to be a wrapper around the compiler as it has
# to touch the output file.
tool_paths["parse_headers"] = "cc_wrapper.sh"
- cc_toolchain_identifier = escape_string(get_env_var(
+ cc_toolchain_identifier = escape_percent(get_env_var(
repository_ctx,
"CC_TOOLCHAIN_NAME",
"local",
@@ -487,12 +481,12 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
if "nm" in tool_paths and "c++filt" in tool_paths:
repository_ctx.template(
"validate_static_library.sh",
- paths["@rules_cc//cc/private/toolchain:validate_static_library.sh.tpl"],
+ Label("@rules_cc//cc/private/toolchain:validate_static_library.sh.tpl"),
{
- "%{c++filt}": escape_string(str(repository_ctx.path(tool_paths["c++filt"]))),
+ "%{c++filt}": escape_percent(str(repository_ctx.path(tool_paths["c++filt"]))),
# Certain weak symbols are otherwise listed with type T in the output of nm on macOS.
"%{nm_extra_args}": "--no-weak" if darwin else "",
- "%{nm}": escape_string(str(repository_ctx.path(tool_paths["nm"]))),
+ "%{nm}": escape_percent(str(repository_ctx.path(tool_paths["nm"]))),
},
)
tool_paths["validate_static_library"] = "validate_static_library.sh"
@@ -502,10 +496,10 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
)
repository_ctx.template(
"cc_wrapper.sh",
- paths[cc_wrapper_src],
+ Label(cc_wrapper_src),
{
- "%{cc}": escape_string(str(cc)),
- "%{env}": escape_string(get_env(repository_ctx)),
+ "%{cc}": escape_percent(str(cc)),
+ "%{env}": escape_percent(get_env(repository_ctx)),
},
)
deps_scanner_wrapper_src = (
@@ -513,17 +507,18 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
)
deps_scanner = "cpp-module-deps-scanner_not_found"
if is_clang:
- cc_str = str(cc)
- path_arr = cc_str.split("/")[:-1]
- path_arr.append("clang-scan-deps")
- deps_scanner = "/".join(path_arr)
+ sibling_deps_scanner = repository_ctx.path(cc).dirname.get_child("clang-scan-deps")
+ if sibling_deps_scanner.exists:
+ deps_scanner = str(sibling_deps_scanner)
+ else:
+ deps_scanner = which(repository_ctx, "clang-scan-deps") or deps_scanner
repository_ctx.template(
"deps_scanner_wrapper.sh",
- paths[deps_scanner_wrapper_src],
+ Label(deps_scanner_wrapper_src),
{
- "%{cc}": escape_string(str(cc)),
- "%{deps_scanner}": escape_string(deps_scanner),
- "%{env}": escape_string(get_env(repository_ctx)),
+ "%{cc}": escape_percent(str(cc)),
+ "%{deps_scanner}": escape_percent(deps_scanner),
+ "%{env}": escape_percent(get_env(repository_ctx)),
},
)
@@ -547,24 +542,30 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
False,
), ":")
- gold_or_lld_linker_path = (
- _find_linker_path(repository_ctx, cc, "lld", is_clang) or
- _find_linker_path(repository_ctx, cc, "gold", is_clang)
+ linker = (
+ _find_linker(repository_ctx, cc, "lld", is_clang) or
+ _find_linker(repository_ctx, cc, "gold", is_clang)
)
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_flags = ["-B" + escape_string(str(cc_path.dirname))]
+ bin_search_flags = ["-B" + escape_percent(str(cc_path.dirname))]
else:
# cc is inside the repository, don't set -B.
- bin_search_flags = []
- if not gold_or_lld_linker_path:
+ bin_search_flags = [] # type: list[str]
+ if not linker:
ld_path = repository_ctx.path(tool_paths["ld"])
if ld_path.dirname != cc_path.dirname:
- bin_search_flags.append("-B" + str(ld_path.dirname))
+ bin_search_flags.append("-B" + escape_percent(str(ld_path.dirname)))
+ elif not linker.path.startswith("/"):
+ ld_binary = repository_ctx.which("ld." + linker.path) or repository_ctx.which(linker.path)
+ if ld_binary:
+ ld_path = repository_ctx.path(ld_binary)
+ if ld_path.dirname != cc_path.dirname:
+ bin_search_flags.append("-B" + escape_percent(str(ld_path.dirname)))
force_linker_flags = []
- if gold_or_lld_linker_path:
- force_linker_flags.append("-fuse-ld=" + gold_or_lld_linker_path)
+ if linker:
+ force_linker_flags.extend(linker.flags)
# TODO: It's unclear why these flags aren't added on macOS.
if bin_search_flags and not darwin:
@@ -661,7 +662,6 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
repository_ctx.file("module.modulemap", _generate_system_module_map(
repository_ctx,
builtin_include_directories,
- paths["@rules_cc//cc/private/toolchain:generate_system_module_map.sh"],
))
extra_flags_per_feature = {}
if is_clang:
@@ -683,16 +683,16 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
write_builtin_include_directory_paths(repository_ctx, cc, builtin_include_directories)
repository_ctx.template(
"BUILD",
- paths["@rules_cc//cc/private/toolchain:BUILD.tpl"],
+ Label("@rules_cc//cc/private/toolchain:BUILD.tpl"),
# @unsorted-dict-items
{
- "%{abi_libc_version}": escape_string(get_env_var(
+ "%{abi_libc_version}": escape_percent(get_env_var(
repository_ctx,
"ABI_LIBC_VERSION",
"local",
False,
)),
- "%{abi_version}": escape_string(get_env_var(
+ "%{abi_version}": escape_percent(get_env_var(
repository_ctx,
"ABI_VERSION",
"local",
@@ -728,7 +728,7 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
"-fno-omit-frame-pointer",
],
),
- "%{compiler}": escape_string(get_env_var(
+ "%{compiler}": escape_percent(get_env_var(
repository_ctx,
"BAZEL_COMPILER",
_get_compiler_name(repository_ctx, cc),
@@ -743,7 +743,7 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
"%{fastbuild_compile_flags}": get_starlark_list([]),
"%{dbg_compile_flags}": get_starlark_list(["-g"]),
"%{extra_flags_per_feature}": repr(extra_flags_per_feature),
- "%{host_system_name}": escape_string(get_env_var(
+ "%{host_system_name}": escape_percent(get_env_var(
repository_ctx,
"BAZEL_HOST_SYSTEM",
"local",
@@ -760,11 +760,10 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
) + (
[
"-headerpad_max_install_names",
- ] if darwin else [
+ ] if darwin else _add_compiler_option_if_supported(
# 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,
@@ -817,21 +816,21 @@ def configure_unix_toolchain(repository_ctx, cpu_value, overridden_tools):
"--start-lib",
) else "False",
"%{toolchain_features}": get_starlark_list(toolchain_features),
- "%{target_cpu}": escape_string(get_env_var(
+ "%{target_cpu}": escape_percent(get_env_var(
repository_ctx,
"BAZEL_TARGET_CPU",
cpu_value,
False,
)),
"%{target_libc}": _get_target_libc(repository_ctx, cc, darwin, all_compile_opts + conly_opts),
- "%{target_system_name}": escape_string(get_env_var(
+ "%{target_system_name}": escape_percent(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() if v != None],
+ ['"%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) + [
diff --git a/cc/private/toolchain/unix_cc_configure.bzli b/cc/private/toolchain/unix_cc_configure.bzli
new file mode 100644
index 000000000..fc4e3078e
--- /dev/null
+++ b/cc/private/toolchain/unix_cc_configure.bzli
@@ -0,0 +1,87 @@
+"""Contracts for discovering and configuring a local Unix C++ toolchain."""
+
+# TODO(https://github.com/bazelbuild/starlark/pull/362): Move the helpers into source when its function syntax can bind T.
+# For example, _uniq returns the same item type that its caller supplies.
+
+type _Executable = str | Label | path
+
+def _uniq[T: Hashable](iterable: Collection[T]) -> list[T]: ...
+
+def _prepare_include_path(repo_ctx: repository_ctx, path: _Executable) -> str: ...
+
+def _get_target_libc(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ darwin: bool,
+ compile_opts: list[str],
+) -> str: ...
+
+def _find_tool[T](
+ repository_ctx: repository_ctx,
+ tool: str,
+ overridden_tools: Mapping[str, T],
+) -> str | T | None: ...
+
+def _get_cxx_include_directories(
+ repository_ctx: repository_ctx,
+ print_resource_dir_supported: bool,
+ cc: _Executable,
+ lang_flag: str,
+ additional_flags: list[str] = ...,
+) -> list[str]: ...
+
+def _is_compiler_option_supported(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ option: str,
+) -> bool: ...
+
+def _is_linker_option_supported(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ force_linker_flags: list[str],
+ option: str,
+ pattern: str,
+) -> bool: ...
+
+def _is_oso_prefix_supported(repository_ctx: repository_ctx, ld: _Executable) -> bool: ...
+
+def _find_linker(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ linker: str,
+ is_clang: bool,
+) -> struct[{"path": str, "flags": list[str]}] | None: ...
+
+def _add_compiler_option_if_supported(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ option: str,
+) -> list[str]: ...
+
+def _add_linker_option_if_supported(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+ force_linker_flags: list[str],
+ option: str,
+ pattern: str,
+) -> list[str]: ...
+
+def _get_no_canonical_prefixes_opt(
+ repository_ctx: repository_ctx,
+ cc: _Executable,
+) -> list[str]: ...
+
+def _is_clang(repository_ctx: repository_ctx, cc: _Executable) -> bool: ...
+
+def _is_gcc(repository_ctx: repository_ctx, cc: _Executable) -> bool: ...
+
+def _get_compiler_name(repository_ctx: repository_ctx, cc: _Executable) -> str: ...
+
+def _find_generic[Override, Missing = Never](
+ repository_ctx: repository_ctx,
+ name: str,
+ env_name: str,
+ overridden_tools: Mapping[str, Override],
+ on_missing: Callable[[str], Missing] = ...,
+) -> Override | Missing | str | path: ...
diff --git a/cc/private/toolchain/unix_cc_toolchain_config.bzl b/cc/private/toolchain/unix_cc_toolchain_config.bzl
index 4724887df..a77ac482b 100644
--- a/cc/private/toolchain/unix_cc_toolchain_config.bzl
+++ b/cc/private/toolchain/unix_cc_toolchain_config.bzl
@@ -13,6 +13,8 @@
# limitations under the License.
"""A Starlark cc_toolchain configuration rule"""
+load("@apple_support//xcode:providers.bzl", "XcodeVersionInfo")
+
#buildifier: disable=bzl-visibility
load("@bazel_features//private:util.bzl", "ge")
load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
@@ -44,7 +46,7 @@ def _cpp_module_extension(compiler):
return ".pcm"
def _target_os_version(ctx):
- xcode_config = ctx.attr._xcode_config[apple_common.XcodeVersionConfig]
+ xcode_config = ctx.attr._xcode_config[XcodeVersionInfo]
return xcode_config.minimum_os_for_platform_type(apple_common.platform_type.macos)
def layering_check_features(compiler, extra_flags_per_feature, is_macos):
diff --git a/cc/private/toolchain/windows_cc_configure.bzl b/cc/private/toolchain/windows_cc_configure.bzl
index 235ebbf76..f37e7f179 100644
--- a/cc/private/toolchain/windows_cc_configure.bzl
+++ b/cc/private/toolchain/windows_cc_configure.bzl
@@ -19,10 +19,10 @@ load(
"auto_configure_fail",
"auto_configure_warning",
"auto_configure_warning_maybe",
- "escape_string",
+ "copy_file",
+ "escape_percent",
"execute",
"get_starlark_list",
- "resolve_labels",
"split_escaped",
"write_builtin_include_directory_paths",
)
@@ -30,25 +30,27 @@ load(
_targets_archs = {"arm": "amd64_arm", "arm64": "amd64_arm64", "x64": "amd64", "x86": "amd64_x86"}
_targets_lib_folder = {"arm": "arm", "arm64": "arm64", "x86": ""}
-def _lookup_env_var(env, name, default = None):
- """Lookup environment variable case-insensitve.
+def _lookup_env_var(env, name):
+ # type: (Mapping[str, str], str) -> tuple[str, str | None]
+ """Look up an environment variable case-insensitively.
If a matching (case-insensitive) entry is found in the env dict both
the key and the value are returned. The returned key might differ from
name in casing.
- If a matching key was found its value is returned otherwise
- the default is returned.
-
- Return a (key, value) tuple"""
+ If no entry matches, return (name, None).
+ """
for key, value in env.items():
if name.lower() == key.lower():
return (key, value)
- return (name, default)
+ return (name, None)
-def _get_env_var(repository_ctx, name, default = None):
+def _get_env_var(repository_ctx, name):
+ # type: (repository_ctx, str) -> str | None
+ # TODO(https://github.com/bazelbuild/bazel/issues/32020): make this an
+ # annotation when supported Bazel versions expose a repository context type.
"""Returns a value from an environment variable."""
- return _lookup_env_var(repository_ctx.os.environ, name, default)[1]
+ return _lookup_env_var(repository_ctx.os.environ, name)[1]
def _get_path_env_var(repository_ctx, name):
"""Returns a path from an environment variable.
@@ -91,7 +93,7 @@ def _get_escaped_windows_msys_starlark_content(repository_ctx, use_mingw = False
msys_root = tokens[0][:len(tokens[0]) - len("bin")]
prefix = "mingw64" if use_mingw else "usr"
- tool_path_prefix = escape_string(msys_root) + prefix
+ tool_path_prefix = escape_percent(msys_root) + prefix
tool_bin_path = tool_path_prefix + "/bin"
tool_path = {}
@@ -113,12 +115,12 @@ def _get_system_root(repository_ctx):
repository_ctx,
"SYSTEMROOT is not set, using default SYSTEMROOT=C:\\Windows",
)
- return escape_string(systemroot)
+ return escape_percent(systemroot)
def _add_system_root(repository_ctx, env):
"""Running VCVARSALL.BAT and VCVARSQUERYREGISTRY.BAT need %SYSTEMROOT%\\\\system32 in PATH."""
- env_key, env_value = _lookup_env_var(env, "PATH", default = "")
- env[env_key] = env_value + ";" + _get_system_root(repository_ctx) + "\\system32"
+ env_key, env_value = _lookup_env_var(env, "PATH")
+ env[env_key] = (env_value or "") + ";" + _get_system_root(repository_ctx) + "\\system32"
return env
def find_vc_path(repository_ctx):
@@ -343,7 +345,7 @@ def _get_vc_env_vars(repository_ctx, vc_path, msvc_vars_x64, target_arch):
env["INCLUDE"] = msvc_vars_x64["%{msvc_env_include_x64}"]
env["LIB"] = lib.replace("x64", target_arch)
- env["PATH"] = escape_string(tools_path.replace("\\", "\\\\")) + ";" + msvc_vars_x64["%{msvc_env_path_x64}"]
+ env["PATH"] = escape_percent(tools_path.replace("\\", "\\\\")) + ";" + msvc_vars_x64["%{msvc_env_path_x64}"]
return env
def setup_vc_env_vars(repository_ctx, vc_path, envvars = [], allow_empty = False, escape = True):
@@ -398,7 +400,7 @@ def setup_vc_env_vars(repository_ctx, vc_path, envvars = [], allow_empty = False
env_map = {}
for env in envs:
key, value = env.split("=", 1)
- env_map[key] = escape_string(value.replace("\\", "\\\\")) if escape else value
+ env_map[key] = escape_percent(value.replace("\\", "\\\\")) if escape else value
if not allow_empty:
_check_env_vars(env_map, cmd, expected = envvars)
@@ -445,7 +447,7 @@ def _get_vc_full_version(repository_ctx, vc_path):
def _get_winsdk_full_version(repository_ctx):
"""Return the value of BAZEL_WINSDK_FULL_VERSION if defined, otherwise an empty string."""
- return _get_env_var(repository_ctx, "BAZEL_WINSDK_FULL_VERSION", default = "")
+ return _get_env_var(repository_ctx, "BAZEL_WINSDK_FULL_VERSION") or ""
def _find_msvc_tools(repository_ctx, vc_path, target_arch = "x64"):
"""Find the exact paths of the build tools in MSVC for the given target. Doesn't %-escape the result."""
@@ -614,7 +616,7 @@ def find_llvm_tool(repository_ctx, llvm_path, tool):
def _use_clang_cl(repository_ctx):
"""Returns True if USE_CLANG_CL is set to 1."""
- return _get_env_var(repository_ctx, "USE_CLANG_CL", default = "0") == "1"
+ return _get_env_var(repository_ctx, "USE_CLANG_CL") == "1"
def _find_missing_llvm_tools(repository_ctx, llvm_path):
"""Check if any required tool is missing under given LLVM path."""
@@ -665,7 +667,7 @@ def _get_msys_mingw_vars(repository_ctx):
}
return msys_mingw_vars
-def _get_msvc_vars(repository_ctx, paths, target_arch = "x64", msvc_vars_x64 = None):
+def _get_msvc_vars(repository_ctx, target_arch = "x64", msvc_vars_x64 = None):
"""Get the variables we need to populate the MSVC toolchains."""
vc_path = find_vc_path(repository_ctx)
missing_tools = None
@@ -673,7 +675,7 @@ def _get_msvc_vars(repository_ctx, paths, target_arch = "x64", msvc_vars_x64 = N
if not vc_path:
repository_ctx.template(
"vc_installation_error_" + target_arch + ".bat",
- paths["@rules_cc//cc/private/toolchain:vc_installation_error.bat.tpl"],
+ Label("@rules_cc//cc/private/toolchain:vc_installation_error.bat.tpl"),
{"%{vc_error_message}": ""},
)
else:
@@ -689,7 +691,7 @@ def _get_msvc_vars(repository_ctx, paths, target_arch = "x64", msvc_vars_x64 = N
])
repository_ctx.template(
"vc_installation_error_" + target_arch + ".bat",
- paths["@rules_cc//cc/private/toolchain:vc_installation_error.bat.tpl"],
+ Label("@rules_cc//cc/private/toolchain:vc_installation_error.bat.tpl"),
{"%{vc_error_message}": message},
)
@@ -715,8 +717,8 @@ def _get_msvc_vars(repository_ctx, paths, target_arch = "x64", msvc_vars_x64 = N
env = _get_vc_env_vars(repository_ctx, vc_path, msvc_vars_x64, target_arch)
else:
env = setup_vc_env_vars(repository_ctx, vc_path)
- escaped_tmp_dir = escape_string(_get_temp_env(repository_ctx).replace("\\", "\\\\"))
- escaped_include_paths = escape_string(env["INCLUDE"])
+ escaped_tmp_dir = escape_percent(_get_temp_env(repository_ctx).replace("\\", "\\\\"))
+ escaped_include_paths = escape_percent(env["INCLUDE"])
build_tools = {}
llvm_path = ""
@@ -752,7 +754,7 @@ def _get_msvc_vars(repository_ctx, paths, target_arch = "x64", msvc_vars_x64 = N
clang_include_path = (clang_dir + "\\include").replace("\\", "\\\\")
escaped_cxx_include_directories.append("\"%s\"" % clang_include_path)
clang_lib_path = (clang_dir + "\\lib\\windows").replace("\\", "\\\\")
- env["LIB"] = escape_string(env["LIB"]) + ";" + clang_lib_path
+ env["LIB"] = escape_percent(env["LIB"]) + ";" + clang_lib_path
support_debug_fastlink = _is_support_debug_fastlink(repository_ctx, build_tools["LINK"])
write_builtin_include_directory_paths(repository_ctx, "msvc", escaped_cxx_include_directories, file_suffix = "_msvc")
@@ -775,8 +777,8 @@ Fix this by installing the English language pack for the Visual Studio installat
"%{msvc_env_tmp_" + target_arch + "}": escaped_tmp_dir,
"%{msvc_env_include_" + target_arch + "}": escaped_include_paths,
"%{msvc_cxx_builtin_include_directories_" + target_arch + "}": " " + ",\n ".join(escaped_cxx_include_directories),
- "%{msvc_env_path_" + target_arch + "}": escape_string(env["PATH"]),
- "%{msvc_env_lib_" + target_arch + "}": escape_string(env["LIB"]),
+ "%{msvc_env_path_" + target_arch + "}": escape_percent(env["PATH"]),
+ "%{msvc_env_lib_" + target_arch + "}": escape_percent(env["LIB"]),
"%{msvc_cl_path_" + target_arch + "}": build_tools["CL"],
"%{msvc_ml_path_" + target_arch + "}": build_tools.get("ML", "msvc_arm_toolchain_does_not_support_ml"),
"%{msvc_link_path_" + target_arch + "}": build_tools["LINK"],
@@ -788,7 +790,7 @@ Fix this by installing the English language pack for the Visual Studio installat
}
return msvc_vars
-def _get_clang_cl_vars(repository_ctx, paths, msvc_vars, target_arch):
+def _get_clang_cl_vars(repository_ctx, msvc_vars, target_arch):
"""Get the variables we need to populate the clang-cl toolchains."""
llvm_path = find_llvm_path(repository_ctx)
error_script = None
@@ -797,7 +799,7 @@ def _get_clang_cl_vars(repository_ctx, paths, msvc_vars, target_arch):
elif not llvm_path:
repository_ctx.template(
"clang_installation_error.bat",
- paths["@rules_cc//cc/private/toolchain:clang_installation_error.bat.tpl"],
+ Label("@rules_cc//cc/private/toolchain:clang_installation_error.bat.tpl"),
{"%{clang_error_message}": ""},
)
error_script = "clang_installation_error.bat"
@@ -813,7 +815,7 @@ def _get_clang_cl_vars(repository_ctx, paths, msvc_vars, target_arch):
])
repository_ctx.template(
"clang_installation_error.bat",
- paths["@rules_cc//cc/private/toolchain:clang_installation_error.bat.tpl"],
+ Label("@rules_cc//cc/private/toolchain:clang_installation_error.bat.tpl"),
{"%{clang_error_message}": message},
)
error_script = "clang_installation_error.bat"
@@ -865,10 +867,10 @@ def _get_clang_cl_vars(repository_ctx, paths, msvc_vars, target_arch):
}
return clang_cl_vars
-def _get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, target_arch = "x64"):
+def _get_msvc_deps_scanner_vars(repository_ctx, template_vars, target_arch = "x64"):
repository_ctx.template(
"msvc_deps_scanner_wrapper_" + target_arch + ".bat",
- paths["@rules_cc//cc/private/toolchain:msvc_deps_scanner_wrapper.bat.tpl"],
+ Label("@rules_cc//cc/private/toolchain:msvc_deps_scanner_wrapper.bat.tpl"),
{
"%{cc}": template_vars["%{msvc_cl_path_" + target_arch + "}"],
},
@@ -878,33 +880,17 @@ def _get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, target_arc
"%{msvc_deps_scanner_wrapper_path_" + target_arch + "}": "msvc_deps_scanner_wrapper_" + target_arch + ".bat",
}
+def _get_env_options(repository_ctx, name):
+ # type: (repository_ctx, str) -> list[str]
+ return split_escaped(_get_env_var(repository_ctx, name) or "", ":")
+
def _get_copts(repository_ctx):
"""Get the variables we need to populate the msys/mingw toolchains."""
- conly_opts = split_escaped(_get_env_var(
- repository_ctx,
- "BAZEL_CONLYOPTS",
- "",
- ), ":")
- all_compile_opts = split_escaped(_get_env_var(
- repository_ctx,
- "BAZEL_COPTS",
- "",
- ), ":")
- cxx_opts = split_escaped(_get_env_var(
- repository_ctx,
- "BAZEL_CXXOPTS",
- "",
- ), ":")
- link_opts = split_escaped(_get_env_var(
- repository_ctx,
- "BAZEL_LINKOPTS",
- "",
- ), ":")
- win32_winnt_opts = _get_env_var(
- repository_ctx,
- "BAZEL_WIN32_WINNT",
- None,
- )
+ conly_opts = _get_env_options(repository_ctx, "BAZEL_CONLYOPTS")
+ all_compile_opts = _get_env_options(repository_ctx, "BAZEL_COPTS")
+ cxx_opts = _get_env_options(repository_ctx, "BAZEL_CXXOPTS")
+ link_opts = _get_env_options(repository_ctx, "BAZEL_LINKOPTS")
+ win32_winnt_opts = _get_env_var(repository_ctx, "BAZEL_WIN32_WINNT")
copts_vars = {
"%{all_compile_flags}": get_starlark_list(all_compile_opts),
"%{conly_flags}": get_starlark_list(conly_opts),
@@ -912,37 +898,31 @@ def _get_copts(repository_ctx):
"%{link_flags}": get_starlark_list(link_opts),
# None means the user didn't provide the override.
# Fall back to the default in that case.
- "%{win32_winnt_flag}": ' win32_winnt_flag = "' + escape_string(win32_winnt_opts) + '", ' if win32_winnt_opts != None else "",
+ "%{win32_winnt_flag}": ' win32_winnt_flag = "' + escape_percent(win32_winnt_opts) + '", ' if win32_winnt_opts != None else "",
}
return copts_vars
def configure_windows_toolchain(repository_ctx):
+ # type: (repository_ctx) -> None
"""Configure C++ toolchain on Windows.
Args:
repository_ctx: The repository context.
"""
- paths = resolve_labels(repository_ctx, [
- "@rules_cc//cc/private/toolchain:BUILD.windows.tpl",
- "@rules_cc//cc/private/toolchain:windows_cc_toolchain_config.bzl",
- "@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl",
- "@rules_cc//cc/private/toolchain:vc_installation_error.bat.tpl",
- "@rules_cc//cc/private/toolchain:msys_gcc_installation_error.bat",
- "@rules_cc//cc/private/toolchain:clang_installation_error.bat.tpl",
- "@rules_cc//cc/private/toolchain:msvc_deps_scanner_wrapper.bat.tpl",
- ])
-
- repository_ctx.symlink(
- paths["@rules_cc//cc/private/toolchain:windows_cc_toolchain_config.bzl"],
+ copy_file(
+ repository_ctx,
+ Label("@rules_cc//cc/private/toolchain:windows_cc_toolchain_config.bzl"),
"windows_cc_toolchain_config.bzl",
)
- repository_ctx.symlink(
- paths["@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"],
+ copy_file(
+ repository_ctx,
+ Label("@rules_cc//cc/private/toolchain:armeabi_cc_toolchain_config.bzl"),
"armeabi_cc_toolchain_config.bzl",
)
- repository_ctx.symlink(
- paths["@rules_cc//cc/private/toolchain:msys_gcc_installation_error.bat"],
+ copy_file(
+ repository_ctx,
+ Label("@rules_cc//cc/private/toolchain:msys_gcc_installation_error.bat"),
"msys_gcc_installation_error.bat",
)
@@ -954,23 +934,23 @@ def configure_windows_toolchain(repository_ctx):
# Set outside _get_msvc_vars so the error-stub configs it returns early for
# are labelled the same as the working ones.
template_vars["%{compiler}"] = "clang-cl" if _use_clang_cl(repository_ctx) else "msvc-cl"
- msvc_vars_x64 = _get_msvc_vars(repository_ctx, paths, "x64")
+ msvc_vars_x64 = _get_msvc_vars(repository_ctx, "x64")
template_vars.update(msvc_vars_x64)
- template_vars.update(_get_clang_cl_vars(repository_ctx, paths, msvc_vars_x64, "x64"))
+ template_vars.update(_get_clang_cl_vars(repository_ctx, msvc_vars_x64, "x64"))
template_vars.update(_get_msys_mingw_vars(repository_ctx))
template_vars.update(_get_copts(repository_ctx))
- template_vars.update(_get_msvc_vars(repository_ctx, paths, "x86", msvc_vars_x64))
- template_vars.update(_get_msvc_vars(repository_ctx, paths, "arm", msvc_vars_x64))
- msvc_vars_arm64 = _get_msvc_vars(repository_ctx, paths, "arm64", msvc_vars_x64)
+ template_vars.update(_get_msvc_vars(repository_ctx, "x86", msvc_vars_x64))
+ template_vars.update(_get_msvc_vars(repository_ctx, "arm", msvc_vars_x64))
+ msvc_vars_arm64 = _get_msvc_vars(repository_ctx, "arm64", msvc_vars_x64)
template_vars.update(msvc_vars_arm64)
- template_vars.update(_get_clang_cl_vars(repository_ctx, paths, msvc_vars_arm64, "arm64"))
+ template_vars.update(_get_clang_cl_vars(repository_ctx, msvc_vars_arm64, "arm64"))
- template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, "x64"))
- template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, "x86"))
- template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, "arm"))
- template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, paths, template_vars, "arm64"))
+ template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, template_vars, "x64"))
+ template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, template_vars, "x86"))
+ template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, template_vars, "arm"))
+ template_vars.update(_get_msvc_deps_scanner_vars(repository_ctx, template_vars, "arm64"))
repository_ctx.template(
"BUILD",
- paths["@rules_cc//cc/private/toolchain:BUILD.windows.tpl"],
+ Label("@rules_cc//cc/private/toolchain:BUILD.windows.tpl"),
template_vars,
)
diff --git a/cc/private/toolchain/windows_cc_toolchain_config.bzl b/cc/private/toolchain/windows_cc_toolchain_config.bzl
index 55b156daf..521a3428d 100644
--- a/cc/private/toolchain/windows_cc_toolchain_config.bzl
+++ b/cc/private/toolchain/windows_cc_toolchain_config.bzl
@@ -177,6 +177,11 @@ def _impl(ctx):
prefix = "",
extension = ".exe",
),
+ artifact_name_pattern(
+ category_name = "dynamic_library",
+ prefix = "lib",
+ extension = ".dll",
+ ),
]
if _use_msvc_toolchain(ctx):
@@ -607,15 +612,7 @@ def _impl(ctx):
] if ctx.attr.conly_flags else []),
),
flag_set(
- actions = [
- ACTION_NAMES.linkstamp_compile,
- ACTION_NAMES.cpp_compile,
- ACTION_NAMES.cpp_header_parsing,
- ACTION_NAMES.cpp_module_compile,
- ACTION_NAMES.cpp_module_codegen,
- ACTION_NAMES.lto_backend,
- ACTION_NAMES.clif_match,
- ],
+ actions = all_cpp_compile_actions + [ACTION_NAMES.lto_backend],
flag_groups = ([
flag_group(
flags = ctx.attr.cxx_flags,
@@ -1666,15 +1663,7 @@ def _impl(ctx):
] if ctx.attr.conly_flags else []),
),
flag_set(
- actions = [
- ACTION_NAMES.linkstamp_compile,
- ACTION_NAMES.cpp_compile,
- ACTION_NAMES.cpp_header_parsing,
- ACTION_NAMES.cpp_module_compile,
- ACTION_NAMES.cpp_module_codegen,
- ACTION_NAMES.lto_backend,
- ACTION_NAMES.clif_match,
- ],
+ actions = all_cpp_compile_actions + [ACTION_NAMES.lto_backend],
flag_groups = ([
flag_group(
flags = ctx.attr.cxx_flags,
@@ -1739,6 +1728,11 @@ def _impl(ctx):
if "dumpbin" in ctx.attr.tool_paths:
make_variables.append(make_variable(name = "DUMPBIN", value = ctx.attr.tool_paths["dumpbin"]))
+ windows_quoting_for_param_files_feature = feature(
+ name = "windows_quoting_for_param_files",
+ enabled = _use_msvc_toolchain(ctx),
+ )
+
# Tell bazel we support C++ modules now
cpp_modules_feature = feature(
name = "cpp_modules",
@@ -1785,7 +1779,7 @@ def _impl(ctx):
],
enabled = True,
)
- features.extend([cpp_modules_feature, cpp_module_modmap_file_feature, cpp20_module_compile_flags_feature])
+ features.extend([windows_quoting_for_param_files_feature, cpp_modules_feature, cpp_module_modmap_file_feature, cpp20_module_compile_flags_feature])
extra_rules_based_features = depset(ctx.attr.extra_enabled_features + ctx.attr.extra_known_features)
features.extend([convert_feature(extra_feature[FeatureInfo], enabled = extra_feature in ctx.attr.extra_enabled_features) for extra_feature in extra_rules_based_features.to_list()])
diff --git a/cc/private/toolchain_config/BUILD b/cc/private/toolchain_config/BUILD
index eb5a48d6e..ccfa6c62a 100644
--- a/cc/private/toolchain_config/BUILD
+++ b/cc/private/toolchain_config/BUILD
@@ -14,6 +14,8 @@
load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+exports_files(["legacy_features.bzli"])
+
bzl_library(
name = "toolchain_config_bzl",
srcs = glob(["*.bzl"]),
@@ -41,6 +43,7 @@ filegroup(
name = "srcs",
srcs = glob([
"**/*.bzl",
+ "**/*.bzli",
"**/BUILD",
]),
visibility = ["//visibility:public"],
diff --git a/cc/private/toolchain_config/legacy_features.bzl b/cc/private/toolchain_config/legacy_features.bzl
index aa5b88a8a..bd7263d93 100644
--- a/cc/private/toolchain_config/legacy_features.bzl
+++ b/cc/private/toolchain_config/legacy_features.bzl
@@ -27,6 +27,8 @@ load(
"with_feature_set",
)
+_NO_FLAGS = [] # type: list[str]
+
def get_legacy_features(ctx, platform, existing_feature_names, linker_tool_path):
"""The features added to all legacy toolchains
@@ -622,7 +624,7 @@ def get_legacy_features(ctx, platform, existing_feature_names, linker_tool_path)
expand_if_available = "output_execpath",
flags = _platform_specific_value(
platform,
- linux = [],
+ linux = _NO_FLAGS,
mac = ["-o"],
) + [
"%{output_execpath}",
@@ -1371,7 +1373,7 @@ def get_legacy_action_configs(
flags = ["-S"] + _platform_specific_value(
platform,
linux = ["-p"],
- mac = [],
+ mac = _NO_FLAGS,
) + ["-o", "%{output_file}"],
),
flag_group(
diff --git a/cc/private/toolchain_config/legacy_features.bzli b/cc/private/toolchain_config/legacy_features.bzli
new file mode 100644
index 000000000..f6ff42b45
--- /dev/null
+++ b/cc/private/toolchain_config/legacy_features.bzli
@@ -0,0 +1,42 @@
+# Copyright 2026 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.
+"""Legacy feature and action configuration builders."""
+
+# TODO(https://github.com/bazelbuild/starlark/pull/362): Move _platform_specific_value into source when its signature can bind
+# L and M separately to preserve the two platforms’ possible result types.
+
+load("//cc:cc_toolchain_config_lib.bzl", "ActionConfigInfo", "FeatureInfo")
+
+type _ExistingNames = Collection[str] | str
+
+type _Platform = Literal["linux", "mac"]
+
+def get_legacy_features(
+ ctx: ctx[object, struct[{"compiler": NotRequired[str]}, ...]],
+ platform: _Platform,
+ existing_feature_names: _ExistingNames,
+ linker_tool_path: str,
+) -> list[FeatureInfo]: ...
+
+def get_features_to_appear_last(existing_feature_names: _ExistingNames) -> list[FeatureInfo]: ...
+
+def get_legacy_action_configs(
+ platform: _Platform,
+ gcc_tool_path: str,
+ ar_tool_path: str,
+ strip_tool_path: str,
+ existing_action_config_names: _ExistingNames,
+) -> list[ActionConfigInfo]: ...
+
+def _platform_specific_value[L, M](platform: str, *, linux: L, mac: M) -> L | M: ...
diff --git a/cc/common/visibility.bzl b/cc/private/visibility.bzl
similarity index 91%
rename from cc/common/visibility.bzl
rename to cc/private/visibility.bzl
index 4ce7ed032..5eb0c6edc 100644
--- a/cc/common/visibility.bzl
+++ b/cc/private/visibility.bzl
@@ -3,6 +3,8 @@
# buildifier: disable=bzl-visibility
load("//cc/private:cc_internal.bzl", _cc_internal = "cc_internal")
+visibility("//cc/...")
+
def check_private_api():
_cc_internal.check_private_api(allowlist = PRIVATE_STARLARKIFICATION_ALLOWLIST, depth = 2)
@@ -21,7 +23,9 @@ def wrap_with_check_private_api(symbol):
return callback
-INTERNAL_VISIBILITY = ["public"]
+# Things that are publicly visible in the open-source Bazel world, but have
+# restricted visibility within Google's monorepo.
+PUBLIC_IF_NOT_GOOGLE = ["public"]
PRIVATE_RULES_VISIBILITY_FOR_BZL = []
diff --git a/cc/repositories.bzl b/cc/repositories.bzl
index 3ff7dbccd..07a2437b0 100644
--- a/cc/repositories.bzl
+++ b/cc/repositories.bzl
@@ -3,8 +3,10 @@
load("//cc/private/toolchain:cc_configure.bzl", "cc_configure")
def rules_cc_dependencies():
+ # type: () -> None
pass
# buildifier: disable=unnamed-macro
-def rules_cc_toolchains(*args):
- cc_configure(*args)
+def rules_cc_toolchains():
+ # type: () -> None
+ cc_configure()
diff --git a/cc/starlark_doc_extract_helper.bzl b/cc/starlark_doc_extract_helper.bzl
index 6c145f304..fc96c726d 100644
--- a/cc/starlark_doc_extract_helper.bzl
+++ b/cc/starlark_doc_extract_helper.bzl
@@ -2,7 +2,10 @@
visibility("//cc/...")
+# TODO(https://github.com/bazelbuild/bazel/issues/32343): Annotate **kwargs
+# when Bazel can derive them from the wrapped starlark_doc_extract rule.
def starlark_doc_extract_helper(**kwargs):
+ # type: (**Unpack[KeywordArgs[native.starlark_doc_extract]]) -> None
"""Creates a starlark_doc_extract target if the native rule is available
Args:
diff --git a/cc/system_library.bzl b/cc/system_library.bzl
index 68477dace..12c720321 100644
--- a/cc/system_library.bzl
+++ b/cc/system_library.bzl
@@ -8,13 +8,16 @@ ENV_VAR_SEPARATOR = ","
ENV_VAR_ASSIGNMENT = "="
def _make_flags(flag_values, flag):
+ # type: (Collection[str] | None, str) -> str
flags = []
if flag_values:
for s in flag_values:
flags.append(flag + s)
return " ".join(flags)
+# TODO(https://github.com/bazelbuild/bazel/issues/32020): use a source annotation once Bazel exposes these context and metadata types.
def _split_env_var(repo_ctx, var_name):
+ # type: (repository_ctx, str) -> dict[str, list[str]]
value = repo_ctx.os.environ.get(var_name)
if value:
assignments = value.split(ENV_VAR_SEPARATOR)
@@ -36,12 +39,15 @@ def _split_env_var(repo_ctx, var_name):
return {}
def _get_list_from_env_var(repo_ctx, var_name, key):
+ # type: (repository_ctx, str, str) -> list[str]
return _split_env_var(repo_ctx, var_name).get(key, default = [])
def _execute_bash(repo_ctx, cmd):
+ # type: (repository_ctx, str) -> str
return repo_ctx.execute(["/usr/bin/env", "bash", "-c", cmd]).stdout.strip("\n")
def _find_linker(repo_ctx):
+ # type: (repository_ctx) -> str
ld = _execute_bash(repo_ctx, "which ld")
lld = _execute_bash(repo_ctx, "which lld")
if ld:
@@ -52,6 +58,7 @@ def _find_linker(repo_ctx):
fail("No linker found")
def _find_compiler(repo_ctx):
+ # type: (repository_ctx) -> str
gcc = _execute_bash(repo_ctx, "which g++")
clang = _execute_bash(repo_ctx, "which clang++")
if gcc:
@@ -62,6 +69,7 @@ def _find_compiler(repo_ctx):
fail("No compiler found")
def _find_lib_path(repo_ctx, lib_name, archive_names, lib_path_hints):
+ # type: (repository_ctx, str, Collection[str], list[str]) -> tuple[str, str] | tuple[None, None]
override_paths = _get_list_from_env_var(
repo_ctx,
BAZEL_LIB_OVERRIDE_PATHS_ENV_VAR,
@@ -96,6 +104,7 @@ def _find_lib_path(repo_ctx, lib_name, archive_names, lib_path_hints):
return (None, None)
def _find_header_path(repo_ctx, lib_name, header_name, includes):
+ # type: (repository_ctx, str, str, list[str]) -> str | None
override_paths = _get_list_from_env_var(
repo_ctx,
BAZEL_INCLUDE_OVERRIDE_PATHS_ENV_VAR,
@@ -127,7 +136,21 @@ def _find_header_path(repo_ctx, lib_name, header_name, includes):
return result
return None
+# TODO(https://github.com/bazelbuild/bazel/issues/32020): Use a native repository
+# context annotation for these attributes when supported Bazel versions expose it.
+# type _Attrs = struct[{
+# "name": str,
+# "includes": list[str],
+# "hdrs": list[str],
+# "optional_hdrs": list[str],
+# "deps": list[str],
+# "lib_path_hints": list[str],
+# "static_lib_names": list[str],
+# "shared_lib_names": list[str],
+# }, ...]
+
def _system_library_impl(repo_ctx):
+ # type: (repository_ctx[_Attrs]) -> repo_metadata | None
repo_name = repo_ctx.attr.name.split("+")[-1]
includes = repo_ctx.attr.includes
hdrs = repo_ctx.attr.hdrs
@@ -180,7 +203,7 @@ def _system_library_impl(repo_ctx):
# The problem is that the quote-includes are assumed to be
# in the same directory as the header they are included from -
# they have no subdir prefix ("SDL2/") in their paths
- include_subdirs = {}
+ include_subdirs = {} # type: dict[str, None]
for hdr in hdr_names:
path_segments = hdr.split("/")
path_segments.pop()
diff --git a/cc/toolchains/BUILD b/cc/toolchains/BUILD
index e9ac62b03..ba57417d3 100644
--- a/cc/toolchains/BUILD
+++ b/cc/toolchains/BUILD
@@ -14,6 +14,14 @@
load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+exports_files(
+ [
+ "cc_toolchain_info.bzli",
+ "tool_map.bzli",
+ ],
+ visibility = ["//visibility:public"],
+)
+
bzl_library(
name = "toolchain_rules",
srcs = glob(["*.bzl"]),
@@ -44,6 +52,7 @@ filegroup(
name = "srcs",
srcs = glob([
"**/*.bzl",
+ "**/*.bzli",
"**/BUILD",
]) + [
"//cc/toolchains/actions:srcs",
diff --git a/cc/toolchains/actions.bzl b/cc/toolchains/actions.bzl
index 9a8928e5b..99e23f0a6 100644
--- a/cc/toolchains/actions.bzl
+++ b/cc/toolchains/actions.bzl
@@ -19,6 +19,7 @@ load(":cc_toolchain_info.bzl", "ActionTypeInfo", "ActionTypeSetInfo")
visibility("public")
def _cc_action_type_impl(ctx):
+ # type: (...) -> list[ActionTypeInfo | ActionTypeSetInfo]
action_type = ActionTypeInfo(label = ctx.label, name = ctx.attr.action_name)
return [
action_type,
@@ -62,6 +63,7 @@ cc_action_type(
)
def _cc_action_type_set_impl(ctx):
+ # type: (...) -> list[ActionTypeSetInfo]
if not ctx.attr.actions and not ctx.attr.allow_empty:
fail("Each cc_action_type_set must contain at least one action type.")
actions = collect_action_types(ctx.attr.actions)
diff --git a/cc/toolchains/actions/BUILD b/cc/toolchains/actions/BUILD
index 80cac26b2..cbf939535 100644
--- a/cc/toolchains/actions/BUILD
+++ b/cc/toolchains/actions/BUILD
@@ -269,6 +269,10 @@ cc_action_type_set(
excludes = [
# `lto_backend` actions do not instantiate the full set of build variables.
":lto_backend",
+ # `cpp_module_codegen` actions compile a precompiled module and never
+ # preprocess, so include paths, defines and other preprocessing flags
+ # don't apply to them and only make Clang warn about unused arguments.
+ ":cpp_module_codegen",
],
)
diff --git a/cc/toolchains/args.bzl b/cc/toolchains/args.bzl
index b07e54ec4..0c18c30de 100644
--- a/cc/toolchains/args.bzl
+++ b/cc/toolchains/args.bzl
@@ -164,6 +164,7 @@ Roughly equivalent to ctx.actions.args()
Examples:
cc_args(
name = "warnings_as_errors",
+ actions = ["//cc/toolchains/actions:compile_actions"],
args = ["-Werror"],
)
""",
@@ -172,7 +173,7 @@ Examples:
def cc_args(
*,
name,
- actions = None,
+ actions,
allowlist_include_directories = None,
allowlist_absolute_include_directories = None,
args = None,
diff --git a/cc/toolchains/args/BUILD b/cc/toolchains/args/BUILD
index 9625c3d9e..3edc7f41a 100644
--- a/cc/toolchains/args/BUILD
+++ b/cc/toolchains/args/BUILD
@@ -36,6 +36,7 @@ cc_feature_set(
"//cc/toolchains/args/linkstamp_flags:feature",
"//cc/toolchains/args/library_search_directories:feature",
"//cc/toolchains/args/dependency_file:feature",
+ "//cc/toolchains/args/cpp_modules:feature",
# NOTE: This should come below default flags so user flags can override them
"//cc/toolchains/args/compile_flags:feature",
@@ -61,5 +62,33 @@ filegroup(
name = "srcs",
srcs = glob(["**"]) + [
"//cc/toolchains/args/archiver_flags:srcs",
+ "//cc/toolchains/args/compile_flags:srcs",
+ "//cc/toolchains/args/compiler_input_flags:srcs",
+ "//cc/toolchains/args/compiler_output_flags:srcs",
+ "//cc/toolchains/args/cpp_modules:srcs",
+ "//cc/toolchains/args/def_file:srcs",
+ "//cc/toolchains/args/dependency_file:srcs",
+ "//cc/toolchains/args/external_include_paths:srcs",
+ "//cc/toolchains/args/fission_flags:srcs",
+ "//cc/toolchains/args/generate_linkmap:srcs",
+ "//cc/toolchains/args/include_flags:srcs",
+ "//cc/toolchains/args/layering_check:srcs",
+ "//cc/toolchains/args/libraries_to_link:srcs",
+ "//cc/toolchains/args/library_search_directories:srcs",
+ "//cc/toolchains/args/link_flags:srcs",
+ "//cc/toolchains/args/linker_param_file:srcs",
+ "//cc/toolchains/args/linkstamp_flags:srcs",
+ "//cc/toolchains/args/objc_arc_flags:srcs",
+ "//cc/toolchains/args/pic_flags:srcs",
+ "//cc/toolchains/args/preprocessor_defines:srcs",
+ "//cc/toolchains/args/random_seed:srcs",
+ "//cc/toolchains/args/runtime_library_search_directories:srcs",
+ "//cc/toolchains/args/sanitize_pwd:srcs",
+ "//cc/toolchains/args/shared_flag:srcs",
+ "//cc/toolchains/args/soname_flags:srcs",
+ "//cc/toolchains/args/static_libgcc:srcs",
+ "//cc/toolchains/args/strip_debug_symbols:srcs",
+ "//cc/toolchains/args/strip_flags:srcs",
+ "//cc/toolchains/args/thin_lto:srcs",
],
)
diff --git a/cc/toolchains/args/compile_flags/BUILD b/cc/toolchains/args/compile_flags/BUILD
index 123892aaa..aa285c379 100644
--- a/cc/toolchains/args/compile_flags/BUILD
+++ b/cc/toolchains/args/compile_flags/BUILD
@@ -62,3 +62,9 @@ cc_args(
iterate_over = "//cc/toolchains/variables:unfiltered_compile_flags",
requires_not_none = "//cc/toolchains/variables:unfiltered_compile_flags",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/compiler_input_flags/BUILD b/cc/toolchains/args/compiler_input_flags/BUILD
index 9bfe6a48b..d4a39d0c1 100644
--- a/cc/toolchains/args/compiler_input_flags/BUILD
+++ b/cc/toolchains/args/compiler_input_flags/BUILD
@@ -5,6 +5,7 @@ cc_feature(
name = "feature",
args = [
":flags",
+ ":module_interface_args",
":header_parsing_args",
],
overrides = "//cc/toolchains/features/legacy:compiler_input_flags",
@@ -15,7 +16,8 @@ cc_args(
name = "flags",
actions = [
"//cc/toolchains/actions:compile_actions_without_header_parsing",
- "//cc/toolchains/actions:cpp20_module_actions",
+ "//cc/toolchains/actions:cpp20_module_codegen",
+ "//cc/toolchains/actions:cpp_module_deps_scanning",
],
args = [
"-c",
@@ -25,6 +27,21 @@ cc_args(
requires_not_none = "//cc/toolchains/variables:source_file",
)
+# A C++20 module interface unit compiles as one whatever its extension. `-x`
+# only applies to the inputs after it, so it goes right before the source.
+cc_args(
+ name = "module_interface_args",
+ actions = ["//cc/toolchains/actions:cpp20_module_compile"],
+ args = [
+ "-x",
+ "c++-module",
+ "-c",
+ "{source_file}",
+ ],
+ format = {"source_file": "//cc/toolchains/variables:source_file"},
+ requires_not_none = "//cc/toolchains/variables:source_file",
+)
+
cc_args(
name = "header_parsing_args",
actions = ["//cc/toolchains/actions:cpp_header_parsing"],
@@ -32,3 +49,9 @@ cc_args(
format = {"source_file": "//cc/toolchains/variables:source_file"},
requires_not_none = "//cc/toolchains/variables:source_file",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/compiler_output_flags/BUILD b/cc/toolchains/args/compiler_output_flags/BUILD
index 068d31085..d6bd17e90 100644
--- a/cc/toolchains/args/compiler_output_flags/BUILD
+++ b/cc/toolchains/args/compiler_output_flags/BUILD
@@ -15,6 +15,7 @@ cc_args_list(
":output_assembly_flags",
":output_preprocess_flags",
":output_flags",
+ ":deps_scanner_output_env",
],
)
@@ -45,3 +46,19 @@ cc_args(
format = {"output_file": "//cc/toolchains/variables:output_file"},
requires_not_none = "//cc/toolchains/variables:output_file",
)
+
+# The C++20 module dependency scanner writes its P1689 output to the file this
+# names; the output_flags above name the scanned compile's object.
+cc_args(
+ name = "deps_scanner_output_env",
+ actions = ["//cc/toolchains/actions:cpp_module_deps_scanning"],
+ env = {"DEPS_SCANNER_OUTPUT_FILE": "{output_file}"},
+ format = {"output_file": "//cc/toolchains/variables:output_file"},
+ requires_not_none = "//cc/toolchains/variables:output_file",
+)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/cpp_modules/BUILD b/cc/toolchains/args/cpp_modules/BUILD
new file mode 100644
index 000000000..6269e5fd9
--- /dev/null
+++ b/cc/toolchains/args/cpp_modules/BUILD
@@ -0,0 +1,56 @@
+load("//cc/toolchains:args.bzl", "cc_args")
+load("//cc/toolchains:feature.bzl", "cc_feature")
+
+# The args C++20 modules need from a clang toolchain, matching
+# unix_cc_toolchain_config. Bazel builds module interfaces only once the
+# toolchain knows the `cpp_modules` feature and the build enables it, so
+# toolchains that map tools for the C++20 module actions should list
+# `:cpp_modules` in their known features and `:feature` in their enabled ones.
+# compiler_input_flags marks a module interface unit as one, since `-x` only
+# applies to the inputs after it.
+
+package(default_visibility = ["//visibility:public"])
+
+cc_feature(
+ name = "cpp_modules",
+ feature_name = "cpp_modules",
+)
+
+cc_feature(
+ name = "feature",
+ args = [
+ ":modmap_file_args",
+ ":module_output_args",
+ ],
+ feature_name = "cpp20_module_flags",
+)
+
+# The module map file names the BMI of each module a source imports.
+cc_args(
+ name = "modmap_file_args",
+ actions = [
+ "//cc/toolchains/actions:cpp_compile",
+ "//cc/toolchains/actions:cpp20_module_compile",
+ "//cc/toolchains/actions:cpp20_module_codegen",
+ ],
+ args = ["@{cpp_module_modmap_file}"],
+ format = {"cpp_module_modmap_file": "//cc/toolchains/variables:cpp_module_modmap_file"},
+ requires_not_none = "//cc/toolchains/variables:cpp_module_modmap_file",
+ visibility = ["//visibility:private"],
+)
+
+# A module interface unit writes its BMI where Bazel declared it.
+cc_args(
+ name = "module_output_args",
+ actions = ["//cc/toolchains/actions:cpp20_module_compile"],
+ args = ["-fmodule-output={cpp_module_output_file}"],
+ format = {"cpp_module_output_file": "//cc/toolchains/variables:cpp_module_output_file"},
+ requires_not_none = "//cc/toolchains/variables:cpp_module_output_file",
+ visibility = ["//visibility:private"],
+)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/def_file/BUILD b/cc/toolchains/args/def_file/BUILD
index 0b6811f95..6449b22f3 100644
--- a/cc/toolchains/args/def_file/BUILD
+++ b/cc/toolchains/args/def_file/BUILD
@@ -16,3 +16,9 @@ cc_args(
format = {"def_file_path": "//cc/toolchains/variables:def_file_path"},
requires_not_none = "//cc/toolchains/variables:def_file_path",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/dependency_file/BUILD b/cc/toolchains/args/dependency_file/BUILD
index 812092b6e..05ac6052c 100644
--- a/cc/toolchains/args/dependency_file/BUILD
+++ b/cc/toolchains/args/dependency_file/BUILD
@@ -22,3 +22,9 @@ cc_args(
format = {"dependency_file": "//cc/toolchains/variables:dependency_file"},
requires_not_none = "//cc/toolchains/variables:dependency_file",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/external_include_paths/BUILD b/cc/toolchains/args/external_include_paths/BUILD
index de2214f3d..f2dfcfab8 100644
--- a/cc/toolchains/args/external_include_paths/BUILD
+++ b/cc/toolchains/args/external_include_paths/BUILD
@@ -20,3 +20,9 @@ cc_nested_args(
},
iterate_over = "//cc/toolchains/variables:external_include_paths",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/fission_flags/BUILD b/cc/toolchains/args/fission_flags/BUILD
index 8ceb501c0..f91cdd9b2 100644
--- a/cc/toolchains/args/fission_flags/BUILD
+++ b/cc/toolchains/args/fission_flags/BUILD
@@ -39,3 +39,9 @@ cc_args(
],
requires_not_none = "//cc/toolchains/variables:per_object_debug_info_file",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/generate_linkmap/BUILD b/cc/toolchains/args/generate_linkmap/BUILD
index b44ecf1bb..27f07a98a 100644
--- a/cc/toolchains/args/generate_linkmap/BUILD
+++ b/cc/toolchains/args/generate_linkmap/BUILD
@@ -20,3 +20,9 @@ cc_args(
requires_not_none = "//cc/toolchains/variables:output_execpath",
visibility = ["//visibility:private"],
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/include_flags/BUILD b/cc/toolchains/args/include_flags/BUILD
index 1ee790e26..b6d76ad92 100644
--- a/cc/toolchains/args/include_flags/BUILD
+++ b/cc/toolchains/args/include_flags/BUILD
@@ -81,3 +81,9 @@ cc_args(
format = {"framework_include_paths": "//cc/toolchains/variables:framework_include_paths"},
iterate_over = "//cc/toolchains/variables:framework_include_paths",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/layering_check/BUILD b/cc/toolchains/args/layering_check/BUILD
index a7672deef..327aaad6e 100644
--- a/cc/toolchains/args/layering_check/BUILD
+++ b/cc/toolchains/args/layering_check/BUILD
@@ -95,3 +95,9 @@ cc_args(
iterate_over = "@rules_cc//cc/toolchains/variables:dependent_module_map_files",
requires_not_none = "@rules_cc//cc/toolchains/variables:dependent_module_map_files",
)
+
+filegroup(
+ name = "srcs",
+ srcs = ["BUILD"],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/libraries_to_link/BUILD b/cc/toolchains/args/libraries_to_link/BUILD
index ebfec9a44..8228f3588 100644
--- a/cc/toolchains/args/libraries_to_link/BUILD
+++ b/cc/toolchains/args/libraries_to_link/BUILD
@@ -180,3 +180,12 @@ cc_nested_args(
requires_equal = "//cc/toolchains/variables:libraries_to_link.type",
requires_equal_value = "versioned_dynamic_library",
)
+
+filegroup(
+ name = "srcs",
+ srcs = [
+ "BUILD",
+ "//cc/toolchains/args/libraries_to_link/private:srcs",
+ ],
+ visibility = ["//cc/toolchains/args:__pkg__"],
+)
diff --git a/cc/toolchains/args/libraries_to_link/private/BUILD b/cc/toolchains/args/libraries_to_link/private/BUILD
index ecb36c3e0..e0b10e88f 100644
--- a/cc/toolchains/args/libraries_to_link/private/BUILD
+++ b/cc/toolchains/args/libraries_to_link/private/BUILD
@@ -1 +1,10 @@
package(default_visibility = ["//visibility:private"])
+
+filegroup(
+ name = "srcs",
+ srcs = [
+ "BUILD",
+ "library_link_args.bzl",
+ ],
+ visibility = ["//cc/toolchains/args/libraries_to_link:__pkg__"],
+)
diff --git a/cc/toolchains/args/libraries_to_link/private/library_link_args.bzl b/cc/toolchains/args/libraries_to_link/private/library_link_args.bzl
index 85e65814d..bc47b4a7e 100644
--- a/cc/toolchains/args/libraries_to_link/private/library_link_args.bzl
+++ b/cc/toolchains/args/libraries_to_link/private/library_link_args.bzl
@@ -16,6 +16,7 @@
load("//cc/toolchains:nested_args.bzl", "cc_nested_args")
def apple_force_load_library_args(name, variable):
+ # type: (str, str | Label) -> None
"""A helper for declaring -force_load argument expansion for a library.
This creates an argument expansion that will expand to -Wl,-force_load,
load("@rules_cc//cc/toolchains/impl:documented_api.bzl", "cc_variable")
-cc_variable(name, type, **kwargs)
+cc_variable(name, type, *, actions, **kwargs)
Exposes a toolchain variable to use in toolchain argument expansions.
@@ -904,6 +904,7 @@ cc_variable(
| :------------- | :------------- | :------------- |
| name | (str) The name of the outer variable, and the rule. | none |
| type | The type of the variable, constructed using `types` factory in [@rules_cc//cc/toolchains/impl:variables.bzl](https://github.com/bazelbuild/rules_cc/tree/main/cc/toolchains/impl/variables.bzl). | none |
+| actions | The actions for which the variable is available. | `[]` |
| kwargs | [common attributes](https://bazel.build/reference/be/common-definitions#common-attributes) that should be applied to this rule. | none |
diff --git a/local_bazel.bzl b/local_bazel.bzl
index ab937b932..78140ca7c 100644
--- a/local_bazel.bzl
+++ b/local_bazel.bzl
@@ -15,6 +15,9 @@
"""Repository rule for importing the copy of Bazel on the user's PATH."""
def _local_bazel_import_impl(repository_ctx):
+ # type: (...) -> repo_metadata | None
+ # TODO(https://github.com/bazelbuild/bazel/issues/32020): make this an
+ # annotation when supported Bazel versions expose metadata types.
if "windows" in repository_ctx.os.name.lower():
bazel_real = "bazel-real.exe"
bazel_name = "bazel.exe"
diff --git a/stubs.toml b/stubs.toml
new file mode 100644
index 000000000..f1b4eff0f
--- /dev/null
+++ b/stubs.toml
@@ -0,0 +1,17 @@
+format-version = 1
+
+[files]
+"cc/cc_postmark_initializers.bzl" = "cc/cc_postmark_initializers.bzli"
+"cc/cc_toolchain_config_lib.bzl" = "cc/cc_toolchain_config_lib.bzli"
+"cc/private/objc_info.bzl" = "cc/private/objc_info.bzli"
+"cc/private/rules_impl/objc_compilation_artifacts_info.bzl" = "cc/private/rules_impl/objc_compilation_artifacts_info.bzli"
+"cc/private/rules_impl/objc_compilation_context_info.bzl" = "cc/private/rules_impl/objc_compilation_context_info.bzli"
+"cc/private/toolchain/lib_cc_configure.bzl" = "cc/private/toolchain/lib_cc_configure.bzli"
+"cc/private/toolchain/unix_cc_configure.bzl" = "cc/private/toolchain/unix_cc_configure.bzli"
+"cc/private/toolchain_config/legacy_features.bzl" = "cc/private/toolchain_config/legacy_features.bzli"
+"cc/toolchains/cc_toolchain_info.bzl" = "cc/toolchains/cc_toolchain_info.bzli"
+"cc/toolchains/impl/collect.bzl" = "cc/toolchains/impl/collect.bzli"
+"cc/toolchains/impl/legacy_converter.bzl" = "cc/toolchains/impl/legacy_converter.bzli"
+"cc/toolchains/impl/nested_args.bzl" = "cc/toolchains/impl/nested_args.bzli"
+"cc/toolchains/impl/variables.bzl" = "cc/toolchains/impl/variables.bzli"
+"cc/toolchains/tool_map.bzl" = "cc/toolchains/tool_map.bzli"
diff --git a/stubs/bazel_skylib/bzl_library.bzli b/stubs/bazel_skylib/bzl_library.bzli
new file mode 100644
index 000000000..5e3bda8fd
--- /dev/null
+++ b/stubs/bazel_skylib/bzl_library.bzli
@@ -0,0 +1,5 @@
+# TODO(https://github.com/bazelbuild/bazel-skylib/pull/641): Remove this stub
+# when the selected Skylib release types the wrapper's forwarded rule attributes.
+load("@bazel_skylib//rules/private:bzl_library.bzl", _rule = "bzl_library")
+
+def bzl_library(name: str, **kwargs: Unpack[KeywordArgs[_rule, "name"]]) -> None: ...
diff --git a/stubs/bazel_skylib/common_settings.bzli b/stubs/bazel_skylib/common_settings.bzli
new file mode 100644
index 000000000..c98968090
--- /dev/null
+++ b/stubs/bazel_skylib/common_settings.bzli
@@ -0,0 +1,3 @@
+# TODO(https://github.com/bazelbuild/bazel-skylib/pull/641): Remove this stub
+# when the selected Skylib release types BuildSettingInfo.value.
+def BuildSettingInfo[T = object](*, value: T) -> record[{"value": T}]: ...
diff --git a/stubs/bazel_skylib/directory_providers.bzli b/stubs/bazel_skylib/directory_providers.bzli
new file mode 100644
index 000000000..94538f239
--- /dev/null
+++ b/stubs/bazel_skylib/directory_providers.bzli
@@ -0,0 +1,26 @@
+# TODO(https://github.com/bazelbuild/bazel-skylib/pull/641): Remove this stub
+# when the selected Skylib release types DirectoryInfo.
+class _Glob(Protocol):
+ def __call__(self, include: Sequence[str], exclude: Sequence[str] = ..., allow_empty: bool = ...) -> depset[File]: ...
+
+type _Fields = dict[{
+ "entries": dict[str, File | DirectoryInfo],
+ "transitive_files": depset[File],
+ "path": str,
+ "human_readable": str,
+ "get_path": Callable[[str], File | DirectoryInfo],
+ "get_file": Callable[[str], File],
+ "get_subdirectory": Callable[[str], DirectoryInfo],
+ "glob": _Glob,
+}]
+
+def DirectoryInfo(**kwargs: Unpack[_Fields]) -> record[{
+ "entries": dict[str, File | DirectoryInfo],
+ "transitive_files": depset[File],
+ "path": str,
+ "human_readable": str,
+ "get_path": Callable[[str], File | DirectoryInfo],
+ "get_file": Callable[[str], File],
+ "get_subdirectory": Callable[[str], DirectoryInfo],
+ "glob": _Glob,
+}]: ...
diff --git a/stubs/bazel_skylib/paths.bzli b/stubs/bazel_skylib/paths.bzli
new file mode 100644
index 000000000..ec6d79705
--- /dev/null
+++ b/stubs/bazel_skylib/paths.bzli
@@ -0,0 +1,12 @@
+# TODO(https://github.com/bazelbuild/bazel-skylib/pull/641): Remove this stub
+# when the selected Skylib release types the functions it exports through paths.
+def _basename(p: str) -> str: ...
+def _dirname(p: str) -> str: ...
+def _is_absolute(path: str) -> bool: ...
+def _join(path: str, *others: str) -> str: ...
+def _normalize(path: str) -> str: ...
+def _is_normalized(str: str, look_for_same_level_references: bool = ...) -> bool: ...
+def _relativize(path: str, start: str) -> str: ...
+def _replace_extension(p: str, new_extension: str) -> str: ...
+def _split_extension(p: str) -> tuple[str, str]: ...
+def _starts_with(path_a: str, path_b: str) -> bool: ...
diff --git a/stubs/bazel_skylib/stubs.toml b/stubs/bazel_skylib/stubs.toml
new file mode 100644
index 000000000..36b7a33c9
--- /dev/null
+++ b/stubs/bazel_skylib/stubs.toml
@@ -0,0 +1,12 @@
+format-version = 1
+
+[source]
+repository = "@bazel_skylib"
+module = "bazel_skylib"
+versions = ["1.9.0"]
+
+[files]
+"bzl_library.bzl" = "bzl_library.bzli"
+"lib/paths.bzl" = "paths.bzli"
+"rules/common_settings.bzl" = "common_settings.bzli"
+"rules/directory/providers.bzl" = "directory_providers.bzli"
diff --git a/sty.toml b/sty.toml
new file mode 100644
index 000000000..0edcbec44
--- /dev/null
+++ b/sty.toml
@@ -0,0 +1,36 @@
+# TODO(https://github.com/bazelbuild/bazel/pull/30373): Move ordinary signatures
+# into function declarations once the minimum Bazel version supports annotation
+# syntax. Bazel 7 must still be able to load these files.
+[analysis]
+strict-generic-narrowing = true
+require-valid-suppressions = true
+
+[rules]
+strict = "error"
+
+# The released provider modules also contain unannotated private helpers.
+# Check the provider contracts and report incomplete types in those helpers.
+[[overrides]]
+include = [
+ "@bazel_skylib//rules:common_settings.bzl",
+ "@bazel_skylib//rules/directory:providers.bzl",
+]
+
+[overrides.rules]
+missing-parameter-annotation = "warn"
+missing-return-annotation = "warn"
+non-static-type = "warn"
+
+# _relativize assigns [] to start_segments; Skylib 1.9.0 leaves its element
+# type unknown. Keep checking the function's inputs and return type.
+[[overrides]]
+include = ["@bazel_skylib//lib:paths.bzl"]
+
+[overrides.rules]
+non-static-type = "warn"
+
+[[stub-packages]]
+manifest = "stubs.toml"
+
+[[stub-packages]]
+manifest = "stubs/bazel_skylib/stubs.toml"
diff --git a/tests/alwayslink_srcs/BUILD b/tests/alwayslink_srcs/BUILD
index 833912012..44015de27 100644
--- a/tests/alwayslink_srcs/BUILD
+++ b/tests/alwayslink_srcs/BUILD
@@ -39,7 +39,7 @@ genrule(
name = "copy_registerer_archive_unix",
srcs = [":registerer_lib"],
outs = ["libregisterer_copied.a"],
- cmd = "for f in $(locations :registerer_lib); do case \"$$f\" in *.a) cp \"$$f\" $@;; esac; done",
+ cmd = "for f in $(execpaths :registerer_lib); do case \"$$f\" in *.a) cp \"$$f\" $@;; esac; done",
target_compatible_with = select({
"@platforms//os:windows": ["@platforms//:incompatible"],
"//conditions:default": [],
@@ -50,7 +50,7 @@ genrule(
name = "copy_registerer_archive_windows",
srcs = [":registerer_lib"],
outs = ["registerer_copied.lib"],
- cmd = "for f in $(locations :registerer_lib); do case \"$$f\" in *.lib) cp \"$$f\" $@;; esac; done",
+ cmd = "for f in $(execpaths :registerer_lib); do case \"$$f\" in *.lib) cp \"$$f\" $@;; esac; done",
target_compatible_with = ["@platforms//os:windows"],
)
diff --git a/tests/builtins_bzl/cc/cc_shared_library/test/BUILD b/tests/builtins_bzl/cc/cc_shared_library/test/BUILD
index d6949cdfa..e6129a9c4 100644
--- a/tests/builtins_bzl/cc/cc_shared_library/test/BUILD
+++ b/tests/builtins_bzl/cc/cc_shared_library/test/BUILD
@@ -135,8 +135,8 @@ cc_shared_library(
user_link_flags = select({
"@platforms//os:linux": [
"-Wl,-rpath,kittens",
- "-Wl,--version-script=$(location :foo.lds)",
- "-Wl,--script=$(location :additional_script.txt)",
+ "-Wl,--version-script=$(execpath :foo.lds)",
+ "-Wl,--script=$(execpath :additional_script.txt)",
"-Wl,--no-gc-sections",
],
"//conditions:default": [],
@@ -272,7 +272,7 @@ cc_shared_library(
features = ["windows_export_all_symbols"],
user_link_flags = select({
"@platforms//os:linux": [
- "-Wl,--version-script=$(location :bar.lds)",
+ "-Wl,--version-script=$(execpath :bar.lds)",
],
"//conditions:default": [],
}),
@@ -399,7 +399,7 @@ genrule(
name = "check_file_named_correctly",
srcs = ["just_main_output_renamed"],
outs = ["renamed_so_file_copy.so"],
- cmd = "cp $$(dirname $(location :just_main_output_renamed))/renamed_so_file.so $@",
+ cmd = "cp $$(dirname $(execpath :just_main_output_renamed))/renamed_so_file.so $@",
)
filegroup(
@@ -552,6 +552,19 @@ exports_test(
],
)
+exports_test(
+ name = "external_select_exports_filter_exports_test",
+ bazel_only = True,
+ # target = "external_export_so", # copybara-comment-this-out-please
+ target = "@cross_repo_test//:bar_so", # copybara-uncomment-this-please
+ targets_that_should_be_claimed_to_be_exported = [
+ # buildifier: disable=canonical-repository
+ "@@test_repo+//:bar", # copybara-uncomment-this-please
+ # buildifier: disable=canonical-repository
+ "@@test_repo+//:bar_wrapper", # copybara-uncomment-this-please
+ ],
+)
+
pdb_test(
name = "pdb_test",
target = ":foo_so",
diff --git a/tests/builtins_bzl/cc/cc_shared_library/test2/BUILD.bazel b/tests/builtins_bzl/cc/cc_shared_library/test2/BUILD.bazel
index 88a92df68..133dff65f 100644
--- a/tests/builtins_bzl/cc/cc_shared_library/test2/BUILD.bazel
+++ b/tests/builtins_bzl/cc/cc_shared_library/test2/BUILD.bazel
@@ -1,4 +1,5 @@
load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_shared_library.bzl", "cc_shared_library")
licenses(["notice"])
@@ -8,3 +9,17 @@ cc_library(
hdrs = ["bar.h"],
visibility = ["//visibility:public"],
)
+
+cc_library(
+ name = "bar_wrapper",
+ visibility = ["//visibility:public"],
+ deps = [":bar"],
+)
+
+cc_shared_library(
+ name = "bar_so",
+ exports_filter = select({"//conditions:default": ["@test_repo//:__pkg__"]}),
+ tags = ["manual"],
+ visibility = ["//visibility:public"],
+ deps = [":bar_wrapper"],
+)
diff --git a/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/BUILD.bazel b/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/BUILD.bazel
new file mode 100644
index 000000000..b5605a2b0
--- /dev/null
+++ b/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/BUILD.bazel
@@ -0,0 +1,31 @@
+load("@rules_cc//cc/toolchains:cc_toolchain.bzl", "cc_toolchain")
+load(":cc_toolchain_config.bzl", "cc_toolchain_config")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(name = "empty")
+
+cc_toolchain_config(
+ name = "toolchain_config",
+ cxx_builtin_include_directories = [
+ "%package(@test_repo//toolchain_include_dirs)%/include",
+ "%package(//toolchain_include_dirs)%/other",
+ "%package(@rules_cc//cc)%",
+ ],
+ tags = ["manual"],
+)
+
+cc_toolchain(
+ name = "toolchain",
+ all_files = ":empty",
+ ar_files = ":empty",
+ as_files = ":empty",
+ compiler_files = ":empty",
+ dwp_files = ":empty",
+ linker_files = ":empty",
+ objcopy_files = ":empty",
+ strip_files = ":empty",
+ tags = ["manual"],
+ toolchain_config = ":toolchain_config",
+ toolchain_identifier = "test-toolchain",
+)
diff --git a/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/cc_toolchain_config.bzl b/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/cc_toolchain_config.bzl
new file mode 100644
index 000000000..2b2c922f0
--- /dev/null
+++ b/tests/builtins_bzl/cc/cc_shared_library/test2/toolchain_include_dirs/cc_toolchain_config.bzl
@@ -0,0 +1,23 @@
+"""A minimal cc_toolchain_config rule for testing cxx_builtin_include_directories."""
+
+load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
+load("@rules_cc//cc/toolchains:cc_toolchain_config_info.bzl", "CcToolchainConfigInfo")
+
+def _impl(ctx):
+ return cc_common.create_cc_toolchain_config_info(
+ ctx = ctx,
+ toolchain_identifier = "test-toolchain",
+ compiler = "test-compiler",
+ target_system_name = "local",
+ target_cpu = "k8",
+ target_libc = "unknown",
+ cxx_builtin_include_directories = ctx.attr.cxx_builtin_include_directories,
+ )
+
+cc_toolchain_config = rule(
+ implementation = _impl,
+ attrs = {
+ "cxx_builtin_include_directories": attr.string_list(),
+ },
+ provides = [CcToolchainConfigInfo],
+)
diff --git a/tests/builtins_bzl/cc/cc_static_library/test/BUILD b/tests/builtins_bzl/cc/cc_static_library/test/BUILD
index 407853e7d..8c01a4cae 100644
--- a/tests/builtins_bzl/cc/cc_static_library/test/BUILD
+++ b/tests/builtins_bzl/cc/cc_static_library/test/BUILD
@@ -34,9 +34,15 @@ cc_library(
linkstatic = True,
)
+filegroup(
+ name = "lib_only_static",
+ srcs = [":lib_only"],
+ output_group = "archive",
+)
+
cc_import(
name = "lib_only_static_lib",
- static_library = ":lib_only",
+ static_library = ":lib_only_static",
)
cc_import(
@@ -84,6 +90,7 @@ sh_test(
],
target_compatible_with = select({
"@platforms//os:linux": [],
+ "@platforms//os:macos": [],
"//conditions:default": ["@platforms//:incompatible"],
}),
)
diff --git a/tests/builtins_bzl/cc/cc_static_library/test/starlark_tests.bzl b/tests/builtins_bzl/cc/cc_static_library/test/starlark_tests.bzl
index 3cba57383..f73ef0af3 100644
--- a/tests/builtins_bzl/cc/cc_static_library/test/starlark_tests.bzl
+++ b/tests/builtins_bzl/cc/cc_static_library/test/starlark_tests.bzl
@@ -19,6 +19,8 @@ load("@rules_testing//lib:util.bzl", "util")
load("//cc:cc_import.bzl", "cc_import")
load("//cc:cc_library.bzl", "cc_library")
load("//cc:cc_static_library.bzl", "cc_static_library")
+load("//tests/cc/testutil:cc_analysis_test.bzl", "cc_analysis_test")
+load("//tests/cc/testutil/toolchains:features.bzl", "FEATURE_NAMES")
load(":mock_toolchain.bzl", "mock_cc_toolchain")
def _set_up_subject(name):
@@ -233,6 +235,40 @@ def _test_validation_disabled_impl(env, target):
env.expect.that_collection(dir(target[OutputGroupInfo])).contains_none_of(["_validation"])
+#buildifier: disable=unused-variable
+def _test_opt_archives_one_object_per_source(name):
+ util.helper_target(
+ cc_library,
+ name = name + "_lib",
+ srcs = ["file.cc"],
+ )
+ util.helper_target(
+ cc_static_library,
+ name = name + "_subject",
+ deps = [name + "_lib"],
+ )
+
+ # With supports_pic in opt mode, cc_library compiles both a PIC and a
+ # non-PIC object for every source.
+ cc_analysis_test(
+ name = name,
+ impl = _test_opt_archives_one_object_per_source_impl,
+ target = name + "_subject",
+ test_features = [FEATURE_NAMES.supports_pic],
+ config_settings = {
+ "//command_line_option:compilation_mode": "opt",
+ },
+ )
+
+def _test_opt_archives_one_object_per_source_impl(env, target):
+ action = env.expect.that_target(target).action_named("CppTransitiveArchive")
+ objects = [
+ f.basename
+ for f in action.actual.inputs.to_list()
+ if f.extension == "o"
+ ]
+ env.expect.that_collection(objects).contains_exactly(["file.pic.o"])
+
def analysis_test_suite(name):
test_suite(
name = name,
@@ -241,5 +277,6 @@ def analysis_test_suite(name):
_test_output_groups,
_test_validation_enabled,
_test_validation_disabled,
+ _test_opt_archives_one_object_per_source, # copybara-uncomment-this-please
],
)
diff --git a/tests/cc/bazel/cpp_modules_test.bzl b/tests/cc/bazel/cpp_modules_test.bzl
index ce1c50d14..948659221 100644
--- a/tests/cc/bazel/cpp_modules_test.bzl
+++ b/tests/cc/bazel/cpp_modules_test.bzl
@@ -18,6 +18,37 @@ def _setup_with_features_target(name, rule_fn, suffix):
module_interfaces = [name + "/foo.cppm"],
)
+def _setup_with_parse_headers_target(name, rule_fn, suffix):
+ util.empty_file(name + "/bar.cc")
+ util.empty_file(name + "/bar.h")
+ util.helper_target(
+ rule_fn,
+ name = name + suffix,
+ srcs = [name + "/bar.cc"],
+ hdrs = [name + "/bar.h"],
+ features = ["parse_headers"],
+ )
+
+def _test_cpp_modules_cc_library_with_parse_headers(name, **kwargs):
+ _setup_with_parse_headers_target(name, cc_library, "_lib")
+ cc_analysis_test(
+ name = name,
+ target = name + "_lib",
+ impl = _test_cpp_modules_with_parse_headers_impl,
+ test_features = ["cpp_modules"],
+ with_action_configs = [
+ ACTION_NAMES.cpp_module_deps_scanning,
+ ACTION_NAMES.cpp20_module_compile,
+ ],
+ config_settings = {
+ "//command_line_option:experimental_cpp_modules": True,
+ },
+ **kwargs
+ )
+
+def _test_cpp_modules_with_parse_headers_impl(env, target):
+ env.expect.that_target(target).action_named("CppCompile")
+
def _test_cpp_modules_cc_library_configuration_with_features(name, **kwargs):
_setup_with_features_target(name, cc_library, "_lib")
cc_analysis_test(
@@ -166,6 +197,7 @@ def cpp_modules_tests(name, **kwargs):
_test_cpp_modules_cc_library_configuration_with_features,
_test_cpp_modules_cc_binary_configuration_with_features,
_test_cpp_modules_cc_test_configuration_with_features,
+ _test_cpp_modules_cc_library_with_parse_headers,
_test_same_module_interfaces_file_in_cc_library_twice,
_test_same_module_interfaces_file_in_cc_binary_twice,
_test_same_module_interfaces_file_in_cc_test_twice,
diff --git a/tests/cc/common/BUILD b/tests/cc/common/BUILD
index 94535da60..cc4dda4ff 100644
--- a/tests/cc/common/BUILD
+++ b/tests/cc/common/BUILD
@@ -12,6 +12,7 @@ load(":cc_link_action_test.bzl", "cc_link_action_tests")
load(":cc_linkstamp_compile_test.bzl", "cc_linkstamp_compile_tests")
load(":cc_objc_library_configured_target_tests.bzl", "cc_objc_library_configured_target_tests")
load(":cc_output_groups_test.bzl", "cc_output_groups_tests")
+load(":cc_toolchain_include_directories_test.bzl", "cc_toolchain_include_directories_tests")
load(":compile_build_variables_tests.bzl", "compile_build_variables_tests")
load(":cpp_modules_test.bzl", "cpp_modules_tests")
load(":debug_info_packaging_test.bzl", "debug_info_packaging_tests")
@@ -55,3 +56,5 @@ cc_link_action_tests(name = "cc_link_action_tests")
cc_linkstamp_compile_tests(name = "cc_linkstamp_compile_tests")
cc_binary_fdo_tests(name = "cc_binary_fdo_tests")
+
+cc_toolchain_include_directories_tests(name = "cc_toolchain_include_directories_tests")
diff --git a/tests/cc/common/cc_binary_configured_target_tests.bzl b/tests/cc/common/cc_binary_configured_target_tests.bzl
index fdde1aeae..75c9ec6d3 100644
--- a/tests/cc/common/cc_binary_configured_target_tests.bzl
+++ b/tests/cc/common/cc_binary_configured_target_tests.bzl
@@ -337,6 +337,105 @@ def _test_generated_def_file_uses_toolchain_action_impl(env, target):
matching.contains("def_parser_tool"),
)
+def _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name,
+ shared_lib_name = None,
+ dynamic_library_pattern = None,
+ **kwargs):
+ util.helper_target(
+ cc_library,
+ name = name + "/foo",
+ srcs = ["foo.cc"],
+ )
+ shared_lib_kwargs = {}
+ if shared_lib_name != None:
+ shared_lib_kwargs["shared_lib_name"] = shared_lib_name
+ util.helper_target(
+ cc_shared_library,
+ name = name + "/foo_shared",
+ deps = [name + "/foo"],
+ **shared_lib_kwargs
+ )
+ config_settings = {}
+ if dynamic_library_pattern != None:
+ config_settings[str(Label("//tests/cc/testutil/toolchains:dynamic_library_pattern"))] = dynamic_library_pattern
+ cc_analysis_test(
+ name = name,
+ impl = _cc_shared_library_generated_def_file_test_impl,
+ target = name + "/foo_shared",
+ test_features = [
+ FEATURE_NAMES.copy_dynamic_libraries_to_binary,
+ FEATURE_NAMES.targets_windows,
+ FEATURE_NAMES.windows_export_all_symbols,
+ ],
+ with_action_configs = [ACTION_NAMES.generate_def_file],
+ config_settings = config_settings,
+ attrs = {
+ "expected_dll_name": attr.string(),
+ },
+ attr_values = {
+ "expected_dll_name": expected_dll_name,
+ },
+ **kwargs
+ )
+
+def _cc_shared_library_generated_def_file_test_impl(env, target):
+ def_file_short_path = "{}/{}.gen.def".format(target.label.package, target.label.name)
+ def_action = _generated_def_file_action(env, target)
+ def_action.argv().contains_at_least_predicates([
+ matching.contains("def_parser_tool"),
+ matching.str_endswith(def_file_short_path),
+ matching.equals_wrapper(env.ctx.attr.expected_dll_name),
+ ]).in_order()
+ env.expect.that_target(target).output_group("def_file").contains_exactly([
+ "{package}/{name}.gen.def",
+ ])
+ link_action = env.expect.that_target(target).action_named("CppLink")
+ link_action.inputs().contains("{package}/{name}.gen.def")
+ link_action.outputs().contains_predicate(
+ matching.file_basename_equals(env.ctx.attr.expected_dll_name),
+ )
+
+def _test_cc_shared_library_generated_def_file_default_dll_name(name, **kwargs):
+ _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name = "libfoo_shared.so",
+ **kwargs
+ )
+
+def _test_cc_shared_library_generated_def_file_mingw_dll_pattern(name, **kwargs):
+ _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name = "libfoo_shared.dll",
+ dynamic_library_pattern = ["lib", ".dll"],
+ **kwargs
+ )
+
+def _test_cc_shared_library_generated_def_file_msvc_dll_pattern(name, **kwargs):
+ _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name = "foo_shared.dll",
+ dynamic_library_pattern = ["", ".dll"],
+ **kwargs
+ )
+
+def _test_cc_shared_library_generated_def_file_shared_lib_name(name, **kwargs):
+ _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name = "custom_foo.pyd",
+ shared_lib_name = "custom_foo.pyd",
+ **kwargs
+ )
+
+def _test_cc_shared_library_generated_def_file_shared_lib_name_with_subdir(name, **kwargs):
+ _cc_shared_library_generated_def_file_test(
+ name,
+ expected_dll_name = "custom_foo.dll",
+ shared_lib_name = "subdir/custom_foo.dll",
+ **kwargs
+ )
+
def _test_duplicate_linkopts(name, **kwargs):
util.helper_target(
cc_library,
@@ -2088,6 +2187,11 @@ def cc_binary_configured_target_tests(name):
_test_system_include_paths_reclassifies_local_includes_without_propagation,
_test_generated_def_file_uses_toolchain_action, # copybara-uncomment-this-please
_test_generated_def_file_uses_default_tool, # copybara-uncomment-this-please
+ _test_cc_shared_library_generated_def_file_default_dll_name,
+ _test_cc_shared_library_generated_def_file_mingw_dll_pattern,
+ _test_cc_shared_library_generated_def_file_msvc_dll_pattern,
+ _test_cc_shared_library_generated_def_file_shared_lib_name,
+ _test_cc_shared_library_generated_def_file_shared_lib_name_with_subdir,
_test_linker_toolchain_feature,
_test_link_staticness_binary_static_dynamic_mode_default,
_test_link_staticness_hello_test_dynamic_mode_default,
diff --git a/tests/cc/common/cc_binary_fdo_test.bzl b/tests/cc/common/cc_binary_fdo_test.bzl
index 4b64aef65..6f4fb9b40 100644
--- a/tests/cc/common/cc_binary_fdo_test.bzl
+++ b/tests/cc/common/cc_binary_fdo_test.bzl
@@ -14,6 +14,7 @@
"""Tests for cc_binary with FDO."""
+load("@bazel_features//:features.bzl", "bazel_features")
load("@rules_testing//lib:analysis_test.bzl", "test_suite")
load("@rules_testing//lib:truth.bzl", "matching")
load("@rules_testing//lib:util.bzl", "util")
@@ -27,6 +28,12 @@ def _test_fdo_profile_action_graph(name, **kwargs):
name = name + "/foo",
srcs = ["foo.cc"],
)
+ util.helper_target(
+ cc_binary,
+ name = name + "/foo_no_fdo",
+ srcs = ["foo.cc"],
+ features = ["-fdo_optimize"],
+ )
util.helper_target(
fdo_profile,
@@ -46,6 +53,7 @@ def _test_fdo_profile_action_graph(name, **kwargs):
impl = _test_fdo_profile_action_graph_impl,
targets = {
"foo": name + "/foo",
+ "foo_no_fdo": name + "/foo_no_fdo",
"gen_profraw": name + "/gen_profraw",
"compiler": select({
"@platforms//os:macos": "//tests/cc/testutil/toolchains:cc-compiler-macos-compiler",
@@ -101,6 +109,11 @@ def _test_fdo_profile_action_graph_impl(env, targets):
# these targets so just assert short_path
assert_compile_action.inputs().contains(profdata.short_path)
+ if bazel_features.cc.cc_common_is_in_rules_cc:
+ env.expect.that_target(targets.foo_no_fdo).action_generating(
+ "{package}/_objs/{name}/foo.o",
+ ).inputs().not_contains(profdata.short_path)
+
def cc_binary_fdo_tests(name):
test_suite(
name = name,
diff --git a/tests/cc/common/cc_common_test.bzl b/tests/cc/common/cc_common_test.bzl
index 15af5008b..39be3c329 100644
--- a/tests/cc/common/cc_common_test.bzl
+++ b/tests/cc/common/cc_common_test.bzl
@@ -7,6 +7,7 @@ load("@rules_testing//lib:util.bzl", "TestingAspectInfo", "util")
load("//cc:cc_binary.bzl", "cc_binary")
load("//cc:cc_library.bzl", "cc_library")
load("//cc/common:cc_info.bzl", "CcInfo")
+load("//cc/private/link:create_extra_link_time_library.bzl", "build_libraries", "create_extra_link_time_libraries", "create_extra_link_time_library", "merge_extra_link_time_libraries") # buildifier: disable=bzl-visibility
load("//tests/cc/testutil:cc_analysis_test.bzl", "cc_analysis_test")
load("//tests/cc/testutil:cc_info_subject.bzl", "cc_info_subject")
@@ -707,6 +708,133 @@ def _test_alwayslink_yields_lo_impl(env, target):
files = [f.basename for f in target[DefaultInfo].files.to_list()]
env.expect.that_collection(files).contains("libalways_link.lo")
+# buildifier: disable=provider-params
+_ExtraLinkTimeLibraryTestInfo = provider(fields = ["stamp_infos"])
+
+def _build_extra_link_time_library(_ctx, _static_mode, _for_dynamic_library, inputs):
+ return struct(
+ linker_input = depset(),
+ runtime_library = depset(),
+ additional_stamp_info = inputs.to_list(),
+ )
+
+def _top_level_extra_link_time_library_impl(ctx):
+ first = create_extra_link_time_library(
+ build_library_func = _build_extra_link_time_library,
+ inputs = depset(["first"]),
+ )
+ second = create_extra_link_time_library(
+ build_library_func = _build_extra_link_time_library,
+ inputs = depset(["second"]),
+ )
+ libraries = merge_extra_link_time_libraries([
+ create_extra_link_time_libraries(first),
+ create_extra_link_time_libraries(second),
+ ])
+ result = build_libraries(libraries.libraries, ctx, False, False)
+ return [_ExtraLinkTimeLibraryTestInfo(stamp_infos = result.additional_stamp_infos)]
+
+_top_level_extra_link_time_library = rule(
+ implementation = _top_level_extra_link_time_library_impl,
+)
+
+def _nested_extra_link_time_library_impl(ctx):
+ def nested_build_library(_ctx, _static_mode, _for_dynamic_library):
+ # buildifier: disable=rule-impl-returns
+ return struct(
+ linker_input = depset(),
+ runtime_library = depset(),
+ )
+
+ library = create_extra_link_time_library(
+ build_library_func = nested_build_library,
+ )
+ build_libraries([library], ctx, False, False)
+ return []
+
+_nested_extra_link_time_library = rule(
+ implementation = _nested_extra_link_time_library_impl,
+)
+
+def _invalid_extra_link_time_library_impl(ctx):
+ create_extra_link_time_library(build_library_func = struct if ctx.attr.builtin else None)
+ return []
+
+_invalid_extra_link_time_library = rule(
+ implementation = _invalid_extra_link_time_library_impl,
+ attrs = {"builtin": attr.bool()},
+)
+
+def _test_top_level_extra_link_time_library(name):
+ util.helper_target(
+ _top_level_extra_link_time_library,
+ name = name + "/library",
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_top_level_extra_link_time_library_impl,
+ target = name + "/library",
+ )
+
+def _test_top_level_extra_link_time_library_impl(env, target):
+ env.expect.that_target(target).failures().contains_exactly([])
+ stamp_infos = target[_ExtraLinkTimeLibraryTestInfo].stamp_infos
+ env.expect.that_collection(stamp_infos).has_size(1)
+ env.expect.that_collection(stamp_infos[0]).contains_exactly(["first", "second"])
+
+def _test_nested_extra_link_time_library(name):
+ util.helper_target(
+ _nested_extra_link_time_library,
+ name = name + "/library",
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_nested_extra_link_time_library_impl,
+ target = name + "/library",
+ expect_failure = True,
+ )
+
+def _test_nested_extra_link_time_library_impl(env, target):
+ env.expect.that_target(target).failures().contains_predicate(
+ matching.custom(
+ "contains 'must be declared by a top-level def statement'",
+ lambda message: "must be declared by a top-level def statement" in message,
+ ),
+ )
+
+def _test_builtin_extra_link_time_library(name):
+ util.helper_target(
+ _invalid_extra_link_time_library,
+ name = name + "/library",
+ builtin = True,
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_invalid_extra_link_time_library_impl,
+ target = name + "/library",
+ expect_failure = True,
+ )
+
+def _test_none_extra_link_time_library(name):
+ util.helper_target(
+ _invalid_extra_link_time_library,
+ name = name + "/library",
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_invalid_extra_link_time_library_impl,
+ target = name + "/library",
+ expect_failure = True,
+ )
+
+def _test_invalid_extra_link_time_library_impl(env, target):
+ env.expect.that_target(target).failures().contains_predicate(
+ matching.custom(
+ "contains 'build_library_func must be a Starlark function'",
+ lambda message: "build_library_func must be a Starlark function" in message,
+ ),
+ )
+
def cc_common_tests(name):
tests = [
_test_same_cc_file_twice,
@@ -732,6 +860,10 @@ def cc_common_tests(name):
]
if bazel_features.cc.cc_common_is_in_rules_cc:
tests.extend([
+ _test_top_level_extra_link_time_library,
+ _test_nested_extra_link_time_library,
+ _test_builtin_extra_link_time_library,
+ _test_none_extra_link_time_library,
_test_strip_include_prefix_uses_virtual_includes_by_default,
_test_strip_include_prefix_no_virtual_includes_when_enabled,
_test_strip_include_prefix_with_include_prefix_uses_virtual_includes,
diff --git a/tests/cc/common/cc_toolchain_include_directories_test.bzl b/tests/cc/common/cc_toolchain_include_directories_test.bzl
new file mode 100644
index 000000000..fdfa88756
--- /dev/null
+++ b/tests/cc/common/cc_toolchain_include_directories_test.bzl
@@ -0,0 +1,37 @@
+"""Tests for the resolution of cxx_builtin_include_directories by cc_toolchain."""
+
+load("@bazel_features//:features.bzl", "bazel_features")
+load("@bazel_skylib//lib:paths.bzl", "paths")
+load("@rules_testing//lib:analysis_test.bzl", "test_suite")
+load("//cc/common:cc_common.bzl", "cc_common")
+load("//tests/cc/testutil:cc_analysis_test.bzl", "cc_analysis_test")
+
+# buildifier: disable=unused-variable
+def _test_package_include_directories_use_toolchain_repo_mapping(name):
+ cc_analysis_test(
+ name = name,
+ impl = _test_package_include_directories_use_toolchain_repo_mapping_impl,
+ target = "@cross_repo_test//toolchain_include_dirs:toolchain",
+ )
+
+def _test_package_include_directories_use_toolchain_repo_mapping_impl(env, target):
+ test_repo_root = Label("@cross_repo_test//toolchain_include_dirs:toolchain").workspace_root
+ rules_cc_root = Label("//cc:BUILD").workspace_root
+ env.expect.that_collection(
+ target[cc_common.CcToolchainInfo].built_in_include_directories,
+ ).contains_exactly([
+ paths.join(test_repo_root, "toolchain_include_dirs/include"),
+ paths.join(test_repo_root, "toolchain_include_dirs/other"),
+ paths.join(rules_cc_root, "cc"),
+ ]).in_order()
+
+def cc_toolchain_include_directories_tests(name):
+ tests = []
+ if bazel_features.cc.cc_common_is_in_rules_cc:
+ tests.append(_test_package_include_directories_use_toolchain_repo_mapping) # copybara-uncomment-this-please
+ # pass # copybara-comment-this-out-please
+
+ test_suite(
+ name = name,
+ tests = tests,
+ )
diff --git a/tests/cc/common/debug_info_packaging_test.bzl b/tests/cc/common/debug_info_packaging_test.bzl
index 662b9c721..3f70ed221 100644
--- a/tests/cc/common/debug_info_packaging_test.bzl
+++ b/tests/cc/common/debug_info_packaging_test.bzl
@@ -1,10 +1,12 @@
"""Tests for debug info packaging (Fission)."""
+load("@bazel_features//:features.bzl", "bazel_features")
load("@rules_testing//lib:analysis_test.bzl", "test_suite")
load("@rules_testing//lib:truth.bzl", "subjects")
load("@rules_testing//lib:util.bzl", "util")
load("//cc:cc_binary.bzl", "cc_binary")
load("//cc:cc_library.bzl", "cc_library")
+load("//cc:cc_test.bzl", "cc_test")
load("//tests/cc/testutil:cc_analysis_test.bzl", "cc_analysis_test")
load("//tests/cc/testutil/toolchains:features.bzl", "FEATURE_NAMES")
@@ -116,7 +118,7 @@ def _test_dwp_action_structure_impl(env, target):
)
dwo_files.contains_exactly([expected_dwo])
-def _create_dwo_input_set_tree(name, linkstatic):
+def _create_dwo_input_set_tree(name, linkstatic, rule_under_test = cc_binary):
util.empty_file(name + "_lib1.cc")
util.empty_file(name + "_lib2.cc")
util.empty_file(name + "_lib_pregen.o")
@@ -143,7 +145,7 @@ def _create_dwo_input_set_tree(name, linkstatic):
name = name + "_empty_lib",
)
util.helper_target(
- cc_binary,
+ rule_under_test,
name = name + "_binary",
srcs = [
name + "_main.cc",
@@ -169,6 +171,15 @@ def _get_dwo_files_subject(env, target, dwp_path):
dwo_files.append(sf.short_path)
return env.expect.that_collection(dwo_files)
+def _get_dwo_files_output_group_subject(env, target):
+ package_prefix = target.label.package + "/"
+ dwo_files = [
+ f.short_path
+ for f in target[OutputGroupInfo].dwo_files.to_list()
+ if f.short_path.startswith(package_prefix)
+ ]
+ return env.expect.that_collection(dwo_files)
+
def _test_dwo_input_set_pic_mode(name):
"""Tests that the set of input .dwo files is as expected.
@@ -248,15 +259,355 @@ def _test_dwo_input_set_dynamic_mode_impl(env, target):
dwo_files.contains_exactly([expected_main])
+def _test_empty_inputs_in_fission_mode(name):
+ """Tests that a fission build with no .dwo inputs from the target package doesn't contribute any .dwo files.
+
+ Note: When there are zero .dwo inputs overall (as in OSS Bazel, where _stl defaults to None),
+ the .dwp action is optimized to an empty FileWrite. When implicit runtime dependencies such as
+ _stl contribute non-package .dwo files, CcGenerateDwp is created and we verify no package-scoped
+ .dwo files are included.
+ """
+ util.helper_target(
+ cc_library,
+ name = name + "_test_malloc",
+ srcs = [name + "_test_malloc_prebuilt.o"],
+ )
+ util.helper_target(
+ cc_library,
+ name = name + "_empty_lib",
+ )
+ util.helper_target(
+ cc_binary,
+ name = name + "_fission",
+ srcs = [name + "_prebuilt.o"],
+ link_extra_lib = name + "_empty_lib", # copybara:strip
+ malloc = name + "_test_malloc",
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_empty_inputs_in_fission_mode_impl,
+ target = name + "_fission",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_empty_inputs_in_fission_mode_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ action = env.expect.that_target(target).action_generating(dwp_path)
+
+ mnemonic = action.actual.mnemonic
+ if mnemonic == "CcGenerateDwp":
+ # Implicit runtime dependencies (such as _stl) can transitively contribute
+ # non-package .dwo inputs, causing CcGenerateDwp to be emitted.
+ dwo_files = _get_dwo_files_subject(env, target, dwp_path)
+ dwo_files.is_empty()
+ elif mnemonic == "FileWrite":
+ # Zero .dwo inputs overall: DWP generation is optimized to an empty FileWrite.
+ action.content().equals("")
+ else:
+ env.fail("Expected DWP action mnemonic to be 'CcGenerateDwp' or 'FileWrite', but got '%s'" % mnemonic)
+
+def _test_dwo_input_set_non_pic_mode(name):
+ """Same as _test_dwo_input_set_pic_mode, but for non-pic-mode linking.
+
+ That means .o files are linked in over their .pic.o counterparts and the
+ .dwo inputs should reflect this change.
+ """
+ _create_dwo_input_set_tree(name, linkstatic = True)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_input_set_non_pic_mode_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:fission": "yes",
+ },
+ )
+
+def _test_dwo_input_set_non_pic_mode_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ dwo_files = _get_dwo_files_subject(env, target, dwp_path)
+
+ pkg = target.label.package
+ prefix = target.label.name.replace("_binary", "")
+ lib_target = prefix + "_lib"
+ malloc_target = prefix + "_test_malloc"
+ bin_target = prefix + "_binary"
+
+ expected_templates = [
+ "{pkg}/_objs/{lib}/{prefix}_lib1.dwo",
+ "{pkg}/_objs/{lib}/{prefix}_lib2.dwo",
+ "{pkg}/_objs/{malloc}/{prefix}_test_malloc.dwo",
+ "{pkg}/_objs/{bin}/{prefix}_main.dwo",
+ ]
+ expected = [t.format(pkg = pkg, lib = lib_target, malloc = malloc_target, bin = bin_target, prefix = prefix) for t in expected_templates]
+ dwo_files.contains_exactly(expected)
+
+def _test_dwo_input_set_no_pic_for_binaries_mode(name):
+ """Same as _test_dwo_input_set_pic_mode, but for pic-mode configurations where binaries are specially linked without pic.
+
+ See CppConfiguration#usePicForBinaries
+ """
+ _create_dwo_input_set_tree(name, linkstatic = True)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_input_set_no_pic_for_binaries_mode_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:fission": "yes",
+ "//command_line_option:compilation_mode": "opt",
+ },
+ )
+
+def _test_dwo_input_set_no_pic_for_binaries_mode_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ dwo_files = _get_dwo_files_subject(env, target, dwp_path)
+
+ pkg = target.label.package
+ prefix = target.label.name.replace("_binary", "")
+ lib_target = prefix + "_lib"
+ malloc_target = prefix + "_test_malloc"
+ bin_target = prefix + "_binary"
+
+ expected_templates = [
+ "{pkg}/_objs/{lib}/{prefix}_lib1.dwo",
+ "{pkg}/_objs/{lib}/{prefix}_lib2.dwo",
+ "{pkg}/_objs/{malloc}/{prefix}_test_malloc.dwo",
+ "{pkg}/_objs/{bin}/{prefix}_main.dwo",
+ ]
+ expected = [t.format(pkg = pkg, lib = lib_target, malloc = malloc_target, bin = bin_target, prefix = prefix) for t in expected_templates]
+ dwo_files.contains_exactly(expected)
+
+def _create_custom_malloc_tree(name):
+ _create_dwo_input_set_tree(name, linkstatic = True)
+ util.helper_target(
+ cc_library,
+ name = name + "_custom_malloc",
+ srcs = [name + "_custom_malloc.cc"],
+ )
+
+def _test_dwo_input_set_custom_malloc(name):
+ """Tests that when --custom_malloc overrides a rule's default malloc, the custom malloc is the one that makes it into the input set."""
+ _create_custom_malloc_tree(name)
+ custom_malloc_label = Label("//{}:{}_custom_malloc".format(native.package_name(), name))
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_input_set_custom_malloc_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ "//command_line_option:custom_malloc": custom_malloc_label,
+ },
+ )
+
+def _test_dwo_input_set_custom_malloc_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ dwo_files = _get_dwo_files_subject(env, target, dwp_path)
+
+ pkg = target.label.package
+ prefix = target.label.name.replace("_binary", "")
+ lib_target = prefix + "_lib"
+ malloc_target = prefix + "_custom_malloc"
+ bin_target = prefix + "_binary"
+
+ expected_templates = [
+ "{pkg}/_objs/{lib}/{prefix}_lib1.pic.dwo",
+ "{pkg}/_objs/{lib}/{prefix}_lib2.pic.dwo",
+ "{pkg}/_objs/{malloc}/{prefix}_custom_malloc.pic.dwo",
+ "{pkg}/_objs/{bin}/{prefix}_main.pic.dwo",
+ ]
+ expected = [t.format(pkg = pkg, lib = lib_target, malloc = malloc_target, bin = bin_target, prefix = prefix) for t in expected_templates]
+ dwo_files.contains_exactly(expected)
+
+def _test_dwo_files_output_group_dbg_static_mode(name):
+ """Tests that the dwo_files output group contains direct and transitive .dwo files in dbg static mode."""
+ _create_dwo_input_set_tree(name, linkstatic = True)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_dbg_static_mode_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_dbg_static_mode_impl(env, target):
+ dwo_files = _get_dwo_files_output_group_subject(env, target)
+
+ pkg = target.label.package
+ prefix = target.label.name.replace("_binary", "")
+ lib_target = prefix + "_lib"
+ malloc_target = prefix + "_test_malloc"
+ bin_target = prefix + "_binary"
+
+ expected = [
+ "{pkg}/_objs/{lib}/{prefix}_lib1.pic.dwo".format(pkg = pkg, lib = lib_target, prefix = prefix),
+ "{pkg}/_objs/{lib}/{prefix}_lib2.pic.dwo".format(pkg = pkg, lib = lib_target, prefix = prefix),
+ "{pkg}/_objs/{malloc}/{prefix}_test_malloc.pic.dwo".format(pkg = pkg, malloc = malloc_target, prefix = prefix),
+ "{pkg}/_objs/{bin}/{prefix}_main.pic.dwo".format(pkg = pkg, bin = bin_target, prefix = prefix),
+ ]
+ dwo_files.contains_exactly(expected)
+
+def _test_dwo_files_output_group_dbg_dynamic_mode(name):
+ """Tests that the dwo_files output group contains only direct .dwo files in dbg dynamic mode."""
+ _create_dwo_input_set_tree(name, linkstatic = False)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_dbg_dynamic_mode_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_dbg_dynamic_mode_impl(env, target):
+ dwo_files = _get_dwo_files_output_group_subject(env, target)
+
+ pkg = target.label.package
+ prefix = target.label.name.replace("_binary", "")
+ bin_target = prefix + "_binary"
+ expected_main = "{pkg}/_objs/{bin}/{prefix}_main.pic.dwo".format(pkg = pkg, bin = bin_target, prefix = prefix)
+
+ dwo_files.contains_exactly([expected_main])
+
+def _test_dwo_files_output_group_fission_disabled(name):
+ """Tests that the dwo_files output group is empty when fission is disabled."""
+ _create_fission_binary(name)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_empty_impl,
+ target = name + "_fission",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "no",
+ },
+ )
+
+def _test_dwo_files_output_group_non_dbg_mode(name):
+ """Tests that the dwo_files output group is empty in non-dbg builds even when fission is enabled."""
+ _create_fission_binary(name)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_empty_impl,
+ target = name + "_fission",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:compilation_mode": "opt",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_empty_impl(env, target):
+ env.expect.that_target(target).output_group("dwo_files").is_empty()
+
+def _test_dwo_files_output_group_cc_test_static_with_build_test_dwp(name):
+ """Tests that a statically linked cc_test with --build_test_dwp builds a .dwp and leaves dwo_files empty."""
+ _create_dwo_input_set_tree(name, linkstatic = True, rule_under_test = cc_test)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_cc_test_static_with_build_test_dwp_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:build_test_dwp": True,
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_cc_test_static_with_build_test_dwp_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ env.expect.that_target(target).default_outputs().contains(dwp_path)
+ env.expect.that_target(target).output_group("dwo_files").is_empty()
+
+def _test_dwo_files_output_group_cc_test_static_without_build_test_dwp(name):
+ """Tests that a statically linked cc_test with --nobuild_test_dwp populates the dwo_files output group."""
+ _create_dwo_input_set_tree(name, linkstatic = True, rule_under_test = cc_test)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_cc_test_static_without_build_test_dwp_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:build_test_dwp": False,
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_cc_test_static_without_build_test_dwp_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ env.expect.that_target(target).default_outputs().not_contains(dwp_path)
+ _test_dwo_files_output_group_dbg_static_mode_impl(env, target)
+
+def _test_dwo_files_output_group_cc_test_dynamic_with_build_test_dwp(name):
+ """Tests that a dynamically linked cc_test populates the dwo_files output group even with --build_test_dwp."""
+ _create_dwo_input_set_tree(name, linkstatic = False, rule_under_test = cc_test)
+ cc_analysis_test(
+ name = name,
+ impl = _test_dwo_files_output_group_cc_test_dynamic_with_build_test_dwp_impl,
+ target = name + "_binary",
+ with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.per_object_debug_info],
+ config_settings = {
+ "//command_line_option:build_test_dwp": True,
+ "//command_line_option:compilation_mode": "dbg",
+ "//command_line_option:fission": "yes",
+ "//command_line_option:force_pic": True,
+ },
+ )
+
+def _test_dwo_files_output_group_cc_test_dynamic_with_build_test_dwp_impl(env, target):
+ executable = target[DefaultInfo].files_to_run.executable
+ dwp_path = executable.short_path + ".dwp"
+ env.expect.that_target(target).default_outputs().not_contains(dwp_path)
+ _test_dwo_files_output_group_dbg_dynamic_mode_impl(env, target)
+
def debug_info_packaging_tests(name):
+ tests = [
+ _test_dwp_output_names,
+ _test_dwp_builds_require_fission_mode_disabled,
+ _test_dwp_builds_require_fission_mode_enabled,
+ _test_dwp_action_structure,
+ _test_dwo_input_set_pic_mode,
+ _test_dwo_input_set_dynamic_mode,
+ _test_empty_inputs_in_fission_mode,
+ _test_dwo_input_set_non_pic_mode,
+ _test_dwo_input_set_no_pic_for_binaries_mode,
+ _test_dwo_input_set_custom_malloc,
+ ]
+ if bazel_features.cc.cc_common_is_in_rules_cc:
+ tests.extend([
+ _test_dwo_files_output_group_dbg_static_mode,
+ _test_dwo_files_output_group_dbg_dynamic_mode,
+ _test_dwo_files_output_group_fission_disabled,
+ _test_dwo_files_output_group_non_dbg_mode,
+ _test_dwo_files_output_group_cc_test_static_with_build_test_dwp,
+ _test_dwo_files_output_group_cc_test_static_without_build_test_dwp,
+ _test_dwo_files_output_group_cc_test_dynamic_with_build_test_dwp,
+ ])
test_suite(
name = name,
- tests = [
- _test_dwp_output_names,
- _test_dwp_builds_require_fission_mode_disabled,
- _test_dwp_builds_require_fission_mode_enabled,
- _test_dwp_action_structure,
- _test_dwo_input_set_pic_mode,
- _test_dwo_input_set_dynamic_mode,
- ],
+ tests = tests,
)
diff --git a/tests/cc/common/disallowed_copts_test.bzl b/tests/cc/common/disallowed_copts_test.bzl
index 1ad8441d1..6384acb3a 100644
--- a/tests/cc/common/disallowed_copts_test.bzl
+++ b/tests/cc/common/disallowed_copts_test.bzl
@@ -6,7 +6,7 @@ load("@rules_testing//lib:truth.bzl", "matching")
load("@rules_testing//lib:util.bzl", "util")
load("//cc:cc_binary.bzl", "cc_binary")
load("//cc:cc_library.bzl", "cc_library")
-load("//tests/cc/testutil:cc_analysis_test.bzl", "MOCK_ALLOWLIST_TOOLCHAINS", "MOCK_EMPTY_ALLOWLIST_TOOLCHAINS", "cc_analysis_test")
+load("//tests/cc/testutil:cc_analysis_test.bzl", "MOCK_ALLOWLIST_TOOLCHAINS", "MOCK_EMPTY_ALLOWLIST_TOOLCHAINS", "MOCK_TARGET_ALLOWLIST_TOOLCHAINS", "cc_analysis_test")
def _test_pass_impl(_env, _target):
pass
@@ -19,7 +19,9 @@ def _test_fail_impl(env, target):
def _test_fail_empty_toolchain_allowlist_impl(env, target):
env.expect.that_target(target).failures().contains_predicate(
matching.contains(
- "- Flag '-Wno-error' (target is not in the allowlist '//custom:toolchain_allowlist'): Custom warning policy guidance.",
+ "- Flag '-Wno-error' in attribute 'copts' disallowed by '{}': Custom warning policy guidance.".format(
+ Label("//tests/cc/testutil/toolchains:k8-compiler_config_with_empty_allowlist"),
+ ),
),
)
@@ -111,6 +113,22 @@ def _test_no_copts_target_passes(name, **kwargs):
**kwargs
)
+def _test_disallowed_copt_in_toolchain_target_allowlist_passes(name, **kwargs):
+ util.helper_target(
+ cc_library,
+ name = name + "/test",
+ copts = ["-Wno-error"],
+ )
+ cc_analysis_test(
+ name = name,
+ impl = _test_pass_impl,
+ target = name + "/test",
+ config_settings = {
+ "//command_line_option:extra_toolchains": ",".join(MOCK_TARGET_ALLOWLIST_TOOLCHAINS),
+ },
+ **kwargs
+ )
+
def disallowed_copts_tests(name):
test_suite(
name = name,
@@ -118,6 +136,7 @@ def disallowed_copts_tests(name):
_test_disallowed_copt_fails,
_test_disallowed_copt_in_toolchain_allowlist_passes,
_test_disallowed_copt_cc_binary_in_toolchain_allowlist_passes,
+ _test_disallowed_copt_in_toolchain_target_allowlist_passes,
_test_disallowed_copt_with_empty_toolchain_allowlist_fails,
_test_valid_warning_passes,
_test_no_copts_target_passes,
diff --git a/tests/cc/testutil/cc_analysis_test.bzl b/tests/cc/testutil/cc_analysis_test.bzl
index 5557975f8..53fb8566c 100644
--- a/tests/cc/testutil/cc_analysis_test.bzl
+++ b/tests/cc/testutil/cc_analysis_test.bzl
@@ -16,6 +16,10 @@ MOCK_EMPTY_ALLOWLIST_TOOLCHAINS = [
"//tests/cc/testutil/toolchains:cc-toolchain-k8-with-empty-allowlist",
]
+MOCK_TARGET_ALLOWLIST_TOOLCHAINS = [
+ "//tests/cc/testutil/toolchains:cc-toolchain-k8-with-target-allowlist",
+]
+
def cc_analysis_test(name, with_features = None, test_features = [], with_action_configs = [], **kwargs):
"""Runs an analysis_test with the a mock C++ toolchain.
diff --git a/tests/cc/testutil/toolchains/BUILD b/tests/cc/testutil/toolchains/BUILD
index 3c750cdf1..0b65bf396 100644
--- a/tests/cc/testutil/toolchains/BUILD
+++ b/tests/cc/testutil/toolchains/BUILD
@@ -59,6 +59,11 @@ string_flag(
build_setting_default = "",
)
+string_list_flag(
+ name = "dynamic_library_pattern",
+ build_setting_default = [],
+)
+
# "everything" is a filegroup that the implementation of --grte_top (more specifically, the
# LibcTopLabelConverter in
# third_party/bazel/src/main/java/com/google/devtools/build/lib/rules/cpp/CppOptions.java)
@@ -449,7 +454,6 @@ cc_toolchain_config(
abi_version = "local",
action_configs = ["c++-header-analysis"],
allowlist_provider = ":mock_allowlist",
- allowlist_target_label = "//custom:toolchain_allowlist",
artifact_name_patterns = {},
builtin_sysroot = "/usr/grte/v1",
cc_target_os = "",
@@ -497,7 +501,6 @@ cc_toolchain_config(
abi_version = "local",
action_configs = ["c++-header-analysis"],
allowlist_provider = ":empty_mock_allowlist",
- allowlist_target_label = "//custom:toolchain_allowlist",
artifact_name_patterns = {},
builtin_sysroot = "/usr/grte/v1",
cc_target_os = "",
@@ -539,3 +542,52 @@ toolchain(
toolchain = ":cc-compiler-k8-with-empty-allowlist",
toolchain_type = "//cc:toolchain_type",
)
+
+cc_toolchain_config(
+ name = "k8-compiler_config_with_target_allowlist",
+ abi_libc_version = "local",
+ abi_version = "local",
+ action_configs = ["c++-header-analysis"],
+ artifact_name_patterns = {},
+ builtin_sysroot = "/usr/grte/v1",
+ cc_target_os = "",
+ compiler = "compiler",
+ cpu = "k8",
+ cxx_builtin_include_directories = [],
+ feature_names = [],
+ host_system_name = "local",
+ make_variables = {},
+ target_allowlist = [
+ "//tests/cc/common:test_disallowed_copt_in_toolchain_target_allowlist_passes/test",
+ ],
+ target_libc = "local",
+ target_system_name = "local",
+ tool_paths = {},
+ toolchain_identifier = "mock-toolchain-k8",
+)
+
+cc_toolchain(
+ name = "cc-compiler-k8-with-target-allowlist",
+ all_files = ":every-file",
+ ar_files = "ar-k8",
+ as_files = "as-k8",
+ compiler_files = "compile-k8",
+ compiler_files_without_includes = "compile-without-includes-k8",
+ coverage_files = "coverage-file",
+ dwp_files = "dwp-k8",
+ licenses = ["unencumbered"],
+ linker_files = "link-k8",
+ module_map = "crosstool.cppmap",
+ objcopy_files = "objcopy-k8",
+ output_licenses = ["unencumbered"],
+ strip_files = ":every-file",
+ supports_header_parsing = 1,
+ toolchain_config = ":k8-compiler_config_with_target_allowlist",
+ toolchain_identifier = "mock-toolchain-k8",
+)
+
+toolchain(
+ name = "cc-toolchain-k8-with-target-allowlist",
+ toolchain = ":cc-compiler-k8-with-target-allowlist",
+ toolchain_type = "//cc:toolchain_type",
+)
diff --git a/tests/cc/testutil/toolchains/additional_toolchains.bzl b/tests/cc/testutil/toolchains/additional_toolchains.bzl
index 1a8320cb7..0b2f7c67d 100644
--- a/tests/cc/testutil/toolchains/additional_toolchains.bzl
+++ b/tests/cc/testutil/toolchains/additional_toolchains.bzl
@@ -1,6 +1,9 @@
"""Additional mock toolchains besides the mock C++ toolchain."""
def mock_additional_toolchains():
+ # type: () -> None
pass
-ADDITIONAL_MOCK_TOOLCHAINS = []
+# TODO(https://github.com/bazelbuild/bazel/pull/30373): Use a variable annotation
+# when Bazel 8.8 is the minimum supported version.
+ADDITIONAL_MOCK_TOOLCHAINS = [] # type: list[str]
diff --git a/tests/cc/testutil/toolchains/cc_toolchain_config.bzl b/tests/cc/testutil/toolchains/cc_toolchain_config.bzl
index 3ed8bbb70..60c332531 100644
--- a/tests/cc/testutil/toolchains/cc_toolchain_config.bzl
+++ b/tests/cc/testutil/toolchains/cc_toolchain_config.bzl
@@ -2057,6 +2057,9 @@ def _impl(ctx):
object_file_extension = ctx.attr._object_file_extension[BuildSettingInfo].value
if object_file_extension:
artifact_name_patterns.append(_get_artifact_name_pattern("object_file", "", object_file_extension))
+ dynamic_library_pattern = ctx.attr._dynamic_library_pattern[BuildSettingInfo].value
+ if dynamic_library_pattern:
+ artifact_name_patterns.append(_get_artifact_name_pattern("dynamic_library", dynamic_library_pattern[0], dynamic_library_pattern[1]))
action_configs = []
@@ -2106,11 +2109,12 @@ def _impl(ctx):
extra_args = {}
if bazel_features.cc.cc_common_is_in_rules_cc:
allowlist = ctx.attr.allowlist_provider[PackageSpecificationInfo] if ctx.attr.allowlist_provider != None else None
- allowlist_target_label = ctx.attr.allowlist_target_label or (str(ctx.attr.allowlist_provider.label) if ctx.attr.allowlist_provider else None)
extra_args["disallowed_copts_infos"] = [struct(
flags = ctx.attr.disallowed_copts,
+ package_allowlist = allowlist,
allowlist = allowlist,
- allowlist_target_label = allowlist_target_label,
+ target_allowlist = ctx.attr.target_allowlist if ctx.attr.target_allowlist else None,
+ policy_label = str(ctx.label),
error_message = ctx.attr.error_message or None,
)]
@@ -2156,7 +2160,7 @@ cc_toolchain_config = rule(
"artifact_name_patterns": attr.string_list_dict(),
"disallowed_copts": attr.string_list(default = ["-w", "-Wno-error"]),
"allowlist_provider": attr.label(providers = [PackageSpecificationInfo]),
- "allowlist_target_label": attr.string(),
+ "target_allowlist": attr.string_list(),
"error_message": attr.string(),
"cc_target_os": attr.string(),
"builtin_sysroot": attr.string(default = "/usr/grte/v1"),
@@ -2166,6 +2170,7 @@ cc_toolchain_config = rule(
"_with_features": attr.label(default = Label("//tests/cc/testutil/toolchains:with_features")),
"_with_action_configs": attr.label(default = Label("//tests/cc/testutil/toolchains:with_action_configs")),
"_object_file_extension": attr.label(default = Label("//tests/cc/testutil/toolchains:object_file_extension")),
+ "_dynamic_library_pattern": attr.label(default = Label("//tests/cc/testutil/toolchains:dynamic_library_pattern")),
},
provides = [CcToolchainConfigInfo],
executable = True,
diff --git a/tests/coverage/BUILD.bazel b/tests/coverage/BUILD.bazel
new file mode 100644
index 000000000..c7cc95327
--- /dev/null
+++ b/tests/coverage/BUILD.bazel
@@ -0,0 +1,9 @@
+load("@rules_shell//shell:sh_test.bzl", "sh_test")
+
+sh_test(
+ name = "collect_cc_coverage_test",
+ size = "small",
+ srcs = ["collect_cc_coverage_test.sh"],
+ data = ["//cc/coverage:srcs"],
+ target_compatible_with = ["@platforms//os:linux"],
+)
diff --git a/tests/coverage/collect_cc_coverage_test.sh b/tests/coverage/collect_cc_coverage_test.sh
new file mode 100755
index 000000000..3f380038a
--- /dev/null
+++ b/tests/coverage/collect_cc_coverage_test.sh
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Copyright 2026 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.
+
+set -euo pipefail
+
+readonly SCRIPT="${TEST_SRCDIR}/${TEST_WORKSPACE}/cc/coverage/collect_cc_coverage.sh"
+readonly WORK_DIR="$(mktemp -d "${TEST_TMPDIR:-/tmp}/cc-coverage-args.XXXXXXXX")"
+trap 'rm -rf "${WORK_DIR}"' EXIT
+
+mkdir -p "${WORK_DIR}/coverage" "${WORK_DIR}/object files"
+readonly OBJECT_WITH_SPACE="${WORK_DIR}/object files/runtime.o"
+readonly SECOND_OBJECT="${WORK_DIR}/second.o"
+touch "${WORK_DIR}/coverage/coverage.profraw" "${OBJECT_WITH_SPACE}" "${SECOND_OBJECT}"
+printf '%s\n' "${OBJECT_WITH_SPACE}" "${SECOND_OBJECT}" > "${WORK_DIR}/runtime_objects_list.txt"
+printf '%s\n' "${WORK_DIR}/runtime_objects_list.txt" > "${WORK_DIR}/manifest.txt"
+
+cat > "${WORK_DIR}/llvm-profdata" <<'EOF'
+#!/usr/bin/env bash
+set -euo pipefail
+[[ "$#" -eq 4 && "$1" == merge && "$2" == -output ]]
+touch "$3"
+EOF
+
+cat > "${WORK_DIR}/llvm-cov" <<'EOF'
+#!/usr/bin/env bash
+set -euo pipefail
+printf '%s\n' "$@" > "${LLVM_COV_ARGS}"
+printf 'TN:\n'
+EOF
+chmod +x "${WORK_DIR}/llvm-profdata" "${WORK_DIR}/llvm-cov"
+
+COVERAGE_DIR="${WORK_DIR}/coverage" \
+COVERAGE_MANIFEST="${WORK_DIR}/manifest.txt" \
+GENERATE_LLVM_LCOV=1 \
+LLVM_PROFDATA="${WORK_DIR}/llvm-profdata" \
+LLVM_COV="${WORK_DIR}/llvm-cov" \
+LLVM_COV_ARGS="${WORK_DIR}/llvm-cov.args" \
+ bash "${SCRIPT}"
+
+printf '%s\n' \
+ export \
+ -instr-profile "${WORK_DIR}/coverage/_cc_coverage.dat.data" \
+ -format=lcov \
+ '-ignore-filename-regex=^/tmp/.+' \
+ -object "${OBJECT_WITH_SPACE}" \
+ -object "${SECOND_OBJECT}" > "${WORK_DIR}/expected.args"
+diff -u "${WORK_DIR}/expected.args" "${WORK_DIR}/llvm-cov.args"
diff --git a/tests/generated_tool_path/BUILD.bazel b/tests/generated_tool_path/BUILD.bazel
new file mode 100644
index 000000000..e2eb86cc4
--- /dev/null
+++ b/tests/generated_tool_path/BUILD.bazel
@@ -0,0 +1,61 @@
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("//cc/toolchains:cc_toolchain.bzl", "cc_toolchain")
+load("//cc/toolchains:cc_toolchain_alias.bzl", "cc_toolchain_alias")
+load(":generated_tool_path_test.bzl", "generated_tool_cc_toolchain_config", "maybe_define_generated_tool_path_targets")
+
+package(default_visibility = ["//visibility:private"])
+
+constraint_setting(name = "toolchain_selector")
+
+constraint_value(
+ name = "use_test_toolchain",
+ constraint_setting = ":toolchain_selector",
+)
+
+platform(
+ name = "test_platform",
+ constraint_values = [":use_test_toolchain"],
+)
+
+filegroup(name = "empty")
+
+# A compiler wrapper generated by the build, as used by e.g. the Apple C++ toolchain.
+write_file(
+ name = "gcc",
+ out = "gcc.sh",
+ content = [
+ "#!/bin/sh",
+ "exit 0",
+ ],
+ is_executable = True,
+)
+
+generated_tool_cc_toolchain_config(
+ name = "config",
+ gcc = ":gcc",
+)
+
+cc_toolchain(
+ name = "cc_toolchain",
+ all_files = ":gcc",
+ ar_files = ":empty",
+ as_files = ":empty",
+ compiler_files = ":gcc",
+ dwp_files = ":empty",
+ linker_files = ":empty",
+ objcopy_files = ":empty",
+ strip_files = ":empty",
+ toolchain_config = ":config",
+ toolchain_identifier = "generated-tool-path-test",
+)
+
+toolchain(
+ name = "cc_toolchain_registration",
+ target_compatible_with = [":use_test_toolchain"],
+ toolchain = ":cc_toolchain",
+ toolchain_type = "//cc:toolchain_type",
+)
+
+cc_toolchain_alias(name = "current_cc_toolchain")
+
+maybe_define_generated_tool_path_targets()
diff --git a/tests/generated_tool_path/generated_tool_path_test.bzl b/tests/generated_tool_path/generated_tool_path_test.bzl
new file mode 100644
index 000000000..02b5784e5
--- /dev/null
+++ b/tests/generated_tool_path/generated_tool_path_test.bzl
@@ -0,0 +1,72 @@
+"""Analysis test for tool paths that refer to files generated by the build."""
+
+load("@bazel_features//:features.bzl", "bazel_features")
+load("@rules_testing//lib:analysis_test.bzl", "analysis_test")
+load("//cc:cc_toolchain_config_lib.bzl", "tool_path") # buildifier: disable=deprecated-function
+load("//cc/common:cc_common.bzl", "cc_common")
+
+def _generated_tool_cc_toolchain_config_impl(ctx):
+ return cc_common.create_cc_toolchain_config_info(
+ ctx = ctx,
+ toolchain_identifier = "generated-tool-path-test",
+ host_system_name = "local",
+ target_system_name = "local",
+ target_cpu = "k8",
+ target_libc = "local",
+ compiler = "compiler",
+ abi_version = "local",
+ abi_libc_version = "local",
+ tool_paths = [
+ # The path of a generated file is relative to the execution root rather than to the
+ # package of the toolchain.
+ tool_path(name = "gcc", path = ctx.file.gcc.path),
+ tool_path(name = "ar", path = "/usr/bin/ar"),
+ tool_path(name = "cpp", path = "/usr/bin/cpp"),
+ tool_path(name = "ld", path = "/usr/bin/ld"),
+ tool_path(name = "nm", path = "/usr/bin/nm"),
+ tool_path(name = "objdump", path = "/usr/bin/objdump"),
+ tool_path(name = "strip", path = "/usr/bin/strip"),
+ ],
+ )
+
+generated_tool_cc_toolchain_config = rule(
+ implementation = _generated_tool_cc_toolchain_config_impl,
+ attrs = {
+ "gcc": attr.label(
+ allow_single_file = True,
+ mandatory = True,
+ ),
+ },
+)
+
+def _generated_tool_path_test_impl(env, target):
+ all_files = target[cc_common.CcToolchainInfo].all_files.to_list()
+ gcc = [file for file in all_files if file.basename == "gcc.sh"]
+ env.expect.that_collection(gcc).has_size(1)
+ cc = target[platform_common.TemplateVariableInfo].variables["CC"]
+ env.expect.that_str(cc).equals(gcc[0].path)
+
+def generated_tool_path_test(name, target):
+ analysis_test(
+ name = name,
+ target = target,
+ impl = _generated_tool_path_test_impl,
+ config_settings = {
+ "//command_line_option:extra_toolchains": [
+ Label("//tests/generated_tool_path:cc_toolchain_registration"),
+ ],
+ "//command_line_option:platforms": [
+ Label("//tests/generated_tool_path:test_platform"),
+ ],
+ },
+ )
+
+def maybe_define_generated_tool_path_targets():
+ # cc_toolchain is implemented in rules_cc only for Bazel 9+. For older Bazel versions, the
+ # native rule is used.
+ if not bazel_features.cc.cc_common_is_in_rules_cc:
+ return
+ generated_tool_path_test(
+ name = "generated_tool_path_test",
+ target = ":current_cc_toolchain",
+ )
diff --git a/tests/integration/BUILD b/tests/integration/BUILD
index 02a083ba5..66b49f31f 100644
--- a/tests/integration/BUILD
+++ b/tests/integration/BUILD
@@ -9,19 +9,28 @@ exports_files(
visibility = ["//tests:__subpackages__"],
)
+VERSION_GATE = [] if bazel_features.cc.cc_common_is_in_rules_cc else ["@platforms//:incompatible"] # copybara-uncomment-this-please
+# VERSION_GATE = ["@platforms//:incompatible"] # copybara-comment-this-out-please
+
rules_cc_integration_test(
name = "cc_tests",
shard_count = 4,
test_script = "cc_tests.sh",
)
+rules_cc_integration_test(
+ name = "cc_linking_tests",
+ tags = ["notap"],
+ target_compatible_with = [] if bazel_features.cc.cc_common_is_in_rules_cc else ["@platforms//:incompatible"],
+ test_script = "cc_linking_tests.sh",
+)
+
# Tests migrated from bazelbuild/bazel/src/test/shell/bazel/cc_integration_test.sh
# In a separate file from cc_tests.sh to make migration clearer.
rules_cc_integration_test(
name = "cc_integration_test",
shard_count = 10,
target_compatible_with = select({
- "@platforms//os:macos": ["@platforms//:incompatible"],
"@platforms//os:windows": ["@platforms//:incompatible"],
"//conditions:default": [],
}) if bazel_features.cc.cc_common_is_in_rules_cc else ["@platforms//:incompatible"],
@@ -40,10 +49,7 @@ rules_cc_integration_test(
rules_cc_integration_test(
name = "cc_shared_library_tests",
- # These could probably be made to work on all CI platforms,
- # but the default toolchains are not properly configured for it.
target_compatible_with = select({
- "@platforms//os:macos": ["@platforms//:incompatible"],
"@platforms//os:windows": ["@platforms//:incompatible"],
"//conditions:default": [],
}),
@@ -60,25 +66,20 @@ rules_cc_integration_test(
test_script = "fission_tests.sh",
)
-STATIC_LIBRARY_VERSION_GATE = [] if bazel_features.cc.cc_common_is_in_rules_cc else ["@platforms//:incompatible"] # copybara-uncomment-this-please
-# STATIC_LIBRARY_VERSION_GATE = ["@platforms//:incompatible"] # copybara-comment-this-out-please
-
rules_cc_integration_test(
name = "cc_static_library_failure_tests",
tags = ["notap"],
target_compatible_with = select({
+ # The default Apple toolchain does not provide symbol_check.
"@platforms//os:macos": ["@platforms//:incompatible"],
- "//conditions:default": STATIC_LIBRARY_VERSION_GATE,
+ "//conditions:default": VERSION_GATE,
}),
test_script = "cc_static_library_failure_tests.sh",
)
rules_cc_integration_test(
name = "cc_shared_library_toolchain_tests",
- # These could probably be made to work on all CI platforms,
- # but the default toolchains are not properly configured for it.
target_compatible_with = select({
- "@platforms//os:macos": ["@platforms//:incompatible"],
"@platforms//os:windows": ["@platforms//:incompatible"],
"//conditions:default": [] if _features_ge("9.2.0") else ["@platforms//:incompatible"],
}),
diff --git a/tests/integration/cc_integration_test.sh b/tests/integration/cc_integration_test.sh
index 0945605a5..4b7e39672 100755
--- a/tests/integration/cc_integration_test.sh
+++ b/tests/integration/cc_integration_test.sh
@@ -324,6 +324,10 @@ def _cc_lib_impl(ctx):
language = "c++",
compilation_outputs = compilation_outputs,
linking_contexts = linking_contexts,
+ disallow_dynamic_library = not cc_common.is_enabled(
+ feature_configuration = feature_configuration,
+ feature_name = "supports_dynamic_linker",
+ ),
)
library = linking_outputs.library_to_link
files = []
@@ -789,13 +793,6 @@ EOF
function test_aspect_accessing_args_link_action_with_tree_artifact() {
is_bazel || return 0
- # This test assumes the presence of "nodeps" dynamic libraries, which do not
- # function on Apple platforms.
- if is_darwin; then
- return 0
- fi
-
-
local package="${FUNCNAME[0]}"
mkdir -p "${package}"
cat > "${package}/makes_tree_artifacts.sh" <