[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

402–403

Sort alphabetically.

496

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

395

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

395

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

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

463

incompatible

498

remove "to"

499

"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

712

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

712

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/ReleaseNotes.rst

* lld can now use existing normal MinGW sysroots with import libraries and
   CRT startup object files for GNU binutils. lld can handle most object
   files produced by GCC, and thus works as a drop-in replacement for
   ld.bfd in such environments.
 
 MachO Improvements
 ------------------
 
 * Item 1.
+
+WebAssembly Improvements
+------------------------
+
+* Add initial support for creating shared libraries (-shared).
+  Note: The shared library format is still under active development and may
+  undergo significant changes in future versions.
+  See: https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md

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 ()* @foo, align 4
+
+define default void @foo() {
+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:     MemorySize:      4
+; CHECK-NEXT:     MemoryAlignment: 2
+; CHECK-NEXT:     TableSize:       1
+; CHECK-NEXT:     TableAlignment:  0
+
+; check for import of __table_base and __memory_base globals
+
+; CHECK:        - Type:            IMPORT
+; CHECK-NEXT:     Imports:
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __indirect_function_table
+; CHECK-NEXT:         Kind:            TABLE
+; CHECK-NEXT:         Table:
+; CHECK-NEXT:           ElemType:        ANYFUNC
+; CHECK-NEXT:           Limits:
+; CHECK-NEXT:             Flags:           [ HAS_MAX ]
+; CHECK-NEXT:             Initial:         0x00000001
+; CHECK-NEXT:             Maximum:         0x00000001
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __memory_base
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         GlobalType:      I32
+; CHECK-NEXT:         GlobalMutable:   false
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __table_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:           1
+; CHECK-NEXT:         Functions:       [ 1 ]
+
+; check the data segment initialized with __memory_base global as offset
+
+; CHECK:        - Type:            DATA
+; CHECK-NEXT:     Segments:
+; CHECK-NEXT:       - SectionOffset:   6
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:
+; CHECK-NEXT:           Opcode:          GET_GLOBAL
+; CHECK-NEXT:           Index:           0
+; 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->Pie = Args.hasFlag(OPT_pie, OPT_no_pie, false);
   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->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->StripDebug = Args.hasArg(OPT_strip_debug);
-  Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   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;
+
+  if (Config->Pic) {
+    if (Config->ExportTable)
+      error("-shared/-pie is incompatible with --export-table");
+    Config->ImportTable = true;
+  }
+
+  if (Config->Shared)
+    Config->ExportDynamic = true;
+
   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);
if (!Config->Relocatable) {
     // 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) {
+      // For PIC code, we import two global variables (__memory_base and
+      // __table_base) from the environment and use these as the offset at
+      // which to load our static data and function table.
+      // See: https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+      static llvm::wasm::WasmGlobalType GlobalTypeI32 = {WASM_TYPE_I32, false};
+
+      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();
+
+      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();
+    }
+
     // 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())
else if (!Config->AllowUndefined)
       error(Twine("symbol exported via --export not found: ") +
             Arg->getValue());
   }
 
   if (!Config->Relocatable) {
     // Add synthetic dummies for weak undefined functions.
     handleWeakUndefines();
 
-    if (!Config->Entry.empty()) {
+    if (!Config->Shared && !Config->Entry.empty()) {
       EntrySym = handleUndefined(Config->Entry);
       if (EntrySym && EntrySym->isDefined())
         EntrySym->ForceExport = true;
       else
         error("entry symbol not defined (pass --no-entry to supress): " +
               Config->Entry);
     }
 

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() <= 1 &&
+             "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, int(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);
-  NumMemoryPages = MemSize / WasmPageSize;
+  MemSize = MemoryPtr;
+  NumMemoryPages = alignTo(MemoryPtr, WasmPageSize) / 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";
void Writer::calculateInitFunctions() {
   // in the correct order.
   std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
                    [](const WasmInitEntry &L, const WasmInitEntry &R) {
                      return L.Priority < R.Priority;
                    });
 }
 
 void Writer::run() {
-  if (Config->Relocatable)
+  if (Config->Relocatable || Config->Pic)
     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();