[lld-macho] Support .subsections_via_symbols

[int3]

Summary

This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.

The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with .alt_entry.

We exercise this functionality in our tests by using order files that
rearrange those symbols.

Depends on D79668.

[int3]

rename

[int3]

rebase

[smeenai]

Looks really good! Putting this back on your queue for some minor comments and questions.

lld/MachO/InputFiles.cpp

146

Nit: would emplace_back let us get rid of one pair of curlies?

153

I think \p only makes sense for Doxygen-style comments (which would have triple slashes)? I'm not very well versed with this though.

157

Nit: make this static

200

I know you're just moving this code here, but we should also add a TODO that the offset of 4 only works for relocations with a length of 4 bytes (i.e. a length field of 2).

215

Thanks for the comment!

253

The implication is that the nList entries aren't (necessarily) in address order, right? Otherwise we'd know the final subsection for an alt-entry symbol by the time we reached it.

281

What's the reason for this?

lld/MachO/InputSection.cpp

45

Nit: now that we're not adjusting addend anywhere, we can just get rid of the variable and use r.addend directly everywhere, right?

lld/test/MachO/subsections-section-relocs.s

10

It'd be nice to dump the string section and confirm the ordering is correct (to make sure we're setting subsection contents directly).

15

Could you add a comment explaining the - 3? I believe it's because L_.str should end up at CSTRING_ADDR + 4, and the leaq instruction is 7 bytes long so the relocation is against ADDR + 7, so you get CSTRING_ADDR + 4 - (ADDR + 7), but that took a bit of working out :)

33

Hmm, how can it emit a symbol relocation against a private symbol? Or does it convert it into a non-private symbol?

In general, ld64 atomizes cstring sections by NUL delimiters instead of by symbols, so we'll need to adjust things if we go down that route. This is good for now though.

lld/test/MachO/subsections-symbol-relocs.s

29

It'd be good to verify the rest of the instructions as well, so we can confirm the subsection contents are correct.

[int3]

lld/MachO/InputFiles.cpp

146

doesn't seem to work:

/Users/jezng/local/llvm-project/lld/MachO/InputFiles.cpp:146:17: error: no matching member function for call to 'emplace_back'
    subsections.emplace_back({0, isec});
    ~~~~~~~~~~~~^~~~~~~~~~~~
/Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/vector:722:19: note: candidate function [with _Args = <>] not viable: requires 0 arguments, but 1 was provided
        void      emplace_back(_Args&&... __args);

not really sure what that means, but I'm guessing that the initializer list is screwing up the template resolution?

153

Ah, yeah I'm not very familiar with Doxygen either... in any case, this static function probably doesn't merit a Doxygen comment, but I wanted a way to denote a parameter, and typing out "parameter foo" quickly gets repetitive. I guess I could do something like "offset: an offset relative to ..."

253

yup. I'll make that explicit

281

The symbol we're splitting on may not be at an aligned offset from the first input section. E.g. we may have a section __text aligned to 0x8 and a symbol offset 0x4 from the start of __text.

lld/test/MachO/subsections-section-relocs.s

15

yup, you're right that it's not straightforward...

33

it doesn't emit a symbol relocation against a private symbol, but private symbols are omitted from the object file, so we have no way of reordering them...

[int3]

address comments

[int3]

update

[smeenai]

LGTM

lld/MachO/InputFiles.cpp

146

Ah, yeah, I think there's some interesting clashes between template deduction and initializer lists.

281

Hmm. I guess choosing the minimum makes sense in that case? I'd be curious if ld64 does that or just preserves the alignment of the original section (and aligns the subsection accordingly).

[int3]

lld/MachO/InputFiles.cpp

281

Good point, I hadn't actually checked what ld64 was doing -- the present minalign behavior was from @pcc's original implementation (with some tweaking).

Some testing suggests that what ld64 is doing is preserving the alignment of the original section, plus adding an offset for each subsection to preserve how far away it is from an aligned address. This is the file I was playing around with to observe this behavior:

.globl _main
.p2align 4
.text
_foo:
  .space 2
_bar:
  .space 1
_baz:

_main:
  ret

.subsections_via_symbols

linked with the order file

_baz
_bar
_foo

_bar ends up at an aligned address + 2, and baz at another aligned address + 3.

I think I'd like to punt on emulating this for now, but I'll add a TODO.

[int3]

add TODO

[thakis]

lld/MachO/InputFiles.cpp

315

This breaks the build on Linux: http://45.33.8.238/linux/18060/step_4.txt
And Windows: http://45.33.8.238/win/15558/step_4.txt

Please take a look, and revert if it takes a while to investigate.

[int3]

lld/MachO/InputFiles.cpp

315

weird, I'd wouldn't have expected ArrayRef to construct an std::vector :/ reverted for now, thanks

[int3]

ArrayRef is immutable so elements don't need to be const

lld/MachO/Driver.cpp

bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   if (config->outputType == MH_EXECUTE && !isa<Defined>(config->entry)) {
     error("undefined symbol: " + config->entry->getName());
     return false;
   }
 
   createSyntheticSections();
 
   // Initialize InputSections.
-  for (InputFile *file : inputFiles)
-    for (InputSection *sec : file->sections)
-      inputSections.push_back(sec);
+  for (InputFile *file : inputFiles) {
+    for (SubsectionMap &map : file->subsections) {
+      for (auto &p : map) {
+        InputSection *isec = p.second;
+        inputSections.push_back(isec);
+      }
+    }
+  }
 
   // Write to an output file.
   writeResult();
 
   if (canExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   freeArena();
   return !errorCount();
 }

lld/MachO/InputFiles.h

 //===- InputFiles.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_INPUT_FILES_H
 #define LLD_MACHO_INPUT_FILES_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
+
+#include <map>
 #include <vector>
 
 namespace lld {
 namespace macho {
 
 class InputSection;
 class Symbol;
 struct Reloc;
 
+// If .subsections_via_symbols is set, each InputSection will be split along
+// symbol boundaries. The keys of a SubsectionMap represent the offsets of
+// each subsection from the start of the original pre-split InputSection.
+using SubsectionMap = std::map<uint32_t, InputSection *>;
+
 class InputFile {
 public:
   enum Kind {
     ObjKind,
     DylibKind,
     ArchiveKind,
   };
 
   virtual ~InputFile() = default;
   Kind kind() const { return fileKind; }
   StringRef getName() const { return mb.getBufferIdentifier(); }
 
   MemoryBufferRef mb;
   std::vector<Symbol *> symbols;
-  std::vector<InputSection *> sections;
+  ArrayRef<llvm::MachO::section_64> sectionHeaders;
+  std::vector<SubsectionMap> subsections;
 
 protected:
   InputFile(Kind kind, MemoryBufferRef mb) : mb(mb), fileKind(kind) {}
 
-  std::vector<InputSection *> parseSections(ArrayRef<llvm::MachO::section_64>);
+  void parseSections(ArrayRef<llvm::MachO::section_64>);
+
+  void parseSymbols(ArrayRef<const llvm::MachO::nlist_64> nList,
+                    const char *strtab, bool subsectionsViaSymbols);
 
-  void parseRelocations(const llvm::MachO::section_64 &,
-                        std::vector<Reloc> &relocs);
+  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
 
 private:
   const Kind fileKind;
 };
 
 // .o file
 class ObjFile : public InputFile {
 public:

lld/MachO/InputFiles.cpp

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;
     p += cmd->cmdsize;
   }
   return nullptr;
 }
 
-std::vector<InputSection *>
-InputFile::parseSections(ArrayRef<section_64> sections) {
-  std::vector<InputSection *> ret;
-  ret.reserve(sections.size());
-
+void InputFile::parseSections(ArrayRef<section_64> sections) {
+  subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const section_64 &sec : sections) {
     InputSection *isec = make<InputSection>();
     isec->file = this;
-    isec->header = &sec;
     isec->name = StringRef(sec.sectname, strnlen(sec.sectname, 16));
     isec->segname = StringRef(sec.segname, strnlen(sec.segname, 16));
     isec->data = {buf + sec.offset, static_cast<size_t>(sec.size)};
     if (sec.align >= 32)
       error("alignment " + std::to_string(sec.align) + " of section " +
             isec->name + " is too large");
     else
       isec->align = 1 << sec.align;
     isec->flags = sec.flags;
-    ret.push_back(isec);
-  }
+    subsections.push_back({{0, isec}});
+  }
 
-  return ret;
+// Find the subsection corresponding to the greatest section offset that is <=
+// that of the given offset.
+//
+// offset: the an offset relative to the start of the original InputSection
+// (before any subsection splitting has occurred). It will be updated to
+// represent the same location as an offset relative to the start of the
+// containing subsection.
+static InputSection *findContainingSubsection(SubsectionMap &map,
+                                              uint32_t *offset) {
+  auto it = std::prev(map.upper_bound(*offset));
+  *offset -= it->first;
+  return it->second;
 }
 
 void InputFile::parseRelocations(const section_64 &sec,
-                                 std::vector<Reloc> &relocs) {
+                                 SubsectionMap &subsecMap) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<any_relocation_info> relInfos(
       reinterpret_cast<const any_relocation_info *>(buf + sec.reloff),
       sec.nreloc);
 
   for (const any_relocation_info &anyRel : relInfos) {
-    Reloc r;
-    if (anyRel.r_word0 & R_SCATTERED) {
-      error("TODO: Scattered relocations not supported");
-    } else {
-      auto rel = reinterpret_cast<const relocation_info &>(anyRel);
-      r.type = rel.r_type;
-      r.offset = rel.r_address;
-      r.addend = target->getImplicitAddend(buf + sec.offset + r.offset, r.type);
-      if (rel.r_extern) {
-        r.target = symbols[rel.r_symbolnum];
-      } else {
-        if (rel.r_symbolnum == 0 || rel.r_symbolnum > sections.size())
-          fatal("invalid section index in relocation for offset " +
-                std::to_string(r.offset) + " in section " + sec.sectname +
-                " of " + getName());
-        r.target = sections[rel.r_symbolnum - 1];
-      }
-    }
-    relocs.push_back(r);
+    if (anyRel.r_word0 & R_SCATTERED)
+      fatal("TODO: Scattered relocations not supported");
+
+    if (!rel.r_pcrel)
+      fatal("TODO: Only pcrel relocations are supported");
+
+    Reloc r;
+    uint32_t secRelOffset = rel.r_address;
+    uint64_t rawAddend =
+        target->getImplicitAddend(buf + sec.offset + secRelOffset, r.type);
+
+      r.addend = rawAddend;
+      if (rel.r_symbolnum == 0 || rel.r_symbolnum > subsections.size())
+
+      SubsectionMap &targetSubsecMap = subsections[rel.r_symbolnum - 1];
+      const section_64 &targetSec = sectionHeaders[rel.r_symbolnum - 1];
+      // The implicit addend for pcrel section relocations is the pcrel offset
+      // in terms of the addresses in the input file. Here we adjust it so that
+      // it describes the offset from the start of the target section.
+      // TODO: Figure out what to do for non-pcrel section relocations.
+      // TODO: The offset of 4 is probably not right for ARM64, nor for
+      //       relocations with r_length != 2.
+      uint32_t targetOffset =
+          sec.addr + secRelOffset + 4 + rawAddend - targetSec.addr;
+      r.target = findContainingSubsection(targetSubsecMap, &targetOffset);
+      r.addend = targetOffset;
+    }
+
+    InputSection *subsec = findContainingSubsection(subsecMap, &secRelOffset);
+    r.offset = secRelOffset;
+    subsec->relocs.push_back(r);
+
+void InputFile::parseSymbols(ArrayRef<const 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 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);
+    else
+      // Local defined symbol
+      return make<Defined>(name, isec, value);
+  };
+
+  for (size_t i = 0, n = nList.size(); i < n; ++i) {
+    const nlist_64 &sym = nList[i];
+
+    // Undefined symbol
+    if (!sym.n_sect) {
+      StringRef name = strtab + sym.n_strx;
+      symbols[i] = symtab->addUndefined(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);
+      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);
+      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);
+    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);
+  }
+
+  for (size_t idx : altEntrySymIdxs) {
+    const nlist_64 &sym = nList[idx];
+    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);
   }
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
-  ArrayRef<section_64> objSections;
 
   if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
     auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
-    objSections = ArrayRef<section_64>{
+    sectionHeaders = ArrayRef<section_64>{
         reinterpret_cast<const section_64 *>(c + 1), c->nsects};
-    sections = parseSections(objSections);
+    parseSections(sectionHeaders);
   }
 
   // TODO: Error on missing LC_SYMTAB?
   if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
     auto *c = reinterpret_cast<const symtab_command *>(cmd);
-    const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
     ArrayRef<const nlist_64> nList(
         reinterpret_cast<const nlist_64 *>(buf + c->symoff), c->nsyms);
-
-    symbols.reserve(c->nsyms);
-
-    for (const nlist_64 &sym : nList) {
-      StringRef name = strtab + sym.n_strx;
-
-      // Undefined symbol
-      if (!sym.n_sect) {
-        symbols.push_back(symtab->addUndefined(name));
-        continue;
-      }
-
-      InputSection *isec = sections[sym.n_sect - 1];
-      const section_64 &objSec = objSections[sym.n_sect - 1];
-      uint64_t value = sym.n_value - objSec.addr;
-
-      // Global defined symbol
-      if (sym.n_type & N_EXT) {
-        symbols.push_back(symtab->addDefined(name, isec, value));
-        continue;
-      }
-
-      // Local defined symbol
-      symbols.push_back(make<Defined>(name, isec, value));
-    }
+    const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
+    bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
+    parseSymbols(nList, strtab, subsectionsViaSymbols);
   }
 
   // The relocations may refer to the symbols, so we parse them after we have
-  // the symbols loaded.
-  if (!sections.empty()) {
-    auto it = sections.begin();
-    for (const section_64 &sec : objSections) {
-      parseRelocations(sec, (*it)->relocs);
-      ++it;
-    }
-  }
+  // parsed all the symbols.
+  for (size_t i = 0, n = subsections.size(); i < n; ++i)
+    parseRelocations(sectionHeaders[i], subsections[i]);
 }
 
 DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella)
     : InputFile(DylibKind, mb) {
   if (umbrella == nullptr)
     umbrella = this;
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
 
   MemoryBufferRef mb =
       CHECK(c.getMemoryBufferRef(),
             toString(this) +
                 ": could not get the buffer for the member defining symbol " +
                 sym.getName());
   auto file = make<ObjFile>(mb);
   symbols.insert(symbols.end(), file->symbols.begin(), file->symbols.end());
-  sections.insert(sections.end(), file->sections.begin(), file->sections.end());
+  subsections.insert(subsections.end(), file->subsections.begin(),
+                     file->subsections.end());
 }
 
 // Returns "<internal>" or "baz.o".
 std::string lld::toString(const InputFile *file) {
   return file ? std::string(file->getName()) : "<internal>";
 }

lld/MachO/InputSection.h

 
 class InputFile;
 class InputSection;
 class OutputSection;
 class Symbol;
 
 struct Reloc {
   uint8_t type;
+  // Adding this offset to the address of the target symbol or subsection gives
+  // the destination that this relocation refers to.
   uint32_t addend;
+  // The offset from the start of the subsection that this relocation belongs
+  // to.
   uint32_t offset;
   llvm::PointerUnion<Symbol *, InputSection *> target;
 };
 
 class InputSection {
 public:
   virtual ~InputSection() = default;
   virtual size_t getSize() const { return data.size(); }
   virtual uint64_t getFileSize() const { return getSize(); }
   uint64_t getFileOffset() const;
   uint64_t getVA() const;
 
   virtual void writeTo(uint8_t *buf);
 
   InputFile *file = nullptr;
   StringRef name;
   StringRef segname;
-  // This provides access to the address of the section in the input file.
-  const llvm::MachO::section_64 *header;
 
   OutputSection *parent = nullptr;
   uint64_t outSecOff = 0;
   uint64_t outSecFileOff = 0;
 
   uint32_t align = 1;
   uint32_t flags = 0;
 

lld/MachO/InputSection.cpp

 uint64_t InputSection::getVA() const { return parent->addr + outSecOff; }
 
 void InputSection::writeTo(uint8_t *buf) {
   if (!data.empty())
     memcpy(buf, data.data(), data.size());
 
   for (Reloc &r : relocs) {
     uint64_t va = 0;
-    uint64_t addend = r.addend;
     if (auto *s = r.target.dyn_cast<Symbol *>()) {
       if (auto *dylibSymbol = dyn_cast<DylibSymbol>(s)) {
         va = target->getDylibSymbolVA(*dylibSymbol, r.type);
       } else {
         va = s->getVA();
       }
     } else if (auto *isec = r.target.dyn_cast<InputSection *>()) {
       va = isec->getVA();
-      // The implicit addend for pcrel section relocations is the pcrel offset
-      // in terms of the addresses in the input file. Here we adjust it so that
-      // it describes the offset from the start of the target section.
-      // TODO: Figure out what to do for non-pcrel section relocations.
-      // TODO: The offset of 4 is probably not right for ARM64.
-      addend -= isec->header->addr - (header->addr + r.offset + 4);
     }
 
-    uint64_t val = va + addend;
+    uint64_t val = va + r.addend;
     if (1) // TODO: handle non-pcrel relocations
       val -= getVA() + r.offset;
     target->relocateOne(buf + r.offset, r.type, val);
   }
 }

lld/test/MachO/subsections-section-relocs.s

+# REQUIRES: x86
+# RUN: mkdir -p %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
+
+# RUN: echo "_bar_str" > %t/order-file
+# RUN: echo "_foo_str" >> %t/order-file
+
+# RUN: lld -flavor darwinnew -o %t/test %t/test.o -order_file %t/order-file
+# RUN: llvm-objdump --section-headers -d --no-show-raw-insn %t/test | FileCheck %s
+# CHECK-LABEL: Sections:
+# CHECK:       __cstring {{[^ ]*}} {{0*}}[[#%x, CSTRING_ADDR:]]
+# CHECK-LABEL: Disassembly of section __TEXT,__text:
+## L._str should end up at CSTRING_ADDR + 4, and leaq is 7 bytes long so we
+## have RIP = ADDR + 7
+# CHECK:       [[#%x, ADDR:]]: leaq
+# CHECK-SAME:    [[#%u, CSTRING_ADDR + 4 - ADDR - 7]](%rip), %rsi {{.*}} <_bar_str+0x4>
+
+# RUN: llvm-readobj --string-dump=__cstring %t/test | FileCheck %s --check-prefix=STRINGS
+# STRINGS: bar
+# STRINGS: Private symbol
+# STRINGS: foo
+
+.text
+.globl _main, _foo_str, _bar_str
+
+_main:
+  leaq L_.str(%rip), %rsi
+  mov $0, %rax
+  ret
+
+.section __TEXT,__cstring
+_foo_str:
+  .asciz "foo"
+
+_bar_str:
+  .asciz "bar"
+
+## References to this generate a section relocation
+## N.B.: ld64 doesn't actually reorder symbols in __cstring based on the order
+##       file. Only our implementation does. However, I'm not sure how else to
+##       test section relocations that target an address inside a relocated
+##       symbol: using a non-__cstring section would cause llvm-mc to emit a
+##       symbol relocation instead using the nearest symbol.
+L_.str:
+  .asciz "Private symbol"
+
+.subsections_via_symbols

lld/test/MachO/subsections-symbol-relocs.s

+# REQUIRES: x86
+# RUN: mkdir -p %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
+
+# RUN: echo "_bar" > %t/order-file-1
+# RUN: echo "_foo" >> %t/order-file-1
+# RUN: echo "_main" >> %t/order-file-1
+## _qux is marked as .alt_entry, so it should not create a new subsection and
+## its contents should move with _bar to the start of the output despite the
+## order file listing it at the end.
+# RUN: echo "_qux" >> %t/order-file-1
+
+## _bar and _baz point to the same address, so both order files should achieve
+## the same result.
+# RUN: echo "_baz" > %t/order-file-2
+# RUN: echo "_foo" >> %t/order-file-2
+# RUN: echo "_main" >> %t/order-file-2
+# RUN: echo "_qux" >> %t/order-file-2
+
+# RUN: lld -flavor darwinnew -o %t/test-1 %t/test.o -order_file %t/order-file-1
+# RUN: llvm-objdump -d --no-show-raw-insn %t/test-1 | FileCheck %s
+# RUN: lld -flavor darwinnew -o %t/test-2 %t/test.o -order_file %t/order-file-2
+# RUN: llvm-objdump -d --no-show-raw-insn %t/test-2 | FileCheck %s
+# CHECK-LABEL: Disassembly of section __TEXT,__text:
+# CHECK:       <_bar>:
+# CHECK-NEXT:    callq {{.*}} <_foo>
+# CHECK-EMPTY:
+# CHECK-NEXT:  <_qux>:
+# CHECK-NEXT:    retq
+# CHECK:       <_foo>:
+# CHECK-NEXT:    retq
+# CHECK:       <_main>:
+# CHECK-NEXT:    callq {{.*}} <_bar>
+# CHECK-NEXT:    movq $0, %rax
+# CHECK-NEXT:    retq
+
+.text
+.globl _main, _foo, _bar, _qux
+.alt_entry _qux
+
+_foo:
+  retq
+
+_main:
+  callq _bar
+  movq $0, %rax
+  retq
+
+_bar:
+_baz:
+  callq _foo
+_qux:
+  retq
+
+.subsections_via_symbols