[lld] BPSectionOrderer: replace Symbol with Defined and optimize getSymbols. NFC

Author: MaskRay

lld/MachO/BPSectionOrderer.cpp

@@ -26,20 +26,16 @@ struct BPOrdererMachO;
 }
 template <> struct lld::BPOrdererTraits<struct BPOrdererMachO> {
   using Section = macho::InputSection;
-  using Symbol = macho::Symbol;
+  using Defined = macho::Defined;
 };
 namespace {
 struct BPOrdererMachO : lld::BPOrderer<BPOrdererMachO> {
   static uint64_t getSize(const Section &sec) { return sec.getSize(); }
   static bool isCodeSection(const Section &sec) {
     return macho::isCodeSection(&sec);
   }
-  static SmallVector<Symbol *, 0> getSymbols(const Section &sec) {
-    SmallVector<Symbol *, 0> symbols;
-    for (auto *sym : sec.symbols)
-      if (auto *d = llvm::dyn_cast_or_null<Defined>(sym))
-        symbols.emplace_back(d);
-    return symbols;
+  static ArrayRef<Defined *> getSymbols(const Section &sec) {
+    return sec.symbols;
   }
 
   // Linkage names can be prefixed with "_" or "l_" on Mach-O. See
@@ -80,17 +76,11 @@ struct BPOrdererMachO : lld::BPOrderer<BPOrdererMachO> {
     hashes.erase(std::unique(hashes.begin(), hashes.end()), hashes.end());
   }
 
-  static llvm::StringRef getSymName(const Symbol &sym) { return sym.getName(); }
-  static uint64_t getSymValue(const Symbol &sym) {
-    if (auto *d = dyn_cast<Defined>(&sym))
-      return d->value;
-    return 0;
-  }
-  static uint64_t getSymSize(const Symbol &sym) {
-    if (auto *d = dyn_cast<Defined>(&sym))
-      return d->size;
-    return 0;
+  static llvm::StringRef getSymName(const Defined &sym) {
+    return sym.getName();
   }
+  static uint64_t getSymValue(const Defined &sym) { return sym.value; }
+  static uint64_t getSymSize(const Defined &sym) { return sym.size; }
 
 private:
   static uint64_t
@@ -141,8 +131,8 @@ DenseMap<const InputSection *, int> lld::macho::runBalancedPartitioning(
     }
   }
 
-  return BPOrdererMachO::computeOrder(profilePath, forFunctionCompression,
-                                      forDataCompression,
-                                      compressionSortStartupFunctions, verbose,
-                                      sections, rootSymbolToSectionIdxs);
+  return BPOrdererMachO().computeOrder(profilePath, forFunctionCompression,
+                                       forDataCompression,
+                                       compressionSortStartupFunctions, verbose,
+                                       sections, rootSymbolToSectionIdxs);
 }

lld/include/lld/Common/BPSectionOrdererBase.inc

@@ -46,7 +46,7 @@ template <class D> struct BPOrdererTraits;
 
 template <class D> struct BPOrderer {
   using Section = typename BPOrdererTraits<D>::Section;
-  using Symbol = typename BPOrdererTraits<D>::Symbol;
+  using Defined = typename BPOrdererTraits<D>::Defined;
 
   // Compute a section order using the Balanced Partitioning algorithm.
   //
@@ -56,12 +56,12 @@ template <class D> struct BPOrderer {
   //   program startup.
   // * compressionSortStartupFunctions: if profilePath is specified, allocate
   //   extra utility vertices to prioritize nearby function similarity.
-  static auto
-  computeOrder(llvm::StringRef profilePath, bool forFunctionCompression,
-               bool forDataCompression, bool compressionSortStartupFunctions,
-               bool verbose, llvm::ArrayRef<Section *> sections,
-               const DenseMap<CachedHashStringRef, DenseSet<unsigned>>
-                   &rootSymbolToSectionIdxs)
+  auto computeOrder(llvm::StringRef profilePath, bool forFunctionCompression,
+                    bool forDataCompression,
+                    bool compressionSortStartupFunctions, bool verbose,
+                    llvm::ArrayRef<Section *> sections,
+                    const DenseMap<CachedHashStringRef, DenseSet<unsigned>>
+                        &rootSymbolToSectionIdxs)
       -> llvm::DenseMap<const Section *, int>;
 };
 } // namespace lld
@@ -357,7 +357,7 @@ auto BPOrderer<D>::computeOrder(
       const uint64_t pageSize = (1 << 14);
       uint64_t currentAddress = 0;
       for (const auto *isec : orderedSections) {
-        for (auto *sym : D::getSymbols(*isec)) {
+        for (auto *sym : static_cast<D *>(this)->getSymbols(*isec)) {
           uint64_t startAddress = currentAddress + D::getSymValue(*sym);
           uint64_t endAddress = startAddress + D::getSymSize(*sym);
           uint64_t firstPage = startAddress / pageSize;