[WebAssembly] Add support for __init_array_start and friends

[ncw]

Nice approach - some things are bit shorter in your version.

A couple of things are a bit more general in mine I think, which uses some more boilerplate, but it emulates more accurately the linkage behaviour of native ELF.

• The toolchain might define __init_array_start etc via crtbegin.o. By defining the symbol up-front, as a weak symbol, that does allow the translation units to provide the symbols if necessary.
• You also need to make sure to provide __init_aray_start even if there isn't a .init_array segment (libc needs to know there are zero constructors to iterate over)
• Is it worth pulling over my tests as well, which model real-world C++ usage

PS. I'm about half-way through getting COMDAT working, I'm not duplicating your work there am I? When COMDAT support is there, I think C++ minus exceptions will be roughly complete!

[sbc100]

I believe __init_aray_start is weakly referenced by libc.. so when its not defined it ends up being null, which means it will not iterate over any initializes. If this wasn't true we'd be seeing link failures with undefined symbols in the tests we are doing today.

[sbc100]

Regarding COMDAT, I was doing some research to see if we can get away with only implementing linkonce_odr and avoid implement the full semantics of COMDAT. This is how mach-o works today, but its not clear to me yet how significant the disadventages are.

I am actively working on (or at least thinking about) this stuff. Very happy for your contributions though! Lets just try to communicate more about the ongoing work. How about we open bugs for all these things we are working on. We can also sync up via email and IRC (I'm sbc100 on llvm and webassembly IRC).

[ruiu]

wasm/SymbolTable.cpp

136

Does this function expect that a given name exists in the hash table? It looks like it does nothing if a given name collides with an existing name. I wonder if it is the right behavior.

If you think that a name given to this function is reserved and shouldn't be user-defined, it is better to emit an error message if there's an existing symbol in the symbol table, isn't it?

[ncw]

In D40760#943155, @sbc100 wrote:

I believe __init_aray_start is weakly referenced by libc.. so when its not defined it ends up being null, which means it will not iterate over any initializes. If this wasn't true we'd be seeing link failures with undefined symbols in the tests we are doing today.

Are you sure? I don't mean to contradict, but with a master build, I find that undefined weak symbols are set to (uint32_t)-1 when not found, and secondly that the output has a global import for __init_array_start if I link in anything from libc that uses it.

My test:

// File test.c
int main() { return 0; }

Commands:

clang -o /tmp/test.o -c /tmp/test.c
wasm-ld -L/home/ncw/workspace/llvm/compile-root/usr/lib /tmp/test.o /home/ncw/workspace/llvm/compile-root/usr/lib/crt1.o -lc -o /tmp/test --allow-undefined

Output contains:

(import "env" "__syscall_set_tid_address" (func $import$0 (param i32 i32) (result i32)))
(import "env" "__syscall_poll" (func $import$1 (param i32 i32) (result i32)))
(import "env" "__syscall_open" (func $import$2 (param i32 i32) (result i32)))
(import "env" "__syscall_exit_group" (func $import$3 (param i32 i32) (result i32)))
(import "env" "__syscall_exit" (func $import$4 (param i32 i32) (result i32)))
(import "env" "__init_array_start" (global $import$5 i32))
(import "env" "__init_array_end" (global $import$6 i32))

wasm/SymbolTable.cpp

136

It's not reserved, I think it's OK for library code to provide this symbol, if the libc implementation is using the crtbegin/crtend trick. I think we should just provide a built-in weak definition of the symbol that takes lowest priority.

I'm not sure though that it really matters what happens if the user tries to provide __init_array_start - as long as things work with musl anyone not using musl can just muddle through!

[ncw]

In D40760#943156, @sbc100 wrote:

Regarding COMDAT, I was doing some research to see if we can get away with only implementing linkonce_odr and avoid implement the full semantics of COMDAT. This is how mach-o works today, but its not clear to me yet how significant the disadventages are.

I am actively working on (or at least thinking about) this stuff. Very happy for your contributions though! Lets just try to communicate more about the ongoing work. How about we open bugs for all these things we are working on. We can also sync up via email and IRC (I'm sbc100 on llvm and webassembly IRC).

I've taken the plunge and had a go just doing COMDAT "properly". I had a look at linkonce_odr, but I wasn't sure it was going to save much time, since the hard work is all in LLD and consists of improvements to the actual function and data segment linkage. We'll have to put in that work regardless.

What I've done is open three more bugzilla bugs for discussion:

• Core COMDAT support https://bugs.llvm.org/show_bug.cgi?id=35533
• Duplicate function pruning https://bugs.llvm.org/show_bug.cgi?id=35534
• Duplicate data segment pruning https://bugs.llvm.org/show_bug.cgi?id=35535

I've implemented a first-cut of the core COMDAT support, and the additional two bugs are non-functional, and simply reduce the binary size without affecting behaviour.

I'm also opening two work-in-progress Phabricator reviews, just to show where I've got to so far.

Please feel free to email [e-mail] or comment on the bugzilla tickets. I work from Cambridge (UK) and I think you're in GMT+8, so not much overlap, but I'll be on IRC when possible.

[sbc100]

In D40760#945281, @ncw wrote:

In D40760#943155, @sbc100 wrote:

I believe __init_aray_start is weakly referenced by libc.. so when its not defined it ends up being null, which means it will not iterate over any initializes. If this wasn't true we'd be seeing link failures with undefined symbols in the tests we are doing today.

Are you sure? I don't mean to contradict, but with a master build, I find that undefined weak symbols are set to (uint32_t)-1 when not found, and secondly that the output has a global import for __init_array_start if I link in anything from libc that uses it.

My test:

// File test.c
int main() { return 0; }

Commands:

clang -o /tmp/test.o -c /tmp/test.c
wasm-ld -L/home/ncw/workspace/llvm/compile-root/usr/lib /tmp/test.o /home/ncw/workspace/llvm/compile-root/usr/lib/crt1.o -lc -o /tmp/test --allow-undefined

Output contains:

(import "env" "__syscall_set_tid_address" (func $import$0 (param i32 i32) (result i32)))
(import "env" "__syscall_poll" (func $import$1 (param i32 i32) (result i32)))
(import "env" "__syscall_open" (func $import$2 (param i32 i32) (result i32)))
(import "env" "__syscall_exit_group" (func $import$3 (param i32 i32) (result i32)))
(import "env" "__syscall_exit" (func $import$4 (param i32 i32) (result i32)))
(import "env" "__init_array_start" (global $import$5 i32))
(import "env" "__init_array_end" (global $import$6 i32))

Hmm.. I can't see the weak reference either now that you mention it. But now I'm confused about why I've never seen undefined errors for those symbols. I'll have to investigate.

BTW, I don't see the same set of undefined symbols as you. Can you build without --allow-undefined and instead use -allow-undefined-file /path/to/wasm.syms (this is what the clang frontend currently does). Also, you must have different musl version to me because the one we use on the waterfall should only depend on env.__syscall3 etc (not the syscalls that include the name).

wasm/SymbolTable.cpp

136

Lets just mimic whatever the native/ELF toolchains do for this. If they allow user-provided __init_array_start then we should too and vice versa.

[sbc100]

Actually they are weakly referenced in musl:
https://github.com/jfbastien/musl/blob/wasm-prototype-1/src/env/__libc_start_main.c#L14

__attribute__((__weak__, __visibility__("hidden")))                              
extern void (*const __init_array_start)(void), (*const __init_array_end)(void);

But it looks to me like the ELF linker always adds them anyway, so maybe we should just do that.

[ncw]

I had a go with this patch, to try and rebase it on top of the synthetic symbols changes you merged recently.

I found that quite a number of tests fail with this patch? In the changes above, you've made it so that the stack pointer symbol isn't given a global declaration anymore, which surely can't be right. Did this diff maybe come from splitting up a larger patch (eg splitting off chunks from D40859) and leaving out a few of the necessary chunks?

I don't think this is usable as-is, but, it's very helpful to see what direction you're trying to nudge things towards.

I decided the most helpful thing would be to rebase this patch, and combine it with my changes in D40614, and I've updated D40614 with the result. Once your global offset changes land (D40859) there'll be a merge needed, but I'm happy to do that in D40614.

[ruiu]

LGTM

[sunfish]

For the record, I believe that it would be better to work towards implementing the proposal here:

https://github.com/WebAssembly/tool-conventions/issues/25

[sbc100]

I'm not quite ready to land this anyway. It needs rebasing and integrating with @ncw proposed version.

Regarding @sunfish's alternative solution, I am still on the fence about the benefits (specifically the security benefit of not have constructors in the indirect function table) vs the costs (having to teach the linker how to synthesize the constructor calling function, and deviating from ELF). I would also be open to landing this first and then switching.

[ncw]

Dan's idea in D40759 is nice!

I listed a lot of "Cons" in D40614, partly because being ELF-like feels "safer", but overall the dedicated start-function-linkage does seem to be a better approach.

I guess there's a question of whether it's worth merging at all this .init_array support Sam (and I) did...? I've integrated Sam's work with mine and fixed the tests, so that could be merged for the time being. From my point of view, the .init_array stuff at least gets Musl working right away.

(Musl aside)

It looks like you guys are using Musl from here: https://github.com/jfbastien/musl. I tried using it, but some things seem to be missing - for some reason dynamic linking was apparently higher priority than working malloc/free!

I've had a fresh go at building a native Wasm Musl port, and I've actually been trying to submit those patches upstream. I've got a working malloc/free/mmap/munmap, and the syscalls are fully statically linked, and come out as imports on the Wasm module with names like "__syscall_open".

Here's the repo with my Musl, which builds and runs out-of-the-box with the .init_array patch: https://github.com/NWilson/musl/pull/1

I've also made a set of instructions for myself and some colleagues on how I'm building Musl at the moment:
https://gist.github.com/NWilson/b0d7a643b66bcd4c118b26d979572c5b

As and when Dan's @llvm.global_ctors change lands, I'll certainly be updating my Musl to match.

I've put in a bit of effort on Musl, it would be nice to package that in a way that's useful to you guys so that it gets used.

[sbc100]

I think I'm going to abandon this, but the work in this patch and in Nicolas's patch will be probably still end up being generally useful.

Nicolas, regarding musl, I suggest we try to concentrate our efforts.
There is discussion here about moving the repo under WebAssmembly: https://github.com/jfbastien/musl/issues/15
And another one here about standardizing on the syscall API: https://github.com/WebAssembly/tool-conventions/issues/27

I'd be wary of upstreaming just yet, except for the most obvious changes. Certainly it would be long term goal. Have you had much success landing patches there? In the past I've heard the musl developers were not interested in ports to non-linux platforms.

I definitely like the idea of each syscall being its own import. What do you think about upstream your patches to https://github.com/jfbastien/musl?

test/wasm/init-fini-array.ll

+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: lld -flavor wasm -r %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+define void @func1() {
+entry:
+  ret void
+}
+
+define void @func2() {
+entry:
+  ret void
+}
+
+define void @_start() {
+entry:
+  ret void
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func1, i8* null }]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func2, i8* null }]
+
+; CHECK:      --- !WASM
+; CHECK:        - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           4
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           4
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           8
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            func1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            func2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            _start
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            __init_array_start
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            __init_array_end
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            __fini_array_start
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            __fini_array_end
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:   - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Functions:       [ 0, 1 ]
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:       
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Relocations:     
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000006
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x0000000F
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - SectionOffset:   6
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Content:         '00000000'
+; CHECK-NEXT:       - SectionOffset:   15
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           4
+; CHECK-NEXT:         Content:         '01000000'
+

wasm/Config.h

struct Configuration {
   uint32_t MaxMemory;
   uint32_t ZStackSize;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile;
   llvm::StringRef Sysroot;
 
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
-  std::vector<std::pair<Symbol *, WasmGlobal>> SyntheticGlobals;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

 static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
   SmallString<128> S;
   path::append(S, Path1, Path2);
   if (fs::exists(S))
     return S.str().str();
   return None;
 }
 
-// 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);
-}
-
 // 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);
+    Symtab->addDefinedGlobal("__stack_pointer", 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/SymbolTable.h

public:
   void reportRemainingUndefines();
 
   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);
+  Symbol *addDefinedGlobal(StringRef Name, uint32_t Value);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/SymbolTable.cpp

 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 #include <unordered_set>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 SymbolTable *lld::wasm::Symtab;
 
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   File->parse();
static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
   if (*NewSig == OldSig)
     return;
 
   error("function signature mismatch: " + New.Name + "\n>>> defined as " +
         toString(OldSig) + " in " + toString(Existing.getFile()) +
         "\n>>> defined as " + toString(*NewSig) + " in " + F.getName());
 }
 
-Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
+Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Value) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
-  if (WasInserted)
+  if (WasInserted) {
     S->update(Symbol::DefinedGlobalKind);
-  else if (!S->isGlobal())
+    S->setVirtualAddress(Value);
+  } else if (!S->isGlobal()) {
     error("symbol type mismatch: " + Name);
+  } else if (!S->isDefined()) {
+    DEBUG(dbgs() << "resolving existing undefined symbol: " << Name
+                 << "\n");
+    S->update(Symbol::DefinedGlobalKind);
+    S->setVirtualAddress(Value);
+  }
   return S;
 }
 
 Symbol *SymbolTable::addDefined(InputFile *F, const WasmSymbol *Sym,
                                 const InputSegment *Segment) {
   DEBUG(dbgs() << "addDefined: " << Sym->Name << "\n");
   Symbol *S;
   bool WasInserted;

wasm/Symbols.h

public:
 
   // Returns true if an output index has been set for this symbol
   bool hasOutputIndex() { 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(wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind &Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 const WasmSignature &Symbol::getFunctionType() const {
   assert(FunctionType != nullptr);
   return *FunctionType;
 }
 
 uint32_t Symbol::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
-  if (isUndefined())
+  if (isUndefined()) {
+    DEBUG(dbgs() << "UNDEFINED\n");
     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

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;
-    writeGlobal(OS, Global);
-  }
 
   if (Config->Relocatable || 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));

 // to each of the input data sections as well as the explicit stack region.
 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
   for (OutputSegment *Seg : Segments) {
     MemoryPtr = alignTo(MemoryPtr, Seg->Alignment);
     Seg->StartVA = MemoryPtr;
     debugPrint("mem: %-10s offset=%-8d size=%-4d align=%d\n",
                Seg->Name.str().c_str(), MemoryPtr, Seg->Size, Seg->Alignment);
+    if (Seg->Name == ".init_array") {
+      Symtab->addDefinedGlobal("__init_array_start", MemoryPtr);
+      Symtab->addDefinedGlobal("__init_array_end", MemoryPtr + Seg->Size);
+    } else if (Seg->Name == ".fini_array") {
+      Symtab->addDefinedGlobal("__fini_array_start", MemoryPtr);
+      Symtab->addDefinedGlobal("__fini_array_end", MemoryPtr + Seg->Size);
+    }
     MemoryPtr += Seg->Size;
   }
 
   DataSize = MemoryPtr;
   if (!Config->Relocatable)
     DataSize -= Config->GlobalBase;
   debugPrint("mem: static data = %d\n", DataSize);
 
   // 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;
+    Symtab->find("__stack_pointer")->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);
 }
 
void Writer::createSections() {
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateOffsets() {
-  NumGlobals = Config->SyntheticGlobals.size();
+  NumGlobals = 0;
   NumTableElems = InitialTableOffset;
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmObjectFile *WasmFile = File->getWasmObj();
 
     // Function Index
     File->FunctionIndexOffset =
         FunctionImports.size() - File->NumFunctionImports() + NumFunctions;
for (ObjFile *File : Symtab->ObjectFiles) {
     }
   }
 }
 
 void Writer::run() {
   if (!Config->Relocatable)
     InitialTableOffset = 1;
 
+  createOutputSegments();
+
+  log("-- layoutMemory");
+  layoutMemory();
+
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateImports");
   calculateImports();
   log("-- calculateOffsets");
   calculateOffsets();
 
   if (errorHandler().Verbose) {
     log("NumFunctions    : " + Twine(NumFunctions));
     log("NumGlobals      : " + Twine(NumGlobals));
     log("NumImports      : " +
         Twine(FunctionImports.size() + GlobalImports.size()));
     log("FunctionImports : " + Twine(FunctionImports.size()));
     log("GlobalImports   : " + Twine(GlobalImports.size()));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
   log("-- assignSymbolIndexes");
   assignSymbolIndexes();
-  log("-- layoutMemory");
-  layoutMemory();
 
   createHeader();
   log("-- createSections");
   createSections();
 
   log("-- openFile");
   openFile();
   if (errorCount())