[lld-macho] Initial groundwork for -bitcode_bundle

[int3]

Summary

This diff creates an empty XAR file and copies it into
__LLVM,__bundle. Follow-up work will actually populate the contents of
that XAR.

[int3]

add test for when libxar isn't available

[gkm]

👍🏼

lld/MachO/SyntheticSections.cpp

34–39

These headers already internally have C(++) compatibility.

1045–1060

For my info ... what is special about xar errors that we need special error-handling infra? If it's not special, will other code benefit from the new infra?

[int3]

lld/MachO/SyntheticSections.cpp

34–39

ah thanks. This was copypasta...

1045–1060

Most LLVM code is nice enough to return something other than a raw int for error handling. But if we find more use cases for this we can for sure factor it out

[tschuett]

Are there plans for an LLVM LIBXAR?

[int3]

Are there plans for an LLVM LIBXAR?

Not particularly. There are several good reasons to write one though:

1. libxar's interface doesn't allow for *not* writing to disk
2. It doesn't support Windows
3. As mentioned in the other comment, it exposes a rather primitive C interface that is out of place in LLVM's C++

However... I don't think any of the above make it enough of a priority for the people currently working on LLD-MachO. I was actually considering proposing it as a GSoC project, but I see that the deadline for this year has passed. You're welcome to take a stab at it if you want :)

[tschuett]

I see your point. It is more in terms of portability and a nicer API.

[int3]

update

lld/MachO/Config.h

struct Configuration {
   bool ltoNewPassManager = LLVM_ENABLE_NEW_PASS_MANAGER;
   bool markDeadStrippableDylib = false;
   bool printEachFile = false;
   bool printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   bool adhocCodesign = false;
   bool emitFunctionStarts = false;
+  bool emitBitcodeBundle = false;
   bool timeTraceEnabled = false;
   uint32_t headerPad;
   uint32_t dylibCompatibilityVersion = 0;
   uint32_t dylibCurrentVersion = 0;
   uint32_t timeTraceGranularity = 500;
   std::string progName;
   llvm::StringRef installName;
   llvm::StringRef mapFile;

lld/MachO/Driver.cpp

 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Config/config.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Parallel.h"
config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
   config->emitFunctionStarts = !args.hasArg(OPT_no_function_starts);
+  config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
+
+#ifndef 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->outputType != MH_DYLIB)
       warn(arg->getAsString(args) + ": ignored, only has effect with -dylib");
     else
       config->installName = arg->getValue();
   } else if (config->outputType == MH_DYLIB) {
     config->installName = config->outputFile;

lld/MachO/InputSection.h

 constexpr const char unwindInfo[] = "__unwind_info";
 constexpr const char compactUnwind[] = "__compact_unwind";
 constexpr const char ehFrame[] = "__eh_frame";
 constexpr const char text[] = "__text";
 constexpr const char stubs[] = "__stubs";
 constexpr const char stubHelper[] = "__stub_helper";
 constexpr const char laSymbolPtr[] = "__la_symbol_ptr";
 constexpr const char data[] = "__data";
+constexpr const char bitcodeBundle[] = "__bundle";
 
 } // namespace section_names
 
 } // namespace macho
 
 std::string toString(const macho::InputSection *);
 
 } // namespace lld
 
 #endif

lld/MachO/Options.td

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">,
-    Flags<[HelpHidden]>,
     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">,

lld/MachO/OutputSection.h

public:
   // as-is so their file size is the same as their address space size.
   virtual uint64_t getFileSize() const { return getSize(); }
 
   // Hidden sections omit header content, but body content may still be present.
   virtual bool isHidden() const { return false; }
   // Unneeded sections are omitted entirely (header and body).
   virtual bool isNeeded() const { return true; }
 
-  // Specifically finalizes addresses and section size, not content.
   virtual void finalize() {
     // TODO investigate refactoring synthetic section finalization logic into
     // overrides of this function.
   }
 
   virtual void writeTo(uint8_t *buf) const = 0;
 
   StringRef name;

lld/MachO/OutputSegment.h

 
 constexpr const char pageZero[] = "__PAGEZERO";
 constexpr const char text[] = "__TEXT";
 constexpr const char data[] = "__DATA";
 constexpr const char linkEdit[] = "__LINKEDIT";
 constexpr const char dataConst[] = "__DATA_CONST";
 constexpr const char ld[] = "__LD"; // output only with -r
 constexpr const char dwarf[] = "__DWARF";
+constexpr const char llvm[] = "__LLVM";
 
 } // namespace segment_names
 
 class OutputSection;
 class InputSection;
 
 class OutputSegment {
 public:

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 : 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;
+};
+
 static_assert((CodeSignatureSection::blobHeadersSize % 8) == 0, "");
 static_assert((CodeSignatureSection::fixedHeadersSize % 8) == 0, "");
 
 struct InStruct {
   MachHeaderSection *header = nullptr;
   RebaseSection *rebase = nullptr;
   BindingSection *binding = nullptr;
   WeakBindingSection *weakBinding = nullptr;

lld/MachO/SyntheticSections.cpp

 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Config/config.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA256.h"
 
 #if defined(__APPLE__)
 #include <sys/mman.h>
 #endif
 
+#ifdef HAVE_LIBXAR
+#include <fcntl.h>
+#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;
 
 InStruct macho::in;
 std::vector<SyntheticSection *> macho::syntheticSections;
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:
+  ErrorCodeWrapper(std::error_code ec) : errorCode(ec.value()) {}
+  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 HAVE_LIBXAR
+  using namespace llvm::sys::fs;
+  CHECK_EC(createTemporaryFile("bitcode-bundle", "xar", xarPath));
+
+  xar_t xar(xar_open(xarPath.data(), O_RDWR));
+  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(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);
+}
+
 void macho::createSyntheticSymbols() {
   auto addHeaderSymbol = [](const char *name) {
     symtab->addSynthetic(name, in.header->isec, 0,
                          /*privateExtern=*/true,
                          /*includeInSymtab*/ false);
   };
 
   switch (config->outputType) {

lld/MachO/Writer.cpp

template <class LP> void Writer::createOutputSections() {
   // First, create hidden sections
   stringTableSection = make<StringTableSection>();
   symtabSection = makeSymtabSection<LP>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
   if (config->adhocCodesign)
     codeSignatureSection = make<CodeSignatureSection>();
   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/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
+
+; 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>
+
+;--- 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-libxar.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
+
+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

 
 # Indirectly check if the mt.exe Microsoft utility exists by searching for
 # 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.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.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.errc_messages = "@LLVM_LIT_ERRC_MESSAGES@"
 config.lld_obj_root = "@LLD_BINARY_DIR@"
 config.lld_libs_dir = "@LLD_LIBS_DIR@"
 config.lld_tools_dir = "@LLD_TOOLS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
+config.have_libxar = @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@
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params

lld/tools/lld/CMakeLists.txt

target_link_libraries(lld
   lldCOFF
   lldDriver
   lldELF
   lldMachO2
   lldMinGW
   lldWasm
   )
 
+if(HAVE_LIBXAR)
+  target_link_libraries(lld PRIVATE ${XAR_LIB})
+endif()
+
 install(TARGETS lld
   RUNTIME DESTINATION bin)
 
 if(NOT LLD_SYMLINKS_TO_CREATE)
   set(LLD_SYMLINKS_TO_CREATE
       lld-link ld.lld ld64.lld ld64.lld.darwinnew ld64.lld.darwinold wasm-ld)
 endif()
 
 foreach(link ${LLD_SYMLINKS_TO_CREATE})
   add_lld_symlink(${link} lld)
 endforeach()