[lld-macho] Support -order_file

[int3]

Summary

The order file indicates how input sections should be sorted within each output
section, based on the symbols contained within those sections.

This diff sets the stage for implementing and testing
.subsections_via_symbols, where we will break up InputSections by each symbol
and sort them more granularly.

Depends on D79228.

[int3]

update

[int3]

update

[int3]

update

[int3]

rebase + support archive files

[smeenai]

Looks great; it's a really clean implementation :) Just had a few comments and questions; requesting changes to put it back on your queue.

lld/MachO/Config.h

31

From what I understand of https://llvm.org/docs/ProgrammersManual.html#dss-stringmap, StringMap copies key strings over into its own storage. That's great when you want it to take ownership of the key strings, but all our strings here should already be part of the global allocator pool. I think DenseMap<StringRef, SymbolPriorityEntry> would work better for us here.

In the process, I went down a bit of a rabbit hole on LLVM's hash tables and CachedHashStringRef, and now I'm confused about LLD's usage of the latter :D I'll probably post to llvm-dev.

38

Grammar nit: "naturally end up" -> "naturally ends up"

40

It'd be helpful to have a comment explaining what these represent.

lld/MachO/Driver.cpp

132

I'm assuming the names are the same ld64 uses? ("arm" in particular.)

Also, considering these are string constants and there's therefore no ownership concerns, a DenseSet<StringRef> might be better, for the same reasons as discussed above with the DenseMap? (Tbh, for this number of entries, just a linear search might be faster still, but that's definitely getting into unnecessary premature optimization territory :)).

168

Add a TODO or other comment to serve as a reminder to change this when we add support for other architectures?

171

It's valid (albeit unlikely) for a symbol name to end with .o. It's also valid (albeit unlikely) for a symbol to have the same name as an architecture.

Can we keep track of fields explicitly instead? For each line, build up its colon delimited fields. If you have more than three fields, it's an error. If you have three fields, the first one should be an architecture (which we should verify), the second one should be an object file (which we should verify), and the third one should be the symbol name. If you have only one field, it's the symbol name. And so on.

lld/MachO/InputFiles.cpp

326

Ah, I didn't realize we'd need to copy over the symbols too. Given that, making a global objFiles vector (or other similar solution to not have to do this copying) would be a good follow-up.

lld/MachO/Writer.cpp

323

ELF iterates over the global symbols from the symbol table and only looks at the input files for local symbols. I'm not entirely sure why it's done that way ... perhaps it's so that for weak symbols, the ordering reflects the final symbol resolution?

As in, let's say foo.o defines importantFunction weakly and bar.o defines it strongly. With the input file search, we'd order both foo.o and bar.o for importantFunction. With the symbol table search, we'd only order bar.o.

We don't have weak symbols right now, so we can just add a TODO and punt on it for now. It'd be interesting to look at how ld64 handles such weak symbol ordering scenarios though.

lld/test/MachO/order-file.s

5

You have a : after .text, so that's gonna create a label called .text instead of being the .text directive.

18

For all these tests, can you pass the object files in both orders, to confirm that the order file does the right thing regardless of the order of object files on the command line?

32

Can we also test the FOO-FIRST case for archives?

34

Can you add a test case for the order file being something like

foo.o:_foo
_main

to make sure the object file matching works in the positive case as well? (We're only checking the negative case above, with bar.o.) It's indirectly tested by the ordering tests below, but it'd be nice to have an explicit test too.

62

Probably worth adding a comment about what's going on here ... it took me a bit to understand it.

With multiple symbols pointing to the same location, I think it's technically arbitrary which one llvm-objdump chooses to display, but it seems like it's just picking the first name, so that works for us.

Is the intention here that _foo and _bar are different symbols in the same section (and they'd be split into their own sections once we have subsections via symbols), or that they're aliases to the same symbol (and therefore ordering one should order the other)?

[int3]

lld/MachO/Config.h

41

I guess I should change this to a DenseMap too

lld/MachO/Driver.cpp

132

I'm assuming the names are the same ld64 uses? ("arm" in particular.)

yup

171

I think ld64 makes these assumptions as well (that symbol names in the order file will never end with an .o), but yeah, I'll try and make this more robust

lld/test/MachO/order-file.s

62

they're aliases to the same symbol (and therefore ordering one should order the other)?

This latter one is the reason. The subsections code actually looks for and avoids creating a new subsection when two symbols alias the same location.

[int3]

lld/test/MachO/order-file.s

62

I'll make _bar non-global so the objdump output will be unambiguous

[int3]

address comments

[int3]

update

[smeenai]

Thanks for changing the parsing! LGTM with the comments addressed.

lld/MachO/Driver.cpp

131

I *think* this'll end up creating a global constructor, which is unfortunate. Would a std::array suffice, either globally or as a function static? I think it'd let us avoid that. Or even an llvm::ArrayRef, perhaps? (Haven't thought about that too much.)

Also, I'm assuming the DenseSet can't just be directly constructed with the names :(

182

This could either be the object file or the architecture. We'll need some additional checking here (I think assuming it's an architecture if it doesn't end with .o will just do the right thing, cos then the later check will bail out).

[int3]

lld/MachO/Driver.cpp

131

DenseSet can be directly constructed; this is defined outside isArchName so that the error message can list out all the valid archs

182

oh yeah, good catch

[int3]

address comments

[smeenai]

lld/MachO/Driver.cpp

182

Hah, a ternary operator as an lvalue ... neat. It's been a long time since I've seen that.

Useless language trivia: ternary operators can only be lvalues in C++, not C.

lld/MachO/Config.h

 //===- Config.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_CONFIG_H
 #define LLD_MACHO_CONFIG_H
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 #include <vector>
 
 namespace lld {
 namespace macho {
 
 class Symbol;
+struct SymbolPriorityEntry;
 
 struct Configuration {
   Symbol *entry;
   bool hasReexports = false;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> searchPaths;
+  llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
+};
+
+// The symbol with the highest priority should be ordered first in the output
+// section (modulo input section contiguity constraints). Using priority
+// (highest first) instead of order (lowest first) has the convenient property
+// that the default-constructed zero priority -- for symbols/sections without a
+// user-defined order -- naturally ends up putting them at the end of the
+// output.
+struct SymbolPriorityEntry {
+  // The priority given to a matching symbol, regardless of which object file
+  // it originated from.
+  size_t anyObjectFile = 0;
+  // The priority given to a matching symbol from a particular object file.
+  llvm::DenseMap<llvm::StringRef, size_t> objectFiles;
 };
 
 extern Configuration *config;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

 #include "Writer.h"
 
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.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/Object/Archive.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/MemoryBuffer.h"
static void addFile(StringRef path) {
   case file_magic::macho_dynamically_linked_shared_lib:
     inputFiles.push_back(make<DylibFile>(mbref));
     break;
   default:
     error(path + ": unhandled file type");
   }
 }
 
+static std::array<StringRef, 6> archNames{"arm",    "arm64", "i386",
+                                          "x86_64", "ppc",   "ppc64"};
+static bool isArchString(StringRef s) {
+  static DenseSet<StringRef> archNamesSet(archNames.begin(), archNames.end());
+  return archNamesSet.find(s) != archNamesSet.end();
+}
+
+// An order file has one entry per line, in the following format:
+//
+//   <arch>:<object file>:<symbol name>
+//
+// <arch> and <object file> are optional. If not specified, then that entry
+// matches any symbol of that name.
+//
+// If a symbol is matched by multiple entries, then it takes the lowest-ordered
+// entry (the one nearest to the front of the list.)
+//
+// The file can also have line comments that start with '#'.
+void parseOrderFile(StringRef path) {
+  Optional<MemoryBufferRef> buffer = readFile(path);
+  if (!buffer) {
+    error("Could not read order file at " + path);
+    return;
+  }
+
+  MemoryBufferRef mbref = *buffer;
+  size_t priority = std::numeric_limits<size_t>::max();
+  for (StringRef rest : args::getLines(mbref)) {
+    StringRef arch, objectFile, symbol;
+
+    std::array<StringRef, 3> fields;
+    uint8_t fieldCount = 0;
+    while (rest != "" && fieldCount < 3) {
+      std::pair<StringRef, StringRef> p = getToken(rest, ": \t\n\v\f\r");
+      StringRef tok = p.first;
+      rest = p.second;
+
+      // Check if we have a comment
+      if (tok == "" || tok[0] == '#')
+        break;
+
+      fields[fieldCount++] = tok;
+    }
+
+    switch (fieldCount) {
+    case 3:
+      arch = fields[0];
+      objectFile = fields[1];
+      symbol = fields[2];
+      break;
+    case 2:
+      (isArchString(fields[0]) ? arch : objectFile) = fields[0];
+      symbol = fields[1];
+      break;
+    case 1:
+      symbol = fields[0];
+      break;
+    case 0:
+      break;
+    default:
+      llvm_unreachable("too many fields in order file");
+    }
+
+    if (!arch.empty()) {
+      if (!isArchString(arch)) {
+        error("invalid arch \"" + arch + "\" in order file: expected one of " +
+              llvm::join(archNames, ", "));
+        continue;
+      }
+
+      // TODO: Update when we extend support for other archs
+      if (arch != "x86_64")
+        continue;
+    }
+
+    if (!objectFile.empty() && !objectFile.endswith(".o")) {
+      error("invalid object file name \"" + objectFile +
+            "\" in order file: should end with .o");
+      continue;
+    }
+
+    if (!symbol.empty()) {
+      SymbolPriorityEntry &entry = config->priorities[symbol];
+      if (!objectFile.empty())
+        entry.objectFiles.insert(std::make_pair(objectFile, priority));
+      else
+        entry.anyObjectFile = std::max(entry.anyObjectFile, priority);
+    }
+
+    --priority;
+  }
+}
+
 // We expect sub-library names of the form "libfoo", which will match a dylib
 // with a path of .*/libfoo.dylib.
 static bool markSubLibrary(StringRef searchName) {
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       StringRef filename = path::filename(dylibFile->getName());
       if (filename.consume_front(searchName) && filename == ".dylib") {
         dylibFile->reexport = true;
bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   // re-exported.
   for (opt::Arg *arg : args.filtered(OPT_sub_library)) {
     config->hasReexports = true;
     StringRef searchName = arg->getValue();
     if (!markSubLibrary(searchName))
       error("-sub_library " + searchName + " does not match a supplied dylib");
   }
 
+  StringRef orderFile = args.getLastArgValue(OPT_order_file);
+  if (!orderFile.empty())
+    parseOrderFile(orderFile);
+
   // dyld requires us to load libSystem. Since we may run tests on non-OSX
   // systems which do not have libSystem, we mock it out here.
   // TODO: Replace this with a stub tbd file once we have TAPI support.
   if (StringRef(getenv("LLD_IN_TEST")) == "1" &&
       config->outputType == MH_EXECUTE) {
     inputFiles.push_back(DylibFile::createLibSystemMock());
   }
 

lld/MachO/InputFiles.cpp

if (!seen.insert(c.getChildOffset()).second)
     return;
 
   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());
 }
 
 // Returns "<internal>" or "baz.o".
 std::string lld::toString(const InputFile *file) {
   return file ? std::string(file->getName()) : "<internal>";
 }

lld/MachO/MergedOutputSection.h

 namespace macho {
 
 // Linking multiple files will inevitably mean resolving sections in different
 // files that are labeled with the same segment and section name. This class
 // contains all such sections and writes the data from each section sequentially
 // in the final binary.
 class MergedOutputSection : public OutputSection {
 public:
-  MergedOutputSection(StringRef name) : OutputSection(name) {}
+  MergedOutputSection(StringRef name) : OutputSection(MergedKind, name) {}
 
   const InputSection *firstSection() const { return inputs.front(); }
   const InputSection *lastSection() const { return inputs.back(); }
 
   // These accessors will only be valid after finalizing the section
   size_t getSize() const override { return size; }
   uint64_t getFileSize() const override { return fileSize; }
 
   void mergeInput(InputSection *input) override;
   void finalize() override;
 
   void writeTo(uint8_t *buf) const override;
 
   std::vector<InputSection *> inputs;
 
+  static bool classof(const OutputSection *sec) {
+    return sec->kind() == MergedKind;
+  }
+
 private:
   void mergeFlags(uint32_t inputFlags);
 
   size_t size = 0;
   uint64_t fileSize = 0;
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Options.td

def install_name: Separate<["-"], "install_name">,
   HelpText<"Set the install path of the dynamic library.">;
 
 def l: Joined<["-"], "l">, MetaVarName<"<libname>">,
   HelpText<"Base name of library searched for in -L directories">;
 
 def o: Separate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
+def order_file: Separate<["-"], "order_file">,
+  HelpText<"Lay out symbols within each section in the order specified by the "
+           "order file">;
+
 def sub_library: Separate<["-"], "sub_library">, MetaVarName<"<libname>">,
   HelpText<"Re-export the specified dylib">;
 
 def v: Flag<["-"], "v">, HelpText<"Display the version number and exit">;
 
 // Ignored options
 def: Flag<["-"], "demangle">;
 def: Flag<["-"], "dynamic">;
 def: Flag<["-"], "no_deduplicate">;
 def platform_version: Flag<["-"], "platform_version">;
 def: Separate<["-"], "lto_library">;
 def: Separate<["-"], "macosx_version_min">;
 def: Separate<["-"], "syslibroot">;

lld/MachO/OutputSection.h

 class OutputSegment;
 
 // Output sections represent the finalized sections present within the final
 // linked executable. They can represent special sections (like the symbol
 // table), or represent coalesced sections from the various inputs given to the
 // linker with the same segment / section name.
 class OutputSection {
 public:
-  OutputSection(StringRef name) : name(name) {}
+  enum Kind {
+    MergedKind,
+    SyntheticKind,
+  };
+
+  OutputSection(Kind kind, StringRef name) : name(name), sectionKind(kind) {}
   virtual ~OutputSection() = default;
+  Kind kind() const { return sectionKind; }
 
   // These accessors will only be valid after finalizing the section.
   uint64_t getSegmentOffset() const;
 
   // How much space the section occupies in the address space.
   virtual size_t getSize() const = 0;
   // How much space the section occupies in the file. Most sections are copied
   // as-is so their file size is the same as their address space size.
public:
   StringRef name;
   OutputSegment *parent = nullptr;
 
   uint32_t index = 0;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   uint32_t align = 1;
   uint32_t flags = 0;
+
+private:
+  Kind sectionKind;
 };
 
 class OutputSectionComparator {
 public:
   OutputSectionComparator(uint32_t segmentOrder,
                           const std::vector<StringRef> &sectOrdering)
       : segmentOrder(segmentOrder) {
     for (uint32_t j = 0, m = sectOrdering.size(); j < m; ++j)

lld/MachO/OutputSegment.h

private:
   llvm::DenseMap<StringRef, OutputSectionComparator> orderMap;
   OutputSectionComparator *defaultPositionComparator;
 };
 
 extern std::vector<OutputSegment *> outputSegments;
 
 OutputSegment *getOutputSegment(StringRef name);
 OutputSegment *getOrCreateOutputSegment(StringRef name);
-void sortOutputSegmentsAndSections();
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/OutputSegment.cpp

OutputSegment *macho::getOrCreateOutputSegment(StringRef name) {
   segRef = make<OutputSegment>();
   segRef->name = name;
   segRef->maxProt = maxProt(name);
   segRef->initProt = initProt(name);
 
   outputSegments.push_back(segRef);
   return segRef;
 }
-
-void macho::sortOutputSegmentsAndSections() {
-  // Sorting only can happen once all outputs have been collected.
-  // Since output sections are grouped by segment, sorting happens
-  // first over all segments, then over sections per segment.
-  auto comparator = OutputSegmentComparator();
-  llvm::stable_sort(outputSegments, comparator);
-
-  // Now that the output sections are sorted, assign the final
-  // output section indices.
-  uint32_t sectionIndex = 0;
-  for (OutputSegment *seg : outputSegments) {
-    seg->sortOutputSections(&comparator);
-    for (auto &p : seg->getSections()) {
-      OutputSection *section = p.second;
-      if (!section->isHidden())
-        section->index = ++sectionIndex;
-    }
-  }
-}

lld/MachO/SyntheticSections.h

 
 class DylibSymbol;
 class LoadCommand;
 
 class SyntheticSection : public OutputSection {
 public:
   SyntheticSection(const char *segname, const char *name);
   virtual ~SyntheticSection() = default;
+
+  static bool classof(const OutputSection *sec) {
+    return sec->kind() == SyntheticKind;
+  }
 };
 
 // The header of the Mach-O file, which must have a file offset of zero.
 class MachHeaderSection : public SyntheticSection {
 public:
   MachHeaderSection();
   void addLoadCommand(LoadCommand *);
   bool isHidden() const override { return true; }

lld/MachO/SyntheticSections.cpp

 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 namespace lld {
 namespace macho {
 
 SyntheticSection::SyntheticSection(const char *segname, const char *name)
-    : OutputSection(name) {
+    : OutputSection(SyntheticKind, name) {
   // Synthetic sections always know which segment they belong to so hook
   // them up when they're made
   getOrCreateOutputSegment(segname)->addOutputSection(this);
 }
 
 // dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
 // from the beginning of the file (i.e. the header).
 MachHeaderSection::MachHeaderSection()

lld/MachO/Writer.cpp

 //===- Writer.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 "Writer.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "InputSection.h"
+#include "MergedOutputSection.h"
+#include "OutputSection.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 class LCLinkEdit;
if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
 
       if (dylibFile->reexport)
         headerSection->addLoadCommand(
             make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->dylibName));
     }
   }
 }
 
+static size_t getSymbolPriority(const SymbolPriorityEntry &entry,
+                                const InputFile &file) {
+  return std::max(entry.objectFiles.lookup(sys::path::filename(file.getName())),
+                  entry.anyObjectFile);
+}
+
+// Each section gets assigned the priority of the highest-priority symbol it
+// contains.
+static DenseMap<const InputSection *, size_t> buildInputSectionPriorities() {
+  DenseMap<const InputSection *, size_t> sectionPriorities;
+
+  if (config->priorities.empty())
+    return sectionPriorities;
+
+  auto addSym = [&](Defined &sym) {
+    auto it = config->priorities.find(sym.getName());
+    if (it == config->priorities.end())
+      return;
+
+    SymbolPriorityEntry &entry = it->second;
+    size_t &priority = sectionPriorities[sym.isec];
+    priority = std::max(priority, getSymbolPriority(entry, *sym.isec->file));
+  };
+
+  // TODO: Make sure this handles weak symbols correctly.
+  for (InputFile *file : inputFiles)
+    if (isa<ObjFile>(file) || isa<ArchiveFile>(file))
+      for (Symbol *sym : file->symbols)
+        if (auto *d = dyn_cast<Defined>(sym))
+          addSym(*d);
+
+  return sectionPriorities;
+}
+
+// Sorting only can happen once all outputs have been collected. Here we sort
+// segments, output sections within each segment, and input sections within each
+// output segment.
+static void sortSegmentsAndSections() {
+  auto comparator = OutputSegmentComparator();
+  llvm::stable_sort(outputSegments, comparator);
+
+  DenseMap<const InputSection *, size_t> isecPriorities =
+      buildInputSectionPriorities();
+
+  uint32_t sectionIndex = 0;
+  for (OutputSegment *seg : outputSegments) {
+    seg->sortOutputSections(&comparator);
+    for (auto &p : seg->getSections()) {
+      OutputSection *section = p.second;
+      // Now that the output sections are sorted, assign the final
+      // output section indices.
+      if (!section->isHidden())
+        section->index = ++sectionIndex;
+
+      if (!isecPriorities.empty()) {
+        if (auto *merged = dyn_cast<MergedOutputSection>(section)) {
+          llvm::stable_sort(merged->inputs,
+                            [&](InputSection *a, InputSection *b) {
+                              return isecPriorities[a] > isecPriorities[b];
+                            });
+        }
+      }
+    }
+  }
+}
+
 void Writer::createOutputSections() {
   // First, create hidden sections
   headerSection = make<MachHeaderSection>();
   bindingSection = make<BindingSection>();
   lazyBindingSection = make<LazyBindingSection>();
   stringTableSection = make<StringTableSection>();
   symtabSection = make<SymtabSection>(*stringTableSection);
   exportSection = make<ExportSection>();
void Writer::run() {
   OutputSegment *linkEditSegment =
       getOrCreateOutputSegment(segment_names::linkEdit);
 
   scanRelocations();
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
 
   // Sort and assign sections to their respective segments. No more sections nor
-  // segments may be created after this method runs.
+  // segments may be created after these methods run.
   createOutputSections();
-  sortOutputSegmentsAndSections();
+  sortSegmentsAndSections();
 
   createLoadCommands();
 
   // Ensure that segments (and the sections they contain) are allocated
   // addresses in ascending order, which dyld requires.
   //
   // Note that at this point, __LINKEDIT sections are empty, but we need to
   // determine addresses of other segments/sections before generating its

lld/test/MachO/invalid/order-file-bad-arch.test

+# REQUIRES: x86
+# RUN: echo ".globl _main; .text; _main: ret" | llvm-mc -filetype=obj -triple=x86_64-apple-darwin -o %t.o
+# RUN: not lld -flavor darwinnew -o %t %t.o -order_file %s 2>&1 | FileCheck %s
+# CHECK: error: invalid arch "sparc" in order file:  expected one of arm, arm64, i386, x86_64, ppc, ppc64
+# CHECK-EMPTY:
+
+_barsymbol
+sparc:hello.o:_foosymbol
+i386:hello.o:_foosymbol

lld/test/MachO/invalid/order-file-bad-objfile.test

+# REQUIRES: x86
+# RUN: echo ".globl _main; .text; _main: ret" | llvm-mc -filetype=obj -triple=x86_64-apple-darwin -o %t.o
+# RUN: not lld -flavor darwinnew -o %t %t.o -order_file %s 2>&1 | FileCheck %s
+# CHECK: invalid object file name "helloo" in order file: should end with .o
+# CHECK: invalid object file name "z80" in order file: should end with .o
+# CHECK-EMPTY:
+
+_barsymbol
+x86_64:helloo:_foosymbol
+z80:_foosymbol

lld/test/MachO/order-file.s

+# REQUIRES: x86
+# RUN: mkdir -p %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
+# RUN: echo ".globl _foo; .text; _foo: _bar: ret" | \
+# RUN:   llvm-mc -filetype=obj -triple=x86_64-apple-darwin -o %t/foo.o
+# RUN: rm -f %t/foo.a
+# RUN: llvm-ar rcs %t/foo.a %t/foo.o
+
+# FOO-FIRST: <_foo>:
+# FOO-FIRST: <_main>:
+
+# FOO-SECOND: <_main>:
+# FOO-SECOND: <_foo>:
+
+# RUN: echo "_foo # just a comment" > %t/ord-1
+# RUN: echo "_main # another comment" >> %t/ord-1
+# RUN: lld -flavor darwinnew -o %t/test-1 %t/test.o %t/foo.o -order_file %t/ord-1
+# RUN: llvm-objdump -d %t/test-1 | FileCheck %s --check-prefix=FOO-FIRST
+## Output should be the same regardless of the command-line order of object files
+# RUN: lld -flavor darwinnew -o %t/test-1 %t/foo.o %t/test.o -order_file %t/ord-1
+# RUN: llvm-objdump -d %t/test-1 | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "_main # just a comment" > %t/ord-2
+# RUN: echo "_foo # another comment" >> %t/ord-2
+# RUN: lld -flavor darwinnew -o %t/test-2 %t/test.o %t/foo.o -order_file %t/ord-2
+# RUN: llvm-objdump -d %t/test-2 | FileCheck %s --check-prefix=FOO-SECOND
+# RUN: lld -flavor darwinnew -o %t/test-2 %t/foo.o %t/test.o -order_file %t/ord-2
+# RUN: llvm-objdump -d %t/test-2 | FileCheck %s --check-prefix=FOO-SECOND
+
+# RUN: echo "foo.o:_foo" > %t/ord-file-match
+# RUN: echo "_main" >> %t/ord-file-match
+# RUN: lld -flavor darwinnew -o %t/test-file-match %t/test.o %t/foo.o -order_file %t/ord-file-match
+# RUN: llvm-objdump -d %t/test-file-match | FileCheck %s --check-prefix=FOO-FIRST
+## Output should be the same regardless of the command-line order of object files
+# RUN: lld -flavor darwinnew -o %t/test-file-match %t/foo.o %t/test.o -order_file %t/ord-file-match
+# RUN: llvm-objdump -d %t/test-file-match | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "bar.o:_foo" > %t/ord-file-nomatch
+# RUN: echo "_main" >> %t/ord-file-nomatch
+# RUN: echo "_foo" >> %t/ord-file-nomatch
+# RUN: lld -flavor darwinnew -o %t/test-file-nomatch %t/test.o %t/foo.o -order_file %t/ord-file-nomatch
+# RUN: llvm-objdump -d %t/test-file-nomatch | FileCheck %s --check-prefix=FOO-SECOND
+# RUN: lld -flavor darwinnew -o %t/test-file-nomatch %t/foo.o %t/test.o -order_file %t/ord-file-nomatch
+# RUN: llvm-objdump -d %t/test-file-nomatch | FileCheck %s --check-prefix=FOO-SECOND
+
+# RUN: echo "x86_64:_foo" > %t/ord-arch-match
+# RUN: echo "_main" >> %t/ord-arch-match
+# RUN: lld -flavor darwinnew -o %t/test-arch-match %t/test.o %t/foo.o -order_file %t/ord-arch-match
+# RUN: llvm-objdump -d %t/test-arch-match | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-arch-match %t/foo.o %t/test.o -order_file %t/ord-arch-match
+# RUN: llvm-objdump -d %t/test-arch-match | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "ppc:_foo" > %t/ord-arch-nomatch
+# RUN: echo "_main" >> %t/ord-arch-nomatch
+# RUN: echo "_foo" >> %t/ord-arch-nomatch
+# RUN: lld -flavor darwinnew -o %t/test-arch-nomatch %t/test.o %t/foo.o -order_file %t/ord-arch-nomatch
+# RUN: llvm-objdump -d %t/test-arch-nomatch | FileCheck %s --check-prefix=FOO-SECOND
+# RUN: lld -flavor darwinnew -o %t/test-arch-nomatch %t/foo.o %t/test.o -order_file %t/ord-arch-nomatch
+# RUN: llvm-objdump -d %t/test-arch-nomatch | FileCheck %s --check-prefix=FOO-SECOND
+
+# RUN: echo "x86_64:bar.o:_foo" > %t/ord-arch-file-match
+# RUN: echo "_main" >> %t/ord-arch-match
+# RUN: lld -flavor darwinnew -o %t/test-arch-match %t/test.o %t/foo.o -order_file %t/ord-arch-match
+# RUN: llvm-objdump -d %t/test-arch-match | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-arch-match %t/foo.o %t/test.o -order_file %t/ord-arch-match
+# RUN: llvm-objdump -d %t/test-arch-match | FileCheck %s --check-prefix=FOO-FIRST
+
+## Test archives
+
+# RUN: lld -flavor darwinnew -o %t/test-archive-1 %t/test.o %t/foo.a -order_file %t/ord-1
+# RUN: llvm-objdump -d %t/test-archive-1 | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-archive-1 %t/foo.a %t/test.o -order_file %t/ord-1
+# RUN: llvm-objdump -d %t/test-archive-1 | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: lld -flavor darwinnew -o %t/test-archive-file-no-match %t/test.o %t/foo.a -order_file %t/ord-file-nomatch
+# RUN: llvm-objdump -d %t/test-archive-file-no-match | FileCheck %s --check-prefix=FOO-SECOND
+# RUN: lld -flavor darwinnew -o %t/test-archive %t/foo.a %t/test.o -order_file %t/ord-file-nomatch
+# RUN: llvm-objdump -d %t/test-archive-file-no-match | FileCheck %s --check-prefix=FOO-SECOND
+
+## The following tests check that if an address is matched by multiple order
+## file entries, it should always use the lowest-ordered match.
+
+# RUN: echo "_foo" > %t/ord-multiple-1
+# RUN: echo "_main" >> %t/ord-multiple-1
+# RUN: echo "foo.o:_foo" >> %t/ord-multiple-1
+# RUN: lld -flavor darwinnew -o %t/test-1 %t/test.o %t/foo.o -order_file %t/ord-multiple-1
+# RUN: llvm-objdump -d %t/test-1 | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-1 %t/foo.o %t/test.o -order_file %t/ord-multiple-1
+# RUN: llvm-objdump -d %t/test-1 | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "foo.o:_foo" > %t/ord-multiple-2
+# RUN: echo "_main" >> %t/ord-multiple-2
+# RUN: echo "_foo" >> %t/ord-multiple-2
+# RUN: lld -flavor darwinnew -o %t/test-2 %t/test.o %t/foo.o -order_file %t/ord-multiple-2
+# RUN: llvm-objdump -d %t/test-2 | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-2 %t/foo.o %t/test.o -order_file %t/ord-multiple-2
+# RUN: llvm-objdump -d %t/test-2 | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "_foo" > %t/ord-multiple-3
+# RUN: echo "_main" >> %t/ord-multiple-3
+# RUN: echo "_foo" >> %t/ord-multiple-3
+# RUN: lld -flavor darwinnew -o %t/test-3 %t/test.o %t/foo.o -order_file %t/ord-multiple-3
+# RUN: llvm-objdump -d %t/test-3 | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-3 %t/foo.o %t/test.o -order_file %t/ord-multiple-3
+# RUN: llvm-objdump -d %t/test-3 | FileCheck %s --check-prefix=FOO-FIRST
+
+# RUN: echo "foo.o:_foo" > %t/ord-multiple-4
+# RUN: echo "_main" >> %t/ord-multiple-4
+# RUN: echo "foo.o:_foo" >> %t/ord-multiple-4
+# RUN: lld -flavor darwinnew -o %t/test-4 %t/test.o %t/foo.o -order_file %t/ord-multiple-4
+# RUN: llvm-objdump -d %t/test-4 | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-4 %t/foo.o %t/test.o -order_file %t/ord-multiple-4
+# RUN: llvm-objdump -d %t/test-4 | FileCheck %s --check-prefix=FOO-FIRST
+
+## _foo and _bar both point to the same location. When both symbols appear in
+## an order file, the location in question should be ordered according to the
+## lowest-ordered symbol that references it.
+# RUN: echo "_bar" > %t/ord-alias
+# RUN: echo "_main" >> %t/ord-alias
+# RUN: echo "_foo" >> %t/ord-alias
+# RUN: lld -flavor darwinnew -o %t/test-alias %t/test.o %t/foo.o -order_file %t/ord-alias
+# RUN: llvm-objdump -d %t/test-alias | FileCheck %s --check-prefix=FOO-FIRST
+# RUN: lld -flavor darwinnew -o %t/test-alias %t/foo.o %t/test.o -order_file %t/ord-alias
+# RUN: llvm-objdump -d %t/test-alias | FileCheck %s --check-prefix=FOO-FIRST
+
+.text
+.globl _main
+
+_main:
+  callq _foo
+  ret