[WebAssembly] Enable nontrapping-fptoint for `default` cpu

[sbc100]

Summary

Since this feature is now merged into the upstream wasm spec it
makes sense to enable it by default, at least for the default CPU.
The mvp CPU can still be used to avoid this feature.

See: https://github.com/WebAssembly/spec/pull/1143

This is just to test the water and the plan is to enable all features
that have been merged, assuming this change is accepted.

[tlively]

Do we have tests that check that passing -nontrapping-fptoint to llc (or clang) successfully disables the feature?

clang/lib/Basic/Targets/WebAssembly.h

33 ↗

(On Diff #256662)

It seems strange to change the default here. x86 initializes all its corresponding features to false then selectively enables them in initFeatureMap. I think we should stick with that pattern if possible.

clang/test/Preprocessor/wasm-target-features.c

11

Is there a RUN line corresponding to this check anymore?

lld/test/wasm/data-layout.ll

72

Would it make more sense to use the MVP CPU to avoid the unnecessary nontrapping-fptoint? I feel like it just distracts from the point of the test here.

lld/test/wasm/import-memory.test

36

Same here about using the mvp cpu.

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

229

Nice!

llvm/test/CodeGen/WebAssembly/multivalue.ll

259

Might want to use mvp cpu here too, not because this is necessarily distracting, but because I don't see any value in updating this test every time we standardize another feature. Same with many other tests.

llvm/test/MC/WebAssembly/array-fill.ll

27

In some tests you just remove this line and in others you explicitly check for the start of the target features section. Would it make sense to just choose one or the other? FWIW I think checking for the start of the target features section makes the most sense.

[sbc100]

feedback

clang/lib/Basic/Targets/WebAssembly.h

33 ↗

(On Diff #256662)

Right.. makes sense. Done.

clang/test/Preprocessor/wasm-target-features.c

11

Oops, deleted that line.

35

Here is t he test for disabling in clang.

For llc there was already a test for -mattr=-nontrapping-fptoint in the form of llvm/test/CodeGen/WebAssembly/conv-trap.ll. This is what caused me to need to fix getFeatureString.

[sbc100]

err.. arc diff did something funny.

[sunfish]

Looks good! I don't have anything to add beyond Thomas' review comments.

[kripken]

Is the general plan for LLVM documented somewhere?

It's not obvious to me why something being in the wasm spec means it should be enabled by default in LLVM. (It's also not obvious to me that is wrong! I'm just not sure what the reasoning is here.)

In particular, something being in the wasm spec doesn't mean it is widespread yet. I see https://github.com/emscripten-core/emscripten/pull/10885 proposes to diverge the emscripten defaults from LLVMs. That seems odd to me - why shouldn't those be the same? If they aren't the same it's a potential source of confusion in multiple ways. For example, if the reasoning is "LLVM moves with the spec, emscripten moves with the web" then that means *non*-emscripten toolchains targeting the web have more work to do. Also comparisons between toolchains will get harder to get apples-to-apples.

Again, not opposed to this, just not sure what the big picture is.

[sbc100]

I don't have documented plan anywhere. I simply observed that we have CPUs called mvp and generic and it made sense to start including more things in the generic CPU, leaving the mvp option open to those who want to be conservative.

I don't think its a huge issue that emscripten should have different default cpu to llvm itself. Emscripten already passes flags to llvm and has different defaults. It even has its own target triple.

I confess my main goal here was to be able to encode a configuration which represents the "current spec", but its not "bleeding edge". This also happens to the CPU that the wasi SDK would want to use as I believe almost all the users of wasi-sdk are targeting VMs which include the current spec features.

As a less controversial version of this change I could instead create a new CPU called current and leave generic as is (basically leave it at mvp) until we can agree that a features is widespread enough to warrant being part of generic?

Having said that, any*non*-emscripten toolchains that are targeting the web already, like emscripten, have to decide which feature flags to pass by default. Its not something they can avoid. They need to have some opinion. I don't think that llvm and emscripten having different opinions on the default set of features to target is terrible outcome.

[kripken]

In D77908#1977039, @sbc100 wrote:

As a less controversial version of this change I could instead create a new CPU called current and leave generic as is (basically leave it at mvp) until we can agree that a features is widespread enough to warrant being part of generic?

That makes a lot of sense to me. current or current-spec or such seems pretty clear. Then generic stays as it always was (at mvp) and that seems safer for the ecosystem.

Btw, how does LLVM handle this issue with other backends? When say Intel releases a new CPU with a new feature, are those automatically applied in the generic CPU for Intel? (and hence people that want older CPUs will get breakage unless they change the CPU target) If those are automatically applied, at what frequency/policy?

clang/lib/Basic/Targets/WebAssembly.cpp

void WebAssemblyTargetInfo::setSIMDLevel(llvm::StringMap<bool> &Features,
   case NoSIMD:
     break;
   }
 }
 
 bool WebAssemblyTargetInfo::initFeatureMap(
     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
     const std::vector<std::string> &FeaturesVec) const {
+  if (CPU == "generic") {
+    Features["nontrapping-fptoint"] = true;
+  }
+
   if (CPU == "bleeding-edge") {
     Features["nontrapping-fptoint"] = true;
     Features["sign-ext"] = true;
     Features["bulk-memory"] = true;
     Features["atomics"] = true;
     Features["mutable-globals"] = true;
     Features["tail-call"] = true;
     setSIMDLevel(Features, SIMD128);
   }
+
   // Other targets do not consider user-configured features here, but while we
   // are actively developing new features it is useful to let user-configured
   // features control availability of builtins
   setSIMDLevel(Features, SIMDLevel);
   if (HasNontrappingFPToInt)
     Features["nontrapping-fptoint"] = true;
   if (HasSignExt)
     Features["sign-ext"] = true;

clang/test/CodeGen/builtins-wasm.c

-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +unimplemented-simd128 -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32
-// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +unimplemented-simd128 -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64
-// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD
+// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +unimplemented-simd128 -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32
+// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +unimplemented-simd128 -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64
+// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +exception-handling -target-feature +bulk-memory -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD
 
 // SIMD convenience types
 typedef char i8x16 __attribute((vector_size(16)));
 typedef short i16x8 __attribute((vector_size(16)));
 typedef int i32x4 __attribute((vector_size(16)));
 typedef long long i64x2 __attribute((vector_size(16)));
 typedef unsigned char u8x16 __attribute((vector_size(16)));
 typedef unsigned short u16x8 __attribute((vector_size(16)));

clang/test/Preprocessor/wasm-target-features.c

 // RUN: %clang -E -dM %s -o - 2>&1 \
+// RUN:     -target wasm32-unknown-unknown \
+// RUN:   | FileCheck %s -check-prefix=DEFAULT
+// RUN: %clang -E -dM %s -o - 2>&1 \
+// RUN:     -target wasm64-unknown-unknown \
+// RUN:   | FileCheck %s -check-prefix=DEFAULT
+
+// DEFAULT:#define __wasm_nontrapping_fptoint__ 1{{$}}
+
+// RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm32-unknown-unknown -msimd128 \
 // RUN:   | FileCheck %s -check-prefix=SIMD128
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm64-unknown-unknown -msimd128 \
 // RUN:   | FileCheck %s -check-prefix=SIMD128
 //
 // SIMD128:#define __wasm_simd128__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm32-unknown-unknown -munimplemented-simd128 \
 // RUN:   | FileCheck %s -check-prefix=SIMD128-UNIMPLEMENTED
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm64-unknown-unknown -munimplemented-simd128 \
 // RUN:   | FileCheck %s -check-prefix=SIMD128-UNIMPLEMENTED
 //
 // SIMD128-UNIMPLEMENTED:#define __wasm_unimplemented_simd128__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
-// RUN:     -target wasm32-unknown-unknown -mnontrapping-fptoint \
-// RUN:   | FileCheck %s -check-prefix=NONTRAPPING-FPTOINT
+// RUN:     -target wasm32-unknown-unknown -mno-nontrapping-fptoint \
+// RUN:   | FileCheck %s -check-prefix=NO-NONTRAPPING-FPTOINT
 // RUN: %clang -E -dM %s -o - 2>&1 \
-// RUN:     -target wasm64-unknown-unknown -mnontrapping-fptoint \
-// RUN:   | FileCheck %s -check-prefix=NONTRAPPING-FPTOINT
+// RUN:     -target wasm64-unknown-unknown -mno-nontrapping-fptoint \
+// RUN:   | FileCheck %s -check-prefix=NO-NONTRAPPING-FPTOINT
 //
-// NONTRAPPING-FPTOINT:#define __wasm_nontrapping_fptoint__ 1{{$}}
+// NO-NONTRAPPING-FPTOINT-NOT:#define __wasm_nontrapping_fptoint__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm32-unknown-unknown -msign-ext \
 // RUN:   | FileCheck %s -check-prefix=SIGN-EXT
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN:     -target wasm64-unknown-unknown -msign-ext \
 // RUN:   | FileCheck %s -check-prefix=SIGN-EXT
 //

lld/test/wasm/alias.ll

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/call-indirect.ll

 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            call_bar_indirect
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_ptr
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/cxx-mangling.ll

 ; CHECK-NEXT:       - Index:           0
 ; DEMANGLE-NEXT:      Name:            'undefined:bar(int)'
 ; MANGLE-NEXT:        Name:            'undefined:_Z3bari'
 ; CHECK-NEXT:       - Index:           1
 ; DEMANGLE-NEXT:      Name:            'foo(int)'
 ; MANGLE-NEXT:        Name:            _Z3fooi
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            _start
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/data-layout.ll

-; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
-; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llc -mcpu=mvp -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
+; RUN: llc -mcpu=mvp -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown"
 
 @foo = hidden global i32 1, align 4
 @aligned_bar = hidden global i32 3, align 16
 
 @hello_str = external global i8*
 @external_ref = global i8** @hello_str, align 8

 
 ; 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:     --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/test/wasm/function-imports-first.ll

 ; CHECK-NEXT:        Body:            41000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            ret32
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/function-imports.ll

 ; CHECK:           - Index:       0
 ; CHECK:           - Index:       1
 ; CHECK:         Name:            name
 ; CHECK-NEXT:    FunctionNames:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            ret32
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Name:            _start
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/gc-imports.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            used_undef_function
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            use_undef_global
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features
 
 ; RUN: wasm-ld --no-gc-sections --allow-undefined \
 ; RUN:     -o %t1.no-gc.wasm %t.o %t_globals.o
 ; RUN: obj2yaml %t1.no-gc.wasm | FileCheck %s -check-prefix=NO-GC
 
 ; NO-GC:        - Type:            IMPORT
 ; NO-GC-NEXT:     Imports:
 ; NO-GC-NEXT:       - Module:          env

 ; NO-GC-NEXT:       - Index:           2
 ; NO-GC-NEXT:         Name:            __wasm_call_ctors
 ; NO-GC-NEXT:       - Index:           3
 ; NO-GC-NEXT:         Name:            foo
 ; NO-GC-NEXT:       - Index:           4
 ; NO-GC-NEXT:         Name:            _start
 ; NO-GC-NEXT:       - Index:           5
 ; NO-GC-NEXT:         Name:            use_undef_global
-; NO-GC-NEXT: ...
+; NO-GC-NEXT:   - Type:            CUSTOM
+; NO-GC-NEXT:     Name:            target_features

lld/test/wasm/gc-sections.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            used_function
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            use_global
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features
 
 ; RUN: wasm-ld -print-gc-sections --no-gc-sections -o %t1.no-gc.wasm \
 ; RUN:     %t.o %t_globals.o
 ; RUN: obj2yaml %t1.no-gc.wasm | FileCheck %s -check-prefix=NO-GC
 
 ; NO-GC:        - Type:            TYPE
 ; NO-GC-NEXT:     Signatures:
 ; NO-GC-NEXT:       - Index:           0

 ; NO-GC-NEXT:       - Index:           1
 ; NO-GC-NEXT:         Name:            unused_function
 ; NO-GC-NEXT:       - Index:           2
 ; NO-GC-NEXT:         Name:            used_function
 ; NO-GC-NEXT:       - Index:           3
 ; NO-GC-NEXT:         Name:            _start
 ; NO-GC-NEXT:       - Index:           4
 ; NO-GC-NEXT:         Name:            use_global
-; NO-GC-NEXT: ...
+; NO-GC-NEXT:   - Type:            CUSTOM
+; NO-GC-NEXT:     Name:            target_features
 
 ; RUN: not wasm-ld --gc-sections --relocatable -o %t1.no-gc.wasm %t.o 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR
 ; CHECK-ERROR: error: -r and --gc-sections may not be used together

lld/test/wasm/import-memory.test

-# RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
+# RUN: llc -mcpu=mvp -filetype=obj %p/Inputs/start.ll -o %t.start.o
 # RUN: wasm-ld --import-memory -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --import-memory flag creates a memory import
 
 # CHECK:       - Type:            IMPORT
 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env

 # 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 --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/test/wasm/init-fini.ll

 ; CHECK-NEXT:       - Index:           19
 ; CHECK-NEXT:         Name:            .Lcall_dtors.202
 ; CHECK-NEXT:       - Index:           20
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
 ; CHECK-NEXT:       - Index:           21
 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           22
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features
 
 ; RUN: wasm-ld -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: llvm-readobj --symbols --sections %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:       Name: linking
 ; RELOC-NEXT:  InitFunctions [
 ; RELOC-NEXT:    0 (priority=101)
 ; RELOC-NEXT:    1 (priority=101)

lld/test/wasm/load-undefined.test

 ; 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:            ret64
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Name:            ret32
-; CHECK-NEXT: ...
+; CHECK-NEXT:  - Type:            CUSTOM
+; CHECK-NEXT:    Name:            target_features
 
 ; NO-LOAD:         Name:            name
 ; NO-LOAD-NEXT:    FunctionNames:   
 ; NO-LOAD-NEXT:      - Index:           0
 ; NO-LOAD-NEXT:        Name:            __wasm_call_ctors
 ; NO-LOAD-NEXT:      - Index:           1
 ; NO-LOAD-NEXT:        Name:            _start
 ; NO-LOAD-NEXT:      - Index:           2
 ; NO-LOAD-NEXT:        Name:            ret64
-; NO-LOAD-NEXT: ...
+; NO-LOAD-NEXT:  - Type:            CUSTOM
+; NO-LOAD-NEXT:    Name:            target_features
 
 ; Verify that referencing a symbol that is not found doesn't result in a link
 ; failure.  This matches the behaviour of the ELF linker.
 ; RUN: wasm-ld %t.start.o -o %t.wasm -u symboldoesnotexist

lld/test/wasm/local-symbols.ll

 ; CHECK-NEXT:         Content:         '0100000003000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            baz
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/locals-duplicate.test

 ; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Name:            get_global3B
 ; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Name:            get_func1B
 ; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Name:            get_func2B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func3B
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features
 
 
 ; RUN: wasm-ld -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001

 ; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Name:            get_global3B
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Name:            get_func1B
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Name:            get_func2B
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Name:            get_func3B
-; RELOC-NEXT: ...
+; RELOC-NEXT:   - Type:            CUSTOM
+; RELOC-NEXT:     Name:            target_features

lld/test/wasm/relocatable.ll

 ; NORMAL-NEXT:      - Index:           2
 ; NORMAL-NEXT:        Name:            bar_import
 ; NORMAL-NEXT:      - Index:           3
 ; NORMAL-NEXT:        Name:            hello
 ; NORMAL-NEXT:      - Index:           4
 ; NORMAL-NEXT:        Name:            my_func
 ; NORMAL-NEXT:      - Index:           5
 ; NORMAL-NEXT:        Name:            func_comdat
-; NORMAL-NEXT:...
+; NORMAL-NEXT:  - Type:            CUSTOM
+; NORMAL-NEXT:    Name:            target_features

lld/test/wasm/signature-mismatch-export.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            'signature_mismatch:ret32'
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            ret32
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/signature-mismatch.ll

 ; YAML-NEXT:       - Index:           0
 ; YAML-NEXT:         Name:            'signature_mismatch:ret32'
 ; YAML-NEXT:       - Index:           1
 ; YAML-NEXT:         Name:            _start
 ; YAML-NEXT:       - Index:           2
 ; YAML-NEXT:         Name:            ret32
 ; YAML-NEXT:       - Index:           3
 ; YAML-NEXT:         Name:            call_ret32
-; YAML-NEXT: ...
-
+; YAML-NEXT:   - Type:            CUSTOM
+; YAML-NEXT:     Name:            target_features

lld/test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Global:          0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/undefined-weak-call.ll

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            'undefined:weakFunc1'
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            'undefined:weakFunc2'
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            'undefined:weakFunc3'
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            callWeakFuncs
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/weak-alias-overide.ll

 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            call_direct_ptr
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/weak-alias.ll

 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_direct_ptr
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features
 
 ; RUN: wasm-ld --relocatable %t.o %t2.o -o %t.reloc.o
 ; RUN: obj2yaml %t.reloc.o | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:

 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            call_direct_ptr
-; RELOC-NEXT: ...
+; RELOC-NEXT:   - Type:            CUSTOM
+; RELOC-NEXT:     Name:            target_features

lld/test/wasm/weak-symbols.ll

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            weakFn
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            exportWeak1
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            exportWeak2
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

lld/test/wasm/weak-undefined.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1081808080001A1080808080001A0B
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

llvm/lib/Target/WebAssembly/WebAssembly.td

 //===----------------------------------------------------------------------===//
 // WebAssembly Processors supported.
 //===----------------------------------------------------------------------===//
 
 // Minimal Viable Product.
 def : ProcessorModel<"mvp", NoSchedModel, []>;
 
 // Generic processor: latest stable version.
-def : ProcessorModel<"generic", NoSchedModel, []>;
+def : ProcessorModel<"generic", NoSchedModel, [FeatureNontrappingFPToInt]>;
 
 // Latest and greatest experimental version of WebAssembly. Bugs included!
 def : ProcessorModel<"bleeding-edge", NoSchedModel,
                       [FeatureSIMD128, FeatureAtomics,
                        FeatureNontrappingFPToInt, FeatureSignExt,
                        FeatureMutableGlobals, FeatureBulkMemory,
                        FeatureTailCall]>;
 

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

FeatureBitset Features =
             ->getFeatureBits();
     for (auto &F : M)
       Features |= WasmTM->getSubtargetImpl(F)->getFeatureBits();
     return Features;
   }
 
   std::string getFeatureString(const FeatureBitset &Features) {
     std::string Ret;
+    FeatureBitset Defaults =
+        WasmTM->getSubtargetImpl(std::string(WasmTM->getTargetCPU()), "")
+            ->getFeatureBits();
     for (const SubtargetFeatureKV &KV : WebAssemblyFeatureKV) {
-      if (Features[KV.Value])
+      if (Features[KV.Value] && !Defaults[KV.Value])
         Ret += (StringRef("+") + KV.Key + ",").str();
+      if (!Features[KV.Value] && Defaults[KV.Value])
+        Ret += (StringRef("-") + KV.Key + ",").str();
     }
     return Ret;
   }
 
   void replaceFeatures(Function &F, const std::string &Features) {
     F.removeFnAttr("target-features");
     F.removeFnAttr("target-cpu");
     F.addFnAttr("target-features", Features);

llvm/test/CodeGen/WebAssembly/conv.ll

-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+nontrapping-fptoint | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s
 
 ; Test that basic conversion operations assemble as expected.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: i32_wrap_i64:
 ; CHECK-NEXT: .functype i32_wrap_i64 (i64) -> (i32){{$}}

llvm/test/CodeGen/WebAssembly/multivalue.ll

-; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -mattr=+multivalue,+tail-call | FileCheck %s
-; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+multivalue,+tail-call | FileCheck %s --check-prefix REGS
+; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -mcpu=mvp -mattr=+multivalue,+tail-call | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -mcpu=mvp -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+multivalue,+tail-call | FileCheck %s --check-prefix REGS
 ; RUN: llc < %s --filetype=obj -mattr=+multivalue,+tail-call | obj2yaml | FileCheck %s --check-prefix OBJ
 
 ; Test that the multivalue calls, returns, function types, and block
 ; types work as expected.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 

 ; CHECK-LABEL: .section .custom_section.target_features
 ; CHECK-NEXT: .int8 2
 ; CHECK-NEXT: .int8 43
 ; CHECK-NEXT: .int8 10
 ; CHECK-NEXT: .ascii "multivalue"
 ; CHECK-NEXT: .int8 43
 ; CHECK-NEXT: .int8 9
 ; CHECK-NEXT: .ascii "tail-call"
 
 ; OBJ-LABEL:  - Type:            TYPE
 ; OBJ-NEXT:     Signatures:
 ; OBJ-NEXT:       - Index:           0
 ; OBJ-NEXT:         ParamTypes:      []
 ; OBJ-NEXT:         ReturnTypes:
 ; OBJ-NEXT:           - I32
 ; OBJ-NEXT:           - I64
 ; OBJ-NEXT:       - Index:           1

llvm/test/CodeGen/WebAssembly/mutable-globals.ll

 ; RUN: llc < %s -mattr=+mutable-globals | FileCheck %s
 
 ; Test that mutable globals is properly emitted into the target features section
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 define void @foo() {
   ret void
 }
 
 ; CHECK-LABEL: .custom_section.target_features
-; CHECK-NEXT: .int8 1
+; CHECK-NEXT: .int8 2
 ; CHECK-NEXT: .int8 43
 ; CHECK-NEXT: .int8 15
 ; CHECK-NEXT: .ascii "mutable-globals"

llvm/test/CodeGen/WebAssembly/reference-types.ll

 ; RUN: llc < %s -mattr=+reference-types | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: reference-types
 define void @reference-types() {
   ret void
 }
 
-; CHECK:      .int8 1
+; CHECK:      .int8 2
+; CHECK-NEXT: .int8 43
+; CHECK-NEXT: .int8 19
+; CHECK-NEXT: .ascii "nontrapping-fptoint"
 ; CHECK-NEXT: .int8 43
 ; CHECK-NEXT: .int8 15
 ; CHECK-NEXT: .ascii "reference-types"

llvm/test/CodeGen/WebAssembly/tailcall.ll

 ; YAML-NEXT:      - I32
 define i32 @unique_caller(i32 (i32, float, i64, double)** %p) {
   %f = load i32 (i32, float, i64, double)*, i32 (i32, float, i64, double)** %p
   %v = tail call i32 %f(i32 0, float 0., i64 0, double 0.)
   ret i32 %v
 }
 
 ; CHECK-LABEL: .section .custom_section.target_features
-; CHECK-NEXT: .int8 1
+; CHECK-NEXT: .int8 2
+; CHECK-NEXT: .int8 43
+; CHECK-NEXT: .int8 19
+; CHECK-NEXT: .ascii "nontrapping-fptoint"
 ; CHECK-NEXT: .int8 43
 ; CHECK-NEXT: .int8 9
 ; CHECK-NEXT: .ascii "tail-call"

llvm/test/CodeGen/WebAssembly/target-features-tls.ll

 ; RUN: llc < %s -mattr=-bulk-memory | FileCheck %s --check-prefixes NO-BULK-MEM
 ; RUN: llc < %s -mattr=+bulk-memory | FileCheck %s --check-prefixes BULK-MEM
 
 ; Test that the target features section contains -atomics or +atomics
 ; for modules that have thread local storage in their source.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 @foo = internal thread_local global i32 0
 
 ; -bulk-memory
 ; NO-BULK-MEM-LABEL: .custom_section.target_features,"",@
-; NO-BULK-MEM-NEXT: .int8 1
+; NO-BULK-MEM-NEXT: .int8 2
 ; NO-BULK-MEM-NEXT: .int8 45
 ; NO-BULK-MEM-NEXT: .int8 7
 ; NO-BULK-MEM-NEXT: .ascii "atomics"
+; NO-BULK-MEM-NEXT: .int8 43
+; NO-BULK-MEM-NEXT: .int8 19
+; NO-BULK-MEM-NEXT: .ascii "nontrapping-fptoint"
 ; NO-BULK-MEM-NEXT: .bss.foo,"",@
 
 ; +bulk-memory
 ; BULK-MEM-LABEL: .custom_section.target_features,"",@
-; BULK-MEM-NEXT: .int8 1
+; BULK-MEM-NEXT: .int8 2
 ; BULK-MEM-NEXT: .int8 43
 ; BULK-MEM-NEXT: .int8 11
 ; BULK-MEM-NEXT: .ascii "bulk-memory"
+; BULK-MEM-NEXT: .int8 43
+; BULK-MEM-NEXT: .int8 19
+; BULK-MEM-NEXT: .ascii "nontrapping-fptoint"
 ; BULK-MEM-NEXT: .tbss.foo,"",@

llvm/test/MC/WebAssembly/array-fill.ll

 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            2
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
-; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/assembler-binary.ll

 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Function:        1
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            bar
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        0
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

llvm/test/MC/WebAssembly/basic-assembly-errors.s

-# RUN: not llvm-mc -triple=wasm32-unknown-unknown -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s 2>&1 | FileCheck %s
+# RUN: not llvm-mc -triple=wasm32-unknown-unknown -mattr=+simd128,+exception-handling < %s 2>&1 | FileCheck %s
 
 # CHECK: invalid operand for instruction
 # (must be 0.0 or similar)
     f32.const 0
 
 # CHECK: End of block construct with no start: end_try
     end_try
 test0:

llvm/test/MC/WebAssembly/basic-assembly.s

-# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+atomics,+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+atomics,+unimplemented-simd128,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors, but don't check any output:
-# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+atomics,+unimplemented-simd128,+nontrapping-fptoint,+exception-handling -o %t.o < %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+atomics,+unimplemented-simd128,+exception-handling -o %t.o < %s
 
 
 empty_func:
     .functype empty_func () -> ()
     end_function
 
 test0:
     # Test all types:

llvm/test/MC/WebAssembly/bss.ll

 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .bss.foo
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            .bss.bar
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

llvm/test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           2
 ; CHECK-NEXT:        Name:            sharedComdat
 ; CHECK-NEXT:        Entries:
 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           3
 ; CHECK-NEXT:          - Kind:            DATA
 ; CHECK-NEXT:            Index:           0
-; CHECK-NEXT: ...
+; CHECK-NEXT:  - Type:            CUSTOM
+; CHECK-NEXT:    Name:            target_features

llvm/test/MC/WebAssembly/data-section.s

-# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors:
-# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Minimal test for data sections.
 
 test0:
     .functype   test0 () -> (i32)
     i32.const .L.str
 .Ltestlabel:
     end_function

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

 ; CHECK-NEXT:    Name: reloc..debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 77
 ; CHECK-NEXT:    Offset: 1013
 ; CHECK-NEXT:    Name: producers
 ; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 22
+; CHECK-NEXT:    Offset: 1106
+; CHECK-NEXT:    Name: target_features
+; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (7) DATA {
 ; CHECK-NEXT:    0x6 R_WASM_MEMORY_ADDR_I32 myextern 0
 ; CHECK-NEXT:    0xF R_WASM_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (9) .debug_info {
 ; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_abbrev 0

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

 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .sec1
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .sec2
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

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

 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 9
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 2
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 10
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 7
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features

llvm/test/MC/WebAssembly/objdump.s

-# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o -mattr=+simd128,+exception-handling < %s
 # RUN: llvm-objdump --triple=wasm32-unknown-unknown -d %t.o | FileCheck %s
 
 test0:
     .functype   test0 (i32, i64) -> (i32)
     .local      f32, f64, v128, v128
     local.get   2
     end_function
 

llvm/test/MC/WebAssembly/type-index.s

-# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors:
-# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Minimal test for type indices in call_indirect.
 
 test0:
     .functype   test0 (i32) -> (i32)
     call_indirect (f64) -> (f64)
     end_function
 

llvm/test/MC/WebAssembly/visibility.ll

 ; CHECK-NEXT:         Name:            defaultVis
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            hiddenVis
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        1
-; CHECK-NEXT: ...
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            target_features