[WebAssembly] Use passive segments by default when memory is shared

[tlively]

Summary

This change makes it so that passing --shared-memory is all a user
needs to do to get proper multithreaded code. This default can still
be explicitly overridden for any reason using --passive-segments and
--active-segments.

[quantum]

lld/wasm/Driver.cpp

323–325

This logic seems a bit hard to understand...

Would this work?

args.hasFlag(OPT_passive_segments, OPT_active_segments, config->sharedMemory);

[tlively]

• Simplify flags logic

lld/wasm/Driver.cpp

323–325

Nice! I thought that bool was for something else entirely.

lld/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:     %t.hello.o
+; RUN:     --active-segments %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/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 => active segments (TODO: error)
-; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 %t.atomics.o -o %t.atomics.wasm
-; RUN: obj2yaml %t.atomics.wasm | FileCheck %s --check-prefixes ACTIVE,ACTIVE-TLS
+; atomics => 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
 ; 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 => active segments (TODO: passive)
+; atomics, bulk 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 ACTIVE,ACTIVE-TLS
+; RUN: obj2yaml %t.atomics.bulk-mem.wasm | FileCheck %s --check-prefixes PASSIVE,PASSIVE-TLS
 
-; atomics, bulk memory, active segments   => active segments
+; 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
+; 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
 
 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

lld/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 --initial-memory=262144 \
-# RUN:     --max-memory=327680 -o %t.max.wasm %t.start.o
+# RUN: wasm-ld --import-memory --shared-memory --active-segments \
+# 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/test/wasm/shared-memory.yaml

 # RUN: yaml2obj %s -o %t1.o
 
-# 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 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-MAX
 
-# RUN: not wasm-ld --no-entry --shared-memory --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-UNALIGNED
+# 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: wasm-ld --no-entry --shared-memory --max-memory=131072 %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
+# 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 --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-SHARED
 
-# RUN: not wasm-ld --no-entry --features=atomics --shared-memory %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-MAX
+# 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 --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-UNALIGNED
+# 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: wasm-ld --no-entry --features=atomics --shared-memory --max-memory=131072 %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
+# RUN: wasm-ld --no-entry --features=atomics --shared-memory --active-segments --max-memory=131072 %t1.o -o - | obj2yaml | FileCheck %s --check-prefix SHARED
 
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            IMPORT
     Imports:

lld/test/wasm/tls.ll

 ; CHECK-NEXT:       Mutable:         false
 ; CHECK-NEXT:       InitExpr:
 ; CHECK-NEXT:         Opcode:          I32_CONST
 ; CHECK-NEXT:         Value:           8
 
 
 ; CHECK:      - Type:            CODE
 ; CHECK-NEXT:   Functions:
-; CHECK-NEXT:     - Index:           0
-; CHECK-NEXT:       Locals:          []
-; CHECK-NEXT:       Body:            0B
-; CHECK-NEXT:     - Index:           1
+; Skip __wasm_call_ctors and __wasm_init_memory
+; CHECK:          - Index:           2
 ; CHECK-NEXT:       Locals:          []
 ; CHECK-NEXT:       Body:            20002401200041004108FC0800000B
 
 ; Expected body of __wasm_init_tls:
 ;   local.get 0
 ;   global.set  1
 ;   local.get 0
 ;   i32.const 0
 ;   i32.const 8
 ;   memory.init 0, 0
 ;   end
 
-; CHECK-NEXT:     - Index:           2
+; CHECK-NEXT:     - Index:           3
 ; CHECK-NEXT:       Locals:          []
 ; CHECK-NEXT:       Body:            2381808080004180808080006A0B
 
 ; Expected body of tls1_addr:
 ;   global.get 1
 ;   i32.const 0
 ;   i32.add
 ;   end
 
-; CHECK-NEXT:     - Index:           3
+; CHECK-NEXT:     - Index:           4
 ; CHECK-NEXT:       Locals:          []
 ; CHECK-NEXT:       Body:            2381808080004184808080006A0B
 
 ; Expected body of tls1_addr:
 ;   global.get 1
 ;   i32.const 4
 ;   i32.add
 ;   end

lld/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->exportAll = args.hasArg(OPT_export_all);
   config->exportDynamic = args.hasFlag(OPT_export_dynamic,
       OPT_no_export_dynamic, false);
   config->exportTable = args.hasArg(OPT_export_table);
   errorHandler().fatalWarnings =
       args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   config->importMemory = args.hasArg(OPT_import_memory);
   config->sharedMemory = args.hasArg(OPT_shared_memory);
-  // TODO: Make passive segments the default with shared memory
-  config->passiveSegments =
-      args.hasFlag(OPT_passive_segments, OPT_active_segments, false);
+  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);
   config->mergeDataSegments =

lld/wasm/Options.td

 
 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">;
+  HelpText<"Force segments to be active (default with unshared memory)">;
 
 def passive_segments: F<"passive-segments">,
-  HelpText<"Force segments to be passive">;
+  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=">,