[lld-macho] Implement -ObjC

[int3]

Summary

It's roughly like -force_load with some filtering.

[compnerd]

lld/MachO/ObjC.cpp

27

Would you mind replacing 16 with sizeof(llvm::MachO::section::sectname) and sizeof(llvm::MachO::section::segname) respectively?

[int3]

use sizeof

[smeenai]

LGTM

lld/MachO/Driver.cpp

254

I don't think this'll cause any issues with actual usage, but I'll just note that this isn't strictly equivalent to forcing a load of the archive member with that symbol. For example, if you already had a symbol with the same name (e.g. from an object file that's already been processed), this implementation won't load the archive member containing that symbol, whereas I believe ld64 would (and give you a multiply defined symbol error).

264

So we'd be adding ObjC-containing members twice, once as an ObjFile above and once as part of this archive? I don't think it'll cause any issues in practice, but it feels a little ugly conceptually. I think this is fine for now, but long-term it'd be nice to have something like LazyObjFile (like COFF and ELF do) to add each member only once (as either an ObjFile or a LazyObjFile). That would also address the TODO above and my previous comment.

lld/test/MachO/objc.s

2

Can you add an input archive with multiple members and show that only the member containing the Obj-C symbols/sections gets pulled in? Right now I think all the tests would pass if you replaced -ObjC with -all_load; I want a test which shows the difference between the two.

[int3]

address comments

lld/MachO/Driver.cpp

264

yeah, that's true. I'll expand the TODO comment above to mention this.

lld/MachO/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(MachOOptionsTableGen)
 
 add_lld_library(lldMachO2
   Arch/X86_64.cpp
   Driver.cpp
   DriverUtils.cpp
   ExportTrie.cpp
   InputFiles.cpp
   InputSection.cpp
   MergedOutputSection.cpp
+  ObjC.cpp
   OutputSection.cpp
   OutputSegment.cpp
   SymbolTable.cpp
   Symbols.cpp
   SyntheticSections.cpp
   Target.cpp
   Writer.cpp
 

lld/MachO/Config.h

struct PlatformInfo {
   llvm::MachO::PlatformKind kind;
   llvm::VersionTuple minimum;
   llvm::VersionTuple sdk;
 };
 
 struct Configuration {
   Symbol *entry;
   bool hasReexports = false;
+  bool forceLoadObjC = false;
   uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::MachO::Architecture arch;
   PlatformInfo platform;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> systemLibraryRoots;
   std::vector<llvm::StringRef> librarySearchPaths;

lld/MachO/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "DriverUtils.h"
 #include "InputFiles.h"
+#include "ObjC.h"
 #include "OutputSection.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 

 
 static void getFrameworkSearchPaths(opt::InputArgList &args,
                                     const std::vector<StringRef> &roots,
                                     std::vector<StringRef> &paths) {
   getSearchPaths(paths, OPT_F, args, roots,
                  {"/Library/Frameworks", "/System/Library/Frameworks"});
 }
 
+// Returns slices of MB by parsing MB as an archive file.
+// Each slice consists of a member file in the archive.
+static std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef mb) {
+  std::unique_ptr<Archive> file =
+      CHECK(Archive::create(mb),
+            mb.getBufferIdentifier() + ": failed to parse archive");
+
+  std::vector<MemoryBufferRef> v;
+  Error err = Error::success();
+  for (const Archive::Child &c : file->children(err)) {
+    MemoryBufferRef mbref =
+        CHECK(c.getMemoryBufferRef(),
+              mb.getBufferIdentifier() +
+                  ": could not get the buffer for a child of the archive");
+    v.push_back(mbref);
+  }
+  if (err)
+    fatal(mb.getBufferIdentifier() +
+          ": Archive::children failed: " + toString(std::move(err)));
+
+  return v;
+}
+
 static void addFile(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::archive: {
     std::unique_ptr<object::Archive> file = CHECK(
         object::Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable())
       error(path + ": archive has no index; run ranlib to add one");
 
+    if (config->forceLoadObjC) {
+      for (const object::Archive::Symbol &sym : file->symbols())
+        if (sym.getName().startswith(objc::klass))
+          symtab->addUndefined(sym.getName());
+
+      // TODO: no need to look for ObjC sections for a given archive member if
+      // we already found that it contains an ObjC symbol
+      if (Optional<MemoryBufferRef> buffer = readFile(path))
+        for (MemoryBufferRef member : getArchiveMembers(*buffer))
+          if (hasObjCSection(member))
+            inputFiles.push_back(make<ObjFile>(member));
+    }
+
     inputFiles.push_back(make<ArchiveFile>(std::move(file)));
     break;
   }
   case file_magic::macho_object:
     inputFiles.push_back(make<ObjFile>(mbref));
     break;
   case file_magic::macho_dynamically_linked_shared_lib:
     inputFiles.push_back(make<DylibFile>(mbref));
     break;
static void addFileList(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
   for (StringRef path : args::getLines(mbref))
     addFile(path);
 }
 
-// Returns slices of MB by parsing MB as an archive file.
-// Each slice consists of a member file in the archive.
-static std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef mb) {
-  std::unique_ptr<Archive> file =
-      CHECK(Archive::create(mb),
-            mb.getBufferIdentifier() + ": failed to parse archive");
-
-  std::vector<MemoryBufferRef> v;
-  Error err = Error::success();
-  for (const Archive::Child &c : file->children(err)) {
-    MemoryBufferRef mbref =
-        CHECK(c.getMemoryBufferRef(),
-              mb.getBufferIdentifier() +
-                  ": could not get the buffer for a child of the archive");
-    v.push_back(mbref);
-  }
-  if (err)
-    fatal(mb.getBufferIdentifier() +
-          ": Archive::children failed: " + toString(std::move(err)));
-
-  return v;
-}
-
 static void forceLoadArchive(StringRef path) {
   if (Optional<MemoryBufferRef> buffer = readFile(path))
     for (MemoryBufferRef member : getArchiveMembers(*buffer))
       inputFiles.push_back(make<ObjFile>(member));
 }
 
 static std::array<StringRef, 6> archNames{"arm",    "arm64", "i386",
                                           "x86_64", "ppc",   "ppc64"};
if (roots.size() && roots.back() == "/")
     roots.clear();
   // NOTE: roots can never be empty - add an empty root to simplify the library
   // and framework search path computation.
   if (roots.empty())
     roots.emplace_back("");
 
   getLibrarySearchPaths(args, roots, config->librarySearchPaths);
   getFrameworkSearchPaths(args, roots, config->frameworkSearchPaths);
+  config->forceLoadObjC = args.hasArg(OPT_ObjC);
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     message(StringRef("Library search paths:") +
             (config->librarySearchPaths.size()
                  ? "\n\t" + llvm::join(config->librarySearchPaths, "\n\t")
                  : ""));
     message(StringRef("Framework search paths:") +
for (const auto &arg : args) {
     case OPT_platform_version:
       handlePlatformVersion(arg);
       break;
     case OPT_o:
     case OPT_dylib:
     case OPT_e:
     case OPT_F:
     case OPT_L:
+    case OPT_ObjC:
     case OPT_headerpad:
     case OPT_install_name:
     case OPT_rpath:
     case OPT_sub_library:
     case OPT_Z:
     case OPT_arch:
     case OPT_syslibroot:
     case OPT_sectcreate:

lld/MachO/InputFiles.h

private:
   // which address offsets have been fetched already.
   llvm::DenseSet<uint64_t> seen;
 };
 
 extern std::vector<InputFile *> inputFiles;
 
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
+const llvm::MachO::load_command *
+findCommand(const llvm::MachO::mach_header_64 *, uint32_t type);
+
 } // namespace macho
 
 std::string toString(const macho::InputFile *file);
 } // namespace lld
 
 #endif

lld/MachO/InputFiles.cpp

 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "DriverUtils.h"
 #include "ExportTrie.h"
 #include "InputSection.h"
 #include "MachOStructs.h"
+#include "ObjC.h"
 #include "OutputSection.h"
+#include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/MachO.h"
if (offset + size > mbref.getBufferSize())
       error(path + ": slice extends beyond end of file");
     return MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
   }
 
   error("unable to find matching architecture in " + path);
   return None;
 }
 
-static const load_command *findCommand(const mach_header_64 *hdr,
+const load_command *macho::findCommand(const mach_header_64 *hdr,
                                        uint32_t type) {
   const uint8_t *p =
       reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
 
   for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const load_command *>(p);
     if (cmd->cmd == type)
       return cmd;
for (const auto symbol : interface.symbols()) {
 
     switch (symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       addSymbol(symbol->getName());
       break;
     case SymbolKind::ObjectiveCClass:
       // XXX ld64 only creates these symbols when -ObjC is passed in. We may
       // want to emulate that.
-      addSymbol("_OBJC_CLASS_$_" + symbol->getName());
-      addSymbol("_OBJC_METACLASS_$_" + symbol->getName());
+      addSymbol(objc::klass + symbol->getName());
+      addSymbol(objc::metaclass + symbol->getName());
       break;
     case SymbolKind::ObjectiveCClassEHType:
-      addSymbol("_OBJC_EHTYPE_$_" + symbol->getName());
+      addSymbol(objc::ehtype + symbol->getName());
       break;
     case SymbolKind::ObjectiveCInstanceVariable:
-      addSymbol("_OBJC_IVAR_$_" + symbol->getName());
+      addSymbol(objc::ivar + symbol->getName());
       break;
     }
   }
 
   inlineDocuments.insert(inlineDocuments.end(), interface.documents().begin(),
                          interface.documents().end());
   for (InterfaceFileRef intfRef : interface.reexportedLibraries())
     if (Optional<DylibFile *> reexport =

lld/MachO/ObjC.h

+//===- ObjC.h ---------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_MACHO_OBJC_H
+#define LLD_MACHO_OBJC_H
+
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace lld {
+namespace macho {
+
+namespace objc {
+
+constexpr const char klass[] = "_OBJC_CLASS_$_";
+constexpr const char metaclass[] = "_OBJC_METACLASS_$_";
+constexpr const char ehtype[] = "_OBJC_EHTYPE_$_";
+constexpr const char ivar[] = "_OBJC_IVAR_$_";
+
+} // namespace objc
+
+bool hasObjCSection(llvm::MemoryBufferRef);
+
+} // namespace macho
+} // namespace lld
+
+#endif

lld/MachO/ObjC.cpp

+//===- ObjC.cpp -----------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ObjC.h"
+#include "InputFiles.h"
+#include "OutputSegment.h"
+
+#include "llvm/BinaryFormat/MachO.h"
+
+using namespace llvm;
+using namespace llvm::MachO;
+using namespace lld;
+
+bool macho::hasObjCSection(MemoryBufferRef mb) {
+  auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+  if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
+    auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
+    auto sectionHeaders = ArrayRef<section_64>{
+        reinterpret_cast<const section_64 *>(c + 1), c->nsects};
+    for (const section_64 &sec : sectionHeaders) {
+      StringRef sectname(sec.sectname, strnlen(sec.sectname, 16));
+      StringRef segname(sec.segname, strnlen(sec.segname, 16));
+      if ((segname == segment_names::data && sectname == "__objc_catlist") ||
+          (segname == segment_names::text && sectname == "__swift")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

lld/test/MachO/objc.s

+# REQUIRES: x86
+# RUN: split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libHasObjCSymbol.s -o %t/libHasObjCSymbol.o
+# RUN: rm -f %t/libHasObjCSymbol.a
+# RUN: llvm-ar rcs %t/libHasObjCSymbol.a %t/libHasObjCSymbol.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libHasObjCCategory.s -o %t/libHasObjCCategory.o
+# RUN: rm -f %t/libHasObjCCategory.a
+# RUN: llvm-ar rcs %t/libHasObjCCategory.a %t/libHasObjCCategory.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libHasSwift.s -o %t/libHasSwift.o
+# RUN: rm -f %t/libHasSwift.a
+# RUN: llvm-ar rcs %t/libHasSwift.a %t/libHasSwift.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
+# RUN: lld -flavor darwinnew -syslibroot %S/Inputs/MacOSX.sdk -lSystem %t/test.o -o %t/objc \
+# RUN:   -L%t -lHasObjCSymbol -lHasObjCCategory -lHasSwift -ObjC
+# RUN: llvm-objdump --section-headers --syms %t/objc | FileCheck %s --check-prefix=OBJC
+
+# OBJC:       Sections:
+# OBJC-NEXT:  Idx Name           Size   VMA  Type
+# OBJC-NEXT:    0 __text         {{.*}}      TEXT
+# OBJC-NEXT:    1 __swift        {{.*}}      DATA
+# OBJC-NEXT:    2 __objc_catlist {{.*}}      DATA
+# OBJC-EMPTY:
+# OBJC-NEXT:  SYMBOL TABLE:
+# OBJC-NEXT:  g     F __TEXT,__text _main
+# OBJC-NEXT:  g     F __TEXT,__text _OBJC_CLASS_$_MyObject
+
+# RUN: lld -flavor darwinnew -syslibroot %S/Inputs/MacOSX.sdk -lSystem %t/test.o -o %t/objc \
+# RUN:   -L%t -lHasObjCSymbol -lHasObjCCategory -lHasSwift
+# RUN: llvm-objdump --section-headers --syms %t/objc | FileCheck %s --check-prefix=NO-OBJC
+
+# NO-OBJC:       Sections:
+# NO-OBJC-NEXT:  Idx Name           Size   VMA  Type
+# NO-OBJC-NEXT:    0 __text         {{.*}}      TEXT
+# NO-OBJC-EMPTY:
+# NO-OBJC-NEXT:  SYMBOL TABLE:
+# NO-OBJC-NEXT:  g     F __TEXT,__text _main
+# NO-OBJC-EMPTY:
+
+#--- libHasObjCSymbol.s
+.globl _OBJC_CLASS_$_MyObject
+_OBJC_CLASS_$_MyObject:
+
+#--- libHasObjCCategory.s
+.section  __DATA,__objc_catlist
+.quad 0x1234
+
+#--- libHasSwift.s
+.section  __TEXT,__swift
+.quad 0x1234
+
+#--- test.s
+.globl _main
+_main:
+  ret