[lld-macho][nfc] Simplify MarkLive.cpp using `if constexpr`

[int3]

Summary

No significant perf diff, as expected.

           base           diff           difference (95% CI)
sys_time   1.722 ± 0.030  1.727 ± 0.027  [  -0.6% ..   +1.2%]
user_time  5.081 ± 0.032  5.087 ± 0.030  [  -0.2% ..   +0.4%]
wall_time  6.008 ± 0.056  6.029 ± 0.053  [  -0.1% ..   +0.8%]
samples    25             37

[oontvoo]

nice!

lld/MachO/MarkLive.cpp

void enqueue(InputSection *isec, uint64_t off) override {
     enqueue(isec, off, nullptr);
   }
   void addSym(Symbol *s) override { addSym(s, nullptr); }
   void markTransitively() override;
 
 private:
   void enqueue(InputSection *isec, uint64_t off, const WorklistEntry *prev);
   void addSym(Symbol *s, const WorklistEntry *prev);
-  void printWhyLive(Symbol *s, const WorklistEntry *prev);
   const InputSection *getInputSection(const WorklistEntry *) const;
   WorklistEntry *makeEntry(InputSection *, const WorklistEntry *prev) const;
 
   // We build up a worklist of sections which have been marked as live. We
   // only push into the worklist when we discover an unmarked section, and we
   // mark as we push, so sections never appear twice in the list. Literal
   // sections cannot contain references to other sections, so we only store
   // ConcatInputSections in our worklist.
   SmallVector<WorklistEntry *, 256> worklist;
 };
 
 template <bool RecordWhyLive>
 void MarkLiveImpl<RecordWhyLive>::enqueue(
     InputSection *isec, uint64_t off,
     const typename MarkLiveImpl<RecordWhyLive>::WorklistEntry *prev) {
   if (isec->isLive(off))
     return;
   isec->markLive(off);
   if (auto s = dyn_cast<ConcatInputSection>(isec)) {
     assert(!s->isCoalescedWeak());
     worklist.push_back(makeEntry(s, prev));
   }
 }
 
-template <bool RecordWhyLive>
-void MarkLiveImpl<RecordWhyLive>::addSym(
-    Symbol *s,
-    const typename MarkLiveImpl<RecordWhyLive>::WorklistEntry *prev) {
-  if (s->used)
-    return;
-  s->used = true;
-  printWhyLive(s, prev);
-  if (auto *d = dyn_cast<Defined>(s)) {
-    if (d->isec)
-      enqueue(d->isec, d->value, prev);
-    if (d->unwindEntry)
-      enqueue(d->unwindEntry, 0, prev);
-  }
-}
-
-static void printWhyLiveImpl(const Symbol *s, const WhyLiveEntry *prev) {
+static void printWhyLive(const Symbol *s, const WhyLiveEntry *prev) {
   std::string out = toString(*s) + " from " + toString(s->getFile());
   int indent = 2;
   for (const WhyLiveEntry *entry = prev; entry;
        entry = entry->prev, indent += 2) {
     const TinyPtrVector<Defined *> &symbols = entry->isec->symbols;
     // With .subsections_with_symbols set, most isecs will have exactly one
     // entry in their symbols vector, so we just print the first one.
     if (!symbols.empty())
       out += "\n" + std::string(indent, ' ') + toString(*symbols.front()) +
              " from " + toString(symbols.front()->getFile());
   }
   message(out);
 }
 
-// NOTE: if/when `constexpr if` becomes available, we can simplify a lot of
-// the partial template specializations below.
-
-template <>
-void MarkLiveImpl<true>::printWhyLive(Symbol *s, const WhyLiveEntry *prev) {
+template <bool RecordWhyLive>
+void MarkLiveImpl<RecordWhyLive>::addSym(
+    Symbol *s,
+    const typename MarkLiveImpl<RecordWhyLive>::WorklistEntry *prev) {
+  if (s->used)
+    return;
+  s->used = true;
+  if constexpr (RecordWhyLive)
     if (!config->whyLive.empty() && config->whyLive.match(s->getName()))
-    printWhyLiveImpl(s, prev);
+      printWhyLive(s, prev);
+  if (auto *d = dyn_cast<Defined>(s)) {
+    if (d->isec)
+      enqueue(d->isec, d->value, prev);
+    if (d->unwindEntry)
+      enqueue(d->unwindEntry, 0, prev);
   }
-
-template <>
-void MarkLiveImpl<false>::printWhyLive(Symbol *s, const InputSection *prev) {}
-
-template <>
-const InputSection *
-MarkLiveImpl<true>::getInputSection(const WhyLiveEntry *entry) const {
-  return entry->isec;
 }
 
-template <>
-const InputSection *
-MarkLiveImpl<false>::getInputSection(const InputSection *isec) const {
-  return isec;
+template <bool RecordWhyLive>
+const InputSection *MarkLiveImpl<RecordWhyLive>::getInputSection(
+    const MarkLiveImpl<RecordWhyLive>::WorklistEntry *entry) const {
+  if constexpr (RecordWhyLive)
+    return entry->isec;
+  else
+    return entry;
 }
 
-template <>
-typename MarkLiveImpl<true>::WorklistEntry *MarkLiveImpl<true>::makeEntry(
-    InputSection *isec, const MarkLiveImpl<true>::WorklistEntry *prev) const {
+template <bool RecordWhyLive>
+typename MarkLiveImpl<RecordWhyLive>::WorklistEntry *
+MarkLiveImpl<RecordWhyLive>::makeEntry(
+    InputSection *isec,
+    const MarkLiveImpl<RecordWhyLive>::WorklistEntry *prev) const {
+  if constexpr (RecordWhyLive) {
     if (!isec) {
       assert(!prev);
       return nullptr;
     }
     return make<WhyLiveEntry>(isec, prev);
-}
-
-template <>
-typename MarkLiveImpl<false>::WorklistEntry *MarkLiveImpl<false>::makeEntry(
-    InputSection *isec, const MarkLiveImpl<false>::WorklistEntry *prev) const {
+  } else {
     return isec;
   }
+}
 
 template <bool RecordWhyLive>
 void MarkLiveImpl<RecordWhyLive>::markTransitively() {
   do {
     // Mark things reachable from GC roots as live.
     while (!worklist.empty()) {
       WorklistEntry *entry = worklist.pop_back_val();
       // Entries that get placed onto the worklist always contain