- rebase

wasm/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "Config.h"
+#include "InputGlobal.h"
 #include "MarkLive.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"

 public:
   void link(ArrayRef<const char *> ArgsArr);
 
 private:
   void createFiles(llvm::opt::InputArgList &Args);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
   std::vector<InputFile *> Files;
+  std::unique_ptr<InputGlobal> StackPointer;
+  llvm::wasm::WasmGlobal StackPointerGlobal;
 };
 
 } // anonymous namespace
 
 Configuration *lld::wasm::Config;
 
 bool lld::wasm::link(ArrayRef<const char *> Args, bool CanExitEarly,
                      raw_ostream &Error) {
if (Config->Relocatable) {
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
   }
 
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
-    static WasmSignature NullSignature = {{}, WASM_TYPE_NORESULT};
-    static WasmGlobalType StackPointerType = {WASM_TYPE_I32, true};
-
-    // Add synthetic symbols before any others
-    WasmSym::CallCtors = Symtab->addSyntheticFunction(
-        "__wasm_call_ctors", &NullSignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
     // Can't export the SP right now because it's mutable, and mutable
     // globals aren't yet supported in the official binary format.
     // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN if/when the
     // "mutable global" proposal is accepted.
+    StackPointerGlobal.Type = {WASM_TYPE_I32, true};
+    StackPointerGlobal.InitExpr.Value.Int32 = 0;
+    StackPointerGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+    StackPointer = llvm::make_unique<InputGlobal>(StackPointerGlobal);
+    StackPointer->Live = true;
+
+    static WasmSignature NullSignature = {{}, WASM_TYPE_NORESULT};
+    // Add synthetic symbols before any others
+    WasmSym::CallCtors = Symtab->addSyntheticFunction(
+        "__wasm_call_ctors", &NullSignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
-        "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, &StackPointerType);
+        "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer.get());
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base");
     WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
         "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end");
 
     if (!Config->Entry.empty())
       EntrySym = addUndefinedFunction(Config->Entry, &NullSignature);
 

wasm/InputChunks.h

 //===- InputChunks.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// An input chunk represents an indivisible blocks of code or data from an input
-// file.  i.e. a single wasm data segment or a single wasm function.
+// An InputChunks represents an indivisible opaque region of a input wasm file.
+// i.e. a single wasm data segment or a single wasm function.
+//
+// They are writen directly to the mmap'd output file afterwhich relcoations
+// are applied.  Because each Chunk is independed they can be written in
+// parallel.
+//
+// Chunks are also unit on which garbage collection (--gc-sections) operates.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::WasmSegment;
 using llvm::wasm::WasmFunction;
-using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
-using llvm::wasm::WasmInitExpr;
 using llvm::object::WasmSection;
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
-  enum Kind { DataSegment, Function, Global };
+  enum Kind { DataSegment, Function };
 
   Kind kind() const { return SectionKind; }
 
   uint32_t getSize() const { return data().size(); }
 
   void copyRelocations(const WasmSection &Section);
 
   void writeTo(uint8_t *SectionStart) const;
protected:
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
   SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body,
                     StringRef Name)
-      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body) {
-    Live = true;
-  }
+      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body) {}
 
   StringRef getName() const override { return Name; }
 
 protected:
   ArrayRef<uint8_t> data() const override { return Body; }
 
   StringRef Name;
   ArrayRef<uint8_t> Body;
 };
 
-// Represents a single Wasm Global within an input file. These are combined to
-// form the final GLOBALS section.
-class InputGlobal : public InputChunk {
-public:
-  InputGlobal(const WasmGlobal *G, ObjFile *F)
-      : InputChunk(F, InputChunk::Global), Global(G) {}
-
-  static bool classof(const InputChunk *C) {
-    return C->kind() == InputChunk::Global;
-  }
-
-  StringRef getComdat() const override { return StringRef(); }
-  uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
-  bool hasOutputIndex() const { return OutputIndex.hasValue(); }
-  void setOutputIndex(uint32_t Index);
-
-  virtual const WasmInitExpr &getInitExpr() const { return Global->InitExpr; }
-  virtual const WasmGlobalType &getType() const { return Global->Type; }
-
-protected:
-  // TODO(sbc): Globals don't really belong in this class heirarchy.
-  // Refactor so to avoid this ugliness.
-  StringRef getName() const override { return {}; }
-  ArrayRef<uint8_t> data() const override { return {}; }
-  uint32_t getInputSectionOffset() const override { return 0; }
-
-  const WasmGlobal *Global;
-  llvm::Optional<uint32_t> OutputIndex;
-};
-
-class SyntheticGlobal : public InputGlobal {
-public:
-  SyntheticGlobal(const WasmGlobalType &Type, const WasmInitExpr &InitExpr)
-      : InputGlobal(nullptr, nullptr), InitExpr(InitExpr), Type(Type) {
-    Live = true;
-  }
-
-  const WasmInitExpr &getInitExpr() const override { return InitExpr; }
-  const WasmGlobalType &getType() const override { return Type; }
-
-protected:
-  WasmInitExpr InitExpr;
-  const WasmGlobalType Type;
-};
-
 } // namespace wasm
 
 std::string toString(const wasm::InputChunk *);
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

void InputFunction::setOutputIndex(uint32_t Index) {
   OutputIndex = Index;
 }
 
 void InputFunction::setTableIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n");
   assert(!hasTableIndex());
   TableIndex = Index;
 }
-
-void InputGlobal::setOutputIndex(uint32_t Index) {
-  DEBUG(dbgs() << "InputGlobal::setOutputIndex: " << getName() << " -> "
-               << Index << "\n");
-  assert(!hasOutputIndex());
-  OutputIndex = Index;
-}

wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "InputChunks.h"
+#include "InputGlobal.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
void ObjFile::initializeSymbols() {
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, this);
     Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
   for (const WasmGlobal &G : WasmObj->globals()) {
-    InputGlobal *Global = make<InputGlobal>(&G, this);
+    InputGlobal *Global = make<InputGlobal>(G);
     Globals.emplace_back(Global);
   }
 
   for (size_t I = 0; I < Funcs.size(); ++I) {
     const WasmFunction &Func = Funcs[I];
     const WasmSignature &Sig = Types[FuncTypes[I]];
     InputFunction *F = make<InputFunction>(Sig, &Func, this);
     F->copyRelocations(*CodeSection);

wasm/InputGlobal.h

+//===- InputChunks.h --------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_GLOBAL_H
+#define LLD_WASM_INPUT_GLOBAL_H
+
+#include "Config.h"
+#include "InputFiles.h"
+#include "WriterUtils.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/Object/Wasm.h"
+
+using llvm::wasm::WasmGlobal;
+using llvm::wasm::WasmInitExpr;
+
+namespace lld {
+namespace wasm {
+
+// Represents a single Wasm Global within an input file. These are combined to
+// form the final GLOBALS section.
+class InputGlobal {
+public:
+  InputGlobal(const WasmGlobal &G) : Global(G) {}
+
+  const WasmGlobalType &getType() const { return Global.Type; }
+
+  uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
+  bool hasOutputIndex() const { return OutputIndex.hasValue(); }
+  void setOutputIndex(uint32_t Index) {
+    assert(!hasOutputIndex());
+    OutputIndex = Index;
+  }
+
+  bool Live = false;
+
+  WasmGlobal Global;
+
+protected:
+  llvm::Optional<uint32_t> OutputIndex;
+};
+
+} // namespace wasm
+
+} // namespace lld
+
+#endif // LLD_WASM_INPUT_GLOBAL_H

wasm/SymbolTable.h

public:
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   Symbol *addUndefined(StringRef Name, WasmSymbolType Type, uint32_t Flags,
                        InputFile *F, const WasmSignature *Signature = nullptr,
                        const WasmGlobalType *GlobalType = nullptr);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
   bool addComdat(StringRef Name, ObjFile *);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags = 0);
-  DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags = 0,
-                                    const WasmGlobalType *Type = nullptr);
+  DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
+                                    InputGlobal *Global);
   DefinedFunction *addSyntheticFunction(StringRef Name,
                                         const WasmSignature *Type,
                                         uint32_t Flags = 0);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, ObjFile *> ComdatMap;

wasm/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "InputChunks.h"
+#include "InputGlobal.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
   DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   return replaceSymbol<DefinedData>(S, Name, Flags);
 }
 
 DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
-                                               const WasmGlobalType *Type) {
-  DEBUG(dbgs() << "addSyntheticGlobal: " << Name << "\n");
+                                               InputGlobal *Global) {
+  DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
-  return replaceSymbol<DefinedGlobal>(S, Name, Flags, Type);
+  assert(WasInserted);
+  return replaceSymbol<DefinedGlobal>(S, Name, Flags, nullptr, Global);
 }
 
 static bool shouldReplace(const Symbol &Existing, InputFile *NewFile,
                           WasmSymbolType NewType, uint32_t NewFlags,
                           const WasmSignature *NewFuncType = nullptr,
                           const WasmGlobalType *NewGlobalType = nullptr) {
 
   // If existing symbol is lazy, replace it without checking types since

wasm/Symbols.h

protected:
 
   // Explicit function type, needed for undefined or synthetic functions only.
   // For regular defined globals this information comes from the InputChunk.
   const WasmGlobalType *GlobalType = nullptr;
 };
 
 class DefinedGlobal : public GlobalSymbol {
 public:
-  // Primary constructor for file-defined globals.
   DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                 InputGlobal *Global);
 
-  // Second constructor used when creating synthetic globals.
-  DefinedGlobal(StringRef Name, uint32_t Flags, const WasmGlobalType *Type)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, nullptr, Type) {}
+  static bool classof(const Symbol *S) {
+    return S->kind() == DefinedGlobalKind;
+  }
 
   InputGlobal *Global;
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
   UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                   const WasmGlobalType *Type = nullptr)

wasm/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "Config.h"
 #include "InputChunks.h"
+#include "InputGlobal.h"
 #include "InputFiles.h"
 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;

wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "InputChunks.h"
+#include "InputGlobal.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/DenseSet.h"

 
 private:
   void openFile();
 
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
 
   void createCtorFunction();
-  void createStackPointer(uint32_t Address);
-
   void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateExports();
   void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
private:
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
   std::unique_ptr<SyntheticFunction> CtorFunction;
   std::string CtorFunctionBody;
-  std::unique_ptr<SyntheticGlobal> StackPtrGlobal;
+  std::unique_ptr<InputGlobal> StackPointerInputGlobal;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
 };
 
 } // anonymous namespace
 
 static void debugPrint(const char *fmt, ...) {
void Writer::createGlobalSection() {
   unsigned NumGlobals = DefinedGlobals.size() + DefinedFakeGlobals.size();
   if (NumGlobals == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumGlobals, "global count");
-  for (const InputGlobal *G : DefinedGlobals) {
-    WasmGlobal Global;
-    Global.Type = G->getType();
-    Global.InitExpr = G->getInitExpr();
-    writeGlobal(OS, Global);
-  }
+  for (const InputGlobal *G : DefinedGlobals)
+    writeGlobal(OS, G->Global);
   for (const DefinedData *Sym : DefinedFakeGlobals) {
     WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, false};
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
void Writer::layoutMemory() {
   // 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;
-    createStackPointer(MemoryPtr);
+    WasmSym::StackPointer->Global->Global.InitExpr.Value.Int32 = 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.
     WasmSym::HeapBase->setVirtualAddress(MemoryPtr);
     debugPrint("mem: heap base   = %d\n", MemoryPtr);
   }
for (const Symbol *Sym : ImportedSymbols)
     if (auto *F = dyn_cast<FunctionSymbol>(Sym))
       registerType(*F->getFunctionType());
 
   for (const InputFunction *F : DefinedFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
-  uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size();
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
-    for (InputGlobal *Global : File->Globals) {
-      if (!Global->Live)
-        continue;
-      Global->setOutputIndex(GlobalIndex++);
-      DefinedGlobals.push_back(Global);
-    }
-  }
-
   uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions) {
       if (!Func->Live)
         continue;
       DefinedFunctions.emplace_back(Func);
       Func->setOutputIndex(FunctionIndex++);
     }
   }
 
   uint32_t TableIndex = kInitialTableOffset;
   auto HandleRelocs = [&](InputChunk *Chunk) {
     if (!Chunk->Live)
       return;
-    ObjFile *File = Chunk->File;
+    ObjFile* File = Chunk->File;
     ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
     for (const WasmRelocation& Reloc : Chunk->getRelocations()) {
       if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32 ||
           Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB) {
         FunctionSymbol *Sym = File->getFunctionSymbol(Reloc.Index);
         if (Sym->hasTableIndex() || !Sym->hasOutputIndex())
           continue;
         Sym->setTableIndex(TableIndex++);
         IndirectFunctions.emplace_back(Sym);
       } else if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+        // Mark target type as live
         File->TypeMap[Reloc.Index] = registerType(Types[Reloc.Index]);
         File->TypeIsUsed[Reloc.Index] = true;
+      } else if (Reloc.Type == R_WEBASSEMBLY_GLOBAL_INDEX_LEB) {
+        // Mark target global as live
+        GlobalSymbol *Sym = File->getGlobalSymbol(Reloc.Index);
+        if (auto *G = dyn_cast<DefinedGlobal>(Sym)) {
+          DEBUG(dbgs() << "marking global live: " << Sym->getName() << "\n");
+          G->Global->Live = true;
+        }
       }
     }
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
-
     for (InputChunk* Chunk : File->Functions)
       HandleRelocs(Chunk);
     for (InputChunk* Chunk : File->Segments)
       HandleRelocs(Chunk);
   }
+
+  uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size();
+  auto AddDefinedGlobal = [&](InputGlobal* Global) {
+    if (Global->Live) {
+      DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
+      Global->setOutputIndex(GlobalIndex++);
+      DefinedGlobals.push_back(Global);
+    }
+  };
+
+  if (WasmSym::StackPointer)
+    AddDefinedGlobal(WasmSym::StackPointer->Global);
+
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
+    for (InputGlobal *Global : File->Globals)
+      AddDefinedGlobal(Global);
+  }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   if (Config->Relocatable)
     return Name;
 
   for (StringRef V :
        {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
void Writer::createCtorFunction() {
   OS.flush();
   CtorFunctionBody += FunctionBody;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
       *Signature, BodyArray, WasmSym::CallCtors->getName());
   CtorFunction->setOutputIndex(FunctionIndex);
+  CtorFunction->Live = true;
   WasmSym::CallCtors->Function = CtorFunction.get();
   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() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
     InitFunctions.reserve(InitFunctions.size() + L.InitFunctions.size());
     for (const WasmInitFunc &F : L.InitFunctions)
       InitFunctions.emplace_back(
           WasmInitEntry{File->getFunctionSymbol(F.Symbol), F.Priority});
   }
   // Sort in order of priority (lowest first) so that they are called
   // in the correct order.
   std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
                    [](const WasmInitEntry &L, const WasmInitEntry &R) {
                      return L.Priority < R.Priority;
                    });
 }
 
-void Writer::createStackPointer(uint32_t Address) {
-  WasmInitExpr InitExpr;
-  InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-  InitExpr.Value.Int32 = Address;
-  StackPtrGlobal = make_unique<SyntheticGlobal>(
-      WasmSym::StackPointer->getGlobalType(), InitExpr);
-  StackPtrGlobal->setOutputIndex(NumImportedGlobals + DefinedGlobals.size());
-  DefinedGlobals.emplace_back(StackPtrGlobal.get());
-  WasmSym::StackPointer->Global = StackPtrGlobal.get();
-}
-
 void Writer::run() {
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)