[lld-macho] Remove linking bitcode support

[keith]

Summary

Apple deprecated bitcode in the deployment process in Xcode 14.0. Last
month Apple started requiring Xcode 14.1+ to submit apps to the App
Store. Since there isn't a use for bundling bitcode outside of
submitting to the App Store we should be safe to delete this handling
entirely from LLD.

[int3]

lld/MachO/Driver.cpp

1657

nit: wording seems slightly confusing here, since the bitcode args are still supported in ld64 (just not for App Store uploads). anyway see my suggestion in Options.td

lld/MachO/Options.td

646–647

how about moving all these to grp_obsolete, with a message like "Obsolete since the App Store no longer supports the bitcode build flow"?

We could then drop the custom error message in Driver.cpp for these flags

[keith]

Move options to obselete instead

[keith]

friendly bump

[int3]

Sorry, I thought I'd stamped this

lld/CMakeLists.txt

if(LLVM_LIT)
       # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
       if(WIN32 AND NOT CYGWIN)
         set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
       endif()
     else()
       set(LLVM_INCLUDE_TESTS OFF)
     endif()
   endif()
-
-  if(LLVM_HAVE_LIBXAR)
-    set(XAR_LIB xar)
-  endif()
 endif() # standalone
 
 set(LLD_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
 mark_as_advanced(LLD_TOOLS_INSTALL_DIR)
 
 set(LLD_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LLD_INCLUDE_DIR ${LLD_SOURCE_DIR}/include )

lld/MachO/CMakeLists.txt

add_lld_library(lldMachO
   Passes
   Support
   TargetParser
   TextAPI
 
   LINK_LIBS
   lldCommon
   ${LLVM_PTHREAD_LIB}
-  ${XAR_LIB}
 
   DEPENDS
   MachOOptionsTableGen
   ${tablegen_deps}
   )
-
-if(LLVM_HAVE_LIBXAR)
-  target_link_libraries(lldMachO PRIVATE ${XAR_LIB})
-endif()

lld/MachO/Config.h

struct Configuration {
   bool markDeadStrippableDylib = false;
   bool printDylibSearch = false;
   bool printEachFile = false;
   bool printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   bool adhocCodesign = false;
   bool emitFunctionStarts = false;
-  bool emitBitcodeBundle = false;
   bool emitDataInCodeInfo = false;
   bool emitEncryptionInfo = false;
   bool emitInitOffsets = false;
   bool emitChainedFixups = false;
   bool thinLTOEmitImportsFiles;
   bool thinLTOEmitIndexFiles;
   bool thinLTOIndexOnly;
   bool timeTraceEnabled = false;

lld/MachO/Driver.cpp

bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config->exportDynamic = args.hasArg(OPT_export_dynamic);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->forceLoadSwift = args.hasArg(OPT_force_load_swift_libs);
   config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
   config->emitFunctionStarts =
       args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
-  config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
   config->emitDataInCodeInfo =
       args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
   config->emitChainedFixups = shouldEmitChainedFixups(args);
   config->emitInitOffsets =
       config->emitChainedFixups || args.hasArg(OPT_init_offsets);
   config->icfLevel = getICFLevel(args);
   config->dedupStrings =
       args.hasFlag(OPT_deduplicate_strings, OPT_no_deduplicate_strings, true);
if (args.getLastArg(OPT_reproducible))
     config->zeroModTime = true;
 
   std::array<PlatformType, 3> encryptablePlatforms{
       PLATFORM_IOS, PLATFORM_WATCHOS, PLATFORM_TVOS};
   config->emitEncryptionInfo =
       args.hasFlag(OPT_encryptable, OPT_no_encryption,
                    is_contained(encryptablePlatforms, config->platform()));
 
-#ifndef LLVM_HAVE_LIBXAR
-  if (config->emitBitcodeBundle)
-    error("-bitcode_bundle unsupported because LLD wasn't built with libxar");
-#endif
-
   if (const Arg *arg = args.getLastArg(OPT_install_name)) {
     if (config->warnDylibInstallName && config->outputType != MH_DYLIB)
       warn(
           arg->getAsString(args) +
           ": ignored, only has effect with -dylib [--warn-dylib-install-name]");
     else
       config->installName = arg->getValue();
   } else if (config->outputType == MH_DYLIB) {
     config->installName = config->finalOutput;
   }

lld/MachO/Options.td

 def oso_prefix : Separate<["-"], "oso_prefix">,
     MetaVarName<"<path>">,
     HelpText<"Remove the prefix <path> from OSO symbols in the debug map">,
     Group<grp_symtab>;
 def add_ast_path : Separate<["-"], "add_ast_path">,
     MetaVarName<"<path>">,
     HelpText<"AST paths will be emitted as STABS">,
     Group<grp_symtab>;
 
-def grp_bitcode : OptionGroup<"bitcode">, HelpText<"BITCODE BUILD FLOW">;
-
-def bitcode_bundle : Flag<["-"], "bitcode_bundle">,
-    HelpText<"Generate an embedded bitcode bundle in the __LLVM,__bundle section of the output">,
-    Group<grp_bitcode>;
-def bitcode_hide_symbols : Flag<["-"], "bitcode_hide_symbols">,
-    HelpText<"With -bitcode_bundle, hide all non-exported symbols from output bitcode bundle.">,
-    Flags<[HelpHidden]>,
-    Group<grp_bitcode>;
-def bitcode_symbol_map : Separate<["-"], "bitcode_symbol_map">,
-    MetaVarName<"<path>">,
-    HelpText<"Write the bitcode symbol reverse mapping to file <path>, or if a directory, to <path>/UUID.bcsymbolmap">,
-    Flags<[HelpHidden]>,
-    Group<grp_bitcode>;
-
 def grp_rare : OptionGroup<"rare">, HelpText<"RARELY USED">;
 
 def v : Flag<["-"], "v">,
     HelpText<"Print the linker version and search paths in addition to linking">,
     Group<grp_rare>;
 def adhoc_codesign : Flag<["-"], "adhoc_codesign">,
     HelpText<"Write an ad-hoc code signature to the output file (default for arm64 binaries)">,
     Group<grp_rare>;
 def no_adhoc_codesign : Flag<["-"], "no_adhoc_codesign">,
def twolevel_namespace_hints : Flag<["-"], "twolevel_namespace_hints">,
     HelpText<"This option is obsolete in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_obsolete>;
 def slow_stubs : Flag<["-"], "slow_stubs">,
     HelpText<"This option is obsolete in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_obsolete>;
 
+def bitcode_bundle : Flag<["-"], "bitcode_bundle">,
+    HelpText<"Obsolete since the App Store no longer supports binaries with embedded bitcode">,
+    Flags<[HelpHidden]>,
+    Group<grp_obsolete>;
+def bitcode_hide_symbols : Flag<["-"], "bitcode_hide_symbols">,
+    HelpText<"Obsolete since the App Store no longer supports binaries with embedded bitcode">,
+    Flags<[HelpHidden]>,
+    Group<grp_obsolete>;
+def bitcode_symbol_map : Separate<["-"], "bitcode_symbol_map">,
+    MetaVarName<"<path>">,
+    HelpText<"Obsolete since the App Store no longer supports binaries with embedded bitcode">,
+    Flags<[HelpHidden]>,
+    Group<grp_obsolete>;
+def bitcode_process_mode : Separate<["-"], "bitcode_process_mode">,
+    HelpText<"Obsolete since the App Store no longer supports binaries with embedded bitcode">,
+    Flags<[HelpHidden]>,
+    Group<grp_obsolete>;
+def bitcode_verify : Flag<["-"], "bitcode_verify">,
+    HelpText<"Obsolete since the App Store no longer supports binaries with embedded bitcode">,
+    Flags<[HelpHidden]>,
+    Group<grp_obsolete>;
+
 def grp_undocumented : OptionGroup<"undocumented">, HelpText<"UNDOCUMENTED">;
 
 def add_linker_option : Flag<["-"], "add_linker_option">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def add_source_version : Flag<["-"], "add_source_version">,
     HelpText<"This option is undocumented in ld64">,

 def allow_dead_duplicates : Flag<["-"], "allow_dead_duplicates">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def allow_simulator_linking_to_macosx_dylibs : Flag<["-"], "allow_simulator_linking_to_macosx_dylibs">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
-def bitcode_process_mode : Separate<["-"], "bitcode_process_mode">,
-    HelpText<"This option is undocumented in ld64">,
-    Flags<[HelpHidden]>,
-    Group<grp_undocumented>;
-def bitcode_verify : Flag<["-"], "bitcode_verify">,
-    HelpText<"This option is undocumented in ld64">,
-    Flags<[HelpHidden]>,
-    Group<grp_undocumented>;
 def classic_linker : Flag<["-"], "classic_linker">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def data_in_code_info : Flag<["-"], "data_in_code_info">,
     HelpText<"Emit data-in-code information (default)">,
     Group<grp_undocumented>;
 def no_data_in_code_info : Flag<["-"], "no_data_in_code_info">,

lld/MachO/SyntheticSections.h

public:
   CodeSignatureSection();
   uint64_t getRawSize() const override;
   bool isNeeded() const override { return true; }
   void writeTo(uint8_t *buf) const override;
   uint32_t getBlockCount() const;
   void writeHashes(uint8_t *buf) const;
 };
 
-class BitcodeBundleSection final : public SyntheticSection {
-public:
-  BitcodeBundleSection();
-  uint64_t getSize() const override { return xarSize; }
-  void finalize() override;
-  void writeTo(uint8_t *buf) const override;
-
-private:
-  llvm::SmallString<261> xarPath;
-  uint64_t xarSize;
-};
-
 class CStringSection : public SyntheticSection {
 public:
   CStringSection(const char *name);
   void addInput(CStringInputSection *);
   uint64_t getSize() const override { return size; }
   virtual void finalizeContents();
   bool isNeeded() const override { return !inputs.empty(); }
   void writeTo(uint8_t *buf) const override;

lld/MachO/SyntheticSections.cpp

 #include <sys/mman.h>
 
 #define COMMON_DIGEST_FOR_OPENSSL
 #include <CommonCrypto/CommonDigest.h>
 #else
 #include "llvm/Support/SHA256.h"
 #endif
 
-#ifdef LLVM_HAVE_LIBXAR
-#include <fcntl.h>
-extern "C" {
-#include <xar/xar.h>
-}
-#endif
-
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 // Reads `len` bytes at data and writes the 32-byte SHA256 checksum to `output`.
void CodeSignatureSection::writeTo(uint8_t *buf) const {
   write64be(&codeDirectory->execSegLimit, textSeg->fileSize);
   write64be(&codeDirectory->execSegFlags,
             config->outputType == MH_EXECUTE ? CS_EXECSEG_MAIN_BINARY : 0);
   auto *id = reinterpret_cast<char *>(&codeDirectory[1]);
   memcpy(id, fileName.begin(), fileName.size());
   memset(id + fileName.size(), 0, fileNamePad);
 }
 
-BitcodeBundleSection::BitcodeBundleSection()
-    : SyntheticSection(segment_names::llvm, section_names::bitcodeBundle) {}
-
-class ErrorCodeWrapper {
-public:
-  explicit ErrorCodeWrapper(std::error_code ec) : errorCode(ec.value()) {}
-  explicit ErrorCodeWrapper(int ec) : errorCode(ec) {}
-  operator int() const { return errorCode; }
-
-private:
-  int errorCode;
-};
-
-#define CHECK_EC(exp)                                                          \
-  do {                                                                         \
-    ErrorCodeWrapper ec(exp);                                                  \
-    if (ec)                                                                    \
-      fatal(Twine("operation failed with error code ") + Twine(ec) + ": " +    \
-            #exp);                                                             \
-  } while (0);
-
-void BitcodeBundleSection::finalize() {
-#ifdef LLVM_HAVE_LIBXAR
-  using namespace llvm::sys::fs;
-  CHECK_EC(createTemporaryFile("bitcode-bundle", "xar", xarPath));
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-  xar_t xar(xar_open(xarPath.data(), O_RDWR));
-#pragma clang diagnostic pop
-  if (!xar)
-    fatal("failed to open XAR temporary file at " + xarPath);
-  CHECK_EC(xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE));
-  // FIXME: add more data to XAR
-  CHECK_EC(xar_close(xar));
-
-  file_size(xarPath, xarSize);
-#endif // defined(LLVM_HAVE_LIBXAR)
-}
-
-void BitcodeBundleSection::writeTo(uint8_t *buf) const {
-  using namespace llvm::sys::fs;
-  file_t handle =
-      CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),
-            "failed to open XAR file");
-  std::error_code ec;
-  mapped_file_region xarMap(handle, mapped_file_region::mapmode::readonly,
-                            xarSize, 0, ec);
-  if (ec)
-    fatal("failed to map XAR file");
-  memcpy(buf, xarMap.const_data(), xarSize);
-
-  closeFile(handle);
-  remove(xarPath);
-}
-
 CStringSection::CStringSection(const char *name)
     : SyntheticSection(segment_names::text, name) {
   flags = S_CSTRING_LITERALS;
 }
 
 void CStringSection::addInput(CStringInputSection *isec) {
   isec->parent = this;
   inputs.push_back(isec);

lld/MachO/Writer.cpp

template <class LP> void Writer::createOutputSections() {
   symtabSection = makeSymtabSection<LP>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
   if (config->adhocCodesign)
     codeSignatureSection = make<CodeSignatureSection>();
   if (config->emitDataInCodeInfo)
     dataInCodeSection = make<DataInCodeSection>();
   if (config->emitFunctionStarts)
     functionStartsSection = make<FunctionStartsSection>();
-  if (config->emitBitcodeBundle)
-    make<BitcodeBundleSection>();
 
   switch (config->outputType) {
   case MH_EXECUTE:
     make<PageZeroSection>();
     break;
   case MH_DYLIB:
   case MH_BUNDLE:
     break;

lld/test/CMakeLists.txt

 llvm_canonicalize_cmake_booleans(
   ENABLE_BACKTRACES
   LLVM_ENABLE_ZLIB
   LLVM_ENABLE_ZSTD
   LLVM_ENABLE_LIBXML2
   LLD_DEFAULT_LD_LLD_IS_MINGW
-  LLVM_HAVE_LIBXAR
   LLVM_BUILD_EXAMPLES
   LLVM_ENABLE_PLUGINS
   LLVM_BYE_LINK_INTO_TOOLS
   )
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py

lld/test/MachO/bitcode-bundle.ll

-; REQUIRES: x86, xar
-; RUN: rm -rf %t; split-file %s %t
-; RUN: opt -module-summary %t/test.ll -o %t/test.o
-; RUN: opt -module-summary %t/foo.ll -o %t/foo.o
-; RUN: %lld -lSystem -bitcode_bundle %t/test.o %t/foo.o -o %t/test
-; RUN: llvm-objdump --macho --section=__LLVM,__bundle %t/test | FileCheck %s
-; RUN: llvm-readobj --macho-segment %t/test | FileCheck %s --check-prefix=SEGMENT
-
-; CHECK:      Contents of (__LLVM,__bundle) section
-; CHECK-NEXT: For (__LLVM,__bundle) section: xar header
-; CHECK-NEXT:                   magic XAR_HEADER_MAGIC
-; CHECK-NEXT:                    size 28
-; CHECK-NEXT:                 version 1
-; CHECK-NEXT:   toc_length_compressed
-; CHECK-NEXT: toc_length_uncompressed
-; CHECK-NEXT:               cksum_alg XAR_CKSUM_SHA1
-; CHECK-NEXT: For (__LLVM,__bundle) section: xar table of contents:
-; CHECK-NEXT: <?xml version="1.0" encoding="UTF-8"?>
-; CHECK-NEXT: <xar>
-; CHECK-NEXT:  <toc>
-; CHECK-NEXT:   <checksum style="sha1">
-; CHECK-NEXT:    <size>20</size>
-; CHECK-NEXT:    <offset>0</offset>
-; CHECK-NEXT:   </checksum>
-; CHECK-NEXT:   <creation-time>{{.*}}</creation-time>
-; CHECK-NEXT:  </toc>
-; CHECK-NEXT: </xar>
-
-;; __LLVM must directly precede __LINKEDIT.
-; SEGMENT:        Name: __LLVM
-; SEGMENT-NEXT:   Size: 152
-; SEGMENT-NEXT:   vmaddr: 0x[[#%X,LLVM_ADDR:]]
-; SEGMENT-NEXT:   vmsize: 0x[[#%X,LLVM_VMSIZE:]]
-; SEGMENT-NEXT:   fileoff: [[#LLVM_OFF:]]
-; SEGMENT-NEXT:   filesize: [[#LLVM_FILESIZE:]]
-; SEGMENT-NEXT:   maxprot: rw-
-; SEGMENT-NEXT:   initprot: rw-
-; SEGMENT-NEXT:   nsects: 1
-; SEGMENT-NEXT:   flags: 0x0
-; SEGMENT-NEXT: }
-; SEGMENT-NEXT: Segment {
-; SEGMENT-NEXT:   Cmd: LC_SEGMENT_64
-; SEGMENT-NEXT:   Name: __LINKEDIT
-; SEGMENT-NEXT:   Size: 72
-; SEGMENT-NEXT:   vmaddr: 0x[[#LLVM_ADDR + LLVM_VMSIZE]]
-; SEGMENT-NEXT:   vmsize:
-; SEGMENT-NEXT:   fileoff: [[#LLVM_OFF + LLVM_FILESIZE]]
-; SEGMENT-NEXT:   filesize:
-; SEGMENT-NEXT:   maxprot: r--
-; SEGMENT-NEXT:   initprot: r--
-; SEGMENT-NEXT:   nsects: 0
-; SEGMENT-NEXT:   flags: 0x0
-; SEGMENT-NEXT: }
-
-;--- foo.ll
-target triple = "x86_64-apple-darwin"
-target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-
-define void @foo() {
-  ret void
-}
-
-;--- test.ll
-target triple = "x86_64-apple-darwin"
-target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-
-define void @main() {
-  ret void
-}

lld/test/MachO/invalid/no-bitcode-support.ll

 ; REQUIRES: x86
-; UNSUPPORTED: xar
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: not %lld -lSystem -bitcode_bundle %t.o -o /dev/null 2>&1 | FileCheck %s
-; CHECK: error: -bitcode_bundle unsupported because LLD wasn't built with libxar
+; CHECK: error: Option `-bitcode_bundle' is obsolete. Please modernize your usage.
 
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @main() {
   ret void
 }

lld/test/lit.cfg.py

 # cvtres, which always accompanies it.  Alternatively, check if we can use
 # libxml2 to merge manifests.
 if lit.util.which("cvtres", config.environment["PATH"]) or config.have_libxml2:
     config.available_features.add("manifest_tool")
 
 if config.enable_backtrace:
     config.available_features.add("backtrace")
 
-if config.have_libxar:
-    config.available_features.add("xar")
-
 if config.have_libxml2:
     config.available_features.add("libxml2")
 
 if config.have_dia_sdk:
     config.available_features.add("diasdk")
 
 if config.sizeof_void_p == 8:
     config.available_features.add("llvm-64-bits")

lld/test/lit.site.cfg.py.in

 config.lld_obj_root = "@LLD_BINARY_DIR@"
 config.lld_libs_dir = lit_config.substitute("@CURRENT_LIBS_DIR@")
 config.lld_tools_dir = lit_config.substitute("@CURRENT_TOOLS_DIR@")
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.target_triple = "@LLVM_TARGET_TRIPLE@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
 config.have_zstd = @LLVM_ENABLE_ZSTD@
-config.have_libxar = @LLVM_HAVE_LIBXAR@
 config.have_libxml2 = @LLVM_ENABLE_LIBXML2@
 config.sizeof_void_p = @CMAKE_SIZEOF_VOID_P@
 config.ld_lld_default_mingw = @LLD_DEFAULT_LD_LLD_IS_MINGW@
 config.build_examples = @LLVM_BUILD_EXAMPLES@
 config.has_plugins = @LLVM_ENABLE_PLUGINS@
 config.linked_bye_extension = @LLVM_BYE_LINK_INTO_TOOLS@
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLD_SOURCE_DIR@/test/lit.cfg.py")