[WebAssembly] Initial support for shared objects (-shared)

[sbc100]

Summary

Based on the initial spec proposal:
https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md

The llvm/codegen side of this is still missing but I believe this change is
still worth landing as an incremental step

[sbc100]

• docs

[sbc100]

• add assert
• clang format

[sbc100]

fix test

[dschuff]

docs/WebAssembly.rst

34

not related to this CL, but we should probably update the list of missing features.

[sbc100]

docs/WebAssembly.rst

34

Yes, I did that a while back but had to revert because of some sphinx issue: https://reviews.llvm.org/D52048

Will try again,

[ruiu]

Can you add this to ReleaseNotes?

wasm/Driver.cpp

403–404

Sort alphabetically.

489

Can you add a comment for this code block so that it is clear what we are doing if Config->Pic?

[sbc100]

• feedback
• add comment

[ruiu]

wasm/Driver.cpp

397

This may be a silly question, but in wasm, what is the notion of position-independent executable? Are executable expected to be loaded at a fixed address by default, and you can opt out with -pie? The notion of PIE is dependent on the memory layout of the physical machine, and that's quite different from wasm's memory model.

[sbc100]

wasm/Driver.cpp

397

The meaning of -fPIC/-fpie is a little different for wasm. Since the code its JITd rather than mmaped, all the code is position independent by defintion. However there are two things these flags are needed for:

1. For -fPIC code the location of global data is not known at link time, so global data accesses are offset from the __memory_base import.
2. All indirect function calls need to go via the indirect function table, but for -fPIE the region of the table we are using is not known until runtime so we need to be offset all table indexes by __table_base.

This means that code compiled with -fPIC pays a slight performance cost for accessing global data and calling non-hidden function.

In these respect -shared and -fpie produce very similar results (both these options set Config->Pie which triggers most of this behaviour).

For an executable compiled without -fpie the location of memory_base and table_base is fixed at link time so slightly more efficient even when given code compiled with -fPIC.

[sbc100]

• fix global base

[sunfish]

docs/ReleaseNotes.rst

72 ↗

(On Diff #173898)

We should make it clear that the ABI is not stable. In fact, it may change significantly in the future if we move to two-level namespacing and/or making use of ES6 module integration.

[sbc100]

• add note about current status

[sbc100]

• don't require entry point for shared libraries

[sbc100]

• Always import the table with -shared

[dschuff]

wasm/Driver.cpp

465

incompatible

491

remove "to"

492

"static data and function table" is the opposite of the order that __table_base and __memory base have above.

wasm/OutputSections.cpp

141

Can this be a report_fatal_error or something even more friendly instead of an assert, since this could happen as the result of user input?

wasm/Writer.cpp

714

shouldn't this go after the data section since it's a custom section?

[sbc100]

• feedback

wasm/OutputSections.cpp

141

This should not be able to occur due to user input since we only ever create a single segment in Writer.cpp if Config->Pic, so this is really just an internal check.

wasm/Writer.cpp

714

No, this section actually always comes first in the entire file to make dll's easy to detect.

The "spec" says: The "dylink" section should be the very first section in the module; this allows detection of whether a binary is a dynamic library without having to scan the entire contents.

[sbc100]

• update test

docs/WebAssembly.rst

 
 
 Missing features
 ----------------
 
 There are several key features that are not yet implement in the WebAssembly
 ports:
 
+- Support for building shared libraries via ``-shared`` is still as work in
+  progress.
 - COMDAT support.  This means that support for C++ is still very limited.
 - Function stripping.  Currently there is no support for ``--gc-sections`` so
   functions and data from a given object will linked as a unit.
 - Section start/end symbols.  The synthetic symbols that mark the start and
   of data regions are not yet created in the output file.

test/wasm/shared.ll

+; RUN: llc -O0 -filetype=obj %s -o %t.o
+; RUN: wasm-ld -shared -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+@used_data = hidden global i32 2, align 4
+@indirect_func = local_unnamed_addr global void ()* @_start, align 4
+
+define hidden void @_start() {
+entry:
+  %0 = load i32, i32* @used_data, align 4
+  %1 = load void ()*, void ()** @indirect_func, align 4
+  call void %1()
+  ret void
+}
+
+; check for dylink section at start
+
+; CHECK:      Sections:
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            dylink
+; CHECK-NEXT:     Payload:         '808004020100'
+
+; check for import of __table_base and __memory_base globals
+
+; CHECK:        - Type:            IMPORT
+; CHECK-NEXT:     Imports:
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __table_base
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         GlobalType:      I32
+; CHECK-NEXT:         GlobalMutable:   false
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __memory_base
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         GlobalType:      I32
+; CHECK-NEXT:         GlobalMutable:   false
+
+; check for elem segment initialized with __table_base global as offset
+
+; CHECK:        - Type:            ELEM
+; CHECK-NEXT:     Segments:
+; CHECK-NEXT:       - Offset:
+; CHECK-NEXT:           Opcode:          GET_GLOBAL
+; CHECK-NEXT:           Index:           0
+; CHECK-NEXT:         Functions:       [ 1 ]
+
+; check the data segment initialized with __memory_base global as offset
+
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Segments:
+; CHECK-NEXT:       - SectionOffset:   6
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:
+; CHECK-NEXT:           Opcode:          GET_GLOBAL
+; CHECK-NEXT:           Index:           1
+; CHECK-NEXT:         Content:         '00000000'

wasm/Config.h

struct Configuration {
   bool ExportAll;
   bool ExportDynamic;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
   bool SharedMemory;
   bool ImportTable;
   bool MergeDataSegments;
+  bool Pie;
   bool PrintGcSections;
   bool Relocatable;
   bool SaveTemps;
+  bool Shared;
   bool StripAll;
   bool StripDebug;
   bool StackFirst;
   uint32_t GlobalBase;
   uint32_t InitialMemory;
   uint32_t MaxMemory;
   uint32_t ZStackSize;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile;
   llvm::StringRef ThinLTOCacheDir;
 
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
+
+  // True if we are creating position-independent code.
+  bool Pic;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   V.push_back("wasm-ld (LLVM option parsing)");
   for (auto *Arg : Args.filtered(OPT_mllvm))
     V.push_back(Arg->getValue());
   cl::ParseCommandLineOptions(V.size(), V.data());
 
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
+  Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
   Config->ExportAll = Args.hasArg(OPT_export_all);
   Config->ExportDynamic = Args.hasFlag(OPT_export_dynamic,
       OPT_no_export_dynamic, false);
   Config->ExportTable = Args.hasArg(OPT_export_table);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
   Config->SharedMemory = Args.hasArg(OPT_shared_memory);
   Config->ImportTable = Args.hasArg(OPT_import_table);
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->Optimize = args::getInteger(Args, OPT_O, 0);
   Config->OutputFile = Args.getLastArgValue(OPT_o);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->GcSections =
       Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !Config->Relocatable);
   Config->MergeDataSegments =
       Args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
                    !Config->Relocatable);
   Config->PrintGcSections =
       Args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->SearchPaths = args::getStrings(Args, OPT_L);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->StripDebug = Args.hasArg(OPT_strip_debug);
-  Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
+  Config->Pie = Args.hasFlag(OPT_pie, OPT_no_pie, false);
+  Config->Shared = Args.hasArg(OPT_shared);
   Config->StackFirst = Args.hasArg(OPT_stack_first);
   Config->ThinLTOCacheDir = Args.getLastArgValue(OPT_thinlto_cache_dir);
   Config->ThinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u);
   errorHandler().Verbose = Args.hasArg(OPT_verbose);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file))
     readImportFile(Arg->getValue());
 
   if (!Args.hasArg(OPT_INPUT)) {
     error("no input files");
     return;
   }
 
+  if (Config->Pie && Config->Shared)
+    error("-shared and -pie may not be used together");
+
   if (Config->OutputFile.empty())
     error("no output file specified");
 
   if (Config->ImportTable && Config->ExportTable)
     error("--import-table and --export-table may not be used together");
 
   if (Config->Relocatable) {
     if (!Config->Entry.empty())
       error("entry point specified for relocatable output file");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Config->CompressRelocations)
       error("-r -and --compress-relocations may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
+    if (Config->Pie)
+      error("-r and -pie may not be used together");
   }
 
+  Config->Pic = Config->Pie || Config->Shared;
+
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
     llvm::wasm::WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, true};
     Global.InitExpr.Value.Int32 = 0;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.SymbolName = "__stack_pointer";
     InputGlobal *StackPointer = make<InputGlobal>(Global, nullptr);
     StackPointer->Live = true;
 
     static WasmSignature NullSignature = {{}, {}};
 
     // Add synthetic symbols before any others
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
     // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
     // spec proposal is implemented in all major browsers.
     // See: https://github.com/WebAssembly/mutable-global
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
     WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
         "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end", 0);
 
+    if (Config->Pic) {
+      static llvm::wasm::WasmGlobalType GlobalTypeI32 = {WASM_TYPE_I32, false};
+
+      WasmSym::TableBase = Symtab->addUndefinedGlobal(
+          "__table_base", WASM_SYMBOL_VISIBILITY_HIDDEN, nullptr,
+          &GlobalTypeI32);
+      Config->AllowUndefinedSymbols.insert(WasmSym::TableBase->getName());
+      WasmSym::TableBase->IsUsedInRegularObj = true;
+      WasmSym::TableBase->markLive();
+
+      WasmSym::MemoryBase = Symtab->addUndefinedGlobal(
+          "__memory_base", WASM_SYMBOL_VISIBILITY_HIDDEN, nullptr,
+          &GlobalTypeI32);
+      Config->AllowUndefinedSymbols.insert(WasmSym::MemoryBase->getName());
+      WasmSym::MemoryBase->IsUsedInRegularObj = true;
+      WasmSym::MemoryBase->markLive();
+    }
+
     // These two synthetic symbols exist purely for the embedder so we always
     // want to export them.
     WasmSym::HeapBase->ForceExport = true;
     WasmSym::DataEnd->ForceExport = true;
   }
 
   createFiles(Args);
   if (errorCount())

wasm/LTO.cpp

static std::unique_ptr<lto::LTO> createLTO() {
   // Wasm currently only supports ThreadModel::Single
   C.Options.ThreadModel = ThreadModel::Single;
 
   C.DisableVerify = Config->DisableVerify;
   C.DiagHandler = diagnosticHandler;
   C.OptLevel = Config->LTOO;
   C.MAttrs = GetMAttrs();
 
+  if (Config->Relocatable)
+    C.RelocModel = None;
+  else if (Config->Pic)
+    C.RelocModel = Reloc::PIC_;
+  else
+    C.RelocModel = Reloc::Static;
+
   if (Config->SaveTemps)
     checkError(C.addSaveTemps(Config->OutputFile.str() + ".",
                               /*UseInputModulePath*/ true));
 
   lto::ThinBackend Backend;
   if (Config->ThinLTOJobs != -1U)
     Backend = lto::createInProcessThinBackend(Config->ThinLTOJobs);
   return llvm::make_unique<lto::LTO>(std::move(C), Backend,

wasm/Options.td

def NAME # _eq: Joined<["--", "-"], name # "=">, Alias<!cast<Separate>(NAME)>,
     HelpText<help>;
 }
 
 multiclass B<string name, string help1, string help2> {
   def NAME: Flag<["--", "-"], name>, HelpText<help1>;
   def no_ # NAME: Flag<["--", "-"], "no-" # name>, HelpText<help2>;
 }
 
-// The follow flags are shared with the ELF linker
+// The following flags are shared with the ELF linker
 def color_diagnostics: F<"color-diagnostics">,
   HelpText<"Use colors in diagnostics">;
 
 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics; one of 'always', 'never', 'auto'">;
 
 def compress_relocations: F<"compress-relocations">,
   HelpText<"Compress the relocation targets in the code section.">;

 
 def no_fatal_warnings: F<"no-fatal-warnings">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def O: JoinedOrSeparate<["-"], "O">, HelpText<"Optimize output file size">;
 
+defm pie: B<"pie",
+    "Create a position independent executable",
+    "Do not create a position independent executable (default)">;
+
 defm print_gc_sections: B<"print-gc-sections",
     "List removed unused sections",
     "Do not list removed unused sections">;
 
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
+def shared: F<"shared">, HelpText<"Build a shared object">;
+
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
 def threads: F<"threads">, HelpText<"Run the linker multi-threaded">;
 
 defm undefined: Eq<"undefined", "Force undefined symbol during linking">;
 

wasm/OutputSections.cpp

DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
 
   writeUleb128(OS, Segments.size(), "data segment count");
   OS.flush();
   BodySize = DataSectionHeader.size();
 
   for (OutputSegment *Segment : Segments) {
     raw_string_ostream OS(Segment->Header);
     writeUleb128(OS, 0, "memory index");
-    writeUleb128(OS, WASM_OPCODE_I32_CONST, "opcode:i32const");
-    writeSleb128(OS, Segment->StartVA, "memory offset");
-    writeUleb128(OS, WASM_OPCODE_END, "opcode:end");
+    WasmInitExpr InitExpr;
+    if (Config->Pic) {
+      assert(Segments.size() == 0 &&
+             "Currenly only a single data segment is supported in PIC mode");
+      InitExpr.Opcode = WASM_OPCODE_GET_GLOBAL;
+      InitExpr.Value.Global =
+          cast<GlobalSymbol>(WasmSym::MemoryBase)->getGlobalIndex();
+    } else {
+      InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+      InitExpr.Value.Int32 = Segment->StartVA;
+    }
+    writeInitExpr(OS, InitExpr);
     writeUleb128(OS, Segment->Size, "segment size");
     OS.flush();
 
     Segment->SectionOffset = BodySize;
     BodySize += Segment->Header.size() + Segment->Size;
     log("Data segment: size=" + Twine(Segment->Size));
 
     for (InputSegment *InputSeg : Segment->InputSegments)

wasm/Symbols.h

struct WasmSym {
 
   // __wasm_call_ctors
   // Function that directly calls all ctors in priority order.
   static DefinedFunction *CallCtors;
 
   // __dso_handle
   // Symbol used in calls to __cxa_atexit to determine current DLL
   static DefinedData *DsoHandle;
+
+  // __table_base
+  // Used in PIC code for offset of indirect function table
+  static Symbol *TableBase;
+
+  // __memory_base
+  // Used in PIC code for offset of global data
+  static Symbol *MemoryBase;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
   alignas(DefinedData) char B[sizeof(DefinedData)];

wasm/Symbols.cpp

 using namespace lld;
 using namespace lld::wasm;
 
 DefinedFunction *WasmSym::CallCtors;
 DefinedData *WasmSym::DsoHandle;
 DefinedData *WasmSym::DataEnd;
 DefinedData *WasmSym::HeapBase;
 DefinedGlobal *WasmSym::StackPointer;
+Symbol *WasmSym::TableBase;
+Symbol *WasmSym::MemoryBase;
 
 WasmSymbolType Symbol::getWasmType() const {
   if (isa<FunctionSymbol>(this))
     return WASM_SYMBOL_TYPE_FUNCTION;
   if (isa<DataSymbol>(this))
     return WASM_SYMBOL_TYPE_DATA;
   if (isa<GlobalSymbol>(this))
     return WASM_SYMBOL_TYPE_GLOBAL;

wasm/Writer.cpp

 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 static constexpr int kStackAlignment = 16;
-static constexpr int kInitialTableOffset = 1;
 static constexpr const char *kFunctionTableName = "__indirect_function_table";
 
 namespace {
 
 // An init entry to be written to either the synthetic init func or the
 // linking metadata.
 struct WasmInitEntry {
   const FunctionSymbol *Sym;
private:
   void createImportSection();
   void createMemorySection();
   void createElemSection();
   void createCodeSection();
   void createDataSection();
   void createCustomSections();
 
   // Custom sections
+  void createDylinkSection();
   void createRelocSections();
   void createLinkingSection();
   void createNameSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
+  uint32_t TableBase = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t MaxMemoryPages = 0;
+  // Memory size and aligment. Written to the "dylink" section
+  // when build with -shared or -pie.
+  uint32_t MemAlign = 0;
+  uint32_t MemSize = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t> TypeIndices;
   std::vector<const Symbol *> ImportedSymbols;
   unsigned NumImportedFunctions = 0;
   unsigned NumImportedGlobals = 0;
   std::vector<WasmExport> Exports;
   std::vector<const DefinedData *> DefinedFakeGlobals;
if (MaxMemoryPages != 0) {
       Import.Memory.Maximum = MaxMemoryPages;
     }
     if (Config->SharedMemory)
       Import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED;
     writeImport(OS, Import);
   }
 
   if (Config->ImportTable) {
-    uint32_t TableSize = kInitialTableOffset + IndirectFunctions.size();
+    uint32_t TableSize = TableBase + IndirectFunctions.size();
     WasmImport Import;
     Import.Module = "env";
     Import.Field = kFunctionTableName;
     Import.Kind = WASM_EXTERNAL_TABLE;
     Import.Table.ElemType = WASM_TYPE_ANYFUNC;
     Import.Table.Limits = {WASM_LIMITS_FLAG_HAS_MAX, TableSize, TableSize};
     writeImport(OS, Import);
   }
void Writer::createTableSection() {
   // Always output a table section (or table import), even if there are no
   // indirect calls.  There are two reasons for this:
   //  1. For executables it is useful to have an empty table slot at 0
   //     which can be filled with a null function call handler.
   //  2. If we don't do this, any program that contains a call_indirect but
   //     no address-taken function will fail at validation time since it is
   //     a validation error to include a call_indirect instruction if there
   //     is not table.
-  uint32_t TableSize = kInitialTableOffset + IndirectFunctions.size();
+  uint32_t TableSize = TableBase + IndirectFunctions.size();
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TABLE);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "table count");
   WasmLimits Limits = {WASM_LIMITS_FLAG_HAS_MAX, TableSize, TableSize};
   writeTableType(OS, WasmTable{WASM_TYPE_ANYFUNC, Limits});
 }
if (IndirectFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_ELEM);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "segment count");
   writeUleb128(OS, 0, "table index");
   WasmInitExpr InitExpr;
+  if (Config->Pic) {
+    InitExpr.Opcode = WASM_OPCODE_GET_GLOBAL;
+    InitExpr.Value.Global =
+        cast<GlobalSymbol>(WasmSym::TableBase)->getGlobalIndex();
+  } else {
     InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-  InitExpr.Value.Int32 = kInitialTableOffset;
+    InitExpr.Value.Int32 = TableBase;
+  }
   writeInitExpr(OS, InitExpr);
   writeUleb128(OS, IndirectFunctions.size(), "elem count");
 
-  uint32_t TableIndex = kInitialTableOffset;
+  uint32_t TableIndex = TableBase;
   for (const FunctionSymbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getFunctionIndex(), "function index");
     ++TableIndex;
   }
 }
 
 void Writer::createCodeSection() {

 private:
   uint32_t Type;
   std::string Body;
 
 public:
   raw_string_ostream OS{Body};
 };
 
+// Create the custom "dylink" section containing information for the dynamic
+// linker.
+// See
+// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+void Writer::createDylinkSection() {
+  SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "dylink");
+  raw_ostream &OS = Section->getStream();
+
+  writeUleb128(OS, MemSize, "MemSize");
+  writeUleb128(OS, log2(MemAlign), "MemAlign");
+  writeUleb128(OS, IndirectFunctions.size(), "TableSize");
+  writeUleb128(OS, 0, "TableAlign");
+}
+
 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, WasmMetadataVersion, "Version");

 // rather than overwriting global data, but also increases code size since all
 // static data loads and stores requires larger offsets.
 void Writer::layoutMemory() {
   createOutputSegments();
 
   uint32_t MemoryPtr = 0;
 
   auto PlaceStack = [&]() {
-    if (Config->Relocatable)
+    if (Config->Relocatable || Config->Shared)
       return;
     MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
     if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
       error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
     log("mem: stack size  = " + Twine(Config->ZStackSize));
     log("mem: stack base  = " + Twine(MemoryPtr));
     MemoryPtr += Config->ZStackSize;
     WasmSym::StackPointer->Global->Global.InitExpr.Value.Int32 = MemoryPtr;
void Writer::layoutMemory() {
 
   uint32_t DataStart = MemoryPtr;
 
   // Arbitrarily set __dso_handle handle to point to the start of the data
   // segments.
   if (WasmSym::DsoHandle)
     WasmSym::DsoHandle->setVirtualAddress(DataStart);
 
+  MemAlign = 0;
   for (OutputSegment *Seg : Segments) {
+    MemAlign = std::max(MemAlign, Seg->Alignment);
     MemoryPtr = alignTo(MemoryPtr, Seg->Alignment);
     Seg->StartVA = MemoryPtr;
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", Seg->Name,
                 MemoryPtr, Seg->Size, Seg->Alignment));
     MemoryPtr += Seg->Size;
   }
 
   // TODO: Add .bss space here.
void Writer::layoutMemory() {
   if (Config->InitialMemory != 0) {
     if (Config->InitialMemory != alignTo(Config->InitialMemory, WasmPageSize))
       error("initial memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (MemoryPtr > Config->InitialMemory)
       error("initial memory too small, " + Twine(MemoryPtr) + " bytes needed");
     else
       MemoryPtr = Config->InitialMemory;
   }
-  uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
+  MemSize = alignTo(MemoryPtr, WasmPageSize);
   NumMemoryPages = MemSize / WasmPageSize;
   log("mem: total pages = " + Twine(NumMemoryPages));
 
   if (Config->MaxMemory != 0) {
     if (Config->MaxMemory != alignTo(Config->MaxMemory, WasmPageSize))
       error("maximum memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (MemoryPtr > Config->MaxMemory)
       error("maximum memory too small, " + Twine(MemoryPtr) + " bytes needed");
     MaxMemoryPages = Config->MaxMemory / WasmPageSize;
     log("mem: max pages   = " + Twine(MaxMemoryPages));
   }
 }
 
 SyntheticSection *Writer::createSyntheticSection(uint32_t Type,
                                                  StringRef Name) {
   auto Sec = make<SyntheticSection>(Type, Name);
   log("createSection: " + toString(*Sec));
   OutputSections.push_back(Sec);
   return Sec;
 }
 
 void Writer::createSections() {
   // Known sections
+  if (Config->Pic)
+    createDylinkSection();
   createTypeSection();
   createImportSection();
   createFunctionSection();
   createTableSection();
   createMemorySection();
   createGlobalSection();
   createExportSection();
   createElemSection();
for (InputFunction *Func : Symtab->SyntheticFunctions)
     AddDefinedFunction(Func);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions)
       AddDefinedFunction(Func);
   }
 
-  uint32_t TableIndex = kInitialTableOffset;
+  uint32_t TableIndex = TableBase;
   auto HandleRelocs = [&](InputChunk *Chunk) {
     if (!Chunk->Live)
       return;
     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) {
void Writer::assignIndexes() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
     for (InputGlobal *Global : File->Globals)
       AddDefinedGlobal(Global);
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
+  // With PIC code we currently only support a single data segment since
+  // we only have a single __memory_base to use as our base address.
+  if (Config->Pic)
+    return "data";
   if (!Config->MergeDataSegments)
     return Name;
   if (Name.startswith(".text."))
     return ".text";
   if (Name.startswith(".data."))
     return ".data";
   if (Name.startswith(".bss."))
     return ".bss";
std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
                      return L.Priority < R.Priority;
                    });
 }
 
 void Writer::run() {
   if (Config->Relocatable)
     Config->GlobalBase = 0;
 
+  // For PIC code the table base is assigned dynamically by the loader.
+  // For non-PIC, we start at 1 so that accessing table index 0 always traps.
+  if (!Config->Pic)
+    TableBase = 1;
+
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();