[WebAssembly] Seal imports section before counting imports

[sbc100]

Summary

Before we can assign entries in the function of global index space
we need to know the total number of function and global imports
respectively.

To avoid programmer error this change seals that imports section before
assigned function and global index space. Any attempt to add an import
after the section is sealed will assert.

The lack this such as check caused https://reviews.llvm.org/D61876
to be reverted. I'm also trying to craft a test case the this
failure.

[ruiu]

LGTM

[sbc100]

• fix tests

lld/wasm/SyntheticSections.h

 
 class ImportSection : public SyntheticSection {
 public:
   ImportSection() : SyntheticSection(llvm::wasm::WASM_SEC_IMPORT) {}
   bool isNeeded() const override { return numImports() > 0; }
   void writeBody() override;
   void addImport(Symbol *Sym);
   void addGOTEntry(Symbol *Sym);
+  void seal() { IsSealed = true; }
   uint32_t numImports() const;
+  uint32_t numImportedGlobals() const {
+    assert(IsSealed);
+    return NumImportedGlobals;
+  }
+  uint32_t numImportedFunctions() const {
+    assert(IsSealed);
+    return NumImportedFunctions;
+  }
+  uint32_t numImportedEvents() const {
+    assert(IsSealed);
+    return NumImportedEvents;
+  }
 
-  unsigned NumImportedGlobals = 0;
-  unsigned NumImportedFunctions = 0;
-  unsigned NumImportedEvents = 0;
   std::vector<const Symbol *> ImportedSymbols;
 
 protected:
+  bool IsSealed = false;
+  unsigned NumImportedGlobals = 0;
+  unsigned NumImportedFunctions = 0;
+  unsigned NumImportedEvents = 0;
   std::vector<const Symbol *> GOTSymbols;
 };
 
 class FunctionSection : public SyntheticSection {
 public:
   FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
 
   bool isNeeded() const override { return InputFunctions.size() > 0; };

lld/wasm/SyntheticSections.cpp

 
 void TypeSection::writeBody() {
   writeUleb128(BodyOutputStream, Types.size(), "type count");
   for (const WasmSignature *Sig : Types)
     writeSig(BodyOutputStream, *Sig);
 }
 
 uint32_t ImportSection::numImports() const {
+  assert(IsSealed);
   uint32_t NumImports = ImportedSymbols.size() + GOTSymbols.size();
   if (Config->ImportMemory)
     ++NumImports;
   if (Config->ImportTable)
     ++NumImports;
   return NumImports;
 }
 
 void ImportSection::addGOTEntry(Symbol *Sym) {
+  //assert(!IsSealed);
   if (Sym->hasGOTIndex())
     return;
   Sym->setGOTIndex(NumImportedGlobals++);
   GOTSymbols.push_back(Sym);
 }
 
 void ImportSection::addImport(Symbol *Sym) {
+  assert(!IsSealed);
   ImportedSymbols.emplace_back(Sym);
   if (auto *F = dyn_cast<FunctionSymbol>(Sym))
     F->setFunctionIndex(NumImportedFunctions++);
   else if (auto *G = dyn_cast<GlobalSymbol>(Sym))
     G->setGlobalIndex(NumImportedGlobals++);
   else
     cast<EventSymbol>(Sym)->setEventIndex(NumImportedEvents++);
 }
void FunctionSection::writeBody() {
   for (const InputFunction *Func : InputFunctions)
     writeUleb128(OS, Out.TypeSec->lookupType(Func->Signature), "sig index");
 }
 
 void FunctionSection::addFunction(InputFunction *Func) {
   if (!Func->Live)
     return;
   uint32_t FunctionIndex =
-      Out.ImportSec->NumImportedFunctions + InputFunctions.size();
+      Out.ImportSec->numImportedFunctions() + InputFunctions.size();
   InputFunctions.emplace_back(Func);
   Func->setFunctionIndex(FunctionIndex);
 }
 
 void TableSection::writeBody() {
   uint32_t TableSize = Out.ElemSec->ElemOffset + Out.ElemSec->numEntries();
 
   raw_ostream &OS = BodyOutputStream;
for (const DefinedData *Sym : DefinedFakeGlobals) {
     writeGlobal(OS, Global);
   }
 }
 
 void GlobalSection::addGlobal(InputGlobal *Global) {
   if (!Global->Live)
     return;
   uint32_t GlobalIndex =
-      Out.ImportSec->NumImportedGlobals + InputGlobals.size();
+      Out.ImportSec->numImportedGlobals() + InputGlobals.size();
   LLVM_DEBUG(dbgs() << "addGlobal: " << GlobalIndex << "\n");
   Global->setGlobalIndex(GlobalIndex);
   Out.GlobalSec->InputGlobals.push_back(Global);
 }
 
 void EventSection::writeBody() {
   raw_ostream &OS = BodyOutputStream;
 
   writeUleb128(OS, InputEvents.size(), "event count");
   for (InputEvent *E : InputEvents) {
     E->Event.Type.SigIndex = Out.TypeSec->lookupType(E->Signature);
     writeEvent(OS, E->Event);
   }
 }
 
 void EventSection::addEvent(InputEvent *Event) {
   if (!Event->Live)
     return;
-  uint32_t EventIndex = Out.ImportSec->NumImportedEvents + InputEvents.size();
+  uint32_t EventIndex = Out.ImportSec->numImportedEvents() + InputEvents.size();
   LLVM_DEBUG(dbgs() << "addEvent: " << EventIndex << "\n");
   Event->setEventIndex(EventIndex);
   InputEvents.push_back(Event);
 }
 
 void ExportSection::writeBody() {
   raw_ostream &OS = BodyOutputStream;
 

 }
 
 void LinkingSection::addToSymtab(Symbol *Sym) {
   Sym->setOutputSymbolIndex(SymtabEntries.size());
   SymtabEntries.emplace_back(Sym);
 }
 
 unsigned NameSection::numNames() const {
-  unsigned NumNames = Out.ImportSec->NumImportedFunctions;
+  unsigned NumNames = Out.ImportSec->numImportedFunctions();
   for (const InputFunction *F : Out.FunctionSec->InputFunctions)
     if (!F->getName().empty() || !F->getDebugName().empty())
       ++NumNames;
 
   return NumNames;
 }
 
 // Create the custom "name" section containing debug symbol names.

lld/wasm/Writer.cpp

if (!Config->Relocatable && !Config->ImportMemory)
     Out.ExportSec->Exports.push_back(
         WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
 
   if (!Config->Relocatable && Config->ExportTable)
     Out.ExportSec->Exports.push_back(
         WasmExport{FunctionTableName, WASM_EXTERNAL_TABLE, 0});
 
   unsigned FakeGlobalIndex =
-      Out.ImportSec->NumImportedGlobals + Out.GlobalSec->InputGlobals.size();
+      Out.ImportSec->numImportedGlobals() + Out.GlobalSec->InputGlobals.size();
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isExported())
       continue;
     if (!Sym->isLive())
       continue;
 
     StringRef Name = Sym->getName();
for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputChunk *Chunk : File->Segments)
       scanRelocations(Chunk);
     for (auto &P : File->CustomSections)
       scanRelocations(P);
   }
 }
 
 void Writer::assignIndexes() {
-  assert(Out.FunctionSec->InputFunctions.empty());
+  // Seal the import section, since other index spaces such as function and
+  // global are effected by the number of imports.
+  Out.ImportSec->seal();
 
   for (InputFunction *Func : Symtab->SyntheticFunctions)
     Out.FunctionSec->addFunction(Func);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions)
       Out.FunctionSec->addFunction(Func);
void Writer::run() {
   populateSymtab();
   log("-- addSections");
   addSections();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(Out.FunctionSec->InputFunctions.size()));
     log("Defined Globals  : " + Twine(Out.GlobalSec->InputGlobals.size()));
     log("Defined Events   : " + Twine(Out.EventSec->InputEvents.size()));
-    log("Function Imports : " + Twine(Out.ImportSec->NumImportedFunctions));
-    log("Global Imports   : " + Twine(Out.ImportSec->NumImportedGlobals));
-    log("Event Imports    : " + Twine(Out.ImportSec->NumImportedEvents));
+    log("Function Imports : " + Twine(Out.ImportSec->numImportedFunctions()));
+    log("Global Imports   : " + Twine(Out.ImportSec->numImportedGlobals()));
+    log("Event Imports    : " + Twine(Out.ImportSec->numImportedEvents()));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
   createHeader();
   log("-- finalizeSections");
   finalizeSections();