[WebAssembly] Improve support for linker synthetic symbols. NFC

[sbc100]

Summary

This is part of larger change to add synthetic symbols
for section start/end points and init/fini_array:
https://reviews.llvm.org/D40760

Allows synthetic global symbol to have explicily set
their virtual address.

[ruiu]

wasm/Driver.cpp

282

Does it make sense to return its return value to Config->StackPointer so that we don't have to look it up again in Writer?

[sbc100]

• define kStackPointer inside namespace

[sbc100]

• Review feedback

[ruiu]

LGTM

wasm/WriterUtils.h

33

In lld, if a constant appears only once in the driver, we write it in place instead of defining a constant.

[sbc100]

• Inline kStackPointer

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;
-  std::vector<std::pair<Symbol *, WasmGlobal>> SyntheticGlobals;
+  std::vector<Symbol *> SyntheticGlobals;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

 
 // Inject a new wasm global into the output binary with the given value.
 // Wasm global are used in relocatable object files to model symbol imports
 // and exports.  In the final executable the only use of wasm globals is
 // for the exlicit stack pointer (__stack_pointer).
 static void addSyntheticGlobal(StringRef Name, int32_t Value) {
   log("injecting global: " + Name);
   Symbol *S = Symtab->addDefinedGlobal(Name);
-  S->setOutputIndex(Config->SyntheticGlobals.size());
-
-  WasmGlobal Global;
-  Global.Mutable = true;
-  Global.Type = WASM_TYPE_I32;
-  Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-  Global.InitExpr.Value.Int32 = Value;
-  Config->SyntheticGlobals.emplace_back(S, Global);
+  S->setVirtualAddress(Value);
+  Config->SyntheticGlobals.emplace_back(S);
 }
 
 // Inject a new undefined symbol into the link.  This will cause the link to
 // fail unless this symbol can be found.
 static void addSyntheticUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   log("injecting undefined func: " + Name);
   Symtab->addUndefinedFunction(Name, Type);
if (Config->Relocatable && !Config->Entry.empty())
     error("entry point specified for relocatable output file");
 
   if (!Config->Relocatable) {
     if (Config->Entry.empty())
       Config->Entry = "_start";
     static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
     addSyntheticUndefinedFunction(Config->Entry, &Signature);
 
-    addSyntheticGlobal("__stack_pointer", 0);
+    addSyntheticGlobal(kStackPointer, 0);
   }
 
   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/Symbols.h

public:
   const WasmSignature &getFunctionType() const;
   uint32_t getOutputIndex() const;
 
   // Returns the virtual address of a defined global.
   // Only works for globals, not functions.
   uint32_t getVirtualAddress() const;
 
   // Returns true if an output index has been set for this symbol
-  bool hasOutputIndex() { return OutputIndex.hasValue(); }
+  bool hasOutputIndex() const { return OutputIndex.hasValue(); }
 
   // Set the output index of the symbol (in the function or global index
   // space of the output object.
   void setOutputIndex(uint32_t Index);
 
+  void setVirtualAddress(uint32_t VA);
+
   void update(Kind K, InputFile *F = nullptr, const WasmSymbol *Sym = nullptr,
               const InputSegment *Segment = nullptr,
               const WasmSignature *Sig = nullptr);
 
   void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
   // This bit is used by Writer::writeNameSection() to prevent
   // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
   unsigned WrittenToNameSec : 1;
 
 protected:
   unsigned IsLocal : 1;
 
   StringRef Name;
   Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
   const WasmSymbol *Sym = nullptr;
   const InputSegment *Segment = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
+  llvm::Optional<uint32_t> VirtualAddress;
   const WasmSignature *FunctionType;
 };
 
 } // 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

const WasmSignature &Symbol::getFunctionType() const {
   return *FunctionType;
 }
 
 uint32_t Symbol::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   if (isUndefined())
     return UINT32_MAX;
+  if (VirtualAddress.hasValue())
+    return VirtualAddress.getValue();
 
   assert(Sym != nullptr);
   ObjFile *Obj = cast<ObjFile>(File);
   const WasmGlobal &Global =
       Obj->getWasmObj()->globals()[getGlobalIndex() - Obj->NumGlobalImports()];
   assert(Global.Type == llvm::wasm::WASM_TYPE_I32);
   assert(Segment);
   return Segment->translateVA(Global.InitExpr.Value.Int32);
 }
 
 uint32_t Symbol::getOutputIndex() const {
   if (isUndefined() && isWeak())
     return 0;
   return OutputIndex.getValue();
 }
 
+void Symbol::setVirtualAddress(uint32_t Value) {
+  DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
+  VirtualAddress = Value;
+}
+
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
   assert(!hasOutputIndex());
   OutputIndex = Index;
 }
 
 void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym,
                     const InputSegment *Seg, const WasmSignature *Sig) {

wasm/Writer.cpp

private:
   uint32_t DataSize = 0;
   uint32_t NumFunctions = 0;
   uint32_t NumGlobals = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t NumTableElems = 0;
   uint32_t NumElements = 0;
   uint32_t InitialTableOffset = 0;
 
+  Symbol *StackSymbol = nullptr;
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<Symbol *> FunctionImports;
   std::vector<Symbol *> GlobalImports;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
void Writer::createImportSection() {
   if (NumImports == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_IMPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumImports, "import count");
 
-  for (Symbol *Sym : FunctionImports) {
+  for (const Symbol *Sym : FunctionImports) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     Import.Kind = WASM_EXTERNAL_FUNCTION;
     assert(TypeIndices.count(Sym->getFunctionType()) > 0);
     Import.SigIndex = TypeIndices.lookup(Sym->getFunctionType());
     writeImport(OS, Import);
   }
 
   if (Config->ImportMemory) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
     Import.Memory.Flags = 0;
     Import.Memory.Initial = NumMemoryPages;
     writeImport(OS, Import);
   }
 
-  for (Symbol *Sym : GlobalImports) {
+  for (const Symbol *Sym : GlobalImports) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     Import.Kind = WASM_EXTERNAL_GLOBAL;
     Import.Global.Mutable = false;
     Import.Global.Type = WASM_TYPE_I32; // Sym->getGlobalType();
     writeImport(OS, Import);
   }
void Writer::createMemorySection() {
   writeUleb128(OS, NumMemoryPages, "initial pages");
 }
 
 void Writer::createGlobalSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumGlobals, "global count");
-  for (auto &Pair : Config->SyntheticGlobals) {
-    WasmGlobal &Global = Pair.second;
+  for (const Symbol *Sym : Config->SyntheticGlobals) {
+    WasmGlobal Global;
+    Global.Type = WASM_TYPE_I32;
+    Global.Mutable = Sym == StackSymbol;
+    Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+    Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 
   if (Config->EmitRelocs) {
     for (ObjFile *File : Symtab->ObjectFiles) {
       uint32_t GlobalIndex = File->NumGlobalImports();
       for (const WasmGlobal &Global : File->getWasmObj()->globals()) {
         WasmGlobal RelocatedGlobal(Global);
void Writer::layoutMemory() {
   // Stack comes after static data
   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->SyntheticGlobals[0].second.InitExpr.Value.Int32 = MemoryPtr;
+    StackSymbol->setVirtualAddress(MemoryPtr);
     debugPrint("mem: stack top   = %d\n", MemoryPtr);
   }
 
   uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
   NumMemoryPages = MemSize / WasmPageSize;
   debugPrint("mem: total pages = %d\n", NumMemoryPages);
 }
 
for (InputSegment *Segment : File->Segments) {
           Segment->Relocations.push_back(R);
         }
       }
     }
   }
 }
 
 void Writer::run() {
-  if (!Config->Relocatable)
+  if (!Config->Relocatable) {
+    StackSymbol = Symtab->find(kStackPointer);
     InitialTableOffset = 1;
+  }
 
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateImports");
   calculateImports();
   log("-- calculateOffsets");
   calculateOffsets();
 

wasm/WriterUtils.h

 inline bool operator!=(const llvm::wasm::WasmSignature &LHS,
                        const llvm::wasm::WasmSignature &RHS) {
   return !(LHS == RHS);
 }
 
 namespace lld {
 namespace wasm {
 
+static const char* kStackPointer = "__stack_pointer";
+
 struct OutputRelocation {
   llvm::wasm::WasmRelocation Reloc;
   uint32_t NewIndex;
   uint32_t Value;
 };
 
 void debugWrite(uint64_t offset, llvm::Twine msg);