[WebAssembly] Update MC for bulk memory

[tlively]

Summary

Rename MemoryIndex to InitFlags and implement logic for determining
data segment layout in ObjectYAML and MC. Also adds a "passive" flag
for the .section assembler directive although this cannot be assembled
yet because the assembler does not support data sections.

[tlively]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

673 ↗

(On Diff #185910)

@aardappel, I wanted to test that this directive would properly round trip through the assembler and disassembler, but I wasn't able to get the assembler to handle a data section properly. Is this something that you would expect to work at the moment?

[sbc100]

lgtm with comments/questions.

llvm/include/llvm/BinaryFormat/Wasm.h

136

Is Flags and enum.. in which case should we name the number values and should these comments say flags & 2?

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

673 ↗

(On Diff #185910)

There are still issues with roundtriping in its full generality. Open any bug you find and we can incrementally improve things.

llvm/test/MC/WebAssembly/init-flags.ll

6

What is .cond_init? I don't see any other mention of it?

Also, am I to understand that enabling bulk memory causes all the data sections to be passive by default?

[tlively]

• Switch to using ThreadModel instead of hasBulkMemory to determine segment initializer types. This creates a dependency on D57874, which makes "single" the default thread model for wasm.

[tlively]

llvm/include/llvm/BinaryFormat/Wasm.h

136

No, in the bulk memory proposal, the meaningful values are referred to only as 1, 2, and 3. Perhaps it would make more sense to name this field "InitType" and the directive ".init_type" or similar and create a corresponding enum for the different values it can take on. I worry that there are already too many too many things called "types" floating around, though. What do you think?

llvm/test/MC/WebAssembly/init-flags.ll

6

Good catch, this should .init_flags. .cond_init was an older name I had for the directive. In the original diff yes, enabling bulk memory was meant to cause all data sections to be passive. Now it is setting -thread-model=posix (or anything non-single threaded, if any other options existed) that controls this.

[aardappel]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

673 ↗

(On Diff #185910)

Nope, was actually just going to look into data sections.

673 ↗

(On Diff #185910)

Also, parsing of segments is in WasmAsmParser.cpp, so this code may make more sense there (if its about the container format, not the instruction set)

290 ↗

(On Diff #186061)

Call expect here instead?

[tlively]

• Move .init_flags parsing to WasmAsmParser.cpp
• Fix old tests to use thread-model=single

[tlively]

• Remove round trip from init-flags.ll because both directions were already tested.

[tlively]

• Use enum for flags instead of int literals

[tlively]

llvm/include/llvm/BinaryFormat/Wasm.h

136

I realized that there was a clean way to interpret the values as flags, so I went ahead and made that change.

[sbc100]

llvm/include/llvm/BinaryFormat/Wasm.h

134–136

InitFlags?

136

I'm happy with ".init_flags" and the field being called InitFlag, but I think it would be better to have the the 3 possible values to be in an enum or #define in BinaryFormat/Wasm.h rather than magic numbers in the sources.

llvm/include/llvm/ObjectYAML/WasmYAML.h

115

InitFlags?

llvm/test/MC/WebAssembly/external-data.ll

1

Why do this, given that single is still the default?

[sbc100]

Sorry my last comments were out-of-date (I think I wrote them yesterday) and don't all apply anymore :)

[dschuff]

Without the context of MC here there's no indication what kind of flags the .init_flags directive refers to. Maybe call it init_segment_flags?

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

20 ↗

(On Diff #186385)

You don't need to include this here, you can just forward declare class MCSectionWasm down on line26 with the others.

[sbc100]

In D57938#1395614, @dschuff wrote:

Without the context of MC here there's no indication what kind of flags the .init_flags directive refers to. Maybe call it init_segment_flags?

Better still perhaps we can attach it to the segment/section declaring in the the asm itself? It should be noted that wouter is working changing this right now.. so it probably OK to land this and then consolidate/iterate?

[tlively]

The way this CL is written now, it parses .init_flags in WasmAsmParser and writes the new data segment headers in WasmObjectWriter, but the streaming is handled in WebAssemblyTargetStreamer. This mismatch between container-level and target-level processing is no good, so I'm going to refactor the CL to use MCWasmStreamer. Unfortunately that means I will have to add new methods to the top level MCStreamer class. There are plenty of other container-specific methods in MCStreamer already, although not so much for wobjects yet. While I'm at it I will change .init_flags so that instead of applying to the current section (which must be a data section), it will take the name of the data section as an argument.

But before I do all that, I'm going to experiment with using the flags mechanism of the .section directive that is used by other container formats for similar purposes. This would mean no new directives and no polluting shared interfaces. Yay!

llvm/test/MC/WebAssembly/external-data.ll

1

Single is the default for clang, but not for llc.

[sbc100]

llvm/test/MC/WebAssembly/external-data.ll

1

Hmm, that doesn't seem great. We don't want llc, but default, generating code that requires the threads proposal. Maybe we should fix that?
(unless its particularly awkward).

[tlively]

• Replace .init_flags directive with a .section directive flag, "passive"

[tlively]

llvm/test/MC/WebAssembly/external-data.ll

1

I'm not sure that needs to be changed, but if it does we should do that as a separate CL.

[tlively]

• Remove unnecessary #include

[tlively]

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

20 ↗

(On Diff #186385)

This was no longer necessary at all, so I removed it.

[tlively]

• Remove unnecessary #include

[• ham999221]

This comment was removed by asl.

lld/test/wasm/call-indirect.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            410028028888808000118180808000001A0B
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            42012000118280808000001A0B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:    7
-; CHECK-NEXT:         MemoryIndex:      0
+; CHECK-NEXT:         InitFlags:        0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '010000000200000002000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0

lld/test/wasm/comdats.ll

 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            4181808080000B
 ; CHECK-NEXT:      - Index:           4
 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            4181808080000B
 ; CHECK-NEXT:  - Type:            DATA
 ; CHECK-NEXT:    Segments:
 ; CHECK-NEXT:      - SectionOffset:   7
-; CHECK-NEXT:        MemoryIndex:     0
+; CHECK-NEXT:        InitFlags:       0
 ; CHECK-NEXT:        Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           1024
 ; CHECK-NEXT:        Content:         '616263'

lld/test/wasm/data-layout.ll

 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
 
 ; CHECK:         - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '0100000000000000000000000000000003000000000000002804000024040000'
 ; CHECK-NEXT:       - SectionOffset:   45
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1056
 ; CHECK-NEXT:         Content:         '0000000000000000'
 ; CHECK-NEXT:       - SectionOffset:   59
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1064
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 ; CHECK-NEXT:    - Type:            CUSTOM
 
 
 ; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry \
 ; RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t.o \

 ; RELOC-NEXT:         Index:           3
 ; RELOC-NEXT:         Offset:          0x00000018
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; RELOC-NEXT:         Index:           4
 ; RELOC-NEXT:         Offset:          0x0000002E
 ; RELOC-NEXT:         Addend:          4
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '01000000'
 ; RELOC-NEXT:       - SectionOffset:   15
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '03000000'
 ; RELOC-NEXT:       - SectionOffset:   24
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           24
 ; RELOC-NEXT:         Content:         '28000000'
 ; RELOC-NEXT:       - SectionOffset:   33
-; RELOC-NEXT:         MemoryIndex:     0
-; RELOC-NEXT:         Offset:          
+; RELOC-NEXT:         InitFlags:       0
+; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           28
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   46
-; RELOC-NEXT:         MemoryIndex:     0
-; RELOC-NEXT:         Offset:          
+; RELOC-NEXT:         InitFlags:       0
+; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           36
 ; RELOC-NEXT:         Content:         '20000000'
 ; RELOC-NEXT:       - SectionOffset:   55
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           40
 ; RELOC-NEXT:         Content:         68656C6C6F0A00
 
 ; RELOC:          SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            DATA

lld/test/wasm/gc-sections.ll

 ; CHECK-NEXT:         Mutable:     true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I64_CONST
 ; CHECK-NEXT:           Value:           456
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '02000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors

 ; NO-GC-NEXT:         Mutable:     true
 ; NO-GC-NEXT:         InitExpr:
 ; NO-GC-NEXT:           Opcode:          I64_CONST
 ; NO-GC-NEXT:           Value:           456
 
 ; NO-GC:        - Type:            DATA
 ; NO-GC-NEXT:     Segments:        
 ; NO-GC-NEXT:       - SectionOffset:   7
-; NO-GC-NEXT:         MemoryIndex:     0
-; NO-GC-NEXT:         Offset:          
+; NO-GC-NEXT:         InitFlags:       0
+; NO-GC-NEXT:         Offset:
 ; NO-GC-NEXT:           Opcode:          I32_CONST
 ; NO-GC-NEXT:           Value:           1024
 ; NO-GC-NEXT:         Content:         '010000000000000002000000'
 ; NO-GC-NEXT:   - Type:            CUSTOM
 ; NO-GC-NEXT:     Name:            name
 ; NO-GC-NEXT:     FunctionNames:
 ; NO-GC-NEXT:       - Index:           0
 ; NO-GC-NEXT:         Name:            __wasm_call_ctors

lld/test/wasm/init-fini.ll

-; RUN: llc -filetype=obj -o %t.o %s
-; RUN: llc -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
+; RUN: llc -filetype=obj -thread-model=single -o %t.o %s
+; RUN: llc -filetype=obj -thread-model=single %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
 
 target triple = "wasm32-unknown-unknown"
 
 define hidden void @func1() {
 entry:
   ret void
 }
 

lld/test/wasm/local-symbols.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284888080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1081808080001A0B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '0100000003000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            baz
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT: ...

lld/test/wasm/locals-duplicate.test

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4185808080000B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4186808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '000000000000000000000000000000000000000000000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0

 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4185808080000B
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4186808080000B
 ; RELOC-NEXT:   - Type:            DATA
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   19
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           8
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   32
-; RELOC-NEXT:         MemoryIndex:     0
+; RELOC-NEXT:         InitFlags:       0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     Version:         2
 ; RELOC-NEXT:     SymbolTable:

lld/test/wasm/lto/used.ll

 
 return:
   ret void
 }
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '01000000'
 
 ; CHECK:       - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            name
 ; CHECK-NEXT:    FunctionNames:   
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            __wasm_call_ctors
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Name:            _start
 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Name:            bar

lld/test/wasm/many-functions.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280280808080000B
 ; CHECK-NEXT:       - Index:           129
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1081818080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:       - SectionOffset:   15
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           4
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:

lld/test/wasm/relocatable.ll

 ; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x00000024
 ; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           12
 ; CHECK-NEXT:         Offset:          0x0000002D
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 ; CHECK-NEXT:       - SectionOffset:   18
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:       - SectionOffset:   27
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           12
 ; CHECK-NEXT:         Content:         '02000000'
 ; CHECK-NEXT:       - SectionOffset:   36
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '03000000'
 ; CHECK-NEXT:       - SectionOffset:   45
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   54
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           28
 ; CHECK-NEXT:         Content:         '616263'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:

lld/test/wasm/shared.ll

 ; CHECK-NEXT:           Index:           2
 ; CHECK-NEXT:         Functions:       [ 2, 0 ]
 
 ; 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:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          GLOBAL_GET
 ; CHECK-NEXT:           Index:           1
 ; CHECK-NEXT:         Content:         '0000000001000000'

lld/test/wasm/weak-symbols.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0

llvm/include/llvm/BinaryFormat/Wasm.h

struct WasmFunction {
   uint32_t Size;
   uint32_t CodeOffset;  // start of Locals and Body
   StringRef SymbolName; // from the "linking" section
   StringRef DebugName;  // from the "name" section
   uint32_t Comdat;      // from the "comdat info" section
 };
 
 struct WasmDataSegment {
-  uint32_t MemoryIndex;
-  WasmInitExpr Offset;
+  uint32_t InitFlags;
+  uint32_t MemoryIndex; // present if InitFlags & WASM_SEGMENT_HAS_MEMINDEX
+  WasmInitExpr Offset; // present if InitFlags & WASM_SEGMENT_IS_PASSIVE == 0
   ArrayRef<uint8_t> Content;
   StringRef Name; // from the "segment info" section
   uint32_t Alignment;
-  uint32_t Flags;
+  uint32_t LinkerFlags;
   uint32_t Comdat; // from the "comdat info" section
 };
 
 struct WasmElemSegment {
   uint32_t TableIndex;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
enum : unsigned {
   WASM_OPCODE_F64_CONST = 0x44,
 };
 
 enum : unsigned {
   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
 };
 
+enum : unsigned {
+  WASM_SEGMENT_IS_PASSIVE = 0x01,
+  WASM_SEGMENT_HAS_MEMINDEX = 0x02,
+};
+
 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL = 0x2,
 };
 
 // Kind codes used in the custom "linking" section
 enum : unsigned {

llvm/include/llvm/MC/MCSectionWasm.h

class MCSectionWasm final : public MCSection {
   // For data relocations the offset is relative to start of the data payload
   // itself and does not include the size of the section header.
   uint64_t SectionOffset = 0;
 
   // For data sections, this is the index of of the corresponding wasm data
   // segment
   uint32_t SegmentIndex = 0;
 
+  // Whether this data segment is passive
+  bool IsPassive = false;
+
   friend class MCContext;
   MCSectionWasm(StringRef Section, SectionKind K, const MCSymbolWasm *group,
                 unsigned UniqueID, MCSymbol *Begin)
       : MCSection(SV_Wasm, K, Begin), SectionName(Section), UniqueID(UniqueID),
         Group(group) {}
 
 public:
   /// Decides whether a '.section' directive should be printed before the
public:
   unsigned getUniqueID() const { return UniqueID; }
 
   uint64_t getSectionOffset() const { return SectionOffset; }
   void setSectionOffset(uint64_t Offset) { SectionOffset = Offset; }
 
   uint32_t getSegmentIndex() const { return SegmentIndex; }
   void setSegmentIndex(uint32_t Index) { SegmentIndex = Index; }
 
+  bool getPassive() const {
+    assert(isWasmData());
+    return IsPassive;
+  }
+  void setPassive(bool V = true) {
+    assert(isWasmData());
+    IsPassive = V;
+  }
   static bool classof(const MCSection *S) { return S->getVariant() == SV_Wasm; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/ObjectYAML/WasmYAML.h

 struct Relocation {
   RelocType Type;
   uint32_t Index;
   yaml::Hex32 Offset;
   int32_t Addend;
 };
 
 struct DataSegment {
-  uint32_t MemoryIndex;
   uint32_t SectionOffset;
+  uint32_t InitFlags;
+  uint32_t MemoryIndex;
   wasm::WasmInitExpr Offset;
   yaml::BinaryRef Content;
 };
 
 struct NameEntry {
   uint32_t Index;
   StringRef Name;
 };

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
 
   Kind = getWasmKindForNamedSection(Name, Kind);
 
   StringRef Group = "";
   if (const Comdat *C = getWasmComdat(GO)) {
     Group = C->getName();
   }
 
-  return getContext().getWasmSection(Name, Kind, Group,
-                                     MCContext::GenericSectionID);
+  MCSectionWasm* Section =
+      getContext().getWasmSection(Name, Kind, Group,
+
+  if (TM.Options.ThreadModel != ThreadModel::Single)
+    Section->setPassive();
+
+  return Section;
 }
 
 static MCSectionWasm *selectWasmSectionForGlobal(
     MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
   StringRef Group = "";
   if (const Comdat *C = getWasmComdat(GO)) {
     Group = C->getName();
if (EmitUniqueSection && UniqueSectionNames) {
     Name.push_back('.');
     TM.getNameWithPrefix(Name, GO, Mang, true);
   }
   unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection && !UniqueSectionNames) {
     UniqueID = *NextUniqueID;
     (*NextUniqueID)++;
   }
-  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
+
+  MCSectionWasm* Section = Ctx.getWasmSection(Name, Kind, Group, UniqueID);
+  if (Section->isWasmData() && TM.Options.ThreadModel != ThreadModel::Single)
+    Section->setPassive();
+
+  return Section;
 }
 
 MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
 
   if (Kind.isCommon())
     report_fatal_error("mergable sections not supported yet on wasm");
 

llvm/lib/MC/MCParser/WasmAsmParser.cpp

bool expect(AsmToken::TokenKind Kind, const char *KindName) {
     return false;
   }
 
   bool parseSectionDirectiveText(StringRef, SMLoc) {
     // FIXME: .text currently no-op.
     return false;
   }
 
+  bool parseSectionFlags(StringRef FlagStr, bool &Passive) {
+    SmallVector<StringRef, 2> Flags;
+    // If there are no flags, keep Flags empty
+    FlagStr.split(Flags, ",", -1, false);
+    for (auto &Flag : Flags) {
+      if (Flag == "passive")
+        Passive = true;
+      else
+        return error("Expected section flags, instead got: ", Lexer->getTok());
+    }
+    return false;
+  }
+
   bool parseSectionDirective(StringRef, SMLoc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
       return TokError("expected identifier in directive");
-    // FIXME: currently requiring this very fixed format.
-    if (expect(AsmToken::Comma, ",") || expect(AsmToken::String, "string") ||
-        expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@") ||
+
+    if (expect(AsmToken::Comma, ","))
+      return true;
+
+    if (Lexer->isNot(AsmToken::String))
+      return error("expected string in directive, instead got: ", Lexer->getTok());
+
+    SectionKind Kind = StringSwitch<SectionKind>(Name)
+                       .StartsWith(".data", SectionKind::getData())
+                       .StartsWith(".rodata", SectionKind::getReadOnly())
+                       .StartsWith(".text", SectionKind::getText())
+                       .StartsWith(".custom_section", SectionKind::getMetadata());
+
+    MCSectionWasm* Section = getContext().getWasmSection(Name, Kind);
+
+    // Update section flags if present in this .section directive
+    bool Passive = false;
+    if (parseSectionFlags(getTok().getStringContents(), Passive))
+      return true;
+
+    if (Passive) {
+      if (!Section->isWasmData())
+        return Parser->Error(getTok().getLoc(),
+                             "Only data sections can be passive");
+      Section->setPassive();
+    }
+
+    Lex();
+
+    if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@") ||
         expect(AsmToken::EndOfStatement, "eol"))
       return true;
     // This is done automatically by the assembler for text sections currently,
     // so we don't need to emit that here. This is what it would do (and may
     // be needed later for other section types):
     // auto WS = getContext().getWasmSection(Name, SectionKind::getText());
     // getStreamer().SwitchSection(WS);
     return false;

llvm/lib/MC/MCSectionWasm.cpp

if (shouldOmitSectionDirective(SectionName, MAI)) {
     OS << '\n';
     return;
   }
 
   OS << "\t.section\t";
   printName(OS, getSectionName());
   OS << ",\"";
 
-  // TODO: Print section flags.
+  if (IsPassive)
+    OS << "passive";
 
   OS << '"';
 
   OS << ',';
 
   // If comment string is '@', e.g. as on ARM - use '%' instead
   if (MAI.getCommentString()[0] == '@')
     OS << '%';

llvm/lib/MC/WasmObjectWriter.cpp

 
 // A wasm data segment.  A wasm binary contains only a single data section
 // but that can contain many segments, each with their own virtual location
 // in memory.  Each MCSection data created by llvm is modeled as its own
 // wasm data segment.
 struct WasmDataSegment {
   MCSectionWasm *Section;
   StringRef Name;
+  uint32_t InitFlags;
   uint32_t Offset;
   uint32_t Alignment;
-  uint32_t Flags;
+  uint32_t LinkerFlags;
   SmallVector<char, 4> Data;
 };
 
 // A wasm function to be written into the function section.
 struct WasmFunction {
   uint32_t SigIndex;
   const MCSymbolWasm *Sym;
 };
void WasmObjectWriter::writeDataSection() {
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATA);
   DataSectionIndex = Section.Index;
 
   encodeULEB128(DataSegments.size(), W.OS); // count
 
   for (const WasmDataSegment &Segment : DataSegments) {
+    encodeULEB128(Segment.InitFlags, W.OS); // flags
+    if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
       encodeULEB128(0, W.OS); // memory index
+    if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
       W.OS << char(wasm::WASM_OPCODE_I32_CONST);
       encodeSLEB128(Segment.Offset, W.OS); // offset
       W.OS << char(wasm::WASM_OPCODE_END);
+    }
     encodeULEB128(Segment.Data.size(), W.OS); // size
     Segment.Section->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
     W.OS << Segment.Data; // data
   }
 
   // Apply fixups.
   applyRelocations(DataRelocations, Section.ContentsOffset);
 
void WasmObjectWriter::writeLinkingMetaDataSection(
   }
 
   if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(DataSegments.size(), W.OS);
     for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
       encodeULEB128(Segment.Alignment, W.OS);
-      encodeULEB128(Segment.Flags, W.OS);
+      encodeULEB128(Segment.LinkerFlags, W.OS);
     }
     endSection(SubSection);
   }
 
   if (!InitFuncs.empty()) {
     startSection(SubSection, wasm::WASM_INIT_FUNCS);
     encodeULEB128(InitFuncs.size(), W.OS);
     for (auto &StartFunc : InitFuncs) {
if (Section.getKind().isText())
       continue;
 
     if (Section.isWasmData()) {
       uint32_t SegmentIndex = DataSegments.size();
       DataSize = alignTo(DataSize, Section.getAlignment());
       DataSegments.emplace_back();
       WasmDataSegment &Segment = DataSegments.back();
       Segment.Name = SectionName;
+      Segment.InitFlags = Section.getPassive() ? wasm::WASM_SEGMENT_IS_PASSIVE : 0;
       Segment.Offset = DataSize;
       Segment.Section = &Section;
       addData(Segment.Data, Section);
       Segment.Alignment = Log2_32(Section.getAlignment());
-      Segment.Flags = 0;
+      Segment.LinkerFlags = 0;
       DataSize += Segment.Data.size();
       Section.setSegmentIndex(SegmentIndex);
 
       if (const MCSymbolWasm *C = Section.getGroup()) {
         Comdats[C->getName()].emplace_back(
             WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
     } else {

llvm/lib/Object/WasmObjectFile.cpp

while (Ctx.Ptr < OrigEnd) {
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ctx);
       if (Count > DataSegments.size())
         return make_error<GenericBinaryError>("Too many segment names",
                                               object_error::parse_failed);
       for (uint32_t I = 0; I < Count; I++) {
         DataSegments[I].Data.Name = readString(Ctx);
         DataSegments[I].Data.Alignment = readVaruint32(Ctx);
-        DataSegments[I].Data.Flags = readVaruint32(Ctx);
+        DataSegments[I].Data.LinkerFlags = readVaruint32(Ctx);
       }
       break;
     }
     case wasm::WASM_INIT_FUNCS: {
       uint32_t Count = readVaruint32(Ctx);
       LinkingData.InitFunctions.reserve(Count);
       for (uint32_t I = 0; I < Count; I++) {
         wasm::WasmInitFunc Init;

 }
 
 Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
   DataSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   DataSegments.reserve(Count);
   while (Count--) {
     WasmSegment Segment;
-    Segment.Data.MemoryIndex = readVaruint32(Ctx);
+    Segment.Data.InitFlags = readVaruint32(Ctx);
+    Segment.Data.MemoryIndex = (Segment.Data.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
+                               ? readVaruint32(Ctx) : 0;
+    if ((Segment.Data.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
       if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
         return Err;
+    } else {
+      Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
+      Segment.Data.Offset.Value.Int32 = 0;
+    }
     uint32_t Size = readVaruint32(Ctx);
     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
       return make_error<GenericBinaryError>("Invalid segment size",
                                             object_error::parse_failed);
     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
     // The rest of these Data fields are set later, when reading in the linking
     // metadata section.
     Segment.Data.Alignment = 0;
-    Segment.Data.Flags = 0;
+    Segment.Data.LinkerFlags = 0;
     Segment.Data.Comdat = UINT32_MAX;
     Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
     Ctx.Ptr += Size;
     DataSegments.push_back(Segment);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Data section ended prematurely",
                                           object_error::parse_failed);

llvm/lib/ObjectYAML/WasmYAML.cpp

case wasm::WASM_OPCODE_GLOBAL_GET:
     IO.mapRequired("Index", Expr.Value.Global);
     break;
   }
 }
 
 void MappingTraits<WasmYAML::DataSegment>::mapping(
     IO &IO, WasmYAML::DataSegment &Segment) {
   IO.mapOptional("SectionOffset", Segment.SectionOffset);
+  IO.mapRequired("InitFlags", Segment.InitFlags);
+  if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX) {
     IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
+  } else {
+    Segment.MemoryIndex = 0;
+  }
+  if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
     IO.mapRequired("Offset", Segment.Offset);
+  } else {
+    Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
+    Segment.Offset.Value.Int32 = 0;
+  }
   IO.mapRequired("Content", Segment.Content);
 }
 
 void MappingTraits<WasmYAML::InitFunction>::mapping(
     IO &IO, WasmYAML::InitFunction &Init) {
   IO.mapRequired("Priority", Init.Priority);
   IO.mapRequired("Symbol", Init.Symbol);
 }

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 extern cl::opt<bool> WasmKeepRegisters;
 
 //===----------------------------------------------------------------------===//
 // Helpers.

llvm/test/CodeGen/WebAssembly/global.ll

-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s
+; RUN: llc < %s -thread-model=single -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefixes=CHECK,SINGLE
+; RUN: llc < %s -thread-model=posix -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefixes=CHECK,THREADS
 
 ; Test that globals assemble as expected.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-NOT: llvm.used
 ; CHECK-NOT: llvm.metadata

 ; CHECK:      ptr:
 ; CHECK-NEXT: .int32 arr+80
 ; CHECK-NEXT: .size ptr, 4
 @arr = global [128 x i32] zeroinitializer, align 16
 @ptr = global i32* getelementptr inbounds ([128 x i32], [128 x i32]* @arr, i32 0, i32 20), align 4
 
 ; Constant global.
 ; CHECK: .type    rom,@object{{$}}
-; CHECK: .section .rodata.rom,
+; SINGLE: .section .rodata.rom,""
+; THREADS: .section .rodata.rom,"passive"
 ; CHECK: .globl   rom{{$}}
 ; CHECK: .p2align   4{{$}}
 ; CHECK: rom:
 ; CHECK: .skip    512{{$}}
 ; CHECK: .size    rom, 512{{$}}
 @rom = constant [128 x i32] zeroinitializer, align 16
 
 ; CHECK: .type       array,@object
 ; CHECK: array:
 ; CHECK-NEXT: .skip       8
 ; CHECK-NEXT: .size       array, 8
 ; CHECK: .type       pointer_to_array,@object
-; CHECK-NEXT: .section    .rodata.pointer_to_array,
+; SINGLE-NEXT: .section    .rodata.pointer_to_array,""
+; THREADS-NEXT: .section    .rodata.pointer_to_array,"passive"
 ; CHECK-NEXT: .globl      pointer_to_array
 ; CHECK-NEXT: .p2align      2
 ; CHECK-NEXT: pointer_to_array:
 ; CHECK-NEXT: .int32      array+4
 ; CHECK-NEXT: .size       pointer_to_array, 4
 @array = internal constant [8 x i8] zeroinitializer, align 1
 @pointer_to_array = constant i8* getelementptr inbounds ([8 x i8], [8 x i8]* @array, i32 0, i32 4), align 4
 
 ; Handle external objects with opaque type.
 %struct.ASTRUCT = type opaque
 @g_struct = external global %struct.ASTRUCT, align 1
 define i32 @address_of_opaque()  {
   ret i32 ptrtoint (%struct.ASTRUCT* @g_struct to i32)
 }

llvm/test/CodeGen/WebAssembly/vtable.ll

-; RUN: llc < %s -asm-verbose=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=TYPEINFONAME
-; RUN: llc < %s -asm-verbose=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=VTABLE
-; RUN: llc < %s -asm-verbose=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=TYPEINFO
+; RUN: llc < %s -asm-verbose=false -thread-model=single -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=TYPEINFONAME
+; RUN: llc < %s -asm-verbose=false -thread-model=single -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=VTABLE
+; RUN: llc < %s -asm-verbose=false -thread-model=single -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefix=TYPEINFO
 
 ; Test that simple vtables assemble as expected.
 ;
 ; The class hierarchy is:
 ;   struct A;
 ;   struct B : public A;
 ;   struct C : public A;
 ;   struct D : public B;

llvm/test/MC/WebAssembly/bss.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @g0 = global i8* null, align 4
 @g1 = global i32 0, align 4
 
 %union.u1 = type {}
 @foo = global %union.u1 zeroinitializer, align 1
 @bar = global %union.u1 zeroinitializer, align 1
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       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:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           4
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   24
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         ''
 ; CHECK-NEXT:       - SectionOffset:   29
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         ''
 
 ; CHECK:          SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA

llvm/test/MC/WebAssembly/comdat.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Import a function just so we can check the index arithmetic for
 ; WASM_COMDAT_FUNCTION entries is performed correctly
 declare i32 @funcImport()
 define i32 @callImport() {
 entry:

 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            41000B
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            41000B
 ; CHECK-NEXT:  - Type:            DATA
 ; CHECK-NEXT:    Segments:
 ; CHECK-NEXT:      - SectionOffset:   6
-; CHECK-NEXT:        MemoryIndex:     0
+; CHECK-NEXT:        InitFlags:       0
 ; CHECK-NEXT:        Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           0
 ; CHECK-NEXT:        Content:         '616263'
 ; CHECK-NEXT:  - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            linking
 ; CHECK-NEXT:    Version:         2
 ; CHECK-NEXT:    SymbolTable:

llvm/test/MC/WebAssembly/debug-info.ll

-; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -s -symbols | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | llvm-readobj -r -s -symbols | FileCheck %s
 
 ; CHECK: Format: WASM
 ; CHECK-NEXT:Arch: wasm32
 ; CHECK-NEXT:AddressSize: 32bit
 ; CHECK-NEXT:Sections [
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: TYPE (0x1)
 ; CHECK-NEXT:    Size: 4

llvm/test/MC/WebAssembly/explicit-sections.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 %struct.bd = type { i32, i8 }
 
 @global0 = global i32 8, align 8
 @global1 = global %struct.bd  { i32 1, i8 3 }, align 8, section ".sec1"
 @global2 = global i64 7, align 8, section ".sec1"
 @global3 = global i32 8, align 8, section ".sec2"
 
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '08000000'
 ; CHECK-NEXT:       - SectionOffset:   15
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '01000000030000000700000000000000'
 ; CHECK-NEXT:       - SectionOffset:   36
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '08000000'
 
 ; CHECK:          SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            global0

llvm/test/MC/WebAssembly/external-data.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Verify relocations are correctly generated for addresses of externals
 ; in the data section.
 
 @myimport = external global i32, align 4
 
 @foo = global i64 7, align 4
 @bar = hidden global i32* @myimport, align 4
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x00000013
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '0700000000000000'
 ; CHECK-NEXT:       - SectionOffset:   19
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '00000000'

llvm/test/MC/WebAssembly/external-func-address.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Verify that addresses of external functions generate correctly typed
 ; imports and relocations of type R_TABLE_INDEX_I32.
 
 declare void @f0(i32) #0
 @ptr_to_f0 = hidden global void (i32)* @f0, align 4

llvm/test/MC/WebAssembly/global-ctor-dtor.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @global1 = global i32 1025, align 8
 
 declare void @func0()
 declare void @func1()
 declare void @func2()

 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1082808080000B
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            024041828080800041004180808080001081808080000D000F0B00000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '01040000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0

llvm/test/MC/WebAssembly/init-flags.ll

+; RUN: llc -filetype=obj %s -thread-model=single -o - | obj2yaml | FileCheck %s --check-prefix=SINGLE
+; RUN: llc -filetype=obj %s -thread-model=posix -o - | obj2yaml | FileCheck %s --check-prefix=THREADS
+
+; Test that setting thread-model=posix causes data segments to be
+; emitted as passive segments (i.e. have InitFlags set to 1).
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@str = private unnamed_addr constant [7 x i8] c"Hello!\00", align 1
+
+; SINGLE:       - Type:            DATA
+; SINGLE-NEXT:    Segments:
+; SINGLE-NEXT:      - SectionOffset:   6
+; SINGLE-NEXT:        InitFlags:       0
+; SINGLE-NEXT:        Offset:
+; SINGLE-NEXT:          Opcode:          I32_CONST
+; SINGLE-NEXT:          Value:           0
+; SINGLE-NEXT:        Content:         48656C6C6F2100
+
+; THREADS:       - Type:            DATA
+; THREADS-NEXT:    Segments:
+; THREADS-NEXT:      - SectionOffset:   3
+; THREADS-NEXT:        InitFlags:       1
+; THREADS-NEXT:        Content:         48656C6C6F2100

llvm/test/MC/WebAssembly/reloc-data.ll

-; RUN: llc -O0 -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
+; RUN: llc -O0 -filetype=obj -thread-model=single %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; foo and bar are external and internal symbols.  a and b are pointers
 ; initialized to these locations offset by 2 and -2 elements respecitively.
 
 @foo = external global i32, align 4
 @bar = global i64 7, align 4

llvm/test/MC/WebAssembly/unnamed-data.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -thread-model=single %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 
 @a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8
 @b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8
 
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000001C
 ; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000025
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         68656C6C6F00
 ; CHECK-NEXT:       - SectionOffset:   17
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           6
 ; CHECK-NEXT:         Content:         776F726C6400
 ; CHECK-NEXT:       - SectionOffset:   28
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   37
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         InitFlags:       0
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '06000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:      
 ; CHECK-NEXT:       - Index:           0

llvm/test/MC/WebAssembly/weak-alias.ll

-; RUN: llc -filetype=obj -wasm-keep-registers %s -o %t.o
+; RUN: llc -filetype=obj -thread-model=single -wasm-keep-registers %s -o %t.o
 ; RUN: obj2yaml %t.o | FileCheck %s
 ; RUN: llvm-objdump -t %t.o | FileCheck --check-prefix=CHECK-SYMS %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; 'foo_alias()' is weak alias of function 'foo()'
 ; 'bar_alias' is weak alias of global variable 'bar'
 ; Generates two exports of the same function, one of them weak

 ; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
 ; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000018
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '07000000'
 ; CHECK-NEXT:       - SectionOffset:   15
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:       - SectionOffset:   24
-; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         InitFlags:       0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:

llvm/test/ObjectYAML/wasm/data_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            MEMORY
     Memories:
       - Initial:         0x00000003
   - Type:            DATA
     Segments:
-      - MemoryIndex:      0
+      - InitFlags:        0
         Offset:
           Opcode:          I32_CONST
           Value:           4
         Content:         '10001000'
+      - InitFlags:       1
+        Content:         '01010101'
+      - InitFlags:       2
+        MemoryIndex:     0
+        Offset:
+          Opcode:        I32_CONST
+          Value:         8
+        Content:         '00110011'
     Relocations:
       - Type:            R_WASM_MEMORY_ADDR_I32
         Index:           0
         Offset:          0x00000006
         Addend:          8
       - Type:            R_WASM_MEMORY_ADDR_I32
         Index:           0
         Offset:          0x00000006

 # CHECK-NEXT:        Index:           0
 # CHECK-NEXT:        Offset:          0x00000006
 # CHECK-NEXT:        Addend:          8
 # CHECK-NEXT:      - Type:            R_WASM_MEMORY_ADDR_I32
 # CHECK-NEXT:        Index:           0
 # CHECK-NEXT:        Offset:          0x00000006
 # CHECK-NEXT:        Addend:          -6
 # CHECK-NEXT:     Segments:
-# CHECK-NEXT:       - SectionOffset:   6
-# CHECK-NEXT:         MemoryIndex:     0
+# CHECK-NEXT:       - SectionOffset:  6
+# CHECK-NEXT:         InitFlags:      0
 # CHECK-NEXT:         Offset:
-# CHECK-NEXT:           Opcode:          I32_CONST
-# CHECK-NEXT:           Value:           4
-# CHECK-NEXT:         Content:         '10001000'
+# CHECK-NEXT:           Opcode:         I32_CONST
+# CHECK-NEXT:           Value:          4
+# CHECK-NEXT:         Content:        '10001000'
+# CHECK-NEXT:       - SectionOffset:  12
+# CHECK-NEXT:         InitFlags:      1
+# CHECK-NEXT:         Content:        '01010101'
+# CHECK-NEXT:       - SectionOffset:  22
+# CHECK-NEXT:         InitFlags:      2
+# CHECK-NEXT:         MemoryIndex:    0
+# CHECK-NEXT:         Offset:
+# CHECK-NEXT:           Opcode:         I32_CONST
+# CHECK-NEXT:           Value:          8
+# CHECK-NEXT:         Content:        '00110011'
 # CHECK-NEXT:   - Type:            CUSTOM

llvm/test/ObjectYAML/wasm/linking_section.yaml

Sections:
   - Type:            IMPORT
     Imports:
       - Module:          foo
         Field:           bar
         Kind:            FUNCTION
         SigIndex:        0
   - Type:            DATA
     Segments:
-      - MemoryIndex:      0
+      - InitFlags:        0
         Offset:
           Opcode:          I32_CONST
           Value:           4
         Content:         '10001000'
-      - MemoryIndex:      0
+      - InitFlags:        0
         Offset:
           Opcode:          I32_CONST
           Value:           8
         Content:         '11110000'
   - Type:            CUSTOM
     Name:            linking
     Version:         2
     SymbolTable:

llvm/test/tools/llvm-nm/wasm/exports.yaml

Sections:
   - Type:            CODE
     Functions:
       - Index:           0
         Locals:
         Body:            00
   - Type:            DATA
     Segments:
       - SectionOffset:   6
-        MemoryIndex:     0
+        InitFlags:       0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         '616263'
   - Type:            CUSTOM
     Name:            linking
     Version:         2
     SymbolTable:

llvm/test/tools/llvm-nm/wasm/local-symbols.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown -o %t.o %s
+; RUN: llc -filetype=obj -thread-model=single -mtriple=wasm32-unknown-unknown -o %t.o %s
 ; RUN: llvm-nm %t.o | FileCheck %s
 
 @foo = internal global i32 1, align 4
 @bar = global i32 1, align 4
 
 ; CHECK: 00000004 D bar
 ; CHECK: 00000000 d foo

llvm/test/tools/llvm-nm/wasm/weak-symbols.yaml

Sections:
   - Type:            CODE
     Functions:
       - Index:           1
         Locals:
         Body:            00
   - Type:            DATA
     Segments:
       - SectionOffset:   6
-        MemoryIndex:     0
+        InitFlags:       0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         '616263'
   - Type:            CUSTOM
     Name:            linking
     Version:         2
     SymbolTable:

llvm/test/tools/llvm-objdump/WebAssembly/relocations.test

-; RUN: llc -mtriple=wasm32-unknown-unknown -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
+; RUN: llc -thread-model=single -mtriple=wasm32-unknown-unknown -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
 
 @foo = external global i32, align 4
 @bar = global i32* @foo, align 4
 
 define void @make_call(void ()* nocapture %func) {
 entry:
   call void %func()
   ret void
 }
 
 ; CHECK:      RELOCATION RECORDS FOR [CODE]:
 ; CHECK-NEXT: 00000006 R_WASM_TYPE_INDEX_LEB 1+0
 
 ; CHECK:      RELOCATION RECORDS FOR [DATA]:
 ; CHECK-NEXT: 00000006 R_WASM_MEMORY_ADDR_I32 foo+0

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink") {
 
     uint32_t SegmentIndex = 0;
     for (const object::WasmSegment &Segment : Obj.dataSegments()) {
       if (!Segment.Data.Name.empty()) {
         WasmYAML::SegmentInfo SegmentInfo;
         SegmentInfo.Name = Segment.Data.Name;
         SegmentInfo.Index = SegmentIndex;
         SegmentInfo.Alignment = Segment.Data.Alignment;
-        SegmentInfo.Flags = Segment.Data.Flags;
+        SegmentInfo.Flags = Segment.Data.LinkerFlags;
         LinkingSec->SegmentInfos.push_back(SegmentInfo);
       }
       if (Segment.Data.Comdat != UINT32_MAX) {
         LinkingSec->Comdats[Segment.Data.Comdat].Entries.emplace_back(
             WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
       SegmentIndex++;
     }
case wasm::WASM_SEC_CODE: {
       S = std::move(CodeSec);
       break;
     }
     case wasm::WASM_SEC_DATA: {
       auto DataSec = make_unique<WasmYAML::DataSection>();
       for (const object::WasmSegment &Segment : Obj.dataSegments()) {
         WasmYAML::DataSegment Seg;
         Seg.SectionOffset = Segment.SectionOffset;
+        Seg.InitFlags = Segment.Data.InitFlags;
         Seg.MemoryIndex = Segment.Data.MemoryIndex;
         Seg.Offset = Segment.Data.Offset;
         Seg.Content = yaml::BinaryRef(Segment.Data.Content);
         DataSec->Segments.push_back(Seg);
       }
       S = std::move(DataSec);
       break;
     }

llvm/tools/yaml2obj/yaml2wasm.cpp

int WasmWriter::writeSectionContent(raw_ostream &OS,
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::DataSection &Section) {
   encodeULEB128(Section.Segments.size(), OS);
   for (auto &Segment : Section.Segments) {
+    encodeULEB128(Segment.InitFlags, OS);
+    if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
       encodeULEB128(Segment.MemoryIndex, OS);
+    if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0)
       writeInitExpr(Segment.Offset, OS);
     encodeULEB128(Segment.Content.binary_size(), OS);
     Segment.Content.writeAsBinary(OS);
   }
   return 0;
 }
 
 int WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                                   uint32_t SectionIndex) {