-fpackage-db-byte-code

android/android_toolchain.bzl

@@ -27,6 +27,7 @@ AndroidToolchainInfo = provider(
         "bundle_builder": provider_field(typing.Any, default = None),
         "combine_native_library_dirs": provider_field(typing.Any, default = None),
         "d8_command": provider_field(typing.Any, default = None),
+        "enabled_voltron_non_asset_libs": provider_field(typing.Any, default = None),
         "exo_resources_rewriter": provider_field(typing.Any, default = None),
         "exopackage_agent_apk": provider_field(typing.Any, default = None),
         "filter_dex_class_names": provider_field(typing.Any, default = None),

apple/tools/linker_wrapper.py

@@ -0,0 +1,138 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under both the MIT license found in the
+# LICENSE-MIT file in the root directory of this source tree and the Apache
+# License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+# of this source tree.
+
+import argparse
+import enum
+import re
+import subprocess
+import sys
+
+from typing import List, Optional, Tuple
+
+
+def _eprintln(msg: str) -> None:
+    print(msg, flush=True, file=sys.stderr)
+
+
+def _expand_arg_files(args: List[str]) -> List[str]:
+    expanded_args = []
+    for arg in args:
+        if arg.startswith("@"):
+            with open(arg[1:]) as argfile:
+                expanded_args.extend(
+                    [line.strip('"') for line in argfile.read().splitlines()]
+                )
+        else:
+            expanded_args.append(arg)
+    return expanded_args
+
+
+def _seperate_wrapper_args_from_linker_args(
+    args: List[str],
+) -> Tuple[List[str], List[str]]:
+    wrapper_args = []
+    linker_args = []
+    expanded_args = _expand_arg_files(args)
+
+    i = 0
+    while i < len(expanded_args):
+        if expanded_args[i] == "-Xwrapper":
+            wrapper_args.append(expanded_args[i + 1])
+            i += 1
+        else:
+            linker_args.append(expanded_args[i])
+        i += 1
+
+    return wrapper_args, linker_args
+
+
+def _diagnose_potential_unexported_symbol_issue(
+    unexported_symbol_lists: List[str], stderr: str
+) -> Optional[str]:
+    stderr_lines = stderr.splitlines()
+    undefined_symbol_re = re.compile(r"undefined symbol:.*\(mangled: (\S+)\)")
+    undefined_symbols = set()
+    for stderr_line in stderr_lines:
+        match = re.search(undefined_symbol_re, stderr_line)
+        if match:
+            undefined_symbols.add(match.group(1))
+
+    if not undefined_symbols:
+        return None
+
+    unexported_symbols = set()
+    incorrectly_unexported_symbols = set()
+    incorrect_unexported_symbol_lists = []
+    for unexported_symbol_list in unexported_symbol_lists:
+        target_name, file_path = unexported_symbol_list.split(",")
+        with open(file_path, "r") as unexported_symbol_list_file:
+            unexported_symbols = set(unexported_symbol_list_file.read().splitlines())
+            intersection = undefined_symbols & unexported_symbols
+            if intersection:
+                incorrectly_unexported_symbols.update(intersection)
+                incorrect_unexported_symbol_lists.append(target_name)
+
+    if not incorrect_unexported_symbol_lists:
+        return None
+
+    return f"""
+UNEXPORTED SYMBOLS ERROR:
+
+At least one symbol is included in an unexported symbol list, but referenced across dylib boundaries. Please
+run the following command to fix the unexported symbol lists:
+
+arc fix-unexported-symbol-lists {"".join(["--target " + target for target in incorrect_unexported_symbol_lists])} {" ".join(["--symbol " + symbol for symbol in sorted(incorrectly_unexported_symbols)])}
+
+Here is the linker failure message:
+"""
+
+
+class Linker(enum.Enum):
+    LLD = "lld"
+    LD64 = "ld64"
+
+
+def _discover_linker(args: List[str]) -> Optional[Linker]:
+    for arg in args:
+        if arg.startswith("-fuse-ld="):
+            linker_name = arg.split("=")[-1]
+            if linker_name == Linker.LLD.value:
+                return Linker.LLD
+            elif linker_name == Linker.LD64.value:
+                return Linker.LD64
+            else:
+                raise Exception(f"Unknown linker: {linker_name}")
+
+
+def main(argv: List[str]) -> int:
+    wrapper_args, linker_args = _seperate_wrapper_args_from_linker_args(argv[1:])
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-linker")
+    parser.add_argument("-unexported_symbol_list", action="append")
+    args = parser.parse_args(wrapper_args)
+
+    linker = _discover_linker(linker_args)
+    if linker == Linker.LLD:
+        linker_args.extend(
+            ["-Xlinker", "-pika_include_mangled_names_in_undefined_symbol_errors"]
+        )
+
+    result = subprocess.run([args.linker] + linker_args, capture_output=True, text=True)
+    if result.returncode != 0:
+        if args.unexported_symbol_list and linker == Linker.LLD:
+            diagnosis = _diagnose_potential_unexported_symbol_issue(
+                args.unexported_symbol_list, result.stderr
+            )
+            if diagnosis:
+                _eprintln(diagnosis)
+        _eprintln(result.stderr)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

cxx/anon_link.bzl

@@ -10,7 +10,11 @@ load(
     "ArtifactInfo",
     "make_artifact_tset",
 )
-load("@prelude//cxx:cxx_toolchain_types.bzl", "CxxToolchainInfo")
+load(
+    "@prelude//cxx:cxx_toolchain_types.bzl",
+    "CxxToolchainInfo",
+    "LinkerType",
+)
 load("@prelude//cxx:cxx_utility.bzl", "cxx_attrs_get_allow_cache_upload")
 load("@prelude//linking:execution_preference.bzl", "LinkExecutionPreference")
 load(
@@ -34,15 +38,15 @@ def _serialize_linkable(linkable):
         return ("archive", (
             (linkable.archive.artifact, linkable.archive.external_objects),
             linkable.link_whole,
-            linkable.linker_type,
+            linkable.linker_type.value,
             linkable.supports_lto,
         ))
 
     if isinstance(linkable, ObjectsLinkable):
         return ("objects", (
             linkable.objects,
             linkable.link_whole,
-            linkable.linker_type,
+            linkable.linker_type.value,
         ))
 
     if isinstance(linkable, SharedLibLinkable):
@@ -107,7 +111,7 @@ def _deserialize_linkable(linkable: (str, typing.Any)) -> typing.Any:
                 external_objects = external_objects,
             ),
             link_whole = link_whole,
-            linker_type = linker_type,
+            linker_type = LinkerType(linker_type),
             supports_lto = supports_lto,
         )
 
@@ -116,7 +120,7 @@ def _deserialize_linkable(linkable: (str, typing.Any)) -> typing.Any:
         return ObjectsLinkable(
             objects = objects,
             link_whole = link_whole,
-            linker_type = linker_type,
+            linker_type = LinkerType(linker_type),
         )
 
     if typ == "shared":
@@ -207,7 +211,7 @@ ANON_ATTRS = {
                                         # ObjectsLinkable
                                         attrs.list(attrs.source()),  # objects
                                         attrs.bool(),  # link_whole
-                                        attrs.string(),  # linker_type
+                                        attrs.enum(LinkerType.values()),  # linker_type
                                     ),
                                     attrs.tuple(
                                         # ArchiveLinkable
@@ -217,7 +221,7 @@ ANON_ATTRS = {
                                             attrs.list(attrs.source()),  # external_objects
                                         ),
                                         attrs.bool(),  # link_whole
-                                        attrs.string(),  # linker_type
+                                        attrs.enum(LinkerType.values()),  # linker_type
                                         attrs.bool(),  # supports_lto
                                     ),
                                     attrs.tuple(

cxx/archive.bzl

@@ -5,15 +5,15 @@
 # License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 # of this source tree.
 
-load("@prelude//cxx:cxx_toolchain_types.bzl", "LinkerInfo")
+load("@prelude//cxx:cxx_toolchain_types.bzl", "LinkerInfo", "LinkerType")
 load("@prelude//linking:link_info.bzl", "Archive")
 load("@prelude//utils:argfile.bzl", "at_argfile")
 load("@prelude//utils:utils.bzl", "value_or")
 load(":cxx_context.bzl", "get_cxx_toolchain_info")
 
 def _archive_flags(
         archiver_type: str,
-        linker_type: str,
+        linker_type: LinkerType,
         use_archiver_flags: bool,
         symbol_table: bool,
         thin: bool) -> list[str]:
@@ -43,7 +43,7 @@ def _archive_flags(
         flags += "T"
 
     # GNU archivers support generating deterministic archives.
-    if linker_type == "gnu":
+    if linker_type == LinkerType("gnu"):
         flags += "D"
 
     return [flags]

cxx/comp_db.bzl

@@ -16,6 +16,7 @@ load(":cxx_context.bzl", "get_cxx_toolchain_info")
 
 # Provider that exposes the compilation database information
 CxxCompilationDbInfo = provider(fields = {
+    "compdb": provider_field(typing.Any, default = None),  # path customly built compile_commands.json (used by Zephyr projects)
     "info": provider_field(typing.Any, default = None),  # A map of the file (an `Artifact`) to its corresponding `CxxSrcCompileCommand`
     "platform": provider_field(typing.Any, default = None),  # platform for this compilation database
     "toolchain": provider_field(typing.Any, default = None),  # toolchain for this compilation database

cxx/cxx_library.bzl

@@ -150,7 +150,12 @@ load(
     "cxx_use_shlib_intfs",
     "cxx_use_shlib_intfs_mode",
 )
-load(":cxx_toolchain_types.bzl", "ShlibInterfacesMode", "is_bitcode_format")
+load(
+    ":cxx_toolchain_types.bzl",
+    "LinkerType",
+    "ShlibInterfacesMode",
+    "is_bitcode_format",
+)
 load(
     ":cxx_types.bzl",
     "CxxRuleConstructorParams",  # @unused Used as a type
@@ -1173,7 +1178,7 @@ def _strip_objects(ctx: AnalysisContext, objects: list[Artifact]) -> list[Artifa
 
     # Stripping is not supported on Windows
     linker_type = cxx_toolchain_info.linker_info.type
-    if linker_type == "windows":
+    if linker_type == LinkerType("windows"):
         return objects
 
     # Disable stripping if no `strip` binary was provided by the toolchain.
@@ -1373,7 +1378,7 @@ def _static_library(
     # On darwin, the linked output references the archive that contains the
     # object files instead of the originating objects.
     object_external_debug_info = []
-    if linker_type == "darwin":
+    if linker_type == LinkerType("darwin"):
         object_external_debug_info.append(archive.artifact)
         object_external_debug_info.extend(archive.external_objects)
     elif objects_have_external_debug_info:

cxx/cxx_library_utility.bzl

@@ -25,7 +25,11 @@ load(
     "from_named_set",
 )
 load(":cxx_context.bzl", "get_cxx_platform_info", "get_cxx_toolchain_info")
-load(":cxx_toolchain_types.bzl", "ShlibInterfacesMode")
+load(
+    ":cxx_toolchain_types.bzl",
+    "LinkerType",
+    "ShlibInterfacesMode",
+)
 load(
     ":headers.bzl",
     "cxx_attr_header_namespace",
@@ -143,7 +147,7 @@ def cxx_attr_resources(ctx: AnalysisContext) -> dict[str, ArtifactOutputs]:
     return resources
 
 def cxx_is_gnu(ctx: AnalysisContext) -> bool:
-    return get_cxx_toolchain_info(ctx).linker_info.type == "gnu"
+    return get_cxx_toolchain_info(ctx).linker_info.type == LinkerType("gnu")
 
 def cxx_use_shlib_intfs(ctx: AnalysisContext) -> bool:
     """

cxx/cxx_link_utility.bzl

@@ -7,7 +7,11 @@
 
 load("@prelude//:artifact_tset.bzl", "project_artifacts")
 load("@prelude//:paths.bzl", "paths")
-load("@prelude//cxx:cxx_toolchain_types.bzl", "CxxToolchainInfo")
+load(
+    "@prelude//cxx:cxx_toolchain_types.bzl",
+    "CxxToolchainInfo",
+    "LinkerType",
+)
 load("@prelude//cxx:debug.bzl", "SplitDebugMode")
 load("@prelude//cxx:linker.bzl", "get_rpath_origin")
 load("@prelude//cxx:target_sdk_version.bzl", "get_target_sdk_version_linker_flags")
@@ -42,14 +46,14 @@ def generates_split_debug(toolchain: CxxToolchainInfo):
 
 def linker_map_args(toolchain: CxxToolchainInfo, linker_map) -> LinkArgs:
     linker_type = toolchain.linker_info.type
-    if linker_type == "darwin":
+    if linker_type == LinkerType("darwin"):
         flags = [
             "-Xlinker",
             "-map",
             "-Xlinker",
             linker_map,
         ]
-    elif linker_type == "gnu":
+    elif linker_type == LinkerType("gnu"):
         flags = [
             "-Xlinker",
             "-Map",
@@ -98,7 +102,7 @@ def make_link_args(
     linker_info = cxx_toolchain_info.linker_info
     linker_type = linker_info.type
 
-    if linker_type == "darwin":
+    if linker_type == LinkerType("darwin"):
         # Darwin requires a target triple specified to
         # control the deployment target being linked for.
         args.add(get_target_sdk_version_linker_flags(ctx))
@@ -132,7 +136,7 @@ def make_link_args(
         hidden.append(pdb_artifact.as_output())
 
     filelists = None
-    if linker_type == "darwin":
+    if linker_type == LinkerType("darwin"):
         filelists = filter(None, [unpack_link_args_filelist(link) for link in links])
         hidden.extend(filelists)
 
@@ -196,7 +200,7 @@ def cxx_sanitizer_runtime_arguments(
     if not linker_info.sanitizer_runtime_files:
         fail("C++ sanitizer runtime enabled but there are no runtime files")
 
-    if linker_info.type == "darwin":
+    if linker_info.type == LinkerType("darwin"):
         # ignore_artifacts as the runtime directory is not required at _link_ time
         runtime_rpath = cmd_args(ignore_artifacts = True)
         runtime_files = linker_info.sanitizer_runtime_files
@@ -247,7 +251,7 @@ def executable_shared_lib_arguments(
     linker_type = cxx_toolchain.linker_info.type
 
     if len(shared_libs) > 0:
-        if linker_type == "windows":
+        if linker_type == LinkerType("windows"):
             shared_libs_symlink_tree = [ctx.actions.symlink_file(
                 shlib.lib.output.basename,
                 shlib.lib.output,