[lld] [lld][ELF] Add --why-live flag (inspired by Mach-O) (PR #127112)

[Peter Smith via llvm-commits]

================
@@ -201,45 +238,126 @@ void MarkLive<ELFT>::enqueue(InputSectionBase *sec, uint64_t offset) {
     return;
   sec->partition = sec->partition ? 1 : partition;
 
+  if (TrackWhyLive) {
+    if (sym) {
+      // If a specific symbol is referenced, that makes it alive. It may in turn
+      // make its section alive.
+      whyLive.try_emplace(sym, reason);
+      whyLive.try_emplace(sec, LiveReason{sym, "contained live symbol"});
+    } else {
+      // Otherwise, the reference generically makes the section live.
+      whyLive.try_emplace(sec, reason);
+    }
+  }
+
   // Add input section to the queue.
   if (InputSection *s = dyn_cast<InputSection>(sec))
     queue.push_back(s);
 }
 
-template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *sym) {
+// Print the stack of reasons that the given symbol is live.
+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 *sec = dyn_cast_or_null<InputSectionBase>(d->section);
+    if (sec && !sec->isLive())
+      return;
+  }
+
+  auto msg = Msg(ctx);
+
+  const auto printSymbol = [&](Symbol *s) {
+    if (s->isLocal())
+      msg << s->file << ":(" << s << ')';
+    else
+      msg << s;
+  };
+
+  msg << "live symbol: ";
+  printSymbol(s);
+
+  LiveObject cur = s;
+  while (true) {
+    auto it = whyLive.find(cur);
+    LiveReason reason;
+    // If there is a specific reason this object is live...
+    if (it != whyLive.end()) {
+      reason = it->second;
+    } else {
+      // This object is live, but it has no tracked reason. It must be an
+      // unreferenced symbol in a live section or a symbol with no section.
+      const auto getParentSec = [&]() -> InputSectionBase * {
+        auto *d = dyn_cast<Defined>(std::get<Symbol *>(cur));
+        if (!d)
+          return nullptr;
+        return dyn_cast_or_null<InputSectionBase>(d->section);
+      };
+      InputSectionBase *sec = getParentSec();
+      reason = sec ? LiveReason{sec, "in live section"}
+                   : LiveReason{std::nullopt, "no section"};
+    }
+
+    if (reason.obj) {
+      msg << "\n>>> " << reason.desc << ": ";
+      // The reason may not yet have been resolved to a symbol; do so now.
+      if (std::holds_alternative<SecOffset>(*reason.obj)) {
+        const auto &so = std::get<SecOffset>(*reason.obj);
+        InputSectionBase *sec = so.first;
+        Defined *sym = sec->getEnclosingSymbol(so.second);
+        cur = sym ? LiveObject(sym) : LiveObject(sec);
+      } else {
+        cur = *reason.obj;
+      }
+
+      if (std::holds_alternative<Symbol *>(cur))
+        printSymbol(std::get<Symbol *>(cur));
+      else
+        msg << std::get<InputSectionBase *>(cur);
+    }
+    if (!reason.obj) {
----------------
smithp35 wrote:

Unless I've missed an update to `reason.obj`, this looks like it could be just `else {`

https://github.com/llvm/llvm-project/pull/127112