[WebAssembly] Support creation and import of shared memories

[dschuff]

Summary

Used for WebAssembly threads proposal. Add a flag --shared-memory
which sets the IS_SHARED bit in WasmLimits

[sbc100]

Nice!

wasm/Writer.cpp

160 ↗

(On Diff #172689)

No curly braces for single line blocks

220 ↗

(On Diff #172689)

For consistency maybe:

unsigned Flags = 0;
if (HasMax)
   Flags |= WASM_LIMITS_FLAG_HAS_MAX;

lld/trunk/test/wasm/data-layout.ll

 ; RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-MAX
 
 ; CHECK-MAX:        - Type:            MEMORY
 ; CHECK-MAX-NEXT:     Memories:
 ; CHECK-MAX-NEXT:       - Flags:           [ HAS_MAX ]
 ; CHECK-MAX-NEXT:         Initial:         0x00000002
 ; CHECK-MAX-NEXT:         Maximum:         0x00000002
 
+; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry --shared-memory \
+; RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t.o \
+; RUN:     %t.hello.o
+; RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-SHARED
+
+; CHECK-SHARED:        - Type:            MEMORY
+; CHECK-SHARED-NEXT:     Memories:
+; CHECK-SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
+; CHECK-SHARED-NEXT:         Initial:         0x00000002
+; CHECK-SHARED-NEXT:         Maximum:         0x00000002
 
 ; RUN: wasm-ld --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:       - Type:            DATA
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; RELOC-NEXT:         Index:           6

lld/trunk/test/wasm/import-memory.test

 # CHECK-MAX-NEXT:      - Module:          env
 # CHECK-MAX-NEXT:        Field:           memory
 # CHECK-MAX-NEXT:        Kind:            MEMORY
 # CHECK-MAX-NEXT:        Memory:
 # CHECK-MAX-NEXT:          Flags:           [ HAS_MAX ]
 # CHECK-MAX-NEXT:          Initial:         0x00000004
 # CHECK-MAX-NEXT:          Maximum:         0x00000005
 # CHECK-MAX-NEXT:  - Type:
+
+# RUN: wasm-ld --import-memory --shared-memory --initial-memory=262144 \
+# RUN:     --max-memory=327680 -o %t.max.wasm %t.start.o
+# RUN: obj2yaml %t.max.wasm | FileCheck -check-prefix=CHECK-SHARED %s
+
+# Verify the --shared-memory flag works with imports
+
+# CHECK-SHARED:       - Type:            IMPORT
+# CHECK-SHARED-NEXT:    Imports:
+# CHECK-SHARED-NEXT:      - Module:          env
+# CHECK-SHARED-NEXT:        Field:           memory
+# CHECK-SHARED-NEXT:        Kind:            MEMORY
+# CHECK-SHARED-NEXT:        Memory:
+# CHECK-SHARED-NEXT:          Flags:           [ HAS_MAX, IS_SHARED ]
+# CHECK-SHARED-NEXT:          Initial:         0x00000004
+# CHECK-SHARED-NEXT:          Maximum:         0x00000005
+# CHECK-SHARED-NEXT:  - Type:

lld/trunk/wasm/Config.h

struct Configuration {
   bool CompressRelocations;
   bool Demangle;
   bool DisableVerify;
   bool ExportAll;
   bool ExportDynamic;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
+  bool SharedMemory;
   bool ImportTable;
   bool MergeDataSegments;
   bool PrintGcSections;
   bool Relocatable;
   bool SaveTemps;
   bool StripAll;
   bool StripDebug;
   bool StackFirst;

lld/trunk/wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   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);

lld/trunk/wasm/Options.td

def export_table: F<"export-table">,
   HelpText<"Export function table to the environment">;
 
 def global_base: J<"global-base=">,
   HelpText<"Where to start to place global data">;
 
 def import_memory: F<"import-memory">,
   HelpText<"Import memory from the environment">;
 
+def shared_memory: F<"shared-memory">,
+  HelpText<"Use shared linear memory">;
+
 def import_table: F<"import-table">,
   HelpText<"Import function table from the environment">;
 
 def initial_memory: J<"initial-memory=">,
   HelpText<"Initial size of the linear memory">;
 
 def max_memory: J<"max-memory=">,
   HelpText<"Maximum size of the linear memory">;

lld/trunk/wasm/Writer.cpp

if (Config->ImportMemory) {
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
     Import.Memory.Flags = 0;
     Import.Memory.Initial = NumMemoryPages;
     if (MaxMemoryPages != 0) {
       Import.Memory.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
       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();
     WasmImport Import;
     Import.Module = "env";
     Import.Field = kFunctionTableName;
void Writer::createMemorySection() {
   if (Config->ImportMemory)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_MEMORY);
   raw_ostream &OS = Section->getStream();
 
   bool HasMax = MaxMemoryPages != 0;
   writeUleb128(OS, 1, "memory count");
-  writeUleb128(OS, HasMax ? static_cast<unsigned>(WASM_LIMITS_FLAG_HAS_MAX) : 0,
-               "memory limits flags");
+  unsigned Flags = HasMax ? static_cast<unsigned>(WASM_LIMITS_FLAG_HAS_MAX) : 0;
+  if (Config->SharedMemory)
+    Flags |= WASM_LIMITS_FLAG_IS_SHARED;
+  writeUleb128(OS, Flags, "memory limits flags");
   writeUleb128(OS, NumMemoryPages, "initial pages");
   if (HasMax)
     writeUleb128(OS, MaxMemoryPages, "max pages");
 }
 
 void Writer::createGlobalSection() {
   unsigned NumGlobals = InputGlobals.size() + DefinedFakeGlobals.size();
   if (NumGlobals == 0)