[lld][WebAssembly] Do not require --shared-memory with --relocatable

[tlively]

Summary

wasm-ld requires --shared-memory to be passed when the atomics feature
is enabled because historically atomic operations were only valid with
shared memories. This change relaxes that requirement for when
building relocatable objects because their memories are not
meaningful. This technically maintains the validity of object files
because the threads spec now allows atomic operations with unshared
memories, although we don't support that elsewhere in the tools yet.

This fixes and Emscripten build issue reported at
https://bugs.chromium.org/p/webp/issues/detail?id=463.

[sbc100]

lgtm with a couple of questions..

lld/wasm/Writer.cpp

444

What about all these other tests that also depend on the sharedMemory flag?

I would have thought that in relocatable mode we simply never look at the sharedMemory flag. In fact it should probably be a link error to use --shared-memory and --relocatable at the same time?

Also. what about --check-features/--no-check-features do they make sense with --relocatable?

[tlively]

lld/wasm/Writer.cpp

444

What about all these other tests

I looked at them, but this was the only one requiring --shared-memory. The other checks are predicated on --shared-memory being present, so they won't run anyway when you pass --relocatable without --shared-memory.

In fact is should probably be a link error to use --shared-memory and --relocatable at the same time.

Yeah, I agree. I'll add a check for that.

What about --check-features/--no-check-features

I think that these do make sense. It is still dangerous to mix pthread code with atomic-stripped non-pthread code even when producing a relocatable object. One related issue is that right now the linker cannot emit target features with the disallowed prefix, so atomic-stripped non-pthread code involved in a --relocatable link is not later prevented from being mixed with pthread code. I can fix that in a follow-up CL.

[tlively]

• disallow --shared-memory with -r

[sbc100]

lld/wasm/Writer.cpp

433

Somehow this condition makes more sense when I read it if the relocatable check comes first. But maybe that just me ..

[tlively]

lld/wasm/Writer.cpp

433

Sure, I'll swap it around.

lld/test/wasm/driver.ll

 
 ; RUN: not wasm-ld 2>&1 | FileCheck -check-prefix=BOTH %s
 ; BOTH:     error: no input files
 ; BOTH-NOT: error: no output file specified
 
 ; RUN: not wasm-ld --export-table --import-table %t.o 2>&1 \
 ; RUN:   | FileCheck -check-prefix=TABLE %s
 ; TABLE: error: --import-table and --export-table may not be used together
+
+; RUN: not wasm-ld --relocatable --shared-memory %t.o 2>&1 \
+; RUN:   | FileCheck -check-prefix=SHARED-MEM %s
+; SHARED-MEM: error: -r and --shared-memory may not be used together

lld/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,+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
+; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Function Attrs: nounwind
 define hidden i32 @my_func() local_unnamed_addr {
 entry:
   %call = tail call i32 @foo_import()
   %call2 = tail call i32 @bar_import()

 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000004
 ; CHECK-NEXT:           Maximum:         0x00000004
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; NORMAL-NEXT:      - Initial:         0x00000001
-; SHARED-NEXT:      - Flags:           [ HAS_MAX, IS_SHARED ]
-; SHARED-NEXT:        Initial:         0x00000001
-; SHARED-NEXT:        Maximum:         0x00000002
+; CHECK-NEXT:      - Initial:         0x00000001
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 4, 1, 2 ]
 ; SHARED-NEXT:  - Type:            DATACOUNT
 ; SHARED-NEXT:    Count:           6

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 --max-memory=100000 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-UNALIGNED
 
 # 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 --shared-memory --max-memory=131072 --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED-NO-BULK-MEM
 
 # RUN: not wasm-ld --no-entry --features=atomics %t1.o -o - 2>&1 | FileCheck %s --check-prefix ATOMICS-NO-SHARED
 
+# RUN: wasm-ld --relocatable --features=atomics %t1.o -o - | obj2yaml | FileCheck %s --check-prefix ATOMICS-RELOCATABLE
+
 # 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:

 # 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{{$}}
 
+# ATOMICS-RELOCATABLE:        - Type:            MEMORY
+# ATOMICS-RELOCATABLE-NEXT:     Memories:
+# ATOMICS-RELOCATABLE-NEXT:         Initial:         0x00000001
+# ATOMICS-RELOCATABLE-NEXT:   - Type:
+
 # SHARED:        - Type:            MEMORY
 # SHARED-NEXT:     Memories:
 # SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
 # SHARED-NEXT:         Initial:         0x00000002
 # SHARED-NEXT:         Maximum:         0x00000002

lld/wasm/Driver.cpp

if (config->relocatable) {
     if (config->gcSections)
       error("-r and --gc-sections may not be used together");
     if (config->compressRelocations)
       error("-r -and --compress-relocations may not be used together");
     if (args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
     if (config->pie)
       error("-r and -pie may not be used together");
+    if (config->sharedMemory)
+      error("-r and --shared-memory may not be used together");
   }
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.
 static Symbol *handleUndefined(StringRef name) {
   Symbol *sym = symtab->find(name);
   if (!sym)
     return nullptr;

lld/wasm/Writer.cpp

for (ObjFile *file : symtab->objectFiles) {
     tlsUsed = tlsUsed ||
               std::any_of(file->segments.begin(), file->segments.end(), isTLS);
   }
 
   if (inferFeatures)
     for (const auto &key : used.keys())
       allowed.insert(std::string(key));
 
-  if (allowed.count("atomics") && !config->sharedMemory) {
+  if (!config->relocatable && 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 (!allowed.count("atomics") && config->sharedMemory)
     error("'atomics' feature must be used in order to use shared "
           "memory");
 
   if (!allowed.count("bulk-memory") && config->sharedMemory)