lld/elf: Serialize undefined symbol diagnostics, emit them in one go later

[thakis]

Summary

Part of PR42260.

lld/ELF/Relocations.h

 struct Relocation {
   RelExpr Expr;
   RelType Type;
   uint64_t Offset;
   int64_t Addend;
   Symbol *Sym;
 };
 
+// This function writes undefined symbol diagnostics to an internal buffer.
+// Call reportUndefinedSymbols() after calling scanRelocations() to emit
+// the diagnostics.
 template <class ELFT> void scanRelocations(InputSectionBase &);
 
+template <class ELFT> void reportUndefinedSymbols();
+
 void addIRelativeRelocs();
 
 class ThunkSection;
 class Thunk;
 struct InputSectionDescription;
 
 class ThunkCreator {
 public:

lld/ELF/Relocations.cpp

static std::string maybeReportDiscarded(Undefined &Sym) {
   StringRef Signature = File->getShtGroupSignature(ObjSections, ELFSec);
   if (const InputFile *Prevailing =
           Symtab->ComdatGroups.lookup(CachedHashStringRef(Signature)))
     Msg += "\n>>> section group signature: " + Signature.str() +
            "\n>>> prevailing definition is in " + toString(Prevailing);
   return Msg;
 }
 
+// Undefined diagnostics are collected in a vector and emitted once all of
+// them are known, so that some postprocessing on the list of undefined symbols
+// can happen before lld emits diagnostics.
 struct UndefinedDiag {
   Symbol *Sym;
   InputSectionBase *Sec;
   uint64_t Offset;
   bool IsWarning;
 };
+static std::vector<UndefinedDiag>& Undefs() {
+  // Function-local static to not require a global initializer.
+  static std::vector<UndefinedDiag> UndefsVector;
+  return UndefsVector;
+}
 
 template <class ELFT>
 static void reportUndefinedSymbol(const UndefinedDiag &Undef) {
   Symbol &Sym = *Undef.Sym;
   InputSectionBase &Sec = *Undef.Sec;
   uint64_t Offset = Undef.Offset;
 
   auto Visibility = [&]() -> std::string {
Msg += "\nthe vtable symbol may be undefined because the class is missing "
            "its key function (see https://lld.llvm.org/missingkeyfunction)";
 
   if (Undef.IsWarning)
     warn(Msg);
   else
     error(Msg);
 }
 
+template <class ELFT>
+void elf::reportUndefinedSymbols() {
+  for (const auto& Undef: Undefs())
+    reportUndefinedSymbol<ELFT>(Undef);
+}
+
 // Report an undefined symbol if necessary.
 // Returns true if this function printed out an error message.
 template <class ELFT>
 static bool maybeReportUndefined(Symbol &Sym, InputSectionBase &Sec,
                                  uint64_t Offset) {
   if (!Sym.isUndefined() || Sym.isWeak())
     return false;
 
if (Config->EMachine == EM_PPC64 &&
       cast<Undefined>(Sym).DiscardedSecIdx != 0 && Sec.Name == ".toc")
     return false;
 
 
   UndefinedDiag Undef = { &Sym, &Sec, Offset, /*IsWarning=*/false };
   if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) ||
       Config->NoinhibitExec)
     Undef.IsWarning = true;
-  reportUndefinedSymbol<ELFT>(Undef);
+
+  {
+    static std::mutex Mu;
+    std::lock_guard<std::mutex> Lock(Mu);
+    Undefs().push_back(Undef);
+  }
+
   return !Undef.IsWarning;
 }
 
 // MIPS N32 ABI treats series of successive relocations with the same offset
 // as a single relocation. The similar approach used by N64 ABI, but this ABI
 // packs all relocations into the single relocation record. Here we emulate
 // this for the N32 ABI. Iterate over relocation with the same offset and put
 // theirs types into the single bit-set.
bool ThunkCreator::createThunks(ArrayRef<OutputSection *> OutputSections) {
   ++Pass;
   return AddressesChanged;
 }
 
 template void elf::scanRelocations<ELF32LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF32BE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64BE>(InputSectionBase &);
+template void elf::reportUndefinedSymbols<ELF32LE>();
+template void elf::reportUndefinedSymbols<ELF32BE>();
+template void elf::reportUndefinedSymbols<ELF64LE>();
+template void elf::reportUndefinedSymbols<ELF64BE>();

lld/ELF/Writer.cpp

 
   Symtab->forEachSymbol([](Symbol *S) {
     if (!S->IsPreemptible)
       S->IsPreemptible = computeIsPreemptible(*S);
   });
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
-  if (!Config->Relocatable)
+  if (!Config->Relocatable) {
     forEachRelSec(scanRelocations<ELFT>);
+    reportUndefinedSymbols<ELFT>();
+  }
 
   addIRelativeRelocs();
 
   if (In.Plt && In.Plt->isNeeded())
     In.Plt->addSymbols();
   if (In.Iplt && In.Iplt->isNeeded())
     In.Iplt->addSymbols();