skia/toolchain/mac_toolchain_config.bzl

"""
This file specifies a clang toolchain that can run on a Mac host (with either M1 or Intel CPU).

Hermetic toolchains still need access to Xcode for sys headers included in Skia's codebase.

See download_mac_toolchain.bzl for more details on the creation of the toolchain.

It uses the usr subfolder of the built toolchain as a sysroot

It follows the example of:
 - linux_amd64_toolchain_config.bzl
"""

# https://github.com/bazelbuild/bazel/blob/master/tools/build_defs/cc/action_names.bzl
load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")

# https://github.com/bazelbuild/bazel/blob/master/tools/cpp/cc_toolchain_config_lib.bzl
load(
    "@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl",
    "action_config",
    "feature",
    "flag_group",
    "flag_set",
    "tool",
    "variable_with_value",
)
load(":clang_layering_check.bzl", "make_layering_check_features")

# The location of the created clang toolchain.
EXTERNAL_TOOLCHAIN = "external/clang_mac"

# Root of our symlinks. These symlinks are created in download_mac_toolchain.bzl
XCODE_MACSDK_SYMLINK = EXTERNAL_TOOLCHAIN + "/symlinks/xcode/MacSDK"

_platform_constraints_to_import = {
    "@platforms//cpu:arm64": "_arm64_cpu",
    "@platforms//cpu:x86_64": "_x86_64_cpu",
}

def _mac_toolchain_info(ctx):
    action_configs = _make_action_configs()
    features = []
    features += _make_default_flags()
    features += make_layering_check_features()
    features += _make_diagnostic_flags()
    features += _make_target_specific_flags(ctx)

    # https://bazel.build/rules/lib/cc_common#create_cc_toolchain_config_info
    # Note, this rule is defined in Java code, not Starlark
    # https://cs.opensource.google/bazel/bazel/+/master:src/main/java/com/google/devtools/build/lib/starlarkbuildapi/cpp/CcModuleApi.java
    return cc_common.create_cc_toolchain_config_info(
        ctx = ctx,
        features = features,
        action_configs = action_configs,
        builtin_sysroot = EXTERNAL_TOOLCHAIN,
        cxx_builtin_include_directories = [
            # https://stackoverflow.com/a/61419490
            # "If the compiler has --sysroot support, then these paths should use %sysroot%
            #  rather than the include path"
            # https://bazel.build/rules/lib/cc_common#create_cc_toolchain_config_info.cxx_builtin_include_directories
            "%sysroot%/symlinks/xcode/MacSDK/System/Library/Frameworks/",
        ],
        # If `ctx.attr.cpu` is blank (which is declared as optional below), this config will target
        # the host CPU. Specifying a target_cpu allows this config to be used for cross compilation.
        target_cpu = ctx.attr.cpu,
        # These are required, but do nothing
        compiler = "",
        target_libc = "",
        target_system_name = "",
        toolchain_identifier = "",
    )

def _import_platform_constraints():
    # In order to "import" constraint values so they can be passed in as parameters to
    # ctx.target_platform_has_constraint(), we need to list them as a default value on a
    # private attributes. It doesn't really matter what we call these private attributes,
    # but to make it easier to read elsewhere, we create a mapping between the "official"
    # name of the constraints and the private name. Then, we can refer to the official name
    # without having to remember the secondary name.
    # https://bazel.build/rules/rules#private_attributes_and_implicit_dependencies
    # https://github.com/bazelbuild/proposals/blob/91579f36031f768bcf68b18a86b8df8b43cc590b/designs/2019-11-11-target-platform-constraints.md
    rule_attributes = {}
    for constraint in _platform_constraints_to_import:
        private_attr = _platform_constraints_to_import[constraint]
        rule_attributes[private_attr] = attr.label(default = constraint)

    # Define an optional attribute to allow the target architecture to be explicitly specified (e.g.
    # when selecting a cross-compilation toolchain).
    rule_attributes["cpu"] = attr.string(
        mandatory = False,
        values = ["arm64", "x64"],
    )
    return rule_attributes

def _has_platform_constraint(ctx, official_constraint_name):
    # ctx is of type https://bazel.build/rules/lib/ctx
    # This pattern is from
    # https://github.com/bazelbuild/proposals/blob/91579f36031f768bcf68b18a86b8df8b43cc590b/designs/2019-11-11-target-platform-constraints.md
    private_attr = _platform_constraints_to_import[official_constraint_name]
    constraint = getattr(ctx.attr, private_attr)[platform_common.ConstraintValueInfo]
    return ctx.target_platform_has_constraint(constraint)

provide_mac_toolchain_config = rule(
    attrs = _import_platform_constraints(),
    provides = [CcToolchainConfigInfo],
    implementation = _mac_toolchain_info,
)

def _make_action_configs():
    """
    This function sets up the tools needed to perform the various compile/link actions.

    Bazel normally restricts us to referring to (and therefore running) executables/scripts
    that are in this directory (That is EXEC_ROOT/toolchain). However, the executables we want
    to run are brought in via WORKSPACE.bazel and are located in EXEC_ROOT/external/clang....
    Therefore, we make use of "trampoline scripts" that will call the binaries from the
    toolchain directory.

    These action_configs also let us dynamically specify arguments from the Bazel
    environment if necessary (see cpp_link_static_library_action).
    """

    # https://cs.opensource.google/bazel/bazel/+/master:tools/cpp/cc_toolchain_config_lib.bzl;l=435;drc=3b9e6f201a9a3465720aad8712ab7bcdeaf2e5da
    clang_tool = tool(path = "mac_trampolines/clang_trampoline_mac.sh")
    ar_tool = tool(path = "mac_trampolines/ar_trampoline_mac.sh")

    # https://cs.opensource.google/bazel/bazel/+/master:tools/cpp/cc_toolchain_config_lib.bzl;l=488;drc=3b9e6f201a9a3465720aad8712ab7bcdeaf2e5da
    assemble_action = action_config(
        action_name = ACTION_NAMES.assemble,
        tools = [clang_tool],
    )
    c_compile_action = action_config(
        action_name = ACTION_NAMES.c_compile,
        tools = [clang_tool],
    )
    cpp_compile_action = action_config(
        action_name = ACTION_NAMES.cpp_compile,
        tools = [clang_tool],
    )
    objc_compile_action = action_config(
        action_name = ACTION_NAMES.objc_compile,
        tools = [clang_tool],
    )
    objcpp_compile_action = action_config(
        action_name = ACTION_NAMES.objcpp_compile,
        tools = [clang_tool],
    )
    linkstamp_compile_action = action_config(
        action_name = ACTION_NAMES.linkstamp_compile,
        tools = [clang_tool],
    )
    preprocess_assemble_action = action_config(
        action_name = ACTION_NAMES.preprocess_assemble,
        tools = [clang_tool],
    )

    cpp_link_dynamic_library_action = action_config(
        action_name = ACTION_NAMES.cpp_link_dynamic_library,
        tools = [clang_tool],
    )
    cpp_link_executable_action = action_config(
        action_name = ACTION_NAMES.cpp_link_executable,
        # Bazel assumes it is talking to clang when building an executable. There are
        # "-Wl" flags on the command: https://releases.llvm.org/6.0.1/tools/clang/docs/ClangCommandLineReference.html#cmdoption-clang-Wl
        tools = [clang_tool],
    )
    cpp_link_nodeps_dynamic_library_action = action_config(
        action_name = ACTION_NAMES.cpp_link_nodeps_dynamic_library,
        tools = [clang_tool],
    )

    # objc archiver and cpp archiver actions use the same base flags
    common_archive_flags = [
        flag_set(
            flag_groups = [
                flag_group(
                    # https://llvm.org/docs/CommandGuide/llvm-ar.html
                    # [r]eplace existing files or insert them if they already exist,
                    # [c]reate the file if it doesn't already exist
                    # [s]ymbol table should be added
                    # [D]eterministic timestamps should be used
                    flags = ["rcsD", "%{output_execpath}"],
                    # Despite the name, output_execpath just refers to linker output,
                    # e.g. libFoo.a
                    expand_if_available = "output_execpath",
                ),
            ],
        ),
        flag_set(
            flag_groups = [
                flag_group(
                    iterate_over = "libraries_to_link",
                    flag_groups = [
                        flag_group(
                            flags = ["%{libraries_to_link.name}"],
                            expand_if_equal = variable_with_value(
                                name = "libraries_to_link.type",
                                value = "object_file",
                            ),
                        ),
                        flag_group(
                            flags = ["%{libraries_to_link.object_files}"],
                            iterate_over = "libraries_to_link.object_files",
                            expand_if_equal = variable_with_value(
                                name = "libraries_to_link.type",
                                value = "object_file_group",
                            ),
                        ),
                    ],
                    expand_if_available = "libraries_to_link",
                ),
            ],
        ),
        flag_set(
            flag_groups = [
                flag_group(
                    flags = ["@%{linker_param_file}"],
                    expand_if_available = "linker_param_file",
                ),
            ],
        ),
    ]

    # This is the same rule as
    # https://github.com/emscripten-core/emsdk/blob/7f39d100d8cd207094decea907121df72065517e/bazel/emscripten_toolchain/crosstool.bzl#L143
    # By default, there are no flags or libraries passed to the llvm-ar tool, so
    # we need to specify them. The variables mentioned by expand_if_available are defined
    # https://bazel.build/docs/cc-toolchain-config-reference#cctoolchainconfiginfo-build-variables
    cpp_link_static_library_action = action_config(
        action_name = ACTION_NAMES.cpp_link_static_library,
        flag_sets = common_archive_flags,
        tools = [ar_tool],
    )

    action_configs = [
        assemble_action,
        c_compile_action,
        cpp_compile_action,
        cpp_link_dynamic_library_action,
        cpp_link_executable_action,
        cpp_link_nodeps_dynamic_library_action,
        cpp_link_static_library_action,
        linkstamp_compile_action,
        objc_compile_action,
        objcpp_compile_action,
        preprocess_assemble_action,
    ]
    return action_configs

# In addition to pointing the c and cpp compile actions to our toolchain, we also need to set objc
# and objcpp action flags as well. We build .m and .mm files with the objc_library rule, which
# will use the default toolchain if not specified here.
# https://docs.bazel.build/versions/3.3.0/be/objective-c.html#objc_library
#
# Note: These values must be kept in sync with those defined in cmake_exporter.go.
def _make_default_flags():
    """Here we define the flags for certain actions that are always applied.

    For any flag that might be conditionally applied, it should be defined in //bazel/copts.bzl.

    Flags that are set here will be unconditionally applied to everything we compile with
    this toolchain, even third_party deps.

    """
    cxx_compile_includes = flag_set(
        actions = [
            ACTION_NAMES.c_compile,
            ACTION_NAMES.cpp_compile,
            ACTION_NAMES.objc_compile,
            ACTION_NAMES.objcpp_compile,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    # THIS ORDER MATTERS GREATLY. If these are in the wrong order, the
                    # #include_next directives will fail to find the files, causing a compilation
                    # error (or, without -no-canonical-prefixes, a mysterious case where files
                    # are included with an absolute path and fail the build).
                    "-isystem",
                    EXTERNAL_TOOLCHAIN + "/include/c++/v1",
                    "-isystem",
                    XCODE_MACSDK_SYMLINK + "/usr/include",
                    "-isystem",
                    EXTERNAL_TOOLCHAIN + "/lib/clang/15.0.1/include",
                    # Set the framework path to the Mac SDK framework directory. This has
                    # subfolders like OpenGL.framework
                    # We want -iframework so Clang hides diagnostic warnings from those header
                    # files we include. -F does not hide those.
                    "-iframework",
                    XCODE_MACSDK_SYMLINK + "/System/Library/Frameworks",
                    # We do not want clang to search in absolute paths for files. This makes
                    # Bazel think we are using an outside resource and fail the compile.
                    "-no-canonical-prefixes",
                ],
            ),
        ],
    )

    cpp_compile_flags = flag_set(
        actions = [
            ACTION_NAMES.cpp_compile,
            ACTION_NAMES.objc_compile,
            ACTION_NAMES.objcpp_compile,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    "-std=c++17",
                ],
            ),
        ],
    )

    # copts and defines appear to not automatically be set
    # https://bazel.build/docs/cc-toolchain-config-reference#cctoolchainconfiginfo-build-variables
    # https://github.com/bazelbuild/bazel/blob/5ad4a6126be2bdc53ee7e2457e076c90efe86d56/tools/cpp/cc_toolchain_config_lib.bzl#L200-L209
    objc_compile_flags = flag_set(
        actions = [
            ACTION_NAMES.objc_compile,
            ACTION_NAMES.objcpp_compile,
        ],
        flag_groups = [
            flag_group(
                iterate_over = "user_compile_flags",
                flags = ["%{user_compile_flags}"],
            ),
            flag_group(
                iterate_over = "preprocessor_defines",
                flags = ["-D%{preprocessor_defines}"],
            ),
        ],
    )

    link_exe_flags = flag_set(
        actions = [
            ACTION_NAMES.cpp_link_executable,
            ACTION_NAMES.cpp_link_dynamic_library,
            ACTION_NAMES.cpp_link_nodeps_dynamic_library,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    # lld goes through dynamic library dependencies for dylib and tbh files through
                    # absolute paths (/System/Library/Frameworks). However, the dependencies live in
                    # [Xcode dir]/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks
                    # -Wl tells clang to forward the next flag to the linker.
                    # -syslibroot appends to the beginning of the dylib dependency path.
                    # https://github.com/llvm/llvm-project/blob/d61341768cf0cff7ceeaddecc2f769b5c1b901c4/lld/MachO/InputFiles.cpp#L1418-L1420
                    "-Wl,-syslibroot",
                    XCODE_MACSDK_SYMLINK,
                    # This path is relative to the syslibroot above, and we want lld to look in the
                    # Frameworks symlink that was created in download_mac_toolchain.bzl.
                    "-F/System/Library/Frameworks",
                    "-fuse-ld=lld",
                    "-std=c++17",
                    "-stdlib=libc++",
                    EXTERNAL_TOOLCHAIN + "/lib/libc++.a",
                    EXTERNAL_TOOLCHAIN + "/lib/libc++abi.a",
                    EXTERNAL_TOOLCHAIN + "/lib/libunwind.a",
                ],
            ),
        ],
    )

    return [feature(
        "default_flags",
        enabled = True,
        flag_sets = [
            cpp_compile_flags,
            cxx_compile_includes,
            link_exe_flags,
            objc_compile_flags,
        ],
    )]

def _make_diagnostic_flags():
    """Here we define the flags that can be turned on via features to yield debug info."""
    cxx_diagnostic = flag_set(
        actions = [
            ACTION_NAMES.c_compile,
            ACTION_NAMES.cpp_compile,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    "--trace-includes",
                    "-v",
                ],
            ),
        ],
    )

    link_diagnostic = flag_set(
        actions = [ACTION_NAMES.cpp_link_executable],
        flag_groups = [
            flag_group(
                flags = [
                    "-Wl,--verbose",
                    "-v",
                ],
            ),
        ],
    )

    link_search_dirs = flag_set(
        actions = [ACTION_NAMES.cpp_link_executable],
        flag_groups = [
            flag_group(
                flags = [
                    "--print-search-dirs",
                ],
            ),
        ],
    )
    return [
        # Running a Bazel command with --features diagnostic will cause the compilation and
        # link steps to be more verbose.
        feature(
            "diagnostic",
            enabled = False,
            flag_sets = [
                cxx_diagnostic,
                link_diagnostic,
            ],
        ),
        feature(
            "link_diagnostic",
            enabled = False,
            flag_sets = [
                link_diagnostic,
            ],
        ),
        # Running a Bazel command with --features print_search_dirs will cause the link to fail
        # but directories searched for libraries, etc will be displayed.
        feature(
            "print_search_dirs",
            enabled = False,
            flag_sets = [
                link_search_dirs,
            ],
        ),
    ]

# The parameter is of type https://bazel.build/rules/lib/ctx
def _make_target_specific_flags(ctx):
    m1_mac_target = flag_set(
        actions = [
            ACTION_NAMES.assemble,
            ACTION_NAMES.preprocess_assemble,
            ACTION_NAMES.c_compile,
            ACTION_NAMES.cpp_compile,
            ACTION_NAMES.objc_compile,
            ACTION_NAMES.objcpp_compile,
            ACTION_NAMES.cpp_link_executable,
            ACTION_NAMES.cpp_link_dynamic_library,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    "--target=arm64-apple-macos12",
                ],
            ),
        ],
    )
    intel_mac_target = flag_set(
        actions = [
            ACTION_NAMES.assemble,
            ACTION_NAMES.preprocess_assemble,
            ACTION_NAMES.c_compile,
            ACTION_NAMES.cpp_compile,
            ACTION_NAMES.objc_compile,
            ACTION_NAMES.objcpp_compile,
            ACTION_NAMES.cpp_link_executable,
            ACTION_NAMES.cpp_link_dynamic_library,
        ],
        flag_groups = [
            flag_group(
                flags = [
                    "--target=x86_64-apple-macos12",
                ],
            ),
        ],
    )

    target_specific_features = []
    if _has_platform_constraint(ctx, "@platforms//cpu:arm64"):
        target_specific_features.append(
            feature(
                name = "_m1_mac_target",
                enabled = True,
                flag_sets = [m1_mac_target],
            ),
        )
    elif _has_platform_constraint(ctx, "@platforms//cpu:x86_64"):
        target_specific_features.append(
            feature(
                name = "_intel_mac_target",
                enabled = True,
                flag_sets = [intel_mac_target],
            ),
        )

    return target_specific_features