Resolve performance issue by templating MarkLive on --why-live

Author: mysterymath

lld/ELF/MarkLive.cpp

@@ -48,18 +48,18 @@ namespace {
 // Something that can be the most proximate reason that something else is alive.
 typedef std::variant<InputSectionBase *, Symbol *> LiveReason;
 
-template <class ELFT> class MarkLive {
+template <class ELFT, bool TrackWhyLive> class MarkLive {
 public:
   MarkLive(Ctx &ctx, unsigned partition) : ctx(ctx), partition(partition) {}
 
   void run();
   void moveToMain();
+  void printWhyLive(Symbol *s) const;
 
 private:
   void enqueue(InputSectionBase *sec, uint64_t offset = 0,
                Symbol *sym = nullptr,
                std::optional<LiveReason> reason = std::nullopt);
-  void printWhyLive(Symbol *s) const;
   void markSymbol(Symbol *sym);
   void mark();
 
@@ -108,16 +108,16 @@ static uint64_t getAddend(Ctx &, InputSectionBase &sec,
   return rel.r_addend;
 }
 
-template <class ELFT>
+template <class ELFT, bool TrackWhyLive>
 template <class RelTy>
-void MarkLive<ELFT>::resolveReloc(InputSectionBase &sec, RelTy &rel,
-                                  bool fromFDE) {
+void MarkLive<ELFT, TrackWhyLive>::resolveReloc(InputSectionBase &sec,
+                                                RelTy &rel, bool fromFDE) {
   // If a symbol is referenced in a live section, it is used.
   Symbol &sym = sec.file->getRelocTargetSym(rel);
   sym.used = true;
 
-  LiveReason reason;
-  if (!ctx.arg.whyLive.empty()) {
+  std::optional<LiveReason> reason;
+  if (TrackWhyLive) {
     Defined *reasonSym = sec.getEnclosingSymbol(rel.r_offset);
     reason = reasonSym ? LiveReason(reasonSym) : LiveReason(&sec);
   }
@@ -142,7 +142,7 @@ void MarkLive<ELFT>::resolveReloc(InputSectionBase &sec, RelTy &rel,
     if (!(fromFDE && ((relSec->flags & (SHF_EXECINSTR | SHF_LINK_ORDER)) ||
                       relSec->nextInSectionGroup))) {
       Symbol *canonicalSym = d;
-      if (!ctx.arg.whyLive.empty() && d->isSection()) {
+      if (TrackWhyLive && d->isSection()) {
         if (Symbol *s = relSec->getEnclosingSymbol(offset))
           canonicalSym = s;
         else
@@ -156,8 +156,8 @@ void MarkLive<ELFT>::resolveReloc(InputSectionBase &sec, RelTy &rel,
   if (auto *ss = dyn_cast<SharedSymbol>(&sym)) {
     if (!ss->isWeak()) {
       cast<SharedFile>(ss->file)->isNeeded = true;
-      if (!ctx.arg.whyLive.empty())
-        whyLive.try_emplace(&sym, reason);
+      if (TrackWhyLive)
+        whyLive.try_emplace(&sym, *reason);
     }
   }
 
@@ -179,10 +179,10 @@ void MarkLive<ELFT>::resolveReloc(InputSectionBase &sec, RelTy &rel,
 // A possible improvement would be to fully process .eh_frame in the middle of
 // the gc pass. With that we would be able to also gc some sections holding
 // LSDAs and personality functions if we found that they were unused.
-template <class ELFT>
+template <class ELFT, bool TrackWhyLive>
 template <class RelTy>
-void MarkLive<ELFT>::scanEhFrameSection(EhInputSection &eh,
-                                        ArrayRef<RelTy> rels) {
+void MarkLive<ELFT, TrackWhyLive>::scanEhFrameSection(EhInputSection &eh,
+                                                      ArrayRef<RelTy> rels) {
   for (const EhSectionPiece &cie : eh.cies)
     if (cie.firstRelocation != unsigned(-1))
       resolveReloc(eh, rels[cie.firstRelocation], false);
@@ -219,9 +219,10 @@ static bool isReserved(InputSectionBase *sec) {
   }
 }
 
-template <class ELFT>
-void MarkLive<ELFT>::enqueue(InputSectionBase *sec, uint64_t offset,
-                             Symbol *sym, std::optional<LiveReason> reason) {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::enqueue(InputSectionBase *sec,
+                                           uint64_t offset, Symbol *sym,
+                                           std::optional<LiveReason> reason) {
   // Usually, a whole section is marked as live or dead, but in mergeable
   // (splittable) sections, each piece of data has independent liveness bit.
   // So we explicitly tell it which offset is in use.
@@ -235,7 +236,7 @@ void MarkLive<ELFT>::enqueue(InputSectionBase *sec, uint64_t offset,
     return;
   sec->partition = sec->partition ? 1 : partition;
 
-  if (!ctx.arg.whyLive.empty() && reason) {
+  if (TrackWhyLive && reason) {
     if (sym) {
       // If a specific symbol is referenced, that makes it alive. It may in turn
       // make its section alive.
@@ -253,7 +254,8 @@ void MarkLive<ELFT>::enqueue(InputSectionBase *sec, uint64_t offset,
 }
 
 // Print the stack of reasons that the given symbol is live.
-template <class ELFT> void MarkLive<ELFT>::printWhyLive(Symbol *s) const {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::printWhyLive(Symbol *s) const {
   // Skip dead symbols. A symbol is dead if it belongs to a dead section.
   if (auto *d = dyn_cast<Defined>(s)) {
     auto *reason = dyn_cast_or_null<InputSectionBase>(d->section);
@@ -296,7 +298,8 @@ template <class ELFT> void MarkLive<ELFT>::printWhyLive(Symbol *s) const {
   }
 }
 
-template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *sym) {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::markSymbol(Symbol *sym) {
   if (auto *d = dyn_cast_or_null<Defined>(sym))
     if (auto *isec = dyn_cast_or_null<InputSectionBase>(d->section))
       enqueue(isec, d->value, sym);
@@ -305,7 +308,8 @@ template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *sym) {
 // This is the main function of the garbage collector.
 // Starting from GC-root sections, this function visits all reachable
 // sections to set their "Live" bits.
-template <class ELFT> void MarkLive<ELFT>::run() {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::run() {
   // Add GC root symbols.
 
   // Preserve externally-visible symbols if the symbols defined by this
@@ -346,7 +350,7 @@ template <class ELFT> void MarkLive<ELFT>::run() {
   }
   for (InputSectionBase *sec : ctx.inputSections) {
     if (sec->flags & SHF_GNU_RETAIN) {
-      enqueue(sec, 0, nullptr, std::nullopt);
+      enqueue(sec);
       continue;
     }
     if (sec->flags & SHF_LINK_ORDER)
@@ -397,9 +401,19 @@ template <class ELFT> void MarkLive<ELFT>::run() {
   }
 
   mark();
+
+  if (TrackWhyLive) {
+    for (Symbol *sym : ctx.symtab->getSymbols()) {
+      if (llvm::any_of(ctx.arg.whyLive, [sym](const llvm::GlobPattern &pat) {
+            return pat.match(sym->getName());
+          }))
+        printWhyLive(sym);
+    }
+  }
 }
 
-template <class ELFT> void MarkLive<ELFT>::mark() {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::mark() {
   // Mark all reachable sections.
   while (!queue.empty()) {
     InputSectionBase &sec = *queue.pop_back_val();
@@ -419,15 +433,6 @@ template <class ELFT> void MarkLive<ELFT>::mark() {
     if (sec.nextInSectionGroup)
       enqueue(sec.nextInSectionGroup, 0, nullptr, &sec);
   }
-
-  if (!ctx.arg.whyLive.empty()) {
-    for (Symbol *sym : ctx.symtab->getSymbols()) {
-      if (llvm::any_of(ctx.arg.whyLive, [sym](const llvm::GlobPattern &pat) {
-            return pat.match(sym->getName());
-          }))
-        printWhyLive(sym);
-    }
-  }
 }
 
 // Move the sections for some symbols to the main partition, specifically ifuncs
@@ -439,7 +444,8 @@ template <class ELFT> void MarkLive<ELFT>::mark() {
 // We also need to move sections whose names are C identifiers that are referred
 // to from __start_/__stop_ symbols because there will only be one set of
 // symbols for the whole program.
-template <class ELFT> void MarkLive<ELFT>::moveToMain() {
+template <class ELFT, bool TrackWhyLive>
+void MarkLive<ELFT, TrackWhyLive>::moveToMain() {
   for (ELFFileBase *file : ctx.objectFiles)
     for (Symbol *s : file->getSymbols())
       if (auto *d = dyn_cast<Defined>(s))
@@ -478,13 +484,16 @@ template <class ELFT> void elf::markLive(Ctx &ctx) {
 
   // Follow the graph to mark all live sections.
   for (unsigned i = 1, e = ctx.partitions.size(); i <= e; ++i)
-    MarkLive<ELFT>(ctx, i).run();
+    if (ctx.arg.whyLive.empty())
+      MarkLive<ELFT, false>(ctx, i).run();
+    else
+      MarkLive<ELFT, true>(ctx, i).run();
 
   // If we have multiple partitions, some sections need to live in the main
   // partition even if they were allocated to a loadable partition. Move them
   // there now.
   if (ctx.partitions.size() != 1)
-    MarkLive<ELFT>(ctx, 1).moveToMain();
+    MarkLive<ELFT, false>(ctx, 1).moveToMain();
 
   // Report garbage-collected sections.
   if (ctx.arg.printGcSections)