COFF: Simplify construction of safe SEH table. NFCI.

[pcc]

Summary

Instead of building intermediate sets of exception handlers for each
object file, just create one for the final output file.

[ruiu]

LGTM. Nice!

lld/COFF/Writer.cpp

802 ↗

(On Diff #124640)

You are creating a copy of ulittle32_t from ulittle32_t. I think it makes more sense if you change the type of I to ulittle32_t & or just uint32_t.

lld/trunk/COFF/InputFiles.h

public:
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
   static std::vector<ObjFile *> Instances;
 
   // True if this object file is compatible with SEH.
   // COFF-specific and x86-only.
   bool SEHCompat = false;
 
-  // The list of safe exception handlers listed in .sxdata section.
+  // The symbol table indexes of the safe exception handlers.
   // COFF-specific and x86-only.
-  std::set<Symbol *> SEHandlers;
+  ArrayRef<llvm::support::ulittle32_t> SXData;
 
   // Pointer to the PDB module descriptor builder. Various debug info records
   // will reference object files by "module index", which is here. Things like
   // source files and section contributions are also recorded here. Will be null
   // if we are not producing a PDB.
   llvm::pdb::DbiModuleDescriptorBuilder *ModuleDBI = nullptr;
 
 private:
   void initializeChunks();
   void initializeSymbols();
-  void initializeSEH();
 
   SectionChunk *
   readSection(uint32_t SectionNumber,
               const llvm::object::coff_aux_section_definition *Def);
 
   void readAssociativeDefinition(
       COFFSymbolRef COFFSym,
       const llvm::object::coff_aux_section_definition *Def);
 
   llvm::Optional<Symbol *>
   createDefined(COFFSymbolRef Sym,
                 std::vector<const llvm::object::coff_aux_section_definition *>
                     &ComdatDefs);
   Symbol *createRegular(COFFSymbolRef Sym);
   Symbol *createUndefined(COFFSymbolRef Sym);
 
   std::unique_ptr<COFFObjectFile> COFFObj;
-  const coff_section *SXData = nullptr;
 
   // List of all chunks defined by this file. This includes both section
   // chunks and non-section chunks for common symbols.
   std::vector<Chunk *> Chunks;
 
   // CodeView debug info sections.
   std::vector<SectionChunk *> DebugChunks;
 

lld/trunk/COFF/InputFiles.cpp

if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
     COFFObj.reset(Obj);
   } else {
     fatal(toString(this) + " is not a COFF file");
   }
 
   // Read section and symbol tables.
   initializeChunks();
   initializeSymbols();
-  initializeSEH();
 }
 
 // We set SectionChunk pointers in the SparseChunks vector to this value
 // temporarily to mark comdat sections as having an unknown resolution. As we
 // walk the object file's symbol table, once we visit either a leader symbol or
 // an associative section definition together with the parent comdat's leader,
 // we set the pointer to either nullptr (to mark the section as discarded) or a
 // valid SectionChunk for that section.
SectionChunk *ObjFile::readSection(uint32_t SectionNumber,
   const coff_section *Sec;
   StringRef Name;
   if (auto EC = COFFObj->getSection(SectionNumber, Sec))
     fatal("getSection failed: #" + Twine(SectionNumber) + ": " + EC.message());
   if (auto EC = COFFObj->getSectionName(Sec, Name))
     fatal("getSectionName failed: #" + Twine(SectionNumber) + ": " +
           EC.message());
   if (Name == ".sxdata") {
-    SXData = Sec;
+    ArrayRef<uint8_t> Data;
+    COFFObj->getSectionContents(Sec, Data);
+    if (Data.size() % 4 != 0)
+      fatal(".sxdata must be an array of symbol table indices");
+    SXData = {reinterpret_cast<const ulittle32_t *>(Data.data()),
+              Data.size() / 4};
     return nullptr;
   }
   if (Name == ".drectve") {
     ArrayRef<uint8_t> Data;
     COFFObj->getSectionContents(Sec, Data);
     Directives = std::string((const char *)Data.data(), Data.size());
     return nullptr;
   }
if (SparseChunks[SectionNumber] == PendingComdat) {
     }
   }
 
   if (SparseChunks[SectionNumber] == PendingComdat)
     return None;
   return createRegular(Sym);
 }
 
-void ObjFile::initializeSEH() {
-  if (!SEHCompat || !SXData)
-    return;
-  ArrayRef<uint8_t> A;
-  COFFObj->getSectionContents(SXData, A);
-  if (A.size() % 4 != 0)
-    fatal(".sxdata must be an array of symbol table indices");
-  auto *I = reinterpret_cast<const ulittle32_t *>(A.data());
-  auto *E = reinterpret_cast<const ulittle32_t *>(A.data() + A.size());
-  for (; I != E; ++I)
-    if (Symbols[*I])
-      SEHandlers.insert(Symbols[*I]);
-}
-
 MachineTypes ObjFile::getMachineType() {
   if (COFFObj)
     return static_cast<MachineTypes>(COFFObj->getMachine());
   return IMAGE_FILE_MACHINE_UNKNOWN;
 }
 
 StringRef ltrim1(StringRef S, const char *Chars) {
   if (!S.empty() && strchr(Chars, S[0]))

lld/trunk/COFF/Writer.cpp

void Writer::createSEHTable(OutputSection *RData) {
   if (Config->Machine != I386)
     return;
 
   std::set<Defined *> Handlers;
 
   for (ObjFile *File : ObjFile::Instances) {
     if (!File->SEHCompat)
       return;
-    for (Symbol *B : File->SEHandlers) {
-      // Make sure the handler is still live.
+    for (uint32_t I : File->SXData)
+      if (Symbol *B = File->getSymbol(I))
         if (B->isLive())
           Handlers.insert(cast<Defined>(B));
-    }
-  }
 
   if (Handlers.empty())
     return;
 
   SEHTable = make<SEHTableChunk>(Handlers);
   RData->addChunk(SEHTable);
 
   // Replace the absolute table symbol with a synthetic symbol pointing to the