[WebAssembly] Export globals when linking with -r/--relocatable

[sbc100]

Summary

This change cleans up the way wasm exports and globals
are generated, particualrly for -r/--relocatable where
globals need to be created and exported in order for
output relocations which reference them.

Remove the need for a per file GlobalIndexOffset and
instead set the output index for each symbol directly.
This simplifies the code in several places.

[sbc100]

@ncw , this is change I've be wroking on for a while now that might be help (or an annoying merge conflict!) for your work on function stripping. It basically does for globals what I imagine we would want to do for functions (i.e. eliminates the per file index offset). Sorry if it doesn't merge well with your work, but hopefully there are things that they share and could make your partch smaller?

[ncw]

This change looks good, it's pretty much the same direction I took with the function-pointer-table.

I didn't try tackling global exports in my COMDAT work, because I don't really understand the use-case for relocatable output, and don't really know how it should work.

I don't mind a few merge conflicts, this should be fine. I can't see anything to reuse in the COMDAT work, it's more a case of doing matching changes elsewhere (for segments and table entries).

wasm/Writer.cpp

283

Can we now get rid of the ugly WrittenToSymtab variable? It's state that doesn't properly belong on the Sym at all - much better to have a local vector like you've done.

[sbc100]

@ruiu, do you prefer that I wait for your LGTM on all lld changes? I'm assuming you would be ok with small-ish wasm-only changes being peer-reviewed rather than requiring owner reviewed? e(assuming you consider yourself the owner of lld?)

[ruiu]

You don't need to wait for my LGTM for small-ish changes. I want to continue reviewing wasm lld patches to (1) keep wasm in line with other ports, (2) keep wasm lld as fast as possible, and (3) prevent wasm from making mistakes that other binary formats made in their history. But that's mostly about high-level design.

[sbc100]

In case it wasn't clear I was asking about this change in particular too. Want me to wait on your LG?

[ruiu]

If I'm not too slow, give me a few hours to review patches. If I didn't respond timely, please go ahead without my LG. Does this sound good?

I'll do post-commit review in the latter case.

[sbc100]

Sorry, didn't mean to imply you were going slow. I just wasn't sure if I was waiting on you at all in this case since I got another LGTM. I can wait :)

[ruiu]

LGTM :)

[ncw]

I'm not at my computer, sorry if I'm wrong, but I think this change leaves an unused variable - Writer::NumGlobals if I remember correctly.

test/wasm/data-layout.ll

 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           1024
+; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           1040
+; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           1048
+; CHECK-NEXT:           Value:           1040
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           1052
+; CHECK-NEXT:           Value:           1048
 
 ; CHECK:       - Type:            DATA
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; CHECK-NEXT:         Index:           4
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000001F
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         0100000000000000000000000000000003000000000000001C040000

test/wasm/relocatable.ll

 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:         
 ; CHECK-NEXT:       - Name:            hello
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            my_func
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:       - Name:            hello_str
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            func_addr1
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            func_addr2
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:       - Name:            data_addr1
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Functions:       [ 3, 1 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     

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 Symbol* addSyntheticGlobal(StringRef Name, int32_t Value) {
   log("injecting global: " + Name);
   Symbol *S = Symtab->addDefinedGlobal(Name);
   S->setVirtualAddress(Value);
-  S->setOutputIndex(Config->SyntheticGlobals.size());
   Config->SyntheticGlobals.emplace_back(S);
   return 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) {

wasm/InputFiles.h

public:
   // Returns true if the given function index is an imported function,
   // as opposed to the locally defined function.
   bool isImportedFunction(uint32_t Index) const;
 
   size_t NumFunctionImports() const { return FunctionImports; }
   size_t NumGlobalImports() const { return GlobalImports; }
 
   int32_t FunctionIndexOffset = 0;
-  int32_t GlobalIndexOffset = 0;
   int32_t TableIndexOffset = 0;
   const WasmSection *CodeSection = nullptr;
   std::vector<OutputRelocation> CodeRelocations;
   int32_t CodeOffset = 0;
   const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;

wasm/InputFiles.cpp

Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   return MBRef;
 }
 
 void ObjFile::dumpInfo() const {
   log("reloc info for: " + getName() + "\n" +
       "        FunctionIndexOffset : " + Twine(FunctionIndexOffset) + "\n" +
       "         NumFunctionImports : " + Twine(NumFunctionImports()) + "\n" +
       "           TableIndexOffset : " + Twine(TableIndexOffset) + "\n" +
-      "          GlobalIndexOffset : " + Twine(GlobalIndexOffset) + "\n" +
       "           NumGlobalImports : " + Twine(NumGlobalImports()) + "\n");
 }
 
 bool ObjFile::isImportedFunction(uint32_t Index) const {
   return Index < NumFunctionImports();
 }
 
 const Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   return FunctionSymbols[Index];
 }
 
 const Symbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
   return GlobalSymbols[Index];
 }
 
 uint32_t ObjFile::getRelocatedAddress(uint32_t Index) const {
   return getGlobalSymbol(Index)->getVirtualAddress();
 }
 
 uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
-  DEBUG(dbgs() << "relocateFunctionIndex: " << Original);
   const Symbol *Sym = getFunctionSymbol(Original);
-  uint32_t Index;
-  if (Sym)
-    Index = Sym->getOutputIndex();
-  else
-    Index = Original + FunctionIndexOffset;
-
-  DEBUG(dbgs() << " -> " << Index << "\n");
+  uint32_t Index = Sym->getOutputIndex();
+  DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
+               << Original << " -> " << Index << "\n");
   return Index;
 }
 
 uint32_t ObjFile::relocateTypeIndex(uint32_t Original) const {
   return TypeMap[Original];
 }
 
 uint32_t ObjFile::relocateTableIndex(uint32_t Original) const {
   return Original + TableIndexOffset;
 }
 
 uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
-  DEBUG(dbgs() << "relocateGlobalIndex: " << Original);
-  uint32_t Index;
-  const Symbol *Sym = getGlobalSymbol(Original);
-  if (Sym)
-    Index = Sym->getOutputIndex();
-  else
-    Index = Original + GlobalIndexOffset;
-
-  DEBUG(dbgs() << " -> " << Index << "\n");
+  const Symbol* Sym = getGlobalSymbol(Original);
+  uint32_t Index = Sym->getOutputIndex();
+  DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
+               << " -> " << Index << "\n");
   return Index;
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> Bin = check(createBinary(MB), toString(this));
 

wasm/OutputSections.cpp

std::string lld::toString(OutputSection *Section) {
   std::string rtn = sectionTypeToString(Section->Type);
   if (!Section->Name.empty())
     rtn += "(" + Section->Name + ")";
   return rtn;
 }
 
 static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
   DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
-               << " index=" << Reloc.Reloc.Index << " new=" << Reloc.NewIndex
-               << " value=" << Reloc.Value << " offset=" << Reloc.Reloc.Offset
-               << "\n");
+               << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
+               << " offset=" << Reloc.Reloc.Offset << "\n");
   Buf += Reloc.Reloc.Offset;
   int64_t ExistingValue;
   switch (Reloc.Reloc.Type) {
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     ExistingValue = decodeULEB128(Buf);
     if (ExistingValue != Reloc.Reloc.Index) {
       DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");

 // relocations based on them. Calculates the updated index and offset for
 // each relocation as well as the value to write out in the final binary.
 static void calcRelocations(const ObjFile &File,
                             ArrayRef<WasmRelocation> Relocs,
                             std::vector<OutputRelocation> &OutputRelocs,
                             int32_t OutputOffset) {
   log("calcRelocations: " + File.getName() + " offset=" + Twine(OutputOffset));
   for (const WasmRelocation &Reloc : Relocs) {
-    int64_t NewIndex = calcNewIndex(File, Reloc);
     OutputRelocation NewReloc;
     NewReloc.Reloc = Reloc;
     NewReloc.Reloc.Offset += OutputOffset;
-    NewReloc.NewIndex = NewIndex;
     DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
-                 << " offset=" << Reloc.Offset << " new=" << NewIndex
+                 << " offset=" << Reloc.Offset
                  << " newOffset=" << NewReloc.Reloc.Offset << "\n");
 
+    if (Config->EmitRelocs)
+      NewReloc.NewIndex = calcNewIndex(File, Reloc);
+    else
+      NewReloc.NewIndex = UINT32_MAX;
+
     switch (Reloc.Type) {
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       NewReloc.Value = File.getRelocatedAddress(Reloc.Index);
       if (NewReloc.Value != UINT32_MAX)
         NewReloc.Value += Reloc.Addend;
       break;
     default:
-      NewReloc.Value = NewIndex;
+      NewReloc.Value = calcNewIndex(File, Reloc);
+      break;
     }
 
     OutputRelocs.emplace_back(NewReloc);
   }
 }
 
 void OutputSection::createHeader(size_t BodySize) {
   raw_string_ostream OS(Header);

wasm/SymbolTable.h

public:
   void addFile(InputFile *File);
 
   std::vector<ObjFile *> ObjectFiles;
   std::vector<Symbol *> SyntheticSymbols;
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
   void reportRemainingUndefines();
 
+  ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
 
   Symbol *addDefined(InputFile *F, const WasmSymbol *Sym,
                      const InputSegment *Segment = nullptr);
   Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   Symbol *addDefinedGlobal(StringRef Name);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
+  std::vector<Symbol *> SymVector;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/SymbolTable.cpp

void SymbolTable::addFile(InputFile *File) {
   File->parse();
 
   if (auto *F = dyn_cast<ObjFile>(File))
     ObjectFiles.push_back(F);
 }
 
 void SymbolTable::reportRemainingUndefines() {
   std::unordered_set<Symbol *> Undefs;
-  for (auto &I : SymMap) {
-    Symbol *Sym = I.second;
+  for (Symbol *Sym : SymVector) {
     if (Sym->isUndefined() && !Sym->isWeak() &&
         Config->AllowUndefinedSymbols.count(Sym->getName()) == 0) {
       Undefs.insert(Sym);
     }
   }
 
   if (Undefs.empty())
     return;
Symbol *SymbolTable::find(StringRef Name) {
   return It->second;
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   Symbol *&Sym = SymMap[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = make<Symbol>(Name, false);
+  SymVector.emplace_back(Sym);
   return {Sym, true};
 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
 }

wasm/Writer.cpp

private:
   uint32_t NumGlobals = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t NumTableElems = 0;
   uint32_t NumElements = 0;
   uint32_t InitialTableOffset = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
-  std::vector<Symbol *> FunctionImports;
-  std::vector<Symbol *> GlobalImports;
+  std::vector<const Symbol *> FunctionImports;
+  std::vector<const Symbol *> GlobalImports;
+  std::vector<const Symbol *> DefinedGlobals;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   std::vector<OutputSegment *> Segments;
void Writer::createMemorySection() {
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "memory count");
   writeUleb128(OS, 0, "memory limits flags");
   writeUleb128(OS, NumMemoryPages, "initial pages");
 }
 
 void Writer::createGlobalSection() {
+  if (DefinedGlobals.empty())
+    return;
+
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, NumGlobals, "global count");
-  for (const Symbol *Sym : Config->SyntheticGlobals) {
+  writeUleb128(OS, DefinedGlobals.size(), "global count");
+  for (const Symbol *Sym : DefinedGlobals) {
     WasmGlobal Global;
     Global.Type = WASM_TYPE_I32;
     Global.Mutable = Sym == Config->StackPointerSymbol;
     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);
-        if (Global.Type != WASM_TYPE_I32)
-          fatal("unsupported global type: " + Twine(Global.Type));
-        if (Global.InitExpr.Opcode != WASM_OPCODE_I32_CONST)
-          fatal("unsupported global init opcode: " +
-                Twine(Global.InitExpr.Opcode));
-        RelocatedGlobal.InitExpr.Value.Int32 =
-            File->getRelocatedAddress(GlobalIndex);
-        writeGlobal(OS, RelocatedGlobal);
-        ++GlobalIndex;
-      }
-    }
-  }
 }
 
 void Writer::createTableSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TABLE);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "table count");
   writeSleb128(OS, WASM_TYPE_ANYFUNC, "table type");
   writeUleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags");
   writeUleb128(OS, NumTableElems, "table initial size");
   writeUleb128(OS, NumTableElems, "table max size");
 }
 
 void Writer::createExportSection() {
-  // Memory is and main function are exported for executables.
   bool ExportMemory = !Config->Relocatable && !Config->ImportMemory;
-  bool ExportOther = true; // ??? TODO Config->Relocatable;
-  bool ExportHidden = Config->Relocatable;
   Symbol *EntrySym = Symtab->find(Config->Entry);
   bool ExportEntry = !Config->Relocatable && EntrySym && EntrySym->isDefined();
+  bool ExportHidden = Config->EmitRelocs;
 
-  uint32_t NumExports = 0;
-
-  if (ExportMemory)
-    ++NumExports;
+  uint32_t NumExports = ExportMemory ? 1 : 0;
 
+  std::vector<const Symbol *> SymbolExports;
   if (ExportEntry)
-    ++NumExports;
+    SymbolExports.emplace_back(EntrySym);
 
-  if (ExportOther) {
-    for (ObjFile *File : Symtab->ObjectFiles) {
-      for (Symbol *Sym : File->getSymbols()) {
-        if (!Sym->isFunction() || Sym->isLocal() || Sym->isUndefined() ||
-            (Sym->isHidden() && !ExportHidden) || Sym->WrittenToSymtab)
-          continue;
-        if (Sym == EntrySym)
-          continue;
-        Sym->WrittenToSymtab = true;
-        ++NumExports;
-      }
-    }
+  for (const Symbol *Sym : Symtab->getSymbols()) {
+    if (Sym->isUndefined() || Sym->isGlobal())
+    if (Sym->isHidden() && !ExportHidden)
+    if (ExportEntry && Sym == EntrySym)
+      continue;
+    SymbolExports.emplace_back(Sym);
+
+  for (const Symbol *Sym : DefinedGlobals) {
+    // Can't export the SP right now because it mutable and mutable globals
+    // connot be exported.
+    if (Sym == Config->StackPointerSymbol)
+      continue;
+    SymbolExports.emplace_back(Sym);
   }
 
+  NumExports += SymbolExports.size();
   if (!NumExports)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_EXPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumExports, "export count");
 
   if (ExportMemory) {
     WasmExport MemoryExport;
     MemoryExport.Name = "memory";
     MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
     MemoryExport.Index = 0;
     writeExport(OS, MemoryExport);
   }
 
-  if (ExportEntry) {
-    WasmExport EntryExport;
-    EntryExport.Name = Config->Entry;
-    EntryExport.Kind = WASM_EXTERNAL_FUNCTION;
-    EntryExport.Index = EntrySym->getOutputIndex();
-    writeExport(OS, EntryExport);
-  }
-
-  if (ExportOther) {
-    for (ObjFile *File : Symtab->ObjectFiles) {
-      for (Symbol *Sym : File->getSymbols()) {
-        if (!Sym->isFunction() || Sym->isLocal() || Sym->isUndefined() ||
-            (Sym->isHidden() && !ExportHidden) || !Sym->WrittenToSymtab)
-          continue;
-        if (Sym == EntrySym)
-          continue;
-        Sym->WrittenToSymtab = false;
-        log("Export: " + Sym->getName());
-        WasmExport Export;
-        Export.Name = Sym->getName();
-        Export.Index = Sym->getOutputIndex();
-        if (Sym->isFunction())
-          Export.Kind = WASM_EXTERNAL_FUNCTION;
-        else
-          Export.Kind = WASM_EXTERNAL_GLOBAL;
-        writeExport(OS, Export);
-      }
-    }
-  }
-}
+  for (const Symbol *Sym : SymbolExports) {
 
 void Writer::createStartSection() {}
 
 void Writer::createElemSection() {
   if (!NumElements)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_ELEM);
void Writer::createSections() {
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateOffsets() {
-  NumGlobals = Config->SyntheticGlobals.size();
   NumTableElems = InitialTableOffset;
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmObjectFile *WasmFile = File->getWasmObj();
 
     // Function Index
     File->FunctionIndexOffset =
         FunctionImports.size() - File->NumFunctionImports() + NumFunctions;
     NumFunctions += WasmFile->functions().size();
 
-    // Global Index
-    if (Config->EmitRelocs) {
-      File->GlobalIndexOffset =
-          GlobalImports.size() - File->NumGlobalImports() + NumGlobals;
-      NumGlobals += WasmFile->globals().size();
-    }
-
     // Memory
     if (WasmFile->memories().size()) {
       if (WasmFile->memories().size() > 1) {
         fatal(File->getName() + ": contains more than one memory");
       }
     }
 
     // Table
void Writer::calculateTypes() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     File->TypeMap.reserve(File->getWasmObj()->types().size());
     for (const WasmSignature &Sig : File->getWasmObj()->types())
       File->TypeMap.push_back(getTypeIndex(Sig));
   }
 }
 
 void Writer::assignSymbolIndexes() {
+  uint32_t GlobalIndex = GlobalImports.size();
+
+  if (Config->StackPointerSymbol) {
+    DefinedGlobals.emplace_back(Config->StackPointerSymbol);
+    Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
+  }
+
+  if (Config->EmitRelocs)
+    DefinedGlobals.reserve(Symtab->getSymbols().size());
+
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "assignSymbolIndexes: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->hasOutputIndex() || !Sym->isDefined())
         continue;
 
+      if (Sym->isFunction()) {
         if (Sym->getFile() && isa<ObjFile>(Sym->getFile())) {
           auto *Obj = cast<ObjFile>(Sym->getFile());
-        if (Sym->isFunction())
             Sym->setOutputIndex(Obj->FunctionIndexOffset +
                                 Sym->getFunctionIndex());
-        else
-          Sym->setOutputIndex(Obj->GlobalIndexOffset + Sym->getGlobalIndex());
+          }
+      } else if (Config->EmitRelocs) {
+        DefinedGlobals.emplace_back(Sym);
+        Sym->setOutputIndex(GlobalIndex++);
       }
     }
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   if (Config->Relocatable)
     return Name;