[WebAssembly] Refactor linker-generated symbols. NFC.

[sbc100]

Summary

Group all sythetic symbols in the in single struct to match
the ELF linker.

This change is part of a larger change to add more linker
symbols such as _end and _edata.

[sbc100]

• [WebAssembly] Add _edata, _end and other link-sythentic symbols

[sbc100]

• revert

[sbc100]

• spelling

[sbc100]

• revert part

[sbc100]

• refactor loop

[ruiu]

LGTM

wasm/Config.h

struct Configuration {
   uint32_t InitialMemory;
   uint32_t MaxMemory;
   uint32_t ZStackSize;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile;
 
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
-  Symbol *StackPointerSymbol = nullptr;
-  Symbol *HeapBaseSymbol = nullptr;
-  Symbol *CtorSymbol = nullptr;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (!Config->Relocatable) {
     static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
     if (!Config->Entry.empty())
       EntrySym = Symtab->addUndefinedFunction(Config->Entry, &Signature);
 
     // Handle the `--undefined <sym>` options.
     for (auto* Arg : Args.filtered(OPT_undefined))
       Symtab->addUndefinedFunction(Arg->getValue(), nullptr);
-
-    // Create linker-synthetic symbols
-    // __wasm_call_ctors:
-    //    Function that directly calls all ctors in priority order.
-    // __stack_pointer:
-    //    Wasm global that holds the address of the top of the explict
-    //    value stack in linear memory.
-    // __dso_handle;
-    //    Global in calls to __cxa_atexit to determine current DLL
-    Config->CtorSymbol = Symtab->addDefinedFunction(
+    WasmSym::CallCtors = Symtab->addDefinedFunction(
         "__wasm_call_ctors", &Signature, WASM_SYMBOL_VISIBILITY_HIDDEN);
-    Config->StackPointerSymbol = Symtab->addDefinedGlobal("__stack_pointer");
-    Config->HeapBaseSymbol = Symtab->addDefinedGlobal("__heap_base");
-    Symtab->addDefinedGlobal("__dso_handle")->setVirtualAddress(0);
+    WasmSym::StackPointer = Symtab->addDefinedGlobal("__stack_pointer");
+    WasmSym::HeapBase = Symtab->addDefinedGlobal("__heap_base");
+    WasmSym::DsoHandle = Symtab->addDefinedGlobal("__dso_handle");
   }
 
   createFiles(Args);
   if (errorCount())
     return;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.

wasm/MarkLive.cpp

if (!Chunk || Chunk->Live)
       return;
     Chunk->Live = true;
     Q.push_back(Chunk);
   };
 
   // Add GC root symbols.
   if (!Config->Entry.empty())
     Enqueue(Symtab->find(Config->Entry));
-  Enqueue(Config->CtorSymbol);
+  Enqueue(WasmSym::CallCtors);
 
   // By default we export all non-hidden, so they are gc roots too
   for (Symbol *Sym : Symtab->getSymbols())
     if (!Sym->isHidden())
       Enqueue(Sym);
 
   // The ctor fuctions are all used the synthetic __wasm_call_ctors function,
   // but since this function is created in-place it doesn't contain reloctations

wasm/Symbols.h

protected:
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
   InputChunk *Chunk = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
   const WasmSignature *FunctionType = nullptr;
 };
 
+// linker-generated symbols
+struct WasmSym {
+  // __stack_pointer
+  // Global that holds the address of the top of the explict  value stack
+  // in linear memory.
+  static Symbol *StackPointer;
+
+  // __heap_base
+  static Symbol *HeapBase;
+
+  // __wasm_call_ctors
+  // Function that directly calls all ctors in priority order.
+  static Symbol *CallCtors;
+
+  // __dso_handle
+  // Global used in calls to __cxa_atexit to determine current DLL
+  static Symbol *DsoHandle;
+};
+
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
+Symbol *WasmSym::CallCtors;
+Symbol *WasmSym::DsoHandle;
+Symbol *WasmSym::HeapBase;
+Symbol *WasmSym::StackPointer;
+
 const WasmSignature &Symbol::getFunctionType() const {
   if (Chunk != nullptr)
     return dyn_cast<InputFunction>(Chunk)->Signature;
 
   assert(FunctionType != nullptr);
   return *FunctionType;
 }
 

wasm/Writer.cpp

void Writer::createGlobalSection() {
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, DefinedGlobals.size(), "global count");
   for (const Symbol *Sym : DefinedGlobals) {
     WasmGlobal Global;
     Global.Type.Type = WASM_TYPE_I32;
-    Global.Type.Mutable = Sym == Config->StackPointerSymbol;
+    Global.Type.Mutable = Sym == WasmSym::StackPointer;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 void Writer::createTableSection() {
   // Always output a table section, even if there are no indirect calls.

 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   parallelForEach(OutputSections, [Buf](OutputSection *S) { S->writeTo(Buf); });
 }
 
 // Fix the memory layout of the output binary.  This assigns memory offsets
 // to each of the input data sections as well as the explicit stack region.
+// The memory layout is as follows, from low to high.
+//  - initialized data (starting at Config->GlobalBase)
+//  - BSS data (not currently implemented in llvm)
+//  - explicit stack (Config->ZStackSize)
+//  - heap start / unallocated
 void Writer::layoutMemory() {
   uint32_t MemoryPtr = 0;
   if (!Config->Relocatable) {
     MemoryPtr = Config->GlobalBase;
     debugPrint("mem: global base = %d\n", Config->GlobalBase);
   }
 
   createOutputSegments();
 
-  // Static data comes first
+  // Arbitrarily set __dso_handle handle to point to the start of the data
+  // segments.
+  if (WasmSym::DsoHandle)
+    WasmSym::DsoHandle->setVirtualAddress(MemoryPtr);
+
   for (OutputSegment *Seg : Segments) {
     MemoryPtr = alignTo(MemoryPtr, Seg->Alignment);
     Seg->StartVA = MemoryPtr;
     debugPrint("mem: %-15s offset=%-8d size=%-8d align=%d\n",
                Seg->Name.str().c_str(), MemoryPtr, Seg->Size, Seg->Alignment);
     MemoryPtr += Seg->Size;
   }
 
+  // TODO: Add .bss space here.
+
   DataSize = MemoryPtr;
   if (!Config->Relocatable)
     DataSize -= Config->GlobalBase;
   debugPrint("mem: static data = %d\n", DataSize);
 
-  // Stack comes after static data
+  // Stack comes after static data and bss
   if (!Config->Relocatable) {
     MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
     if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
       error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
     debugPrint("mem: stack size  = %d\n", Config->ZStackSize);
     debugPrint("mem: stack base  = %d\n", MemoryPtr);
     MemoryPtr += Config->ZStackSize;
-    Config->StackPointerSymbol->setVirtualAddress(MemoryPtr);
+    WasmSym::StackPointer->setVirtualAddress(MemoryPtr);
     debugPrint("mem: stack top   = %d\n", MemoryPtr);
     // Set `__heap_base` to directly follow the end of the stack.  We don't
     // allocate any heap memory up front, but instead really on the malloc/brk
     // implementation growing the memory at runtime.
-    Config->HeapBaseSymbol->setVirtualAddress(MemoryPtr);
+    WasmSym::HeapBase->setVirtualAddress(MemoryPtr);
     debugPrint("mem: heap base   = %d\n", MemoryPtr);
   }
 
   uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
   NumMemoryPages = MemSize / WasmPageSize;
   debugPrint("mem: total pages = %d\n", NumMemoryPages);
 }
 
if (Sym->isFunction()) {
       ImportedGlobals.push_back(Sym);
     }
   }
 }
 
 void Writer::calculateExports() {
   bool ExportHidden = Config->Relocatable;
   StringSet<> UsedNames;
+
   auto BudgeLocalName = [&](const Symbol *Sym) {
     StringRef SymName = Sym->getName();
     // We can't budge non-local names.
     if (!Sym->isLocal())
       return SymName;
     // We must budge local names that have a collision with a symbol that we
     // haven't yet processed.
     if (!Symtab->find(SymName) && UsedNames.insert(SymName).second)
       return SymName;
     for (unsigned I = 1; ; ++I) {
       std::string NameBuf = (SymName + "." + Twine(I)).str();
       if (!UsedNames.count(NameBuf)) {
         StringRef Name = Saver.save(NameBuf);
         UsedNames.insert(Name); // Insert must use safe StringRef from save()
         return Name;
       }
     }
   };
 
-  if (Config->CtorSymbol && (!Config->CtorSymbol->isHidden() || ExportHidden))
+  if (WasmSym::CallCtors && (!WasmSym::CallCtors->isHidden() || ExportHidden))
     ExportedSymbols.emplace_back(
-        WasmExportEntry{Config->CtorSymbol, Config->CtorSymbol->getName()});
+        WasmExportEntry{WasmSym::CallCtors, WasmSym::CallCtors->getName()});
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
       if (!Sym->isDefined() || File != Sym->getFile())
         continue;
       if (Sym->isGlobal())
         continue;
       if (Sym->getChunk()->Discarded)
         continue;
 
       if ((Sym->isHidden() || Sym->isLocal()) && !ExportHidden)
         continue;
 
       // We should never be exporting a non-live symbol
       assert(Sym->getChunk()->Live);
       ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
     }
   }
 
   for (const Symbol *Sym : DefinedGlobals) {
     // Can't export the SP right now because its mutable, and mutuable globals
     // are yet supported in the official binary format.
     // TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
-    if (Sym == Config->StackPointerSymbol)
+    if (Sym == WasmSym::StackPointer)
       continue;
     ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
   }
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {
void Writer::calculateTypes() {
   for (const InputFunction *F : DefinedFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
   uint32_t GlobalIndex = ImportedGlobals.size() + DefinedGlobals.size();
   uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
 
-  if (Config->StackPointerSymbol) {
-    DefinedGlobals.emplace_back(Config->StackPointerSymbol);
-    Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
-  }
-
-  if (Config->HeapBaseSymbol) {
-    DefinedGlobals.emplace_back(Config->HeapBaseSymbol);
-    Config->HeapBaseSymbol->setOutputIndex(GlobalIndex++);
+  auto AddDefinedGlobal = [&](Symbol* Sym) {
+    if (Sym) {
+      DefinedGlobals.emplace_back(Sym);
+      Sym->setOutputIndex(GlobalIndex++);
     }
+  };
+  AddDefinedGlobal(WasmSym::StackPointer);
+  AddDefinedGlobal(WasmSym::HeapBase);
 
   if (Config->Relocatable)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
 
   uint32_t TableIndex = kInitialTableOffset;
 
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    if (Config->Relocatable) {
+    for (ObjFile *File : Symtab->ObjectFiles) {
       DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
       for (Symbol *Sym : File->getSymbols()) {
         // Create wasm globals for data symbols defined in this file
         if (!Sym->isDefined() || File != Sym->getFile())
           continue;
         if (Sym->isFunction())
           continue;
 
-        DefinedGlobals.emplace_back(Sym);
-        Sym->setOutputIndex(GlobalIndex++);
+        AddDefinedGlobal(Sym);
       }
     }
   }
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions) {
       if (Func->Discarded || !Func->Live)

 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCtorFunction() {
   uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
-  Config->CtorSymbol->setOutputIndex(FunctionIndex);
+  WasmSym::CallCtors->setOutputIndex(FunctionIndex);
 
   // First write the body bytes to a string.
   std::string FunctionBody;
   static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, 0, "num locals");
     for (const WasmInitFunc &F : InitFunctions) {
       writeU8(OS, OPCODE_CALL, "CALL");
       writeUleb128(OS, F.FunctionIndex, "function index");
     }
     writeU8(OS, OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
   raw_string_ostream OS(CtorFunctionBody);
   writeUleb128(OS, FunctionBody.size(), "function size");
   OS.flush();
   CtorFunctionBody += FunctionBody;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
-      Signature, BodyArray, Config->CtorSymbol->getName());
+      Signature, BodyArray, WasmSym::CallCtors->getName());
   CtorFunction->setOutputIndex(FunctionIndex);
   DefinedFunctions.emplace_back(CtorFunction.get());
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {