[lld-macho] Support absolute symbols

[int3]

Summary

They operate like Defined symbols but with no associated InputSection.

Note that ld64 seems to treat the weak definition flag like a no-op for
absolute symbols, so I have replicated that behavior.

[int3]

update

[smeenai]

LGTM

lld/MachO/Symbols.cpp

18–20

If you don't anticipate the logic here getting more complex, we could just do a one-liner (and potentially move it back to the header).

lld/MachO/ExportTrie.cpp

struct Edge {
   struct TrieNode *child;
 };
 
 struct ExportInfo {
   uint64_t address;
   uint8_t flags = 0;
   ExportInfo(const Symbol &sym, uint64_t imageBase)
       : address(sym.getVA() - imageBase) {
+    // Set the symbol type.
     if (sym.isWeakDef())
       flags |= EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
-    if (sym.isTlv())
-      flags |= EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL;
     // TODO: Add proper support for re-exports & stub-and-resolver flags.
+
+    // Set the symbol kind.
+    if (sym.isTlv()) {
+      flags |= EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL;
+    } else if (auto *defined = dyn_cast<Defined>(&sym)) {
+      if (defined->isAbsolute())
+        flags |= EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE;
+    }
   }
 };
 
 } // namespace
 
 struct macho::TrieNode {
   std::vector<Edge> edges;
   Optional<ExportInfo> info;

lld/MachO/InputFiles.h

protected:
   InputFile(Kind kind, const llvm::MachO::InterfaceFile &interface)
       : fileKind(kind), name(saver.save(interface.getPath())) {}
 
   void parseSections(ArrayRef<llvm::MachO::section_64>);
 
   void parseSymbols(ArrayRef<lld::structs::nlist_64> nList, const char *strtab,
                     bool subsectionsViaSymbols);
 
+  Symbol *parseNonSectionSymbol(const structs::nlist_64 &sym, StringRef name);
+
   void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
 
 private:
   const Kind fileKind;
   const StringRef name;
 };
 
 // .o file

lld/MachO/InputFiles.cpp

for (const any_relocation_info &anyRelInfo : anyRelInfos) {
     }
 
     r.offset = relInfo.r_address;
     InputSection *subsec = findContainingSubsection(subsecMap, &r.offset);
     subsec->relocs.push_back(r);
   }
 }
 
-void InputFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
-                             const char *strtab, bool subsectionsViaSymbols) {
-  // resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
-  // out-of-sequence.
-  symbols.resize(nList.size());
-  std::vector<size_t> altEntrySymIdxs;
-
-  auto createDefined = [&](const structs::nlist_64 &sym, InputSection *isec,
-                           uint32_t value) -> Symbol * {
-    StringRef name = strtab + sym.n_strx;
-    if (sym.n_type & N_EXT)
-      // Global defined symbol
-      return symtab->addDefined(name, isec, value, sym.n_desc & N_WEAK_DEF);
-    // Local defined symbol
-    return make<Defined>(name, isec, value, sym.n_desc & N_WEAK_DEF,
-                         /*isExternal=*/false);
-  };
+static macho::Symbol *createDefined(const structs::nlist_64 &sym,
+                                    StringRef name, InputSection *isec,
+                                    uint32_t value) {
+}
 
-  for (size_t i = 0, n = nList.size(); i < n; ++i) {
-    const structs::nlist_64 &sym = nList[i];
+// Absolute symbols are defined symbols that do not have an associated
+// InputSection. They cannot be weak.
+static macho::Symbol *createAbsolute(const structs::nlist_64 &sym,
+                                     StringRef name) {
+  if (sym.n_type & N_EXT)
+    return symtab->addDefined(name, nullptr, sym.n_value, /*isWeakDef=*/false);
+  return make<Defined>(name, nullptr, sym.n_value, /*isWeakDef=*/false,
+                       /*isExternal=*/false);
+}
 
-    if ((sym.n_type & N_TYPE) == N_UNDF) {
-      StringRef name = strtab + sym.n_strx;
-      symbols[i] = sym.n_value == 0
-                       ? symtab->addUndefined(name)
-                       : symtab->addCommon(name, this, sym.n_value,
-                                           1 << GET_COMM_ALIGN(sym.n_desc));
+macho::Symbol *InputFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
+                                                StringRef name) {
+  uint8_t type = sym.n_type & N_TYPE;
+  switch (type) {
+  case N_UNDF:
+    return sym.n_value == 0
+  case N_ABS:
+    return createAbsolute(sym, name);
+  case N_PBUD:
+  case N_INDR:
+    error("TODO: support symbols of type " + std::to_string(type));
+    return nullptr;
+  case N_SECT:
+    llvm_unreachable(
+        "N_SECT symbols should not be passed to parseNonSectionSymbol");
+  default:
+    llvm_unreachable("invalid symbol type");
+  }
+}
+
+void InputFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
+                             const char *strtab, bool subsectionsViaSymbols) {
+  // resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
+  // out-of-sequence.
+  symbols.resize(nList.size());
+  std::vector<size_t> altEntrySymIdxs;
+
+  for (size_t i = 0, n = nList.size(); i < n; ++i) {
+    const structs::nlist_64 &sym = nList[i];
+    StringRef name = strtab + sym.n_strx;
+
+    if ((sym.n_type & N_TYPE) != N_SECT) {
+      symbols[i] = parseNonSectionSymbol(sym, name);
       continue;
     }
 
     const section_64 &sec = sectionHeaders[sym.n_sect - 1];
     SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
     uint64_t offset = sym.n_value - sec.addr;
 
     // If the input file does not use subsections-via-symbols, all symbols can
     // use the same subsection. Otherwise, we must split the sections along
     // symbol boundaries.
     if (!subsectionsViaSymbols) {
-      symbols[i] = createDefined(sym, subsecMap[0], offset);
+      symbols[i] = createDefined(sym, name, subsecMap[0], offset);
       continue;
     }
 
     // nList entries aren't necessarily arranged in address order. Therefore,
     // we can't create alt-entry symbols at this point because a later symbol
     // may split its section, which may affect which subsection the alt-entry
     // symbol is assigned to. So we need to handle them in a second pass below.
     if (sym.n_desc & N_ALT_ENTRY) {
       altEntrySymIdxs.push_back(i);
       continue;
     }
 
     // Find the subsection corresponding to the greatest section offset that is
     // <= that of the current symbol. The subsection that we find either needs
     // to be used directly or split in two.
     uint32_t firstSize = offset;
     InputSection *firstIsec = findContainingSubsection(subsecMap, &firstSize);
 
     if (firstSize == 0) {
       // Alias of an existing symbol, or the first symbol in the section. These
       // are handled by reusing the existing section.
-      symbols[i] = createDefined(sym, firstIsec, 0);
+      symbols[i] = createDefined(sym, name, firstIsec, 0);
       continue;
     }
 
     // We saw a symbol definition at a new offset. Split the section into two
     // subsections. The new symbol uses the second subsection.
     auto *secondIsec = make<InputSection>(*firstIsec);
     secondIsec->data = firstIsec->data.slice(firstSize);
     firstIsec->data = firstIsec->data.slice(0, firstSize);
     // TODO: ld64 appears to preserve the original alignment as well as each
     // subsection's offset from the last aligned address. We should consider
     // emulating that behavior.
     secondIsec->align = MinAlign(firstIsec->align, offset);
 
     subsecMap[offset] = secondIsec;
     // By construction, the symbol will be at offset zero in the new section.
-    symbols[i] = createDefined(sym, secondIsec, 0);
+    symbols[i] = createDefined(sym, name, secondIsec, 0);
   }
 
   for (size_t idx : altEntrySymIdxs) {
     const structs::nlist_64 &sym = nList[idx];
+    StringRef name = strtab + sym.n_strx;
     SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
     uint32_t off = sym.n_value - sectionHeaders[sym.n_sect - 1].addr;
     InputSection *subsec = findContainingSubsection(subsecMap, &off);
-    symbols[idx] = createDefined(sym, subsec, off);
+    symbols[idx] = createDefined(sym, name, subsec, off);
   }
 }
 
 OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
                        StringRef sectName)
     : InputFile(OpaqueKind, mb) {
   InputSection *isec = make<InputSection>();
   isec->file = this;

lld/MachO/SymbolTable.cpp

Symbol *SymbolTable::addLazy(StringRef name, ArchiveFile *file,
   return s;
 }
 
 Symbol *SymbolTable::addDSOHandle(const MachHeaderSection *header) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(DSOHandle::name);
   if (!wasInserted) {
+    // FIXME: Make every symbol (including absolute symbols) contain a
+    // reference to their originating file, then add that file name to this
+    // error message.
     if (auto *defined = dyn_cast<Defined>(s))
-      error("found defined symbol from " + defined->isec->file->getName() +
-            " with illegal name " + DSOHandle::name);
+      error("found defined symbol with illegal name " + DSOHandle::name);
   }
   replaceSymbol<DSOHandle>(s, header);
   return s;
 }
 
 SymbolTable *macho::symtab;

lld/MachO/Symbols.h

 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputSection *isec, uint32_t value, bool isWeakDef,
           bool isExternal)
       : Symbol(DefinedKind, name), isec(isec), value(value),
         overridesWeakDef(false), weakDef(isWeakDef), external(isExternal) {}
 
   bool isWeakDef() const override { return weakDef; }
-
-  bool isTlv() const override { return isThreadLocalVariables(isec->flags); }
+  bool isTlv() const override {
+    return !isAbsolute() && isThreadLocalVariables(isec->flags);
+  }
 
   bool isExternal() const { return external; }
+  bool isAbsolute() const { return isec == nullptr; }
 
-  static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
-
-  uint64_t getVA() const override { return isec->getVA() + value; }
+  uint64_t getVA() const override;
+  uint64_t getFileOffset() const override;
 
-  uint64_t getFileOffset() const override {
-    return isec->getFileOffset() + value;
-  }
+  static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 
   InputSection *isec;
   uint32_t value;
 
   bool overridesWeakDef : 1;
 
 private:
   const bool weakDef : 1;

lld/MachO/Symbols.cpp

 //===- Symbols.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 "Symbols.h"
 #include "InputFiles.h"
 #include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
+uint64_t Defined::getVA() const {
+  if (isAbsolute())
+    return value;
+  return isec->getVA() + value;
+}
+
+uint64_t Defined::getFileOffset() const {
+  if (isAbsolute()) {
+    error("absolute symbol " + toString(*this) +
+          " does not have a file offset");
+    return 0;
+  }
+  return isec->getFileOffset() + value;
+}
+
 void LazySymbol::fetchArchiveMember() { file->fetch(sym); }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &sym) {
   if (Optional<std::string> s = demangleItanium(sym.getName()))
     return *s;
   return std::string(sym.getName());
 }
 
 uint64_t DSOHandle::getVA() const { return header->addr; }
 
 uint64_t DSOHandle::getFileOffset() const { return header->fileOff; }
 
 constexpr StringRef DSOHandle::name;

lld/MachO/SyntheticSections.cpp

 
 void SymtabSection::writeTo(uint8_t *buf) const {
   auto *nList = reinterpret_cast<structs::nlist_64 *>(buf);
   for (const SymtabEntry &entry : symbols) {
     nList->n_strx = entry.strx;
     // TODO support other symbol types
     // TODO populate n_desc with more flags
     if (auto *defined = dyn_cast<Defined>(entry.sym)) {
+      if (defined->isAbsolute()) {
+        nList->n_type = MachO::N_EXT | MachO::N_ABS;
+        nList->n_sect = MachO::NO_SECT;
+        nList->n_value = defined->value;
+      } else {
         nList->n_type = MachO::N_EXT | MachO::N_SECT;
         nList->n_sect = defined->isec->parent->index;
-      nList->n_desc |= defined->isWeakDef() ? MachO::N_WEAK_DEF : 0;
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->value + defined->isec->getVA();
       }
+      nList->n_desc |= defined->isWeakDef() ? MachO::N_WEAK_DEF : 0;
+    }
     ++nList;
   }
 }
 
 IndirectSymtabSection::IndirectSymtabSection()
     : LinkEditSection(segment_names::linkEdit,
                       section_names::indirectSymbolTable) {}
 

lld/test/MachO/abs-symbols.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: lld -flavor darwinnew -syslibroot %S/Inputs/MacOSX.sdk -lSystem %t.o -o %t
+# RUN: llvm-objdump --macho --syms --exports-trie %t | FileCheck %s
+
+# CHECK-LABEL: SYMBOL TABLE:
+# CHECK-DAG:   000000000000dead g       *ABS* _foo
+# CHECK-DAG:   000000000000beef g       *ABS* _weakfoo
+
+# CHECK-LABEL: Exports trie:
+# CHECK-DAG:   0x0000DEAD  _foo [absolute]
+# CHECK-DAG:   0x0000BEEF  _weakfoo [absolute]
+
+.globl _foo, _weakfoo, _main
+.weak_definition _weakfoo
+_foo = 0xdead
+_weakfoo = 0xbeef
+
+.text
+_main:
+  ret
+
+## TODO: once we support emitting local symbols in the symtab, test local
+## absolute symbols too

lld/test/MachO/invalid/abs-duplicate.s

+# REQUIRES: x86
+# RUN: split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/weakfoo.s -o %t/weakfoo.o
+# RUN: not lld -flavor darwinnew -syslibroot %S/../Inputs/MacOSX.sdk -lSystem %t/test.o %t/weakfoo.o -o %t/test 2>&1 | FileCheck %s
+
+# CHECK: lld: error: duplicate symbol: _weakfoo
+
+#--- weakfoo.s
+.globl _weakfoo
+## The weak attribute is ignored for absolute symbols, so we will have a
+## duplicate symbol error for _weakfoo.
+.weak_definition _weakfoo
+_weakfoo = 0x1234
+
+#--- test.s
+.globl _main, _weakfoo
+.weak_definition _weakfoo
+_weakfoo = 0x5678
+
+.text
+_main:
+  ret

lld/test/MachO/invalid/dso-handle-duplicate.s

 # REQUIRES: x86
 
 ## If for some bizarre reason the input file defines its own ___dso_handle, we
 ## should raise an error. At least, we've implemented this behavior if the
 ## conflicting symbol is a global. A local symbol of the same name will still
 ## take priority in our implementation, unlike in ld64. But that's a pretty
 ## far-out edge case that should be safe to ignore.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
-# RUN: not lld -flavor darwinnew -dylib %t.o -o %t.dylib 2>&1 | FileCheck %s -DFILE=%t.o
-# CHECK: error: found defined symbol from [[FILE]] with illegal name ___dso_handle
+# RUN: not lld -flavor darwinnew -dylib %t.o -o %t.dylib 2>&1 | FileCheck %s
+# CHECK: error: found defined symbol with illegal name ___dso_handle
 
 .globl _main, ___dso_handle
 .text
 _main:
   leaq ___dso_handle(%rip), %rdx
   ret
 
 ___dso_handle:
   .space 1