Extract the Bazel cc_import rule from @_builtins to @rules_cc

PiperOrigin-RevId: 786644184
Change-Id: I83991e4d83c8700aade3cfee454ef94b8c6ea155

Author: hvadehra

cc/common/cc_helper.bzl

@@ -15,6 +15,15 @@
 
 load("//cc:find_cc_toolchain.bzl", "CC_TOOLCHAIN_TYPE")
 load(":cc_common.bzl", "cc_common")
+load(
+    ":cc_helper_internal.bzl",
+    "get_relative_path",
+    "is_versioned_shared_library_extension_valid",
+    "path_contains_up_level_references",
+    _package_source_root = "package_source_root",
+    _repository_exec_path = "repository_exec_path",
+)
+load(":cc_info.bzl", "CcInfo")
 load(":visibility.bzl", "INTERNAL_VISIBILITY")
 
 visibility(INTERNAL_VISIBILITY)
@@ -27,6 +36,62 @@ linker_mode = struct(
 # LINT.ThenChange(https://github.com/bazelbuild/bazel/blob/master/src/main/starlark/builtins_bzl/common/cc/cc_helper.bzl:linker_mode)
 
 # LINT.IfChange(forked_exports)
+
+def _get_compilation_contexts_from_deps(deps):
+    compilation_contexts = []
+    for dep in deps:
+        if CcInfo in dep:
+            compilation_contexts.append(dep[CcInfo].compilation_context)
+    return compilation_contexts
+
+def _tool_path(cc_toolchain, tool):
+    return cc_toolchain._tool_paths.get(tool, None)
+
+def _get_toolchain_global_make_variables(cc_toolchain):
+    result = {
+        "CC": _tool_path(cc_toolchain, "gcc"),
+        "AR": _tool_path(cc_toolchain, "ar"),
+        "NM": _tool_path(cc_toolchain, "nm"),
+        "LD": _tool_path(cc_toolchain, "ld"),
+        "STRIP": _tool_path(cc_toolchain, "strip"),
+        "C_COMPILER": cc_toolchain.compiler,
+    }  # buildifier: disable=unsorted-dict-items
+
+    obj_copy_tool = _tool_path(cc_toolchain, "objcopy")
+    if obj_copy_tool != None:
+        # objcopy is optional in Crostool.
+        result["OBJCOPY"] = obj_copy_tool
+    gcov_tool = _tool_path(cc_toolchain, "gcov-tool")
+    if gcov_tool != None:
+        # gcovtool is optional in Crostool.
+        result["GCOVTOOL"] = gcov_tool
+
+    libc = cc_toolchain.libc
+    if libc.startswith("glibc-"):
+        # Strip "glibc-" prefix.
+        result["GLIBC_VERSION"] = libc[6:]
+    else:
+        result["GLIBC_VERSION"] = libc
+
+    abi_glibc_version = cc_toolchain._abi_glibc_version
+    if abi_glibc_version != None:
+        result["ABI_GLIBC_VERSION"] = abi_glibc_version
+
+    abi = cc_toolchain._abi
+    if abi != None:
+        result["ABI"] = abi
+
+    result["CROSSTOOLTOP"] = cc_toolchain._crosstool_top_path
+    return result
+
+_SHARED_LIBRARY_EXTENSIONS = ["so", "dll", "dylib", "wasm"]
+
+def _is_valid_shared_library_artifact(shared_library):
+    if (shared_library.extension in _SHARED_LIBRARY_EXTENSIONS):
+        return True
+
+    return is_versioned_shared_library_extension_valid(shared_library.basename)
+
 def _get_static_mode_params_for_dynamic_library_libraries(libs):
     linker_inputs = []
     for lib in libs.to_list():
@@ -285,11 +350,79 @@ def _should_use_pic(ctx, cc_toolchain, feature_configuration):
         )
     )
 
+SYSROOT_FLAG = "--sysroot="
+
+def _contains_sysroot(original_cc_flags, feature_config_cc_flags):
+    if SYSROOT_FLAG in original_cc_flags:
+        return True
+    for flag in feature_config_cc_flags:
+        if SYSROOT_FLAG in flag:
+            return True
+
+    return False
+
+def _get_cc_flags_make_variable(_ctx, feature_configuration, cc_toolchain):
+    original_cc_flags = cc_toolchain._legacy_cc_flags_make_variable
+    sysroot_cc_flag = ""
+    if cc_toolchain.sysroot != None:
+        sysroot_cc_flag = SYSROOT_FLAG + cc_toolchain.sysroot
+
+    build_vars = cc_toolchain._build_variables
+    feature_config_cc_flags = cc_common.get_memory_inefficient_command_line(
+        feature_configuration = feature_configuration,
+        action_name = "cc-flags-make-variable",
+        variables = build_vars,
+    )
+    cc_flags = [original_cc_flags]
+
+    # Only add sysroots flag if nothing else adds sysroot, BUT it must appear
+    # before the feature config flags.
+    if not _contains_sysroot(original_cc_flags, feature_config_cc_flags):
+        cc_flags.append(sysroot_cc_flag)
+    cc_flags.extend(feature_config_cc_flags)
+    return {"CC_FLAGS": " ".join(cc_flags)}
+
+def _package_exec_path(ctx, package, sibling_repository_layout):
+    return get_relative_path(_repository_exec_path(ctx.label.workspace_name, sibling_repository_layout), package)
+
+def _system_include_dirs(ctx, additional_make_variable_substitutions):
+    result = []
+    sibling_repository_layout = ctx.configuration.is_sibling_repository_layout()
+    package = ctx.label.package
+    package_exec_path = _package_exec_path(ctx, package, sibling_repository_layout)
+    package_source_root = _package_source_root(ctx.label.workspace_name, package, sibling_repository_layout)
+    for include in ctx.attr.includes:
+        includes_attr = _expand(ctx, include, additional_make_variable_substitutions)
+        if includes_attr.startswith("/"):
+            continue
+        includes_path = get_relative_path(package_exec_path, includes_attr)
+        if not sibling_repository_layout and path_contains_up_level_references(includes_path):
+            fail("Path references a path above the execution root.", attr = "includes")
+
+        if includes_path == ".":
+            fail("'" + includes_attr + "' resolves to the workspace root, which would allow this rule and all of its " +
+                 "transitive dependents to include any file in your workspace. Please include only" +
+                 " what you need", attr = "includes")
+        result.append(includes_path)
+
+        # We don't need to perform the above checks against out_includes_path again since any errors
+        # must have manifested in includesPath already.
+        out_includes_path = get_relative_path(package_source_root, includes_attr)
+        if (ctx.configuration.has_separate_genfiles_directory()):
+            result.append(get_relative_path(ctx.genfiles_dir.path, out_includes_path))
+        result.append(get_relative_path(ctx.bin_dir.path, out_includes_path))
+    return result
+
 cc_helper = struct(
     create_strip_action = _create_strip_action,
     get_expanded_env = _get_expanded_env,
     get_static_mode_params_for_dynamic_library_libraries = _get_static_mode_params_for_dynamic_library_libraries,
     should_use_pic = _should_use_pic,
     tokenize = _tokenize,
+    is_valid_shared_library_artifact = _is_valid_shared_library_artifact,
+    get_toolchain_global_make_variables = _get_toolchain_global_make_variables,
+    get_cc_flags_make_variable = _get_cc_flags_make_variable,
+    get_compilation_contexts_from_deps = _get_compilation_contexts_from_deps,
+    system_include_dirs = _system_include_dirs,
 )
 # LINT.ThenChange(https://github.com/bazelbuild/bazel/blob/master/src/main/starlark/builtins_bzl/common/cc/cc_helper.bzl:forked_exports)

cc/common/cc_helper_internal.bzl

@@ -0,0 +1,98 @@
+# 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.
+
+"""
+Utility functions for C++ rules that don't depend on cc_common.
+
+Only use those within C++ implementation. The others need to go through cc_common.
+"""
+
+load("@bazel_skylib//lib:paths.bzl", "paths")
+
+# LINT.IfChange(forked_exports)
+
+def is_versioned_shared_library_extension_valid(shared_library_name):
+    """Validates the name against the regex "^.+\\.((so)|(dylib))(\\.\\d\\w*)+$",
+
+    Args:
+        shared_library_name: (str) the name to validate
+
+    Returns:
+        (bool)
+    """
+
+    # must match VERSIONED_SHARED_LIBRARY.
+    for ext in (".so.", ".dylib."):
+        name, _, version = shared_library_name.rpartition(ext)
+        if name and version:
+            version_parts = version.split(".")
+            for part in version_parts:
+                if not part[0].isdigit():
+                    return False
+                for c in part[1:].elems():
+                    if not (c.isalnum() or c == "_"):
+                        return False
+            return True
+    return False
+
+def _is_repository_main(repository):
+    return repository == ""
+
+def package_source_root(repository, package, sibling_repository_layout):
+    """
+    Determines the source root for a given repository and package.
+
+    Args:
+      repository: The repository to get the source root for.
+      package: The package to get the source root for.
+      sibling_repository_layout: Whether the repository layout is a sibling repository layout.
+
+    Returns:
+      The source root for the given repository and package.
+    """
+    if _is_repository_main(repository) or sibling_repository_layout:
+        return package
+    if repository.startswith("@"):
+        repository = repository[1:]
+    return paths.get_relative(paths.get_relative("external", repository), package)
+
+def repository_exec_path(repository, sibling_repository_layout):
+    """
+    Determines the exec path for a given repository.
+
+    Args:
+      repository: The repository to get the exec path for.
+      sibling_repository_layout: Whether the repository layout is a sibling repository layout.
+
+    Returns:
+      The exec path for the given repository.
+    """
+    if _is_repository_main(repository):
+        return ""
+    prefix = "external"
+    if sibling_repository_layout:
+        prefix = ".."
+    if repository.startswith("@"):
+        repository = repository[1:]
+    return paths.get_relative(prefix, repository)
+
+# LINT.ThenChange(https://github.com/bazelbuild/bazel/blob/master/src/main/starlark/builtins_bzl/common/cc/cc_helper_internal.bzl:forked_exports)
+
+def get_relative_path(path_a, path_b):
+    if paths.is_absolute(path_b):
+        return path_b
+    return paths.normalize(paths.join(path_a, path_b))
+
+def path_contains_up_level_references(path):
+    return path.startswith("..") and (len(path) == 2 or path[2] == "/")