[WebAssembly] Add option to emit passive segments

[tlively]

Summary

Adds --passive-segments and --active-segments flags to control
what kind of segments are emitted. For now the default is always
to emit active segments so this is not a breaking change, but in
the future the default will be changed to passive segments when
shared memory is requested and active segments otherwise. When
passive segments are emitted, corresponding memory.init and
data.drop instructions are emitted in a __wasm_init_memory
function that is automatically called at the beginning of
__wasm_call_ctors.

[sbc100]

Mostly lgtm

lld/test/wasm/data-segment-merging.ll

12

The code looks like passive initiazlition is driver by the "--shared-memory" flag rather than atomics. Wouldn't it make more sense to use "SHARED" over "ATOMICS" in this test?

[tlively]

lld/test/wasm/data-segment-merging.ll

12

D59284 makes the "atomics" feature imply the use of shared memory, and in this test the flag that causes shared memory to be used is -mattr=+atomics, so I think the current naming accurately describes what is happening. I expect the common way to get shared memory is by using the atomics feature, so perhaps we can even deprecate the --shared-memory flag, WDYT?

[sbc100]

lld/test/wasm/data-segment-merging.ll

12

I'm not sure. Part of me likes the explicit requirment/ability to pass this kind of thing as a linker flag. I think shared vs non-shared memory is significant enough that I'm not sure it should be driven my object file input.

e.g. As a developer, I don't necessarily want the accidental inclusion of the bad object file to change the type of output object. It would be like infering -shared if I pass objects build with -PIC. I think I'd rather get a linker error (object files use atomics, did you mean to pass --shared-memory?)

[tlively]

lld/test/wasm/data-segment-merging.ll

12

That's a reasonable argument. This CL introduces a similar error when atomics are used but a max memory size is not supplied. But I think requiring an explicit --shared-memory flag when the linker can infer that shared memory is necessary is an unnecessary speed bump for users. Inferring shared memory is consistent with our intent in the clang flags that using the atomics feature implies multithreading. The more robust mechanism for guarding against bad object files is explicitly specifying features with --features=....

[tlively]

• Add --shared-memory to avoid new errors

[tlively]

• ATOMICS -> SHARED in test

[tlively]

lld/test/wasm/data-segment-merging.ll

12

Updated for the new error behavior and changed from ATOMICS to SHARED as originally suggested.

[tlively]

• rebase

[tlively]

@dschuff, @sbc100, @azakai we should figure out what our story is for pthreads and bulk-memory in the LLVM backend. This CL assumes that passive segments will always be available when creating multithreaded binaries, but obviously that's not true for Chrome 74. I was thinking that would be fine because using the asm2wasm path with mem files will suffice for anyone wanting to target chrome 74 with pthreads. But will we want to support mem files going forward? If so, I need to add a linker option to control that.

[tlively]

• Rebase on top of D60637 and add data.drop

[sbc100]

lld/test/wasm/data-segment-merging.ll

61

Can we switch to MERGE-SHARED-NEXT here and below?

lld/wasm/OutputSections.cpp

164

Perhaps we should make this into a fatal error? And we could perhaps catch it earlier. Doesn't need to happen in this CL though I guess,

lld/wasm/Writer.cpp

1350

I'm tempted to make this a new function of its own that is than called as constructor 0. What do you think?

[tlively]

• address comments

[tlively]

lld/test/wasm/data-segment-merging.ll

61

We're deliberately skipping SectionOffset lines in the output because they're not that very interesting. I could include them and switch to MERGE-SHARED-NEXT if you want, though.

I've also de-duplicated a lot of the checking here.

lld/wasm/OutputSections.cpp

164

Makes sense, but I think that can be a separate PR.

lld/wasm/Writer.cpp

1350

Sounds good. Done.

[sbc100]

lld/wasm/Driver.cpp

447 ↗

(On Diff #195277)

It might not be the second so perhaps how about: "which is called from __wasm_call_ctors before the user-level constructors".

lld/wasm/MarkLive.cpp

81 ↗

(On Diff #195277)

The coding style for lld is to not include braces for single line blocks.

We need to think a little more about this is going to work for non-PIC code. Up until now its been possible to write non-PIC static executable that runs the ctors itself via some arbitrary function. e.g.

int mystartfunc() {
  __wasm_call_ctors();
  return main()
}

This part of the markLive is designed to keep __wasm_call_ctors alive even if the user never references it (since its to be exported in the PIC case).

So.. in the non-PIC case, even for shared-memory, I think we should let the normal GC process take its course. If they user forgets to reference __wasm_call_ctors, then there is not way it can ever be called, so we might as well let it be GC'd.

But the dependency setup here is getting a little complicated. Really what we want to say is something like:

"if CallCtors is alive then ApplyRelocs need to be too" and the same for InitMemory. Perhaps we should add Dependencies() to SyntheticFunction?

For now I'm ok with the conservative approach of just keeping InitMemory alive as long as SharedMemory is present.

[tlively]

• Address comments

[tlively]

This CL should not be merged until Chrome 75 releases to stable on June 4.

lld/wasm/MarkLive.cpp

81 ↗

(On Diff #195277)

I looked into adding Dependencies, but because markLive happens before anything in Writer.cpp there didn't seem to be a good way to set that up. I simplified the logic in MarkLive.cpp though, now that I understand what it is doing more.

[tlively]

Change to use explicit flags instead of depending on shared
memory. This means this change is a nop in existing
toolchains. Emscripten can be taught to use the new flags explicitly
without requiring a manual double roll.

After emscripten is updated to use the flags explicitly the default
behavior can be changed to depend on --shared-memory.

[tlively]

• Remove extraneous braces

[tlively]

@sbc100 it's been a long time but there is nothing blocking this change any more, so PTAL!

[sbc100]

Nice!

lld/wasm/Driver.cpp

479 ↗

(On Diff #207178)

The last line of this comment doesn't seem to be full sentence and is inaccurate so perhaps remove that line while you are here?

lld/wasm/Writer.cpp

1309

Take a StringRef rather than const string&?

lld/test/wasm/data-segment-merging.ll

 target triple = "wasm32-unknown-unknown"
 
 @a = hidden global [6 x i8] c"hello\00", align 1
 @b = hidden global [8 x i8] c"goodbye\00", align 1
 @c = hidden global [9 x i8] c"whatever\00", align 1
 @d = hidden global i32 42, align 4
 
 @e = private constant [9 x i8] c"constant\00", align 1
 @f = private constant i8 43, align 4
 
-; RUN: llc -filetype=obj %s -o %t.data-segment-merging.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.atomics.o -mattr=+atomics
+; RUN: llc -filetype=obj %s -o %t.bulk-mem.o -mattr=+bulk-memory
+; RUN: llc -filetype=obj %s -o %t.atomics.bulk-mem.o -mattr=+atomics,+bulk-memory
 
-; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.wasm %t.data-segment-merging.o
+; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.wasm %t.o
 ; RUN: obj2yaml %t.merged.wasm | FileCheck %s --check-prefix=MERGE
 
 ; MERGE-NOT:                  DATACOUNT
+; MERGE:   - Type:            CODE
+; MERGE:     Body:               0B
 ; MERGE:   - Type:            DATA
 ; MERGE:     Segments:
+; MERGE:        InitFlags:       0
 ; MERGE:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
+; MERGE:        InitFlags:       0
 ; MERGE:        Content:         636F6E7374616E74000000002B
 ; MERGE-NOT:    Content:
 
-; RUN: wasm-ld -no-gc-sections --no-entry --no-merge-data-segments -o %t.separate.wasm %t.data-segment-merging.o
+; RUN: wasm-ld -no-gc-sections --no-entry --no-merge-data-segments -o %t.separate.wasm %t.o
 ; RUN: obj2yaml %t.separate.wasm | FileCheck %s --check-prefix=SEPARATE
 
 ; SEPARATE-NOT:                  DATACOUNT
+; SEPARATE:   - Type:            CODE
+; SEPARATE:     Body:               0B
 ; SEPARATE:   - Type:            DATA
 ; SEPARATE:     Segments:
+; SEPARATE:        InitFlags:       0
 ; SEPARATE:        Content:         68656C6C6F00
+; SEPARATE:        InitFlags:       0
 ; SEPARATE:        Content:         676F6F6462796500
+; SEPARATE:        InitFlags:       0
 ; SEPARATE:        Content:         '776861746576657200'
+; SEPARATE:        InitFlags:       0
 ; SEPARATE:        Content:         2A000000
+; SEPARATE:        InitFlags:       0
 ; SEPARATE:        Content:         636F6E7374616E7400
 ; SEPARATE:        Content:         2B
 ; SEPARATE-NOT:    Content:
 
-; RUN: llc -filetype=obj %s -mattr=+bulk-memory -o %t.data-segment-merging.bulk-memory.o
-; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.bulk-memory.wasm %t.data-segment-merging.bulk-memory.o
-; RUN: obj2yaml %t.merged.bulk-memory.wasm | FileCheck %s --check-prefix=BULK-MEMORY
-
-; BULK-MEMORY:   - Type:            DATACOUNT
-; BULK-MEMORY:     Count:           2
-; BULK-MEMORY:   - Type:            DATA
-; BULK-MEMORY:     Segments:
-; BULK-MEMORY:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
-; BULK-MEMORY:        Content:         636F6E7374616E74000000002B
-; BULK-MEMORY-NOT:    Content:
+; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -o %t.merged.atomics.wasm %t.atomics.o
+; RUN: obj2yaml %t.merged.atomics.wasm | FileCheck %s --check-prefix=MERGE-SHARED
+
+; MERGE-SHARED-NOT:                       DATACOUNT
+; MERGE-SHARED:        - Type:            CODE
+; MERGE-SHARED-NEXT:     Functions:
+; MERGE-SHARED-NEXT:       - Index:           0
+; MERGE-SHARED-NEXT:         Locals:          []
+; MERGE-SHARED-NEXT:         Body:            4180084100411CFC080000FC0900419C084100410DFC080100FC09010B
+; MERGE-SHARED:        - Type:            DATA
+; MERGE-SHARED:          Segments:
+; MERGE-SHARED:             InitFlags:       1
+; MERGE-SHARED:             Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
+; MERGE-SHARED:             InitFlags:       1
+; MERGE-SHARED:             Content:         636F6E7374616E74000000002B
+; MERGE-SHARED-NOT:         Content:
+
+; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.bulk-mem.wasm %t.bulk-mem.o
+; RUN: obj2yaml %t.merged.bulk-mem.wasm | FileCheck %s --check-prefix=MERGE-BULK-MEM
+
+; MERGE-BULK-MEM:   - Type:            DATACOUNT
+; MERGE-BULK-MEM:     Count:           2
+; MERGE-BULK-MEM:   - Type:            CODE
+; MERGE-BULK-MEM:     Body:               0B
+; MERGE-BULK-MEM:   - Type:            DATA
+; MERGE-BULK-MEM:     Segments:
+; MERGE-BULK-MEM:        InitFlags:       0
+; MERGE-BULK-MEM:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
+; MERGE-BULK-MEM:        InitFlags:       0
+; MERGE-BULK-MEM:        Content:         636F6E7374616E74000000002B
+; MERGE-BULK-MEM-NOT:    Content:
+
+; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -o %t.merged.atomics.bulk-mem.wasm %t.atomics.bulk-mem.o
+; RUN: obj2yaml %t.merged.atomics.bulk-mem.wasm | FileCheck %s --check-prefix=MERGE-SHARED-BULK-MEM
+
+; MERGE-SHARED-BULK-MEM:        - Type:            DATACOUNT
+; MERGE-SHARED-BULK-MEM-NEXT:     Count:           2
+; MERGE-SHARED-BULK-MEM:        - Type:            CODE
+; MERGE-SHARED-BULK-MEM-NEXT:     Functions:
+; MERGE-SHARED-BULK-MEM-NEXT:       - Index:           0
+; MERGE-SHARED-BULK-MEM-NEXT:         Locals:          []
+; MERGE-SHARED-BULK-MEM-NEXT:         Body:            4180084100411CFC080000FC0900419C084100410DFC080100FC09010B
+; MERGE-SHARED-BULK-MEM:        - Type:            DATA
+; MERGE-SHARED-BULK-MEM:          Segments:
+; MERGE-SHARED-BULK-MEM:             InitFlags:       1
+; MERGE-SHARED-BULK-MEM:             Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
+; MERGE-SHARED-BULK-MEM:             InitFlags:       1
+; MERGE-SHARED-BULK-MEM:             Content:         636F6E7374616E74000000002B
+; MERGE-SHARED-BULK-MEM-NOT:         Content:

lld/wasm/OutputSections.cpp

 DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
     : OutputSection(WASM_SEC_DATA), Segments(Segments) {
   raw_string_ostream OS(DataSectionHeader);
 
   writeUleb128(OS, Segments.size(), "data segment count");
   OS.flush();
   BodySize = DataSectionHeader.size();
 
+  assert(!Config->Pic ||
+         Segments.size() <= 1 &&
+             "Currenly only a single data segment is supported in PIC mode");
+
   for (OutputSegment *Segment : Segments) {
     raw_string_ostream OS(Segment->Header);
+    writeUleb128(OS, Segment->InitFlags, "init flags");
+    if (Segment->InitFlags & WASM_SEGMENT_HAS_MEMINDEX)
       writeUleb128(OS, 0, "memory index");
+    if ((Segment->InitFlags & WASM_SEGMENT_IS_PASSIVE) == 0) {
       WasmInitExpr InitExpr;
       if (Config->Pic) {
-      assert(Segments.size() <= 1 &&
-             "Currenly only a single data segment is supported in PIC mode");
         InitExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
         InitExpr.Value.Global = 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)

lld/wasm/OutputSegment.h

void addInputSegment(InputSegment *InSeg) {
     Size = llvm::alignTo(Size, 1ULL << InSeg->getAlignment());
     InSeg->OutputSeg = this;
     InSeg->OutputSegmentOffset = Size;
     Size += InSeg->getSize();
   }
 
   StringRef Name;
   const uint32_t Index;
+  uint32_t InitFlags = 0;
   uint32_t SectionOffset = 0;
   uint32_t Alignment = 0;
   uint32_t StartVA = 0;
   std::vector<InputSegment *> InputSegments;
 
   // Sum of the size of the all the input segments
   uint32_t Size = 0;
 
   // Segment header
   std::string Header;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SEGMENT_H

lld/wasm/Writer.cpp

for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSegment *Segment : File->Segments) {
       if (!Segment->Live)
         continue;
       StringRef Name = getOutputDataSegmentName(Segment->getName());
       OutputSegment *&S = SegmentMap[Name];
       if (S == nullptr) {
         LLVM_DEBUG(dbgs() << "new segment: " << Name << "\n");
         S = make<OutputSegment>(Name, Segments.size());
+        if (Config->SharedMemory)
+          S->InitFlags = WASM_SEGMENT_IS_PASSIVE;
         Segments.push_back(S);
       }
       S->addInputSegment(Segment);
       LLVM_DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
     }
   }
 }
 
 // For -shared (PIC) output, we create create a synthetic function which will
 // apply any relocations to the data segments on startup.  This function is
 // called __wasm_apply_relocs and is added at the very beginning of
 // __wasm_call_ctors before any of the constructors run.
 void Writer::createApplyRelocationsFunction() {
   LLVM_DEBUG(dbgs() << "createApplyRelocationsFunction\n");
   // First write the body's contents to a string.
   std::string BodyContent;
   {
     raw_string_ostream OS(BodyContent);
void Writer::createCallCtorsFunction() {
   if (!WasmSym::CallCtors->isLive())
     return;
 
   // First write the body's contents to a string.
   std::string BodyContent;
   {
     raw_string_ostream OS(BodyContent);
     writeUleb128(OS, 0, "num locals");
+
+    // initialize passive data segments
+    for (const OutputSegment *S : Segments) {
+      if (S->InitFlags & WASM_SEGMENT_IS_PASSIVE) {
+        // destination address
+        writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const");
+        writeUleb128(OS, S->StartVA, "destination address");
+        // source segment offset
+        writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const");
+        writeUleb128(OS, 0, "segment offset");
+        // memory region size
+        writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const");
+        writeUleb128(OS, S->Size, "memory region size");
+        // memory.init instruction
+        writeU8(OS, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
+        writeUleb128(OS, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT");
+        writeUleb128(OS, S->Index, "segment index immediate");
+        writeU8(OS, 0, "memory index immediate");
+        // data.drop instruction
+        writeU8(OS, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
+        writeUleb128(OS, WASM_OPCODE_DATA_DROP, "DATA.DROP");
+        writeUleb128(OS, S->Index, "segment index immediate");
+      }
+    }
+
     if (Config->Pic) {
       writeU8(OS, WASM_OPCODE_CALL, "CALL");
       writeUleb128(OS, WasmSym::ApplyRelocs->getFunctionIndex(),
                    "function index");
     }
+
+    // call constructors
     for (const WasmInitEntry &F : InitFunctions) {
       writeU8(OS, WASM_OPCODE_CALL, "CALL");
       writeUleb128(OS, F.Sym->getFunctionIndex(), "function index");
     }
     writeU8(OS, WASM_OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
if (!Config->Pic)
     TableBase = 1;
 
   log("-- calculateTargetFeatures");
   calculateTargetFeatures();
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
-  log("-- calculateInitFunctions");
-  calculateInitFunctions();
   log("-- calculateTypes");
   calculateTypes();
   log("-- layoutMemory");
   layoutMemory();
+  log("-- calculateInitFunctions");
+  calculateInitFunctions();
   if (!Config->Relocatable) {
     if (Config->Pic)
       createApplyRelocationsFunction();
     createCallCtorsFunction();
   }
   log("-- calculateExports");
   calculateExports();
   log("-- calculateCustomSections");

llvm/include/llvm/BinaryFormat/Wasm.h

enum : unsigned {
   WASM_OPCODE_CALL = 0x10,
   WASM_OPCODE_GLOBAL_GET = 0x23,
   WASM_OPCODE_I32_STORE = 0x36,
   WASM_OPCODE_I32_CONST = 0x41,
   WASM_OPCODE_I64_CONST = 0x42,
   WASM_OPCODE_F32_CONST = 0x43,
   WASM_OPCODE_F64_CONST = 0x44,
   WASM_OPCODE_I32_ADD = 0x6a,
+  WASM_OPCODE_MISC_PREFIX = 0xfc,
+  WASM_OPCODE_MEMORY_INIT = 0x08,
+  WASM_OPCODE_DATA_DROP = 0x09,
 };
 
 enum : unsigned {
   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
 };
 
 enum : unsigned {