Decouple order file and callgraph ordering logic.

lld/MachO/Driver.cpp

if (config->timeTraceEnabled)
 
     for (const Arg *arg : args.filtered(OPT_mllvm))
       parseClangOption(arg->getValue(), arg->getSpelling());
 
     compileBitcodeFiles();
     replaceCommonSymbols();
 
     StringRef orderFile = args.getLastArgValue(OPT_order_file);
+    PriorityBuilder::SymbolOrder orderFileData;
     if (!orderFile.empty()) {
-      PriorityBuilder::SymbolOrder symbolOrder =
-          priorityBuilder.parseOrderFile(orderFile);
-      priorityBuilder.processOrderFile(symbolOrder);
+      orderFileData = priorityBuilder.parseOrderFile(orderFile);
+      priorityBuilder.populatePriorities(orderFileData);
     }
 
     referenceStubBinder();
 
     // FIXME: should terminate the link early based on errors encountered so
     // far?
 
     createSyntheticSections();
if (config->timeTraceEnabled)
     for (const Arg *arg : args.filtered(OPT_add_empty_section)) {
       StringRef segName = arg->getValue(0);
       StringRef sectName = arg->getValue(1);
       inputFiles.insert(make<OpaqueFile>(MemoryBufferRef(), segName, sectName));
     }
 
     gatherInputSections();
     if (config->callGraphProfileSort)
-      priorityBuilder.extractCallGraphProfile();
+      priorityBuilder.extractCallGraphProfile(orderFileData);
 
     if (config->deadStrip)
       markLive();
 
     // ICF assumes that all literals have been folded already, so we must run
     // foldIdenticalLiterals before foldIdenticalSections.
     foldIdenticalLiterals();
     if (config->icfLevel != ICFLevel::none)

lld/MachO/SectionPriorities.h

 
 namespace lld {
 namespace macho {
 
 using SectionPair = std::pair<const InputSection *, const InputSection *>;
 
 class PriorityBuilder {
 public:
+  using SymbolOrder = llvm::MapVector<StringRef, StringRef>;
   // Reads every input section's call graph profile, and combines them into
   // callGraphProfile. If an order file is present, any edges where one or both
   // of the vertices are specified in the order file are discarded.
-  void extractCallGraphProfile();
+  void extractCallGraphProfile(
+      const macho::PriorityBuilder::SymbolOrder &orderedSymbols);
 
-  using SymbolOrder = std::vector<std::pair<StringRef, StringRef>>;
   // Reads the order file at `path` into config->priorities.
   //
   // An order file has one entry per line, in the following format:
   //
   //   <cpu>:<object file>:<symbol name>
   //
   // <cpu> and <object file> are optional. If not specified, then that entry
   // matches any symbol of that name. Parsing this format is not quite
   // straightforward because the symbol name itself can contain colons, so when
   // encountering a colon, we consider the preceding characters to decide if it
   // can be a valid CPU type or file path.
   //
   // 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 '#'.
   SymbolOrder parseOrderFile(StringRef path) const;
 
-  void processOrderFile(const SymbolOrder &symbolOrder);
+  void populatePriorities(const SymbolOrder &symbolOrder);
 
   // Returns layout priorities for some or all input sections. Sections are laid
   // out in decreasing order; that is, a higher priority section will be closer
   // to the beginning of its output section.
   //
   // If either an order file or a call graph profile are present, this is used
   // as the source of priorities. If both are present, the order file takes
   // precedence, but the call graph profile is still used for symbols that don't

lld/MachO/SectionPriorities.cpp

Optional<size_t> macho::PriorityBuilder::getSymbolPriority(const Defined *sym) {
   if (f->archiveName.empty())
     filename = path::filename(f->getName());
   else
     filename = saver().save(path::filename(f->archiveName) + "(" +
                             path::filename(f->getName()) + ")");
   return std::max(entry.objectFiles.lookup(filename), entry.anyObjectFile);
 }
 
-void macho::PriorityBuilder::extractCallGraphProfile() {
+void macho::PriorityBuilder::extractCallGraphProfile(
+    const macho::PriorityBuilder::SymbolOrder &orderedSymbols) {
   TimeTraceScope timeScope("Extract call graph profile");
-  bool hasOrderFile = !priorities.empty();
+  bool hasOrderedSymbols = !orderedSymbols.empty();
   for (const InputFile *file : inputFiles) {
     auto *obj = dyn_cast_or_null<ObjFile>(file);
     if (!obj)
       continue;
     for (const CallGraphEntry &entry : obj->callGraph) {
       assert(entry.fromIndex < obj->symbols.size() &&
              entry.toIndex < obj->symbols.size());
       auto *fromSym = dyn_cast_or_null<Defined>(obj->symbols[entry.fromIndex]);
       auto *toSym = dyn_cast_or_null<Defined>(obj->symbols[entry.toIndex]);
-      if (!fromSym || !toSym ||
-          (hasOrderFile &&
-           (getSymbolPriority(fromSym) || getSymbolPriority(toSym))))
-        continue;
+      auto isOrdered = [&](const Defined *sym) {
+        return sym->isAbsolute() || orderedSymbols.count(sym->getName()) > 0;
+      };
+      if (fromSym && toSym &&
+          (!hasOrderedSymbols || (!isOrdered(fromSym) && !isOrdered(toSym))))
         callGraphProfile[{fromSym->isec, toSym->isec}] += entry.count;
     }
   }
 }
 
-std::vector<std::pair<StringRef, StringRef>>
+macho::PriorityBuilder::SymbolOrder
 macho::PriorityBuilder::parseOrderFile(StringRef path) const {
   assert(callGraphProfile.empty() &&
          "Order file must be parsed before call graph profile is processed");
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer) {
     error("Could not read order file at " + path);
     return {};
   }
for (StringRef fileEnd : fileEnds) {
         objectFile = line.take_front(pos + fileEnd.size() - 1);
         line = line.drop_front(pos + fileEnd.size());
         break;
       }
     }
     symbol = line.trim();
 
     if (!symbol.empty()) {
-      symbolOrder.emplace_back(
-          std::make_pair(StringRef(symbol), StringRef(objectFile)));
+      symbolOrder[symbol] = objectFile;
     }
   }
 
   return symbolOrder;
 }
 
-void macho::PriorityBuilder::processOrderFile(const SymbolOrder &symbolOrder) {
+void macho::PriorityBuilder::populatePriorities(
+    const SymbolOrder &symbolOrder) {
   for (const auto &symbolObjectFile : symbolOrder) {
     StringRef symbol = symbolObjectFile.first;
     StringRef objectFile = symbolObjectFile.second;
     SymbolPriorityEntry &entry = priorities[symbol];
     if (!objectFile.empty())
       entry.objectFiles.insert(
           std::make_pair(objectFile, highestAvailablePriority));
     else