[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/Config.h

 
 #include <vector>
 
 namespace lld {
 namespace macho {
 
 class InputSection;
 class Symbol;
-struct SymbolPriorityEntry;
 
 using NamePair = std::pair<llvm::StringRef, llvm::StringRef>;
 using SectionRenameMap = llvm::DenseMap<NamePair, NamePair>;
 using SegmentRenameMap = llvm::DenseMap<llvm::StringRef, llvm::StringRef>;
 
 struct PlatformInfo {
   llvm::MachO::Target target;
   llvm::VersionTuple minimum;
struct Configuration {
 
   llvm::MachO::Architecture arch() const { return platformInfo.target.Arch; }
 
   llvm::MachO::PlatformType platform() const {
     return platformInfo.target.Platform;
   }
 };
 
-// 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;
-};
-
 // Whether to force-load an archive.
 enum class ForceLoad {
   Default, // Apply -all_load or -ObjC behaviors if those flags are enabled
   Yes,     // Always load the archive, regardless of other flags
   No,      // Never load the archive, regardless of other flags
 };
 
 extern std::unique_ptr<Configuration> config;
 
 } // namespace macho
 } // namespace lld
 
 #endif

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 "llvm/ADT/SmallVector.h"
 
 namespace lld {
 namespace macho {
 
 using SectionPair = std::pair<const InputSection *, const InputSection *>;
 
 class PriorityBuilder {
 public:
public:
   // 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);
 
+  // Constructs internal mapping of section to priority based on order file
+  // data.
+  //
+  // Should only be called after `parseOrderFile()`.
+  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:
+  // 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;
+  };
+
   llvm::Optional<size_t> getSymbolPriority(const Defined *sym);
+
+  using SymbolObjectFile = std::pair<std::string, std::string>;
+  using SymbolOrder = llvm::SmallVector<SymbolObjectFile, 0>;
+  // 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.str(), objectFile.str()));
+    }
+  }
+}
+
+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;