[WebAssembly] Initialize memory in start function

[tlively]

Summary

• __wasm_init_memory is now the WebAssembly start function instead of being called from __wasm_call_ctors or called directly by the runtime.
• Adds a new synthetic data symbol __wasm_init_memory_flag that is atomically incremented from zero to one by the thread responsible for initializing memory.
• All threads now unconditionally perform data.drop on all passive segments.
• Removes --passive-segments and --active-segments flags and controls segment type based on --shared-memory instead. The deleted flags were only present to ameliorate the upgrade path in Emscripten.

[aheejin]

I don't have the full context/history of this feature, but it mostly looks LGTM to me.

• The tool-convention linking doc says we don't generate the start section for now. I guess we should update that too.
• I'm not sure what the exact condition for the passive segment generation. We should have config->sharedMemory for sure, but in some place we have !config->relocatable and others !config->shared but not both.
• How did we tell which one is the main thread before this patch?

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

92 ↗

(On Diff #213504)

So __wasm_init_tls is also called from the start function in passive segments as in __wasm_init_memory, right?

lld/test/wasm/data-segments.ll

5 ↗

(On Diff #213504)

Now that tests in this file don't have --active-segments and --passive-segments anymore and are instead controlled by --shared-memory, it might be helpful to add whether we have shared memory or not in the comments, like

; atomics, shared memory => error
; atomics, bulk memory, shared memory => passive segments
...

The same for other comments below.

lld/test/wasm/shared-memory.yaml

3 ↗

(On Diff #213504)

Real nit: why remove the whitespace before |?

lld/wasm/Driver.cpp

469 ↗

(On Diff #213504)

Are we guaranteed not to be relocatable here?

516 ↗

(On Diff #213504)

What happens when config->sharedMemory && config->shared?

lld/wasm/MarkLive.cpp

88 ↗

(On Diff #213504)

WasmSym::initMemory was created like

if (config->sharedMemory && !config->shared) {
  WasmSym::initMemory = symtab->addSyntheticFunction(
      "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
      make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
 ...
}

Don't we need the condition !config->shared here too?

lld/wasm/Writer.cpp

375 ↗

(On Diff #213504)

Nit: It looks we have using namespace llvm above, so we don't need llvm::

400 ↗

(On Diff #213504)

This may not be related to this CL, but just wondering, what happens we explicitly enable a feature using --feature= option that's in the disallowed set in one of the objects? Do we error out?

709 ↗

(On Diff #213504)

• Before this change, how did we distinguish the main thread? (I don't know the full history of this feature, sorry)
• Does this new code mean whichever thread that first runs this code becomes the main thread?

[tlively]

Thanks for you comments! I am also planning to update the memory initialization scheme to use wait and notify so that it works with racing modules instead of requiring the runtime to ensure that no module is called into before the main module is finished initializing. In a web context the runtime will have to ensure the main thread wins this race because it is not allowed to wait, but this is still strictly more general than the current scheme. Does that sound good to you?

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

92 ↗

(On Diff #213504)

No, __wasm_init_tls requires a runtime-allocated TLS buffer as an argument, so it has to be called from runtime code rather than a start function.

lld/test/wasm/data-segments.ll

5 ↗

(On Diff #213504)

Good idea, will do.

lld/test/wasm/shared-memory.yaml

3 ↗

(On Diff #213504)

Hmm, I don't think that was intentional. Thanks!

lld/wasm/Driver.cpp

469 ↗

(On Diff #213504)

Yes, this function is only called when !config->relocatable. This may have been refactored in the meantime, though. I'll have to rebase and merge.

516 ↗

(On Diff #213504)

Only the main module (which I understand is never config->shared?) needs to initialize memory. It would be bad if __wasm_init_memory were run more than once per memory. So shared modules just don't have these symbols.

lld/wasm/MarkLive.cpp

88 ↗

(On Diff #213504)

Hmm, I guess it works regardless because enqueue silently disregards null arguments. But you're right that the condition should be there for consistency. Will update.

[aheejin]

Talked offline. Yeah that would be good.

[tlively]

• Switch to more robust scheme with cmpxchg/wait/notify

[tlively]

• Address review comments

lld/wasm/Writer.cpp

400 ↗

(On Diff #213504)

Yes, that would be an error unless --no-check-features is also passed. --feature= is just a more explicit way of passing features and is not meant to be any more privileged than the target features sections in determining what is correct and safe.

709 ↗

(On Diff #213504)

Before this change we relied on the runtime to manually invoke __wasm_init_memory or __wasm_call_ctors (which called __wasm_init_memory) on the main thread. With this change, the code is more robust because it doesn't require the runtime to call anything or even ensure that there is only one thread running during memory initialization.

Whichever thread runs first initializes the memory, but is not otherwise marked as the main thread or privileged in any way. If you instantiate a module on a number of threads at once it should not be possible to determine which one initialized the memory.

[sbc100]

Can you verify that you can pass all the "wasm2" tests in emscripten with this change?

[aheejin]

LGTM % nits if tests pass.

lld/wasm/Writer.cpp

711 ↗

(On Diff #218574)

I can't find this block instruction in the code. Am I missing something?

720 ↗

(On Diff #218574)

Nit: How about $__init_memory_flag for consistency?

[tlively]

In D65783#1656699, @sbc100 wrote:

Can you verify that you can pass all the "wasm2" tests in emscripten with this change?

Yes, although this CL only affects shared-memory builds, so wasm2 tests are not affected. I have also verified that the pthreads tests in the browser test suite also pass with this change.

[tlively]

lld/wasm/Writer.cpp

711 ↗

(On Diff #218574)

I wrote this wat using Binaryen's text format, which requires a block here that is not present in the binary. I will rewrite the wat using the standard text format, which will be less confusing.

720 ↗

(On Diff #218574)

Sounds good.

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

 
 ; 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:     --active-segments %t.hello.o
+; RUN:     --features=atomics,bulk-memory --initial-memory=131072 \
+; RUN:     --max-memory=131072 -o %t_max.wasm %t.o %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
 

lld/trunk/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 -mattr=+bulk-memory -filetype=obj %s -o %t.o
+; RUN: llc -mattr=+bulk-memory,+atomics -filetype=obj %s -o %t.passive.o
+; RUN: llc -filetype=obj %s -o %t.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-LABEL: - Type:            DATA
 ; MERGE-NEXT:    Segments:
 ; MERGE-NEXT:      - SectionOffset:   7
 ; MERGE-NEXT:        InitFlags:       0

 ; SEPARATE:             Content:         2B
 ; SEPARATE-NEXT:  - Type:            CUSTOM
 ; SEPARATE-NEXT:    Name:            name
 ; SEPARATE-NEXT:    FunctionNames:
 ; SEPARATE-NEXT:      - Index:           0
 ; SEPARATE-NEXT:        Name:            __wasm_call_ctors
 ; SEPARATE-NOT:       - Index:
 
-; RUN: wasm-ld -no-gc-sections --no-entry --passive-segments -o %t.merged.passive.wasm %t.o
+; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -o %t.merged.passive.wasm %t.passive.o
 ; RUN: obj2yaml %t.merged.passive.wasm | FileCheck %s --check-prefix=PASSIVE-MERGE
 
 ; PASSIVE-MERGE-LABEL: - Type:            DATACOUNT
 ; PASSIVE-MERGE-NEXT:    Count:           2
 ; PASSIVE-MERGE-LABEL: - Type:            DATA
 ; PASSIVE-MERGE-NEXT:    Segments:
 ; PASSIVE-MERGE-NEXT:      - SectionOffset:   3
 ; PASSIVE-MERGE-NEXT:        InitFlags:       1
 ; PASSIVE-MERGE-NEXT:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
 ; PASSIVE-MERGE-NEXT:      - SectionOffset:   33
 ; PASSIVE-MERGE-NEXT:        InitFlags:       1
 ; PASSIVE-MERGE-NEXT:        Content:         636F6E7374616E74000000002B
 ; PASSIVE-MERGE-NEXT:  - Type:            CUSTOM
 ; PASSIVE-MERGE-NEXT:    Name:            name
 ; PASSIVE-MERGE-NEXT:    FunctionNames:
 ; PASSIVE-MERGE-NEXT:      - Index:           0
 ; PASSIVE-MERGE-NEXT:        Name:            __wasm_call_ctors
 ; PASSIVE-MERGE-NEXT:      - Index:           1
 ; PASSIVE-MERGE-NEXT:        Name:            __wasm_init_memory
-; PASSIVE-MERGE-NOT:       - Index:
+; PASSIVE-MERGE-NEXT:      - Index:           2
+; PASSIVE-MERGE-NEXT:        Name:            __wasm_init_tls
 
-; RUN: wasm-ld -no-gc-sections --no-entry --passive-segments -no-merge-data-segments -o %t.separate.passive.wasm %t.o
+; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -no-merge-data-segments -o %t.separate.passive.wasm %t.passive.o
 ; RUN: obj2yaml %t.separate.passive.wasm | FileCheck %s --check-prefix=PASSIVE-SEPARATE
 
 ; PASSIVE-SEPARATE-LABEL: - Type:            DATACOUNT
 ; PASSIVE-SEPARATE-NEXT:    Count:           6
 ; PASSIVE-SEPARATE-LABEL: - Type:            DATA
 ; PASSIVE-SEPARATE-NEXT:    Segments:
 ; PASSIVE-SEPARATE-NEXT:      - SectionOffset:   3
 ; PASSIVE-SEPARATE-NEXT:        InitFlags:       1

 ; PASSIVE-SEPARATE-NEXT:        Content:         2B
 ; PASSIVE-SEPARATE-NEXT:    - Type:            CUSTOM
 ; PASSIVE-SEPARATE-NEXT:      Name:            name
 ; PASSIVE-SEPARATE-NEXT:      FunctionNames:
 ; PASSIVE-SEPARATE-NEXT:        - Index:           0
 ; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_call_ctors
 ; PASSIVE-SEPARATE-NEXT:        - Index:           1
 ; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_init_memory
-; PASSIVE-SEPARATE-NOT:         - Index
+; PASSIVE-SEPARATE-NEXT:        - Index:           2
+; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_init_tls

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

 ; 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
 
-; atomics => error
+; atomics, shared memory => error
 ; RUN: not wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 %t.atomics.o -o %t.atomics.wasm 2>&1 | FileCheck %s --check-prefix ERROR
 
-; atomics, active segments => active segments
-; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 --active-segments %t.atomics.o -o %t.atomics.active.wasm
-; RUN: obj2yaml %t.atomics.active.wasm | FileCheck %s --check-prefixes ACTIVE,ACTIVE-TLS
-
-; atomics, passive segments => error
-; RUN: not wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 --passive-segments %t.atomics.o -o %t.atomics.passive.wasm 2>&1 | FileCheck %s --check-prefix ERROR
-
-; bulk memory => active segments
+; bulk memory, unshared memory => active segments
 ; RUN: wasm-ld -no-gc-sections --no-entry %t.bulk-mem.o -o %t.bulk-mem.wasm
 ; RUN: obj2yaml %t.bulk-mem.wasm | FileCheck %s --check-prefix ACTIVE
 
-; bulk-memory, active segments => active segments
-; RUN: wasm-ld -no-gc-sections --no-entry --active-segments %t.bulk-mem.o -o %t.bulk-mem.active.wasm
-; RUN: obj2yaml %t.bulk-mem.active.wasm | FileCheck %s --check-prefix ACTIVE
-
-; bulk memory, passive segments => passive segments
-; RUN: wasm-ld -no-gc-sections --no-entry --passive-segments %t.bulk-mem.o -o %t.bulk-mem.passive.wasm
-; RUN: obj2yaml %t.bulk-mem.passive.wasm | FileCheck %s --check-prefix PASSIVE
-
-; atomics, bulk memory => passive segments
+; atomics, bulk memory, shared memory => passive segments
 ; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 %t.atomics.bulk-mem.o -o %t.atomics.bulk-mem.wasm
-; RUN: obj2yaml %t.atomics.bulk-mem.wasm | FileCheck %s --check-prefixes PASSIVE,PASSIVE-TLS
-
-; atomics, bulk memory, active segments => active segments
-; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 --active-segments %t.atomics.bulk-mem.o -o %t.atomics.bulk-mem.active.wasm
-; RUN: obj2yaml %t.atomics.bulk-mem.active.wasm | FileCheck %s --check-prefixes ACTIVE,ACTIVE-TLS
-
-; atomics, bulk memory, passive segments => passive segments
-; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 --passive-segments %t.atomics.bulk-mem.o -o %t.atomics.bulk-mem.passive.wasm
-; RUN: obj2yaml %t.atomics.bulk-mem.passive.wasm | FileCheck %s --check-prefixes PASSIVE,PASSIVE-TLS
+; RUN: obj2yaml %t.atomics.bulk-mem.wasm | FileCheck %s --check-prefixes PASSIVE
 
 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 [10000 x i8] zeroinitializer, 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
 
-; ERROR: 'bulk-memory' feature must be used in order to emit passive segments
+; ERROR: 'bulk-memory' feature must be used in order to use shared memory
 
 ; ACTIVE-LABEL: - Type:            CODE
 ; ACTIVE-NEXT:    Functions:
 ; ACTIVE-NEXT:      - Index:           0
 ; ACTIVE-NEXT:        Locals:          []
 ; ACTIVE-NEXT:        Body:            0B
-; ACTIVE-TLS-NEXT:  - Index:           1
-; ACTIVE-TLS-NEXT:    Locals:          []
-; ACTIVE-TLS-NEXT:    Body:            0B
 ; ACTIVE-NEXT:  - Type:            DATA
 ; ACTIVE-NEXT:    Segments:
 ; ACTIVE-NEXT:      - SectionOffset:   7
 ; ACTIVE-NEXT:        InitFlags:       0
 ; ACTIVE-NEXT:        Offset:
 ; ACTIVE-NEXT:          Opcode:          I32_CONST
 ; ACTIVE-NEXT:          Value:           1024
 ; ACTIVE-NEXT:        Content:         68656C6C6F00676F6F646279650000002A000000

 ; ACTIVE-NEXT:          Opcode:          I32_CONST
 ; ACTIVE-NEXT:          Value:           11044
 ; ACTIVE-NEXT:        Content:         636F6E7374616E74000000002B
 ; ACTIVE-NEXT:  - Type:            CUSTOM
 ; ACTIVE-NEXT:    Name:            name
 ; ACTIVE-NEXT:    FunctionNames:
 ; ACTIVE-NEXT:      - Index:           0
 ; ACTIVE-NEXT:        Name:            __wasm_call_ctors
-; ACTIVE-TLS-NEXT:  - Index:           1
-; ACTIVE-TLS-NEXT:    Name:            __wasm_init_tls
 
+; PASSIVE-LABEL: - Type:            START
+; PASSIVE-NEXT:    StartFunction:   1
 ; PASSIVE-LABEL: - Type:            CODE
 ; PASSIVE-NEXT:    Functions:
 ; PASSIVE-NEXT:      - Index:           0
 ; PASSIVE-NEXT:        Locals:          []
-; PASSIVE-NEXT:        Body:            10010B
+; PASSIVE-NEXT:        Body:            0B
 ; PASSIVE-NEXT:      - Index:           1
 ; PASSIVE-NEXT:        Locals:          []
-; PASSIVE-NEXT:        Body:            41800841004114FC080000FC090041940841004190CE00FC080100FC090141A4D6004100410DFC080200FC09020B
-; PASSIVE-TLS-NEXT:  - Index:           2
-; PASSIVE-TLS-NEXT:    Locals:          []
-; PASSIVE-TLS-NEXT:    Body:            0B
+; PASSIVE-NEXT:        Body:            41B4D60041004101FE480200044041B4D6004101427FFE0102001A0541800841004114FC08000041940841004190CE00FC08010041A4D6004100410DFC08020041B4D6004102FE17020041B4D600417FFE0002001A0BFC0900FC0901FC09020B
+; PASSIVE-NEXT:  - Index:           2
+; PASSIVE-NEXT:    Locals:          []
+; PASSIVE-NEXT:    Body:            0B
 ; PASSIVE-NEXT:  - Type:            DATA
 ; PASSIVE-NEXT:    Segments:
 ; PASSIVE-NEXT:      - SectionOffset:   3
 ; PASSIVE-NEXT:        InitFlags:       1
 ; PASSIVE-NEXT:        Content:         68656C6C6F00676F6F646279650000002A000000
 ; PASSIVE-NEXT:      - SectionOffset:   26
 ; PASSIVE-NEXT:        InitFlags:       1
 ; PASSIVE-NEXT:        Content:         '0000000000
 ; PASSIVE-SAME:                           0000000000'
 ; PASSIVE-NEXT:      - SectionOffset:   10028
 ; PASSIVE-NEXT:        InitFlags:       1
 ; PASSIVE-NEXT:        Content:         636F6E7374616E74000000002B
 ; PASSIVE-NEXT:  - Type:            CUSTOM
 ; PASSIVE-NEXT:    Name:            name
 ; PASSIVE-NEXT:    FunctionNames:
 ; PASSIVE-NEXT:      - Index:           0
 ; PASSIVE-NEXT:        Name:            __wasm_call_ctors
 ; PASSIVE-NEXT:      - Index:           1
 ; PASSIVE-NEXT:        Name:            __wasm_init_memory
-; PASSIVE-TLS-NEXT:  - Index:           2
-; PASSIVE-TLS-NEXT:    Name:            __wasm_init_tls
+; PASSIVE-NEXT:  - Index:           2
+; PASSIVE-NEXT:    Name:            __wasm_init_tls

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

 # 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 --active-segments \
+# RUN: wasm-ld --import-memory --shared-memory --features=atomics,bulk-memory \
 # RUN:     --initial-memory=262144 --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/test/wasm/no-tls.test

 ; Testing that __tls_size and __tls_align are correctly emitted when there are
 ; no thread_local variables.
 
-RUN: llc -mattr=+bulk-memory -filetype=obj %p/Inputs/start.ll -o %t.o
+RUN: llc -mattr=+bulk-memory,+atomics -filetype=obj %p/Inputs/start.ll -o %t.o
 
 RUN: wasm-ld -no-gc-sections --shared-memory --max-memory=131072 --allow-undefined -o %t.wasm %t.o
 RUN: obj2yaml %t.wasm | FileCheck %s
 CHECK:       - Type:            GLOBAL
 CHECK-NEXT:    Globals:
 
 ; __stack_pointer
 CHECK-NEXT:      - Index:           0
 CHECK-NEXT:        Type:            I32
 CHECK-NEXT:        Mutable:         true
 CHECK-NEXT:        InitExpr:
 CHECK-NEXT:          Opcode:          I32_CONST
-CHECK-NEXT:          Value:           66560
+CHECK-NEXT:          Value:           66576
 
 ; __tls_base
 CHECK-NEXT:      - Index:           1
 CHECK-NEXT:        Type:            I32
 CHECK-NEXT:        Mutable:         true
 CHECK-NEXT:        InitExpr:
 CHECK-NEXT:          Opcode:          I32_CONST
 CHECK-NEXT:          Value:           0

lld/trunk/test/wasm/relocatable.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: wasm-ld -r -o %t.wasm %t.hello.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s --check-prefixes CHECK,NORMAL
 
-; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.bm.o -mattr=+bulk-memory
+; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.bm.o -mattr=+bulk-memory,+atomics
 ; RUN: llc -filetype=obj %s -o %t.bm.o -mattr=+bulk-memory
 ; RUN: wasm-ld -r -o %t.mt.wasm %t.hello.bm.o %t.bm.o --shared-memory --max-memory=131072
 ; RUN: obj2yaml %t.mt.wasm | FileCheck %s --check-prefixes CHECK,SHARED
 
 target triple = "wasm32-unknown-unknown"
 
 ; Function Attrs: nounwind
 define hidden i32 @my_func() local_unnamed_addr {

lld/trunk/test/wasm/shared-memory.yaml

 # RUN: yaml2obj %s -o %t1.o
 
-# RUN: not wasm-ld --no-entry --shared-memory --active-segments %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-MAX
+# RUN: not wasm-ld --no-entry --shared-memory %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-MAX
 
-# RUN: not wasm-ld --no-entry --shared-memory --active-segments --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-UNALIGNED
+# RUN: not wasm-ld --no-entry --shared-memory --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-UNALIGNED
 
-# RUN: wasm-ld --no-entry --shared-memory --active-segments --max-memory=131072 %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
+# RUN: not wasm-ld --no-entry --shared-memory --max-memory=131072 --features=bulk-memory %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-ATOMICS
 
-# RUN: not wasm-ld --no-entry --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-SHARED
-
-# RUN: not wasm-ld --no-entry --features=atomics --shared-memory --active-segments %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-MAX
-
-# RUN: not wasm-ld --no-entry --features=atomics --shared-memory --active-segments --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-UNALIGNED
+# RUN: not wasm-ld --no-entry --shared-memory --max-memory=131072 --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-BULK-MEM
 
-# RUN: wasm-ld --no-entry --features=atomics --shared-memory --active-segments --max-memory=131072 %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
+# RUN: not wasm-ld --no-entry --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-SHARED
 
+# RUN: wasm-ld --no-entry --shared-memory --max-memory=131072 --features=atomics,bulk-memory %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            IMPORT
     Imports:
       - Module:          env
SymbolTable:
         Size:            7
     SegmentInfo:
       - Index:           0
         Name:            .rodata.hello_str
         Alignment:       0
         Flags:           [  ]
 ...
 
-# SHARED-NO-MAX: maximum memory too small, 66560 bytes needed{{$}}
+# SHARED-NO-MAX: maximum memory too small, 66576 bytes needed{{$}}
 
 # SHARED-UNALIGNED: maximum memory must be 65536-byte aligned{{$}}
 
+# SHARED-NO-ATOMICS: 'atomics' feature must be used in order to use shared memory
+
+# SHARED-NO-BULK-MEM: 'bulk-memory' feature must be used in order to use shared memory
+
+# ATOMICS-NO-SHARED: 'atomics' feature is used, so --shared-memory must be used{{$}}
+
 # SHARED:        - Type:            MEMORY
 # SHARED-NEXT:     Memories:
 # SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
 # SHARED-NEXT:         Initial:         0x00000002
 # SHARED-NEXT:         Maximum:         0x00000002
-
-# ATOMICS-NO-SHARED: 'atomics' feature is used, so --shared-memory must be used{{$}}
-
-# ATOMICS-NO-MAX: maximum memory too small, 66560 bytes needed{{$}}
-
-# ATOMICS-UNALIGNED: maximum memory must be 65536-byte aligned{{$}}

lld/trunk/test/wasm/tls-align.ll

-; RUN: llc -mattr=+bulk-memory -filetype=obj %s -o %t.o
+; RUN: llc -mattr=+bulk-memory,+atomics -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown"
 
 @no_tls = global i32 0, align 4
 @tls1 = thread_local(localexec) global i32 1, align 4
 @tls2 = thread_local(localexec) global i32 1, align 16
 
 define i32* @tls1_addr() {

lld/trunk/test/wasm/tls.ll

-; RUN: llc -mattr=+bulk-memory -filetype=obj %s -o %t.o
+; RUN: llc -mattr=+bulk-memory,+atomics -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown"
 
 @no_tls = global i32 0, align 4
 @tls1 = thread_local(localexec) global i32 1, align 4
 @tls2 = thread_local(localexec) global i32 1, align 4
 
 define i32* @tls1_addr() {

lld/trunk/wasm/Config.h

struct Configuration {
   bool emitRelocs;
   bool exportAll;
   bool exportDynamic;
   bool exportTable;
   bool growableTable;
   bool gcSections;
   bool importMemory;
   bool sharedMemory;
-  bool passiveSegments;
   bool importTable;
   bool mergeDataSegments;
   bool pie;
   bool printGcSections;
   bool relocatable;
   bool saveTemps;
   bool shared;
   bool stripAll;

lld/trunk/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->entry = getEntry(args);
   config->exportAll = args.hasArg(OPT_export_all);
   config->exportTable = args.hasArg(OPT_export_table);
   config->growableTable = args.hasArg(OPT_growable_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->passiveSegments = args.hasFlag(
-      OPT_passive_segments, OPT_active_segments, config->sharedMemory);
   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);
static void createSyntheticSymbols() {
   if (config->relocatable)
     return;
 
   static WasmSignature nullSignature = {{}, {}};
   static WasmSignature i32ArgSignature = {{}, {ValType::I32}};
   static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
   static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
                                                             true};
-
   WasmSym::callCtors = symtab->addSyntheticFunction(
       "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
       make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
 
-  if (config->passiveSegments) {
-    // Passive segments are used to avoid memory being reinitialized on each
-    // thread's instantiation. These passive segments are initialized and
-    // dropped in __wasm_init_memory, which is the first function called from
-    // __wasm_call_ctors.
-    WasmSym::initMemory = symtab->addSyntheticFunction(
-        "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
-        make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
-  }
-
   if (config->isPic) {
     // For PIC code we create a synthetic function __wasm_apply_relocs which
     // is called from __wasm_call_ctors before the user-level constructors.
     WasmSym::applyRelocs = symtab->addSyntheticFunction(
         "__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
   }
 
if (config->isPic) {
     WasmSym::tableBase->markLive();
   } else {
     // For non-PIC code
     WasmSym::stackPointer = createGlobalVariable("__stack_pointer", true, 0);
     WasmSym::stackPointer->markLive();
   }
 
   if (config->sharedMemory && !config->shared) {
+    // Passive segments are used to avoid memory being reinitialized on each
+    // thread's instantiation. These passive segments are initialized and
+    // dropped in __wasm_init_memory, which is registered as the start function
+    WasmSym::initMemory = symtab->addSyntheticFunction(
+        "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
+        make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
+    WasmSym::initMemoryFlag = symtab->addSyntheticDataSymbol(
+        "__wasm_init_memory_flag", WASM_SYMBOL_VISIBILITY_HIDDEN);
+    assert(WasmSym::initMemoryFlag);
     WasmSym::tlsBase = createGlobalVariable("__tls_base", true, 0);
     WasmSym::tlsSize = createGlobalVariable("__tls_size", false, 0);
     WasmSym::tlsAlign = createGlobalVariable("__tls_align", false, 1);
     WasmSym::initTLS = symtab->addSyntheticFunction(
         "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(i32ArgSignature, "__wasm_init_tls"));
   }
 }

lld/trunk/wasm/MarkLive.cpp

std::function<void(Symbol*)> enqueue = [&](Symbol *sym) {
     sym->markLive();
     if (InputChunk *chunk = sym->getChunk())
       q.push_back(chunk);
 
     // The ctor functions are all referenced by the synthetic callCtors
     // function.  However, this function does not contain relocations so we
     // have to manually mark the ctors as live if callCtors itself is live.
     if (sym == WasmSym::callCtors) {
-      if (config->passiveSegments)
-        enqueue(WasmSym::initMemory);
       if (config->isPic)
         enqueue(WasmSym::applyRelocs);
       for (const ObjFile *obj : symtab->objectFiles) {
         const WasmLinkingData &l = obj->getWasmObj()->linkingData();
         for (const WasmInitFunc &f : l.InitFunctions) {
           auto* initSym = obj->getFunctionSymbol(f.Symbol);
           if (!initSym->isDiscarded())
             enqueue(initSym);
for (const ObjFile *obj : symtab->objectFiles) {
       for (const WasmInitFunc &f : l.InitFunctions)
         enqueue(obj->getFunctionSymbol(f.Symbol));
     }
   }
 
   if (config->isPic)
     enqueue(WasmSym::callCtors);
 
+  if (config->sharedMemory && !config->shared)
+    enqueue(WasmSym::initMemory);
+
   // Follow relocations to mark all reachable chunks.
   while (!q.empty()) {
     InputChunk *c = q.pop_back_val();
 
     for (const WasmRelocation reloc : c->getRelocations()) {
       if (reloc.Type == R_WASM_TYPE_INDEX_LEB)
         continue;
       Symbol *sym = c->file->getSymbol(reloc.Index);

lld/trunk/wasm/Options.td

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 active_segments: F<"active-segments">,
-  HelpText<"Force segments to be active (default with unshared memory)">;
-
-def passive_segments: F<"passive-segments">,
-  HelpText<"Force segments to be passive (default with shared 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/Symbols.h

struct WasmSym {
   static DefinedData *dataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.
   static DefinedData *heapBase;
 
-  // __wasm_call_ctors
-  // Function that directly calls all ctors in priority order.
-  static DefinedFunction *callCtors;
+  // __wasm_init_memory_flag
+  // Symbol whose contents are nonzero iff memory has already been initialized.
+  static DefinedData *initMemoryFlag;
 
   // __wasm_init_memory
-  // Function that initializes passive data segments post-instantiation.
+  // Function that initializes passive data segments during instantiation.
   static DefinedFunction *initMemory;
 
+  // __wasm_call_ctors
+  // Function that directly calls all ctors in priority order.
+  static DefinedFunction *callCtors;
+
   // __wasm_apply_relocs
   // Function that applies relocations to data segment post-instantiation.
   static DefinedFunction *applyRelocs;
 
   // __wasm_init_tls
   // Function that allocates thread-local storage and initializes it.
   static DefinedFunction *initTLS;
 

lld/trunk/wasm/Symbols.cpp

 DefinedFunction *WasmSym::callCtors;
 DefinedFunction *WasmSym::initMemory;
 DefinedFunction *WasmSym::applyRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
+DefinedData *WasmSym::initMemoryFlag;
 GlobalSymbol *WasmSym::stackPointer;
 GlobalSymbol *WasmSym::tlsBase;
 GlobalSymbol *WasmSym::tlsSize;
 GlobalSymbol *WasmSym::tlsAlign;
 UndefinedGlobal *WasmSym::tableBase;
 DefinedData *WasmSym::definedTableBase;
 UndefinedGlobal *WasmSym::memoryBase;
 DefinedData *WasmSym::definedMemoryBase;

lld/trunk/wasm/SyntheticSections.h

 public:
   ExportSection() : SyntheticSection(llvm::wasm::WASM_SEC_EXPORT) {}
   bool isNeeded() const override { return exports.size() > 0; }
   void writeBody() override;
 
   std::vector<llvm::wasm::WasmExport> exports;
 };
 
+class StartSection : public SyntheticSection {
+public:
+  StartSection(uint32_t numSegments)
+      : SyntheticSection(llvm::wasm::WASM_SEC_START), numSegments(numSegments) {
+  }
+  bool isNeeded() const override;
+  void writeBody() override;
+
+protected:
+  uint32_t numSegments;
+};
+
 class ElemSection : public SyntheticSection {
 public:
   ElemSection()
       : SyntheticSection(llvm::wasm::WASM_SEC_ELEM) {}
   bool isNeeded() const override { return indirectFunctions.size() > 0; };
   void writeBody() override;
   void addEntry(FunctionSymbol *sym);
   uint32_t numEntries() const { return indirectFunctions.size(); }
struct OutStruct {
   TypeSection *typeSec;
   FunctionSection *functionSec;
   ImportSection *importSec;
   TableSection *tableSec;
   MemorySection *memorySec;
   GlobalSection *globalSec;
   EventSection *eventSec;
   ExportSection *exportSec;
+  StartSection *startSec;
   ElemSection *elemSec;
   DataCountSection *dataCountSec;
   LinkingSection *linkingSec;
   NameSection *nameSec;
   ProducersSection *producersSec;
   TargetFeaturesSection *targetFeaturesSec;
 };
 
 extern OutStruct out;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/trunk/wasm/SyntheticSections.cpp

 void ExportSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, exports.size(), "export count");
   for (const WasmExport &export_ : exports)
     writeExport(os, export_);
 }
 
+bool StartSection::isNeeded() const {
+  return !config->relocatable && numSegments && config->sharedMemory;
+}
+
+void StartSection::writeBody() {
+  raw_ostream &os = bodyOutputStream;
+  writeUleb128(os, WasmSym::initMemory->getFunctionIndex(), "function index");
+}
+
 void ElemSection::addEntry(FunctionSymbol *sym) {
   if (sym->hasTableIndex())
     return;
   sym->setTableIndex(config->tableBase + indirectFunctions.size());
   indirectFunctions.emplace_back(sym);
 }
 
 void ElemSection::writeBody() {
void ElemSection::writeBody() {
   }
 }
 
 void DataCountSection::writeBody() {
   writeUleb128(bodyOutputStream, numSegments, "data count");
 }
 
 bool DataCountSection::isNeeded() const {
-  return numSegments && config->passiveSegments;
+  return numSegments && config->sharedMemory;
 }
 
 static uint32_t getWasmFlags(const Symbol *sym) {
   uint32_t flags = 0;
   if (sym->isLocal())
     flags |= WASM_SYMBOL_BINDING_LOCAL;
   if (sym->isWeak())
     flags |= WASM_SYMBOL_BINDING_WEAK;

lld/trunk/wasm/Writer.cpp

if (WasmSym::tlsSize && seg->name == ".tdata") {
       auto *tlsSize = cast<DefinedGlobal>(WasmSym::tlsSize);
       tlsSize->global->global.InitExpr.Value.Int32 = seg->size;
 
       auto *tlsAlign = cast<DefinedGlobal>(WasmSym::tlsAlign);
       tlsAlign->global->global.InitExpr.Value.Int32 = 1U << seg->alignment;
     }
   }
 
+  // Make space for the memory initialization flag
+  if (WasmSym::initMemoryFlag) {
+    memoryPtr = alignTo(memoryPtr, 4);
+    WasmSym::initMemoryFlag->setVirtualAddress(memoryPtr);
+    log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}",
+                "__wasm_init_memory_flag", memoryPtr, 4, 4));
+    memoryPtr += 4;
+  }
+
   // TODO: Add .bss space here.
   if (WasmSym::dataEnd)
     WasmSym::dataEnd->setVirtualAddress(memoryPtr);
 
   log("mem: static data = " + Twine(memoryPtr - dataStart));
 
   if (config->shared) {
     out.dylinkSec->memSize = memoryPtr;
void Writer::addSections() {
   addSection(out.typeSec);
   addSection(out.importSec);
   addSection(out.functionSec);
   addSection(out.tableSec);
   addSection(out.memorySec);
   addSection(out.globalSec);
   addSection(out.eventSec);
   addSection(out.exportSec);
+  addSection(out.startSec);
   addSection(out.elemSec);
   addSection(out.dataCountSec);
 
   addSection(make<CodeSection>(out.functionSec->inputFunctions));
   addSection(make<DataSection>(segments));
 
   createCustomSections();
 
for (OutputSection *s : outputSections) {
     fileSize += s->getSize();
   }
 }
 
 void Writer::populateTargetFeatures() {
   StringMap<std::string> used;
   StringMap<std::string> required;
   StringMap<std::string> disallowed;
+  SmallSet<std::string, 8> &allowed = out.targetFeaturesSec->features;
   bool tlsUsed = false;
 
   // Only infer used features if user did not specify features
   bool inferFeatures = !config->features.hasValue();
 
   if (!inferFeatures) {
-    for (auto &feature : config->features.getValue())
-      out.targetFeaturesSec->features.insert(feature);
-    // No need to read or check features
+    auto &explicitFeatures = config->features.getValue();
+    allowed.insert(explicitFeatures.begin(), explicitFeatures.end());
     if (!config->checkFeatures)
       return;
   }
 
   // Find the sets of used, required, and disallowed features
   for (ObjFile *file : symtab->objectFiles) {
     StringRef fileName(file->getName());
     for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
         disallowed.insert({feature.Name, fileName});
         break;
       default:
         error("Unrecognized feature policy prefix " +
               std::to_string(feature.Prefix));
       }
     }
 
-    for (InputSegment *segment : file->segments) {
-      if (!segment->live)
-        continue;
+    // Find TLS data segments
+    auto isTLS = [](InputSegment *segment) {
       StringRef name = segment->getName();
-      if (name.startswith(".tdata") || name.startswith(".tbss"))
-        tlsUsed = true;
-    }
+      return segment->live &&
+             (name.startswith(".tdata") || name.startswith(".tbss"));
+    };
+    tlsUsed = tlsUsed ||
+              std::any_of(file->segments.begin(), file->segments.end(), isTLS);
   }
 
   if (inferFeatures)
-    out.targetFeaturesSec->features.insert(used.keys().begin(),
-                                           used.keys().end());
+    allowed.insert(used.keys().begin(), used.keys().end());
 
-  if (out.targetFeaturesSec->features.count("atomics") &&
-      !config->sharedMemory) {
+  if (allowed.count("atomics") && !config->sharedMemory) {
     if (inferFeatures)
       error(Twine("'atomics' feature is used by ") + used["atomics"] +
             ", so --shared-memory must be used");
     else
       error("'atomics' feature is used, so --shared-memory must be used");
   }
 
   if (!config->checkFeatures)
     return;
 
   if (disallowed.count("atomics") && config->sharedMemory)
     error("'atomics' feature is disallowed by " + disallowed["atomics"] +
           ", so --shared-memory must not be used");
 
-  if (!used.count("bulk-memory") && config->passiveSegments)
-    error("'bulk-memory' feature must be used in order to emit passive "
-          "segments");
+  if (!allowed.count("atomics") && config->sharedMemory)
+    error("'atomics' feature must be used in order to use shared "
+          "memory");
+
+  if (!allowed.count("bulk-memory") && config->sharedMemory)
+    error("'bulk-memory' feature must be used in order to use shared "
+          "memory");
 
-  if (!used.count("bulk-memory") && tlsUsed)
+  if (!allowed.count("bulk-memory") && tlsUsed)
     error("'bulk-memory' feature must be used in order to use thread-local "
           "storage");
 
   // Validate that used features are allowed in output
   if (!inferFeatures) {
     for (auto &feature : used.keys()) {
-      if (!out.targetFeaturesSec->features.count(feature))
+      if (!allowed.count(feature))
         error(Twine("Target feature '") + feature + "' used by " +
               used[feature] + " is not allowed.");
     }
   }
 
   // Validate the required and disallowed constraints for each file
   for (ObjFile *file : symtab->objectFiles) {
     StringRef fileName(file->getName());
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->passiveSegments || name == ".tdata")
+        if (config->sharedMemory || name == ".tdata")
           s->initFlags = WASM_SEGMENT_IS_PASSIVE;
         segments.push_back(s);
       }
       s->addInputSegment(segment);
       LLVM_DEBUG(dbgs() << "added data: " << name << ": " << s->size << "\n");
     }
   }
 }
 
 static void createFunction(DefinedFunction *func, StringRef bodyContent) {
   std::string functionBody;
   {
     raw_string_ostream os(functionBody);
     writeUleb128(os, bodyContent.size(), "function size");
     os << bodyContent;
   }
   ArrayRef<uint8_t> body = arrayRefFromStringRef(saver.save(functionBody));
   cast<SyntheticFunction>(func->function)->setBody(body);
 }
 
 void Writer::createInitMemoryFunction() {
   LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
+  assert(WasmSym::initMemoryFlag);
+  uint32_t flagAddress = WasmSym::initMemoryFlag->getVirtualAddress();
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
 
-    // initialize passive data segments
+    if (segments.size()) {
+      // Initialize memory in a thread-safe manner. The thread that successfully
+      // increments the flag from 0 to 1 is is responsible for performing the
+      // memory initialization. Other threads go sleep on the flag until the
+      // first thread finishing initializing memory, increments the flag to 2,
+      // and wakes all the other threads. Once the flag has been set to 2,
+      // subsequently started threads will skip the sleep. All threads
+      // unconditionally drop their passive data segments once memory has been
+      // initialized. The generated code is as follows:
+      //
+      // (func $__wasm_init_memory
+      //  (if
+      //   (i32.atomic.rmw.cmpxchg align=2 offset=0
+      //    (i32.const $__init_memory_flag)
+      //    (i32.const 0)
+      //    (i32.const 1)
+      //   )
+      //   (then
+      //    (drop
+      //     (i32.atomic.wait align=2 offset=0
+      //      (i32.const $__init_memory_flag)
+      //      (i32.const 1)
+      //      (i32.const -1)
+      //     )
+      //    )
+      //   )
+      //   (else
+      //    ( ... initialize data segments ... )
+      //    (i32.atomic.store align=2 offset=0
+      //     (i32.const $__init_memory_flag)
+      //     (i32.const 2)
+      //    )
+      //    (drop
+      //     (i32.atomic.notify align=2 offset=0
+      //      (i32.const $__init_memory_flag)
+      //      (i32.const -1u)
+      //     )
+      //    )
+      //   )
+      //  )
+      //  ( ... drop data segments ... )
+      // )
+
+      // Atomically check whether this is the main thread.
+      writeI32Const(os, flagAddress, "flag address");
+      writeI32Const(os, 0, "expected flag value");
+      writeI32Const(os, 1, "flag value");
+      writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
+      writeUleb128(os, WASM_OPCODE_I32_RMW_CMPXCHG, "i32.atomic.rmw.cmpxchg");
+      writeMemArg(os, 2, 0);
+      writeU8(os, WASM_OPCODE_IF, "IF");
+      writeU8(os, WASM_TYPE_NORESULT, "blocktype");
+
+      // Did not increment 0, so wait for main thread to initialize memory
+      writeI32Const(os, flagAddress, "flag address");
+      writeI32Const(os, 1, "expected flag value");
+      writeI64Const(os, -1, "timeout");
+      writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
+      writeUleb128(os, WASM_OPCODE_I32_ATOMIC_WAIT, "i32.atomic.wait");
+      writeMemArg(os, 2, 0);
+      writeU8(os, WASM_OPCODE_DROP, "drop");
+
+      writeU8(os, WASM_OPCODE_ELSE, "ELSE");
+
+      // Did increment 0, so conditionally initialize passive data segments
       for (const OutputSegment *s : segments) {
         if (s->initFlags & WASM_SEGMENT_IS_PASSIVE && s->name != ".tdata") {
           // destination address
-        writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
-        writeSleb128(os, s->startVA, "destination address");
+          writeI32Const(os, s->startVA, "destination address");
           // source segment offset
-        writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
-        writeSleb128(os, 0, "segment offset");
+          writeI32Const(os, 0, "segment offset");
           // memory region size
-        writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
-        writeSleb128(os, s->size, "memory region size");
+          writeI32Const(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, WASM_OPCODE_MEMORY_INIT, "memory.init");
           writeUleb128(os, s->index, "segment index immediate");
           writeU8(os, 0, "memory index immediate");
+        }
+      }
+
+      // Set flag to 2 to mark end of initialization
+      writeI32Const(os, flagAddress, "flag address");
+      writeI32Const(os, 2, "flag value");
+      writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
+      writeUleb128(os, WASM_OPCODE_I32_ATOMIC_STORE, "i32.atomic.store");
+      writeMemArg(os, 2, 0);
+
+      // Notify any waiters that memory initialization is complete
+      writeI32Const(os, flagAddress, "flag address");
+      writeI32Const(os, -1, "number of waiters");
+      writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
+      writeUleb128(os, WASM_OPCODE_ATOMIC_NOTIFY, "atomic.notify");
+      writeMemArg(os, 2, 0);
+      writeU8(os, WASM_OPCODE_DROP, "drop");
+
+      writeU8(os, WASM_OPCODE_END, "END");
+
+      // Unconditionally drop passive data segments
+      for (const OutputSegment *s : segments) {
+        if (s->initFlags & WASM_SEGMENT_IS_PASSIVE && s->name != ".tdata") {
           // data.drop instruction
           writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
-        writeUleb128(os, WASM_OPCODE_DATA_DROP, "DATA.DROP");
+          writeUleb128(os, WASM_OPCODE_DATA_DROP, "data.drop");
           writeUleb128(os, s->index, "segment index immediate");
         }
       }
+    }
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::initMemory, bodyContent);
 }
 
 // For -shared (PIC) output, we create create a synthetic function which will
 // apply any relocations to the data segments on startup.  This function is
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");
 
-    if (config->passiveSegments) {
-      writeU8(os, WASM_OPCODE_CALL, "CALL");
-      writeUleb128(os, WasmSym::initMemory->getFunctionIndex(),
-                   "function index");
-    }
-
     if (config->isPic) {
       writeU8(os, WASM_OPCODE_CALL, "CALL");
       writeUleb128(os, WasmSym::applyRelocs->getFunctionIndex(),
                    "function index");
     }
 
     // Call constructors
     for (const WasmInitEntry &f : initFunctions) {
if (tlsSeg) {
       writeUleb128(os, 0, "local index");
 
       writeU8(os, WASM_OPCODE_GLOBAL_SET, "global.set");
       writeUleb128(os, WasmSym::tlsBase->getGlobalIndex(), "global index");
 
       writeU8(os, WASM_OPCODE_LOCAL_GET, "local.get");
       writeUleb128(os, 0, "local index");
 
-      writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
-      writeSleb128(os, 0, "segment offset");
+      writeI32Const(os, 0, "segment offset");
 
-      writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
-      writeSleb128(os, tlsSeg->size, "memory region size");
+      writeI32Const(os, tlsSeg->size, "memory region size");
 
       writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
       writeUleb128(os, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT");
       writeUleb128(os, tlsSeg->index, "segment index immediate");
       writeU8(os, 0, "memory index immediate");
     }
     writeU8(os, WASM_OPCODE_END, "end function");
   }
void Writer::createSyntheticSections() {
   out.typeSec = make<TypeSection>();
   out.importSec = make<ImportSection>();
   out.functionSec = make<FunctionSection>();
   out.tableSec = make<TableSection>();
   out.memorySec = make<MemorySection>();
   out.globalSec = make<GlobalSection>();
   out.eventSec = make<EventSection>();
   out.exportSec = make<ExportSection>();
+  out.startSec = make<StartSection>(segments.size());
   out.elemSec = make<ElemSection>();
   out.dataCountSec = make<DataCountSection>(segments.size());
   out.linkingSec = make<LinkingSection>(initFunctions, segments);
   out.nameSec = make<NameSection>();
   out.producersSec = make<ProducersSection>();
   out.targetFeaturesSec = make<TargetFeaturesSection>();
 }
 
void Writer::run() {
   scanRelocations();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
 
   if (!config->relocatable) {
     // Create linker synthesized functions
-    if (config->passiveSegments)
+    if (config->sharedMemory)
       createInitMemoryFunction();
     if (config->isPic)
       createApplyRelocationsFunction();
     createCallCtorsFunction();
   }
 
   if (!config->relocatable && config->sharedMemory && !config->shared)
     createInitTLSFunction();

lld/trunk/wasm/WriterUtils.h

 
 void writeU32(raw_ostream &os, uint32_t number, const Twine &msg);
 
 void writeValueType(raw_ostream &os, llvm::wasm::ValType type,
                     const Twine &msg);
 
 void writeSig(raw_ostream &os, const llvm::wasm::WasmSignature &sig);
 
+void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg);
+
+void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg);
+
+void writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset);
+
 void writeInitExpr(raw_ostream &os, const llvm::wasm::WasmInitExpr &initExpr);
 
 void writeLimits(raw_ostream &os, const llvm::wasm::WasmLimits &limits);
 
 void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
 
 void writeGlobal(raw_ostream &os, const llvm::wasm::WasmGlobal &global);
 

lld/trunk/wasm/WriterUtils.cpp

for (ValType paramType : sig.Params) {
     writeValueType(os, paramType, "param type");
   }
   writeUleb128(os, sig.Returns.size(), "result Count");
   if (sig.Returns.size()) {
     writeValueType(os, sig.Returns[0], "result type");
   }
 }
 
+void wasm::writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
+  writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
+  writeSleb128(os, number, msg);
+}
+
+void wasm::writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
+  writeU8(os, WASM_OPCODE_I64_CONST, "i64.const");
+  writeSleb128(os, number, msg);
+}
+
+void wasm::writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
+  writeUleb128(os, alignment, "alignment");
+  writeUleb128(os, offset, "offset");
+}
+
 void wasm::writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
   writeU8(os, initExpr.Opcode, "opcode");
   switch (initExpr.Opcode) {
   case WASM_OPCODE_I32_CONST:
     writeSleb128(os, initExpr.Value.Int32, "literal (i32)");
     break;
   case WASM_OPCODE_I64_CONST:
     writeSleb128(os, initExpr.Value.Int64, "literal (i64)");

llvm/trunk/include/llvm/BinaryFormat/Wasm.h

enum : unsigned {
   WASM_OPCODE_GLOBAL_GET = 0x23,
   WASM_OPCODE_GLOBAL_SET = 0x24,
   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,
+};
+
+// Opcodes used in synthetic functions.
+enum : unsigned {
+  WASM_OPCODE_IF = 0x04,
+  WASM_OPCODE_ELSE = 0x05,
+  WASM_OPCODE_DROP = 0x1a,
   WASM_OPCODE_MISC_PREFIX = 0xfc,
   WASM_OPCODE_MEMORY_INIT = 0x08,
   WASM_OPCODE_DATA_DROP = 0x09,
+  WASM_OPCODE_ATOMICS_PREFIX = 0xfe,
+  WASM_OPCODE_ATOMIC_NOTIFY = 0x00,
+  WASM_OPCODE_I32_ATOMIC_WAIT = 0x01,
+  WASM_OPCODE_I32_ATOMIC_STORE = 0x17,
+  WASM_OPCODE_I32_RMW_CMPXCHG = 0x48,
 };
 
 enum : unsigned {
   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
 };
 
 enum : unsigned {