[lld][Mach-O][NFC] split parsing order file and processing its data.

[Roger]

Summary

Currently, the process of assigning priorities to sections for ordering is split across different points in the LLD pipeline. We can consolidate all the logic of assigning priorities under one function if we first split the code that gathers the data for assigning priorities (which needs to be done across different stages of the driver) from the code that actually assigns priorities (which can be done all at once when all the data has been collected). This diff prepares us for that change by splitting those two codes apart.

[Roger]

Update

[Roger]

Update

[Roger]

Update

[Roger]

Update

[Roger]

Update

[Roger]

Ready for review

[Roger]

Add comment

[int3]

I'll wait for the follow-up diff to review this in context :)

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);
-    if (!orderFile.empty())
+    if (!orderFile.empty()) {
       priorityBuilder.parseOrderFile(orderFile);
+      priorityBuilder.populatePriorities();
+    }
 
     referenceStubBinder();
 
     // FIXME: should terminate the link early based on errors encountered so
     // far?
 
     createSyntheticSections();
     createSyntheticSymbols();

lld/MachO/SectionPriorities.h

 //===- SectionPriorities.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_SECTION_PRIORITIES_H
 #define LLD_MACHO_SECTION_PRIORITIES_H
 
 #include "InputSection.h"
 #include "llvm/ADT/DenseMap.h"
+#include <unordered_map>
 
 namespace lld {
 namespace macho {
 
 using SectionPair = std::pair<const InputSection *, const InputSection *>;
 
 class PriorityBuilder {
 public:
+  using SymbolOrder = std::vector<std::pair<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();
 
   // 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 '#'.
   void parseOrderFile(StringRef path);
 
+  void populatePriorities();
+
   // 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
   // appear in the order file. If neither is present, an empty map is returned.
   //
   // Each section gets assigned the priority of the highest-priority symbol it
   // contains.
   llvm::DenseMap<const InputSection *, size_t> buildInputSectionPriorities();
 
 private:
   llvm::Optional<size_t> getSymbolPriority(const Defined *sym);
+  // This will be populated with symbols ordered so that the earlier
+  // symbols will have higher priority than the later symbols.
+  SymbolOrder inputOrder;
   llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
   llvm::MapVector<SectionPair, uint64_t> callGraphProfile;
 };
 
 extern PriorityBuilder priorityBuilder;
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SectionPriorities.cpp

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;
+      if (fromSym && toSym &&
+          (!hasOrderFile ||
+           (!getSymbolPriority(fromSym) && !getSymbolPriority(toSym))))
         callGraphProfile[{fromSym->isec, toSym->isec}] += entry.count;
     }
   }
 }
 
 void macho::PriorityBuilder::parseOrderFile(StringRef path) {
   assert(callGraphProfile.empty() &&
          "Order file must be parsed before call graph profile is processed");
   Optional<MemoryBufferRef> buffer = readFile(path);
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()) {
-      SymbolPriorityEntry &entry = priorities[symbol];
-      if (!objectFile.empty())
-        entry.objectFiles.insert(
-            std::make_pair(objectFile, highestAvailablePriority));
-      else
-        entry.anyObjectFile =
-            std::max(entry.anyObjectFile, highestAvailablePriority);
-    }
+      inputOrder.push_back(std::make_pair(symbol, objectFile));
+    }
+  }
+}
+
+void macho::PriorityBuilder::populatePriorities() {
+  for (const auto &symbolObjectFile : inputOrder) {
+    StringRef symbol = symbolObjectFile.first;
+    StringRef objectFile = symbolObjectFile.second;
 
     --highestAvailablePriority;
   }
 }
 
 DenseMap<const InputSection *, size_t>
 macho::PriorityBuilder::buildInputSectionPriorities() {
   DenseMap<const InputSection *, size_t> sectionPriorities;