[WebAssembly] Add end-to-end codegen tests for wasm_simd128.h

[tlively]

Summary

Add tests checking that each SIMD intrinsic produces the expected instruction.
Assembly tests are generally discouraged in clang, but in this case we actually
care about the specific instruction being generated from the intrinsics. There
are nine problems with the current intrinsic codegen and they are marked in the
tests with FIXMEs.

Also fix the names of a few instructions to match the spec, fix the ordering of
*_const intrinsics, and add the missing wasm_i64x2_make intrinsic.

[tlively]

• squash to include all changes

[aheejin]

Wow these are really a lot of instructions!

clang/test/Headers/wasm.c

2

Now that we have CHECK lines, we don't need this

1060–1069

Why can't this be done in a single instruction and what is the FIXME for? Maybe a bit of more explanation would help.

[dblaikie]

Assembly tests are generally discouraged in clang, but in this case we actually care about the specific instruction being generated from the intrinsics.

I don't think this is a sound reason to add an end-to-end test in clang. The same is true of all clang tests, right? We ultimately care that accessing a parameter lowers to a certain register (because we're trying to implement a certain ABI) but we don't test that in clang - we test that we lower to certain IR which is guaranteed to lower to a certain register use - and then in LLVM we test that that IR does lower to that register.

I think the same holds true here - and a clang test should verify the IR and an LLVM test should verify the assembly.

[tlively]

In D101684#2732310, @dblaikie wrote:

Assembly tests are generally discouraged in clang, but in this case we actually care about the specific instruction being generated from the intrinsics.

I don't think this is a sound reason to add an end-to-end test in clang. The same is true of all clang tests, right? We ultimately care that accessing a parameter lowers to a certain register (because we're trying to implement a certain ABI) but we don't test that in clang - we test that we lower to certain IR which is guaranteed to lower to a certain register use - and then in LLVM we test that that IR does lower to that register.

I think the same holds true here - and a clang test should verify the IR and an LLVM test should verify the assembly.

In order to get the benefit of this end-to-end test from split tests like that, the LLVM test would have to be automatically generated from the clang test. This wouldn't be so bad to do as long as the LLVM test also used autogenerated checks, but overall that would be extra complexity, verbosity, and indirection for no additional testing benefit, especially given that clang and LLVM are now in the same monorepo and can trivially be kept in sync. Do you think that extra complexity is worth it?

[dblaikie]

In D101684#2732366, @tlively wrote:

In D101684#2732310, @dblaikie wrote:

Assembly tests are generally discouraged in clang, but in this case we actually care about the specific instruction being generated from the intrinsics.

I don't think this is a sound reason to add an end-to-end test in clang. The same is true of all clang tests, right? We ultimately care that accessing a parameter lowers to a certain register (because we're trying to implement a certain ABI) but we don't test that in clang - we test that we lower to certain IR which is guaranteed to lower to a certain register use - and then in LLVM we test that that IR does lower to that register.

I think the same holds true here - and a clang test should verify the IR and an LLVM test should verify the assembly.

In order to get the benefit of this end-to-end test from split tests like that, the LLVM test would have to be automatically generated from the clang test.

Why is that? We don't do that for other test surface area between clang and LLVM.

[tlively]

In D101684#2732395, @dblaikie wrote:

In D101684#2732366, @tlively wrote:

In order to get the benefit of this end-to-end test from split tests like that, the LLVM test would have to be automatically generated from the clang test.

Why is that? We don't do that for other test surface area between clang and LLVM.

The question this test answers is "Do the intrinsic functions generate the proper WebAssembly instructions?" (Notably, the test reveals that in multiple cases, they don't). If we had separate C->IR and and IR->Wasm tests, they would be able to answer this question only if we were sure that the output of the C test matched the source of the IR test, and generating the IR test from the C test would be the best way to ensure that.

I understand your point that clang tests typically do not try to answer this kind of question, but this is an important question to be able to answer for the folks working on WebAssembly SIMD. So the options I see are:

1. Have this abnormal end-to-end test in clang.
2. Autogenerate an IR test from the C test so the composition of tests tells us what we want to know.
3. Host the test in some other repository.

Among those, the first is both the easiest to maintain and the most useful.

[dblaikie]

In D101684#2732408, @tlively wrote:

In D101684#2732395, @dblaikie wrote:

In D101684#2732366, @tlively wrote:

In order to get the benefit of this end-to-end test from split tests like that, the LLVM test would have to be automatically generated from the clang test.

Why is that? We don't do that for other test surface area between clang and LLVM.

The question this test answers is "Do the intrinsic functions generate the proper WebAssembly instructions?" (Notably, the test reveals that in multiple cases, they don't). If we had separate C->IR and and IR->Wasm tests, they would be able to answer this question only if we were sure that the output of the C test matched the source of the IR test, and generating the IR test from the C test would be the best way to ensure that.

I understand your point that clang tests typically do not try to answer this kind of question, but this is an important question to be able to answer for the folks working on WebAssembly SIMD.

Is it fundamentally differently/more important than all the other questions like ABI compatibility? In what way?

So the options I see are:

1. Have this abnormal end-to-end test in clang.
2. Autogenerate an IR test from the C test so the composition of tests tells us what we want to know.
3. Host the test in some other repository.

Among those, the first is both the easiest to maintain and the most useful.

My main objection is to the testing itself compared to the rest of the clang/llvm test philosophy - mostly in the hopes that splitting such testing, the same as nearly all other testing, would be sufficient here. If not, it might be nice to understand what kinds of test/properties make this suitable here despite it generally not being suitable for what seem like similar issues elsewhere in the compiler.

Also, other platforms seem to be OK with this sort of split testing - there's lots of testing of intrinsics (mostly in clang/test/CodeGen, rather than clang/test/Headers, by the looks of it) which, at a cursory glance, seems to generally use emit-llvm+FileCheck, not going all the way to assembly. I don't know I've seen much discussion that this has been a problematic gap in testing for LLVM targets so far.

(all that said, if it's really needed, there's something that makes it fundamentally different from what LLVM's done historically here, or evidence that's been problematic/costly in terms of allowing regressions, I don't mind them being in the clang test directory - though there's also the currently-being-refactored debuginfo-tests directory which will also be for higher level more end-to-end tests and these tests might be suitable there... though again, be good to understand why the current testing for other targets has been inadequate or what makes WebAssembly different here)

[aheejin]

I think there's a clear upside on keeping this within clang/.

1. As @tlively said, there are many number of instructions to test and keeping "C function - LLVM intrinsic" and "LLVM intrinsic - Wasm instruction" tests in sync without autogeneration will be hard and error-prone.

2. Also it is not always the case that we have 1-1-1 relationship of C intrinsic function - LLVM intrinsic - Wasm instruction. For some of these we don't have our own intrinsics but rather use LLVM's common intrinsics, and they don't always boil down to a single LLVM intrinsic. There are cases where a single C function call can be lowered to multiple instructions in the LLVM IR, which we try to pattern match and lower to a single Wasm instruction. This kind of relationship can't be tested easily so it will take significantly longer time to check if a single C function call will result in a single Wasm instruction.

It might be good to move this to clang/test/CodeGen though, if that's more suitable.

[dblaikie]

In D101684#2732522, @aheejin wrote:

I think there's a clear upside on keeping this within clang/.

1. As @tlively said, there are many number of instructions to test and keeping "C function - LLVM intrinsic" and "LLVM intrinsic - Wasm instruction" tests in sync without autogeneration will be hard and error-prone.

I don't necessarily see that they should be kept in sync - in the same way that we don't do this for other IR targets and other features, like ABIs - it's important they are lowered to specific instructions, but we don't generally validate that through end to end tests.

2. Also it is not always the case that we have 1-1-1 relationship of C intrinsic function - LLVM intrinsic - Wasm instruction. For some of these we don't have our own intrinsics but rather use LLVM's common intrinsics, and they don't always boil down to a single LLVM intrinsic. There are cases where a single C function call can be lowered to multiple instructions in the LLVM IR, which we try to pattern match and lower to a single Wasm instruction. This kind of relationship can't be tested easily so it will take significantly longer time to check if a single C function call will result in a single Wasm instruction.

The lack of 1-to-1 is part of the reason I prefer these tests to be separate. If one C level intrinsic lowers to multiple IR operations - then it's good to test each of those IR operations separately from each other. So that all their uses can be validated. Then, knowing they are validated - the Clang C-to-IR test can test that suitable operations are generated, knowing that they're tested in LLVM to work as specified.

It might be good to move this to clang/test/CodeGen though, if that's more suitable.

I'm still not following why this is different from existing testing - many targets already exist in LLVM and already test their intrinsics in various ways, generally, so far as I know (though I haven't looked comprehensively - might be worth you taking a look at existing test strategies for intrinsics to compare/contrast?) . Why is WebAssembly different here?

[aheejin]

In D101684#2732551, @dblaikie wrote:

In D101684#2732522, @aheejin wrote:

I think there's a clear upside on keeping this within clang/.

1. As @tlively said, there are many number of instructions to test and keeping "C function - LLVM intrinsic" and "LLVM intrinsic - Wasm instruction" tests in sync without autogeneration will be hard and error-prone.

I don't necessarily see that they should be kept in sync - in the same way that we don't do this for other IR targets and other features, like ABIs - it's important they are lowered to specific instructions, but we don't generally validate that through end to end tests.

What I meant by keeping in sync was, because there are many instructions and some of them are added and deleted as we progress, so making sure the two tests test the same set of instructions without missing anything is different, without resorting to some kind of autogeneration tool.

2. Also it is not always the case that we have 1-1-1 relationship of C intrinsic function - LLVM intrinsic - Wasm instruction. For some of these we don't have our own intrinsics but rather use LLVM's common intrinsics, and they don't always boil down to a single LLVM intrinsic. There are cases where a single C function call can be lowered to multiple instructions in the LLVM IR, which we try to pattern match and lower to a single Wasm instruction. This kind of relationship can't be tested easily so it will take significantly longer time to check if a single C function call will result in a single Wasm instruction.

The lack of 1-to-1 is part of the reason I prefer these tests to be separate. If one C level intrinsic lowers to multiple IR operations - then it's good to test each of those IR operations separately from each other. So that all their uses can be validated. Then, knowing they are validated - the Clang C-to-IR test can test that suitable operations are generated, knowing that they're tested in LLVM to work as specified.

We have tests in LLVM too. But they can't check whether a single C function call boils down to a single Wasm instruction. And it is not always easy to look at those patterns and come up with the reverse mapping that created it. We match and optimize a lot of patterns, some of them generated from a single C function call but others not.

[dblaikie]

I thought maybe /some/ of the other targets used end-to-end clang tests to test intrinsics, but I can't seem to find any (they seem to be a small minority, if there are any):

grep -r -l intrin.h clang/test/ | xargs grep -L emit-llvm.*FileCheck | xargs grep RUN | less

(then looking for any RUN lines that use FileCheck but don't use emit-llvm)

Unless there's something really different about WebAssembly here, or some evidence that the existing test strategy has been problematic - I think it'd be good to stick with this general approach to testing WebAssembly's intrinsics too.

[tlively]

I chatted with @dblaikie offline about this just now, and we both think it makes sense to turn this particular test into a C->IR test, then later potentially add a C->Wasm end-to-end test to the cross-project-tests directory created in this WIP stack of diffs: https://reviews.llvm.org/D95339. I'll also bump the RFC thread about cross-project-tests with a pointer to this conversation to solicit more feedback about whether this kind of end-to-end intrinsic test should be in scope for cross-project-tests.

[penzn]

I think there is another dimension to this aside from project composition - intrinsics have a tendency to "interact" with their surroundings, and it better to capture the IR rather than the end result. Even if we can verify that simple calls produce instructions we expect, this might not hold true is the arguments change, or the call is in a different context. IR definitely gives more opportunities to test things through.

[tlively]

In D101684#2737842, @penzn wrote:

I think there is another dimension to this aside from project composition - intrinsics have a tendency to "interact" with their surroundings, and it better to capture the IR rather than the end result. Even if we can verify that simple calls produce instructions we expect, this might not hold true is the arguments change, or the call is in a different context. IR definitely gives more opportunities to test things through.

Yeah, the contract that specific instructions are generated really only holds in trivial cases by design. I'm not sure how to best formalize that, though.

[dblaikie]

In D101684#2737868, @tlively wrote:

In D101684#2737842, @penzn wrote:

I think there is another dimension to this aside from project composition - intrinsics have a tendency to "interact" with their surroundings, and it better to capture the IR rather than the end result. Even if we can verify that simple calls produce instructions we expect, this might not hold true is the arguments change, or the call is in a different context. IR definitely gives more opportunities to test things through.

Yeah, the contract that specific instructions are generated really only holds in trivial cases by design. I'm not sure how to best formalize that, though.

I don't know that much about intrinsics, but happy to help with test suggestions - do you have any practical examples of this you could show & I can see if I've got any ideas of good ways to test them?

clang/lib/Headers/wasm_simd128.h

 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_make(int32_t __c0,
                                                             int32_t __c1,
                                                             int32_t __c2,
                                                             int32_t __c3) {
   return (v128_t)(__i32x4){__c0, __c1, __c2, __c3};
 }
 
+static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_make(int64_t __c0,
+                                                            int64_t __c1) {
+  return (v128_t)(__i64x2){__c0, __c1};
+}
+
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_make(float __c0,
                                                             float __c1,
                                                             float __c2,
                                                             float __c3) {
   return (v128_t)(__f32x4){__c0, __c1, __c2, __c3};
 }
 
-static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_make(int64_t __c0,
-                                                            int64_t __c1) {
-  return (v128_t)(__i64x2){__c0, __c1};
-}
-
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_make(double __c0,
                                                             double __c1) {
   return (v128_t)(__f64x2){__c0, __c1};
 }
 
 #define wasm_i8x16_const(__c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7, __c8, \
                          __c9, __c10, __c11, __c12, __c13, __c14, __c15)       \
   __extension__({                                                              \
#define wasm_i32x4_const(__c0, __c1, __c2, __c3)                               \
   __extension__({                                                              \
     __REQUIRE_CONSTANT(__c0);                                                  \
     __REQUIRE_CONSTANT(__c1);                                                  \
     __REQUIRE_CONSTANT(__c2);                                                  \
     __REQUIRE_CONSTANT(__c3);                                                  \
     (v128_t)(__i32x4){__c0, __c1, __c2, __c3};                                 \
   })
 
-#define wasm_f32x4_const(__c0, __c1, __c2, __c3)                               \
+#define wasm_i64x2_const(__c0, __c1)                                           \
   __extension__({                                                              \
     __REQUIRE_CONSTANT(__c0);                                                  \
     __REQUIRE_CONSTANT(__c1);                                                  \
-    __REQUIRE_CONSTANT(__c2);                                                  \
-    __REQUIRE_CONSTANT(__c3);                                                  \
-    (v128_t)(__f32x4){__c0, __c1, __c2, __c3};                                 \
+    (v128_t)(__i64x2){__c0, __c1};                                             \
   })
 
-#define wasm_i64x2_const(__c0, __c1)                                           \
+#define wasm_f32x4_const(__c0, __c1, __c2, __c3)                               \
   __extension__({                                                              \
     __REQUIRE_CONSTANT(__c0);                                                  \
     __REQUIRE_CONSTANT(__c1);                                                  \
-    (v128_t)(__i64x2){__c0, __c1};                                             \
+    __REQUIRE_CONSTANT(__c2);                                                  \
+    __REQUIRE_CONSTANT(__c3);                                                  \
+    (v128_t)(__f32x4){__c0, __c1, __c2, __c3};                                 \
   })
 
 #define wasm_f64x2_const(__c0, __c1)                                           \
   __extension__({                                                              \
     __REQUIRE_CONSTANT(__c0);                                                  \
     __REQUIRE_CONSTANT(__c1);                                                  \
     (v128_t)(__f64x2){__c0, __c1};                                             \
   })

 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_andnot(v128_t __a,
                                                              v128_t __b) {
   return __a & ~__b;
 }
 
 static __inline__ bool __DEFAULT_FN_ATTRS wasm_v128_any_true(v128_t __a) {
   return __builtin_wasm_any_true_v128((__i8x16)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_bitselect(v128_t __a,
                                                                 v128_t __b,
                                                                 v128_t __mask) {
   return (v128_t)__builtin_wasm_bitselect((__i32x4)__a, (__i32x4)__b,
                                           (__i32x4)__mask);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_abs(v128_t __a) {
   return (v128_t)__builtin_wasm_abs_i8x16((__i8x16)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_neg(v128_t __a) {
   return (v128_t)(-(__u8x16)__a);
 }
 
 static __inline__ bool __DEFAULT_FN_ATTRS wasm_i8x16_all_true(v128_t __a) {
   return __builtin_wasm_all_true_i8x16((__i8x16)__a);
 }
 
 static __inline__ int32_t __DEFAULT_FN_ATTRS wasm_i8x16_bitmask(v128_t __a) {
   return __builtin_wasm_bitmask_i8x16((__i8x16)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_popcnt(v128_t __a) {
   return (v128_t)__builtin_wasm_popcnt_i8x16((__i8x16)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_shl(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__i8x16)__a << __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_shr(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__i8x16)__a >> __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_shr(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__u8x16)__a >> __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_add(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)((__u8x16)__a + (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_add_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_add_sat_s_i8x16((__i8x16)__a, (__i8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_add_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_add_sat_u_i8x16((__u8x16)__a, (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_sub(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)((__u8x16)__a - (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_sub_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_sub_sat_s_i8x16((__i8x16)__a, (__i8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_sub_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_sub_sat_u_i8x16((__u8x16)__a, (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_min(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)__builtin_wasm_min_s_i8x16((__i8x16)__a, (__i8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_min(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)__builtin_wasm_min_u_i8x16((__u8x16)__a, (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_max(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)__builtin_wasm_max_s_i8x16((__i8x16)__a, (__i8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_max(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)__builtin_wasm_max_u_i8x16((__u8x16)__a, (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_avgr(v128_t __a,
                                                             v128_t __b) {
   return (v128_t)__builtin_wasm_avgr_u_i8x16((__u8x16)__a, (__u8x16)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_abs(v128_t __a) {
   return (v128_t)__builtin_wasm_abs_i16x8((__i16x8)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_neg(v128_t __a) {
   return (v128_t)(-(__u16x8)__a);
 }
 
 static __inline__ bool __DEFAULT_FN_ATTRS wasm_i16x8_all_true(v128_t __a) {
   return __builtin_wasm_all_true_i16x8((__i16x8)__a);
 }
 
 static __inline__ int32_t __DEFAULT_FN_ATTRS wasm_i16x8_bitmask(v128_t __a) {
   return __builtin_wasm_bitmask_i16x8((__i16x8)__a);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_shl(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__i16x8)__a << __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_shr(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__i16x8)__a >> __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_shr(v128_t __a,
                                                            int32_t __b) {
   return (v128_t)((__u16x8)__a >> __b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_add(v128_t __a,
                                                            v128_t __b) {
   return (v128_t)((__u16x8)__a + (__u16x8)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_add_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_add_sat_s_i16x8((__i16x8)__a, (__i16x8)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_add_sat(v128_t __a,
                                                                v128_t __b) {
   return (v128_t)__builtin_wasm_add_sat_u_i16x8((__u16x8)__a, (__u16x8)__b);
 }
 
 static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_sub(v128_t __a,

clang/test/Headers/wasm.c

-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +simd128 -fsyntax-only -ffreestanding %s -verify
-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +simd128 -fsyntax-only -ffreestanding -flax-vector-conversions=none %s -verify
-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +simd128 -fsyntax-only -ffreestanding -x c++ %s -verify
+// REQUIRES: webassembly-registered-target
 // expected-no-diagnostics
 
-#if defined(__wasm__) && defined(__wasm_simd128__)
+// RUN: %clang %s -O2 -S -o - -target wasm32-unknown-unknown -msimd128 | FileCheck %s
 
 #include <wasm_simd128.h>
 
-// Test that macros are correct as well
-int main() {
-  v128_t v;
-  v = wasm_i8x16_const(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-  v = wasm_i16x8_const(0, 1, 2, 3, 4, 5, 6, 7);
-  v = wasm_i32x4_const(0, 1, 2, 3);
-  v = wasm_i64x2_const(0, 1);
-  v = wasm_f32x4_const(0.0, 1.0, 2.0, 3.0);
-  v = wasm_f64x2_const(0.0, 1.0);
-
-  int8_t i8 = wasm_i8x16_extract_lane(v, 0);
-  uint8_t u8 = wasm_u8x16_extract_lane(v, 15);
-  v = wasm_i8x16_replace_lane(v, 0, 42);
-
-  int16_t i16 = wasm_i16x8_extract_lane(v, 0);
-  uint16_t u16 = wasm_u16x8_extract_lane(v, 7);
-  v = wasm_i16x8_replace_lane(v, 0, 42);
-
-  int32_t i32 = wasm_i32x4_extract_lane(v, 0);
-  v = wasm_i32x4_replace_lane(v, 0, 42);
-
-  int64_t i64 = wasm_i64x2_extract_lane(v, 0);
-  v = wasm_i64x2_replace_lane(v, 0, 42);
-
-  float f32 = wasm_f32x4_extract_lane(v, 0);
-  v = wasm_f32x4_replace_lane(v, 0, 42.0);
-
-  double f64 = wasm_f64x2_extract_lane(v, 0);
-  v = wasm_f64x2_replace_lane(v, 0, 42.0);
-
-  wasm_v8x16_shuffle(v, v, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-  wasm_v16x8_shuffle(v, v, 0, 1, 2, 3, 4, 5, 6, 7);
-  wasm_v32x4_shuffle(v, v, 0, 1, 2, 3);
-  wasm_v64x2_shuffle(v, v, 0, 1);
-
-  uint8_t lane8 = 0;
-  uint16_t lane16 = 0;
-  uint32_t lane32 = 0;
-  uint64_t lane64 = 0;
-  v = wasm_v128_load8_lane(&lane8, v, 0);
-  v = wasm_v128_load16_lane(&lane16, v, 0);
-  v = wasm_v128_load32_lane(&lane32, v, 0);
-  v = wasm_v128_load64_lane(&lane64, v, 0);
-  wasm_v128_store8_lane(&lane8, v, 15);
-  wasm_v128_store16_lane(&lane16, v, 7);
-  wasm_v128_store32_lane(&lane32, v, 3);
-  wasm_v128_store64_lane(&lane64, v, 1);
+// CHECK-LABEL: test_v128_load:
+// CHECK: v128.load 0:p2align=0{{$}}
+v128_t test_v128_load(const void *mem) {
+  return wasm_v128_load(mem);
+}
+
+// CHECK-LABEL: test_v128_load8_splat:
+// CHECK: v128.load8_splat 0{{$}}
+v128_t test_v128_load8_splat(const void *mem) {
+  return wasm_v128_load8_splat(mem);
+}
+
+// CHECK-LABEL: test_v128_load16_splat:
+// CHECK: v128.load16_splat 0:p2align=0{{$}}
+v128_t test_v128_load16_splat(const void *mem) {
+  return wasm_v128_load16_splat(mem);
+}
+
+// CHECK-LABEL: test_v128_load32_splat:
+// CHECK: v128.load32_splat 0:p2align=0{{$}}
+v128_t test_v128_load32_splat(const void *mem) {
+  return wasm_v128_load32_splat(mem);
+}
+
+// CHECK-LABEL: test_v128_load64_splat:
+// CHECK: v128.load64_splat 0:p2align=0{{$}}
+v128_t test_v128_load64_splat(const void *mem) {
+  return wasm_v128_load64_splat(mem);
+}
+
+// CHECK-LABEL: test_i16x8_load8x8:
+// CHECK: i16x8.load8x8_s 0:p2align=0{{$}}
+v128_t test_i16x8_load8x8(const void *mem) {
+  return wasm_i16x8_load8x8(mem);
+}
+
+// CHECK-LABEL: test_u16x8_load8x8:
+// CHECK: i16x8.load8x8_u 0:p2align=0{{$}}
+v128_t test_u16x8_load8x8(const void *mem) {
+  return wasm_u16x8_load8x8(mem);
+}
+
+// CHECK-LABEL: test_i32x4_load16x4:
+// CHECK: i32x4.load16x4_s 0:p2align=0{{$}}
+v128_t test_i32x4_load16x4(const void *mem) {
+  return wasm_i32x4_load16x4(mem);
+}
+
+// CHECK-LABEL: test_u32x4_load16x4:
+// CHECK: i32x4.load16x4_u 0:p2align=0{{$}}
+v128_t test_u32x4_load16x4(const void *mem) {
+  return wasm_u32x4_load16x4(mem);
+}
+
+// CHECK-LABEL: test_i64x2_load32x2:
+// CHECK: i64x2.load32x2_s 0:p2align=0{{$}}
+v128_t test_i64x2_load32x2(const void *mem) {
+  return wasm_i64x2_load32x2(mem);
+}
+
+// CHECK-LABEL: test_u64x2_load32x2:
+// CHECK: i64x2.load32x2_u 0:p2align=0{{$}}
+v128_t test_u64x2_load32x2(const void *mem) {
+  return wasm_u64x2_load32x2(mem);
+}
+
+// CHECK-LABEL: test_v128_load32_zero:
+// CHECK:      v128.const 0, 0, 0, 0{{$}}
+// CHECK-NEXT: local.get  0{{$}}
+// CHECK-NEXT: i32.load   0:p2align=0{{$}}
+// CHECK-NEXT: i32x4.replace_lane 0{{$}}
+// FIXME: v128.load32_zero 0:p2align=0{{$}}
+v128_t test_v128_load32_zero(const void *mem) {
+  return wasm_v128_load32_zero(mem);
+}
+
+// CHECK-LABEL: test_v128_load64_zero:
+// CHECK:      v128.const 0, 0{{$}}
+// CHECK-NEXT: local.get  0{{$}}
+// CHECK-NEXT: i64.load   0:p2align=0{{$}}
+// CHECK-NEXT: i64x2.replace_lane 0{{$}}
+// FIXME: v128.load64_zero 0:p2align=0{{$}}
+v128_t test_v128_load64_zero(const void *mem) {
+  return wasm_v128_load64_zero(mem);
+}
+
+// CHECK-LABEL: test_v128_load8_lane:
+// CHECK: v128.load8_lane 0, 15{{$}}
+v128_t test_v128_load8_lane(uint8_t *ptr, v128_t vec) {
+  return wasm_v128_load8_lane(ptr, vec, 15);
+}
+
+// CHECK-LABEL: test_v128_load16_lane:
+// CHECK: v128.load16_lane 0, 7{{$}}
+// FIXME: v128.load16_lane 0:p2align=0, 7{{$}}
+v128_t test_v128_load16_lane(uint16_t *ptr, v128_t vec) {
+  return wasm_v128_load16_lane(ptr, vec, 7);
+}
+
+// CHECK-LABEL: test_v128_load32_lane:
+// CHECK: v128.load32_lane 0, 3{{$}}
+// FIXME: v128.load32_lane 0:p2align=0, 3{{$}}
+v128_t test_v128_load32_lane(uint32_t *ptr, v128_t vec) {
+  return wasm_v128_load32_lane(ptr, vec, 3);
+}
+
+// CHECK-LABEL: test_v128_load64_lane:
+// CHECK: v128.load64_lane 0, 1{{$}}
+// FIXME: v128.load64_lane 0:p2align=0, 1{{$}}
+v128_t test_v128_load64_lane(uint64_t *ptr, v128_t vec) {
+  return wasm_v128_load64_lane(ptr, vec, 1);
+}
+
+// CHECK-LABEL: test_v128_store:
+// CHECK: v128.store 0:p2align=0{{$}}
+void test_v128_store(void *mem, v128_t a) {
+  return wasm_v128_store(mem, a);
+}
+
+// CHECK-LABEL: test_v128_store8_lane:
+// CHECK: v128.store8_lane 0, 15{{$}}
+void test_v128_store8_lane(uint8_t *ptr, v128_t vec) {
+  return wasm_v128_store8_lane(ptr, vec, 15);
+}
+
+// CHECK-LABEL: test_v128_store16_lane:
+// CHECK: v128.store16_lane 0, 7{{$}}
+// FIXME: v128.store16_lane 0:p2align=0, 7{{$}}
+void test_v128_store16_lane(uint16_t *ptr, v128_t vec) {
+  return wasm_v128_store16_lane(ptr, vec, 7);
+}
+
+// CHECK-LABEL: test_v128_store32_lane:
+// CHECK: v128.store32_lane 0, 3{{$}}
+// FIXME: v128.store32_lane 0:p2align=0, 3{{$}}
+void test_v128_store32_lane(uint32_t *ptr, v128_t vec) {
+  return wasm_v128_store32_lane(ptr, vec, 3);
+}
+
+// CHECK-LABEL: test_v128_store64_lane:
+// CHECK: v128.store64_lane 0, 1{{$}}
+// FIXME: v128.store64_lane 0:p2align=0, 1{{$}}
+void test_v128_store64_lane(uint64_t *ptr, v128_t vec) {
+  return wasm_v128_store64_lane(ptr, vec, 1);
+}
+
+// CHECK-LABEL: test_i8x16_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: i8x16.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: i8x16.replace_lane 1{{$}}
+// CHECK-NEXT: local.get 2{{$}}
+// CHECK-NEXT: i8x16.replace_lane 2{{$}}
+// CHECK-NEXT: local.get 3{{$}}
+// CHECK-NEXT: i8x16.replace_lane 3{{$}}
+// CHECK-NEXT: local.get 4{{$}}
+// CHECK-NEXT: i8x16.replace_lane 4{{$}}
+// CHECK-NEXT: local.get 5{{$}}
+// CHECK-NEXT: i8x16.replace_lane 5{{$}}
+// CHECK-NEXT: local.get 6{{$}}
+// CHECK-NEXT: i8x16.replace_lane 6{{$}}
+// CHECK-NEXT: local.get 7{{$}}
+// CHECK-NEXT: i8x16.replace_lane 7{{$}}
+// CHECK-NEXT: local.get 8{{$}}
+// CHECK-NEXT: i8x16.replace_lane 8{{$}}
+// CHECK-NEXT: local.get 9{{$}}
+// CHECK-NEXT: i8x16.replace_lane 9{{$}}
+// CHECK-NEXT: local.get 10{{$}}
+// CHECK-NEXT: i8x16.replace_lane 10{{$}}
+// CHECK-NEXT: local.get 11{{$}}
+// CHECK-NEXT: i8x16.replace_lane 11{{$}}
+// CHECK-NEXT: local.get 12{{$}}
+// CHECK-NEXT: i8x16.replace_lane 12{{$}}
+// CHECK-NEXT: local.get 13{{$}}
+// CHECK-NEXT: i8x16.replace_lane 13{{$}}
+// CHECK-NEXT: local.get 14{{$}}
+// CHECK-NEXT: i8x16.replace_lane 14{{$}}
+// CHECK-NEXT: local.get 15{{$}}
+// CHECK-NEXT: i8x16.replace_lane 15{{$}}
+v128_t test_i8x16_make(int8_t c0, int8_t c1, int8_t c2, int8_t c3, int8_t c4, int8_t c5, int8_t c6, int8_t c7, int8_t c8, int8_t c9, int8_t c10, int8_t c11, int8_t c12, int8_t c13, int8_t c14, int8_t c15) {
+  return wasm_i8x16_make(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15);
+}
+
+// CHECK-LABEL: test_i16x8_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: i16x8.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: i16x8.replace_lane 1{{$}}
+// CHECK-NEXT: local.get 2{{$}}
+// CHECK-NEXT: i16x8.replace_lane 2{{$}}
+// CHECK-NEXT: local.get 3{{$}}
+// CHECK-NEXT: i16x8.replace_lane 3{{$}}
+// CHECK-NEXT: local.get 4{{$}}
+// CHECK-NEXT: i16x8.replace_lane 4{{$}}
+// CHECK-NEXT: local.get 5{{$}}
+// CHECK-NEXT: i16x8.replace_lane 5{{$}}
+// CHECK-NEXT: local.get 6{{$}}
+// CHECK-NEXT: i16x8.replace_lane 6{{$}}
+// CHECK-NEXT: local.get 7{{$}}
+// CHECK-NEXT: i16x8.replace_lane 7{{$}}
+v128_t test_i16x8_make(int16_t c0, int16_t c1, int16_t c2, int16_t c3, int16_t c4, int16_t c5, int16_t c6, int16_t c7) {
+  return wasm_i16x8_make(c0, c1, c2, c3, c4, c5, c6, c7);
+}
+
+// CHECK-LABEL: test_i32x4_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: i32x4.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: i32x4.replace_lane 1{{$}}
+// CHECK-NEXT: local.get 2{{$}}
+// CHECK-NEXT: i32x4.replace_lane 2{{$}}
+// CHECK-NEXT: local.get 3{{$}}
+// CHECK-NEXT: i32x4.replace_lane 3{{$}}
+v128_t test_i32x4_make(int32_t c0, int32_t c1, int32_t c2, int32_t c3) {
+  return wasm_i32x4_make(c0, c1, c2, c3);
+}
+
+// CHECK-LABEL: test_i64x2_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: i64x2.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: i64x2.replace_lane 1{{$}}
+v128_t test_i64x2_make(int64_t c0, int64_t c1) {
+  return wasm_i64x2_make(c0, c1);
+}
+
+// CHECK-LABEL: test_f32x4_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: f32x4.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: f32x4.replace_lane 1{{$}}
+// CHECK-NEXT: local.get 2{{$}}
+// CHECK-NEXT: f32x4.replace_lane 2{{$}}
+// CHECK-NEXT: local.get 3{{$}}
+// CHECK-NEXT: f32x4.replace_lane 3{{$}}
+v128_t test_f32x4_make(float c0, float c1, float c2, float c3) {
+  return wasm_f32x4_make(c0, c1, c2, c3);
+}
+
+// CHECK-LABEL: test_f64x2_make:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: f64x2.splat{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: f64x2.replace_lane 1{{$}}
+v128_t test_f64x2_make(double c0, double c1) {
+  return wasm_f64x2_make(c0, c1);
+}
+
+// CHECK-LABEL: test_i8x16_const:
+// CHECK: v128.const 50462976, 117835012, 185207048, 252579084{{$}}
+v128_t test_i8x16_const() {
+  return wasm_i8x16_const(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+// CHECK-LABEL: test_i16x8_const:
+// CHECK: v128.const 65536, 196610, 327684, 458758{{$}}
+v128_t test_i16x8_const() {
+  return wasm_i16x8_const(0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+// CHECK-LABEL: test_i32x4_const:
+// CHECK: v128.const 0, 1, 2, 3{{$}}
+v128_t test_i32x4_const() {
+  return wasm_i32x4_const(0, 1, 2, 3);
+}
+
+// CHECK-LABEL: test_i64x2_const:
+// CHECK: v128.const 0, 0, 1, 0{{$}}
+v128_t test_i64x2_const() {
+  return wasm_i64x2_const(0, 1);
+}
+
+// CHECK-LABEL: test_f32x4_const:
+// CHECK: v128.const 0, 1065353216, 1073741824, 1077936128{{$}}
+v128_t test_f32x4_const() {
+  return wasm_f32x4_const(0, 1, 2, 3);
+}
+
+// CHECK-LABEL: test_f64x2_const:
+// CHECK: v128.const 0, 0, 0, 1072693248{{$}}
+v128_t test_f64x2_const() {
+  return wasm_f64x2_const(0, 1);
+}
+
+// CHECK-LABEL: test_i8x16_splat:
+// CHECK: i8x16.splat{{$}}
+v128_t test_i8x16_splat(int8_t a) {
+  return wasm_i8x16_splat(a);
+}
+
+// CHECK-LABEL: test_i8x16_extract_lane:
+// CHECK: i8x16.extract_lane_s 15{{$}}
+int8_t test_i8x16_extract_lane(v128_t a) {
+  return wasm_i8x16_extract_lane(a, 15);
+}
+
+// CHECK-LABEL: test_u8x16_extract_lane:
+// CHECK: i8x16.extract_lane_u 15{{$}}
+uint8_t test_u8x16_extract_lane(v128_t a) {
+  return wasm_u8x16_extract_lane(a, 15);
+}
+
+// CHECK-LABEL: test_i8x16_replace_lane:
+// CHECK: i8x16.replace_lane 15{{$}}
+v128_t test_i8x16_replace_lane(v128_t a, int8_t b) {
+  return wasm_i8x16_replace_lane(a, 15, b);
+}
+
+// CHECK-LABEL: test_i16x8_splat:
+// CHECK: i16x8.splat{{$}}
+v128_t test_i16x8_splat(int16_t a) {
+  return wasm_i16x8_splat(a);
+}
+
+// CHECK-LABEL: test_i16x8_extract_lane:
+// CHECK: i16x8.extract_lane_s 7{{$}}
+int16_t test_i16x8_extract_lane(v128_t a) {
+  return wasm_i16x8_extract_lane(a, 7);
+}
+
+// CHECK-LABEL: test_u16x8_extract_lane:
+// CHECK: i16x8.extract_lane_u 7{{$}}
+uint16_t test_u16x8_extract_lane(v128_t a) {
+  return wasm_u16x8_extract_lane(a, 7);
+}
+
+// CHECK-LABEL: test_i16x8_replace_lane:
+// CHECK: i16x8.replace_lane 7{{$}}
+v128_t test_i16x8_replace_lane(v128_t a, int16_t b) {
+  return wasm_i16x8_replace_lane(a, 7, b);
+}
+
+// CHECK-LABEL: test_i32x4_splat:
+// CHECK: i32x4.splat{{$}}
+v128_t test_i32x4_splat(int32_t a) {
+  return wasm_i32x4_splat(a);
+}
+
+// CHECK-LABEL: test_i32x4_extract_lane:
+// CHECK: i32x4.extract_lane 3{{$}}
+int32_t test_i32x4_extract_lane(v128_t a) {
+  return wasm_i32x4_extract_lane(a, 3);
+}
+
+// CHECK-LABEL: test_i32x4_replace_lane:
+// CHECK: i32x4.replace_lane 3{{$}}
+v128_t test_i32x4_replace_lane(v128_t a, int32_t b) {
+  return wasm_i32x4_replace_lane(a, 3, b);
+}
+
+// CHECK-LABEL: test_i64x2_splat:
+// CHECK: i64x2.splat{{$}}
+v128_t test_i64x2_splat(int64_t a) {
+  return wasm_i64x2_splat(a);
+}
+
+// CHECK-LABEL: test_i64x2_extract_lane:
+// CHECK: i64x2.extract_lane 1{{$}}
+int64_t test_i64x2_extract_lane(v128_t a) {
+  return wasm_i64x2_extract_lane(a, 1);
+}
+
+// CHECK-LABEL: test_i64x2_replace_lane:
+// CHECK: i64x2.replace_lane 1{{$}}
+v128_t test_i64x2_replace_lane(v128_t a, int64_t b) {
+  return wasm_i64x2_replace_lane(a, 1, b);
+}
+
+// CHECK-LABEL: test_f32x4_splat:
+// CHECK: f32x4.splat{{$}}
+v128_t test_f32x4_splat(float a) {
+  return wasm_f32x4_splat(a);
+}
+
+// CHECK-LABEL: test_f32x4_extract_lane:
+// CHECK: f32x4.extract_lane 3{{$}}
+float test_f32x4_extract_lane(v128_t a) {
+  return wasm_f32x4_extract_lane(a, 3);
+}
+
+// CHECK-LABEL: test_f32x4_replace_lane:
+// CHECK: f32x4.replace_lane 3{{$}}
+v128_t test_f32x4_replace_lane(v128_t a, float b) {
+  return wasm_f32x4_replace_lane(a, 3, b);
+}
+
+// CHECK-LABEL: test_f64x2_splat:
+// CHECK: f64x2.splat{{$}}
+v128_t test_f64x2_splat(double a) {
+  return wasm_f64x2_splat(a);
+}
+
+// CHECK-LABEL: test_f64x2_extract_lane:
+// CHECK: f64x2.extract_lane 1{{$}}
+double test_f64x2_extract_lane(v128_t a) {
+  return wasm_f64x2_extract_lane(a, 1);
+}
+
+// CHECK-LABEL: test_f64x2_replace_lane:
+// CHECK: f64x2.replace_lane 1{{$}}
+v128_t test_f64x2_replace_lane(v128_t a, double b) {
+  return wasm_f64x2_replace_lane(a, 1, b);
+}
+
+// CHECK-LABEL: test_i8x16_eq:
+// CHECK: i8x16.eq{{$}}
+v128_t test_i8x16_eq(v128_t a, v128_t b) {
+  return wasm_i8x16_eq(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_ne:
+// CHECK: i8x16.ne{{$}}
+v128_t test_i8x16_ne(v128_t a, v128_t b) {
+  return wasm_i8x16_ne(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_lt:
+// CHECK: i8x16.lt_s{{$}}
+v128_t test_i8x16_lt(v128_t a, v128_t b) {
+  return wasm_i8x16_lt(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_lt:
+// CHECK: i8x16.lt_u{{$}}
+v128_t test_u8x16_lt(v128_t a, v128_t b) {
+  return wasm_u8x16_lt(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_gt:
+// CHECK: i8x16.gt_s{{$}}
+v128_t test_i8x16_gt(v128_t a, v128_t b) {
+  return wasm_i8x16_gt(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_gt:
+// CHECK: i8x16.gt_u{{$}}
+v128_t test_u8x16_gt(v128_t a, v128_t b) {
+  return wasm_u8x16_gt(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_le:
+// CHECK: i8x16.le_s{{$}}
+v128_t test_i8x16_le(v128_t a, v128_t b) {
+  return wasm_i8x16_le(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_le:
+// CHECK: i8x16.le_u{{$}}
+v128_t test_u8x16_le(v128_t a, v128_t b) {
+  return wasm_u8x16_le(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_ge:
+// CHECK: i8x16.ge_s{{$}}
+v128_t test_i8x16_ge(v128_t a, v128_t b) {
+  return wasm_i8x16_ge(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_ge:
+// CHECK: i8x16.ge_u{{$}}
+v128_t test_u8x16_ge(v128_t a, v128_t b) {
+  return wasm_u8x16_ge(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_eq:
+// CHECK: i16x8.eq{{$}}
+v128_t test_i16x8_eq(v128_t a, v128_t b) {
+  return wasm_i16x8_eq(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_ne:
+// CHECK: i16x8.ne{{$}}
+v128_t test_i16x8_ne(v128_t a, v128_t b) {
+  return wasm_i16x8_ne(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_lt:
+// CHECK: i16x8.lt_s{{$}}
+v128_t test_i16x8_lt(v128_t a, v128_t b) {
+  return wasm_i16x8_lt(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_lt:
+// CHECK: i16x8.lt_u{{$}}
+v128_t test_u16x8_lt(v128_t a, v128_t b) {
+  return wasm_u16x8_lt(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_gt:
+// CHECK: i16x8.gt_s{{$}}
+v128_t test_i16x8_gt(v128_t a, v128_t b) {
+  return wasm_i16x8_gt(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_gt:
+// CHECK: i16x8.gt_u{{$}}
+v128_t test_u16x8_gt(v128_t a, v128_t b) {
+  return wasm_u16x8_gt(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_le:
+// CHECK: i16x8.le_s{{$}}
+v128_t test_i16x8_le(v128_t a, v128_t b) {
+  return wasm_i16x8_le(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_le:
+// CHECK: i16x8.le_u{{$}}
+v128_t test_u16x8_le(v128_t a, v128_t b) {
+  return wasm_u16x8_le(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_ge:
+// CHECK: i16x8.ge_s{{$}}
+v128_t test_i16x8_ge(v128_t a, v128_t b) {
+  return wasm_i16x8_ge(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_ge:
+// CHECK: i16x8.ge_u{{$}}
+v128_t test_u16x8_ge(v128_t a, v128_t b) {
+  return wasm_u16x8_ge(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_eq:
+// CHECK: i32x4.eq{{$}}
+v128_t test_i32x4_eq(v128_t a, v128_t b) {
+  return wasm_i32x4_eq(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_ne:
+// CHECK: i32x4.ne{{$}}
+v128_t test_i32x4_ne(v128_t a, v128_t b) {
+  return wasm_i32x4_ne(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_lt:
+// CHECK: i32x4.lt_s{{$}}
+v128_t test_i32x4_lt(v128_t a, v128_t b) {
+  return wasm_i32x4_lt(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_lt:
+// CHECK: i32x4.lt_u{{$}}
+v128_t test_u32x4_lt(v128_t a, v128_t b) {
+  return wasm_u32x4_lt(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_gt:
+// CHECK: i32x4.gt_s{{$}}
+v128_t test_i32x4_gt(v128_t a, v128_t b) {
+  return wasm_i32x4_gt(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_gt:
+// CHECK: i32x4.gt_u{{$}}
+v128_t test_u32x4_gt(v128_t a, v128_t b) {
+  return wasm_u32x4_gt(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_le:
+// CHECK: i32x4.le_s{{$}}
+v128_t test_i32x4_le(v128_t a, v128_t b) {
+  return wasm_i32x4_le(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_le:
+// CHECK: i32x4.le_u{{$}}
+v128_t test_u32x4_le(v128_t a, v128_t b) {
+  return wasm_u32x4_le(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_ge:
+// CHECK: i32x4.ge_s{{$}}
+v128_t test_i32x4_ge(v128_t a, v128_t b) {
+  return wasm_i32x4_ge(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_ge:
+// CHECK: i32x4.ge_u{{$}}
+v128_t test_u32x4_ge(v128_t a, v128_t b) {
+  return wasm_u32x4_ge(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_eq:
+// CHECK: i64x2.eq{{$}}
+v128_t test_i64x2_eq(v128_t a, v128_t b) {
+  return wasm_i64x2_eq(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_ne:
+// CHECK: i64x2.ne{{$}}
+v128_t test_i64x2_ne(v128_t a, v128_t b) {
+  return wasm_i64x2_ne(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_lt:
+// CHECK: i64x2.lt_s{{$}}
+v128_t test_i64x2_lt(v128_t a, v128_t b) {
+  return wasm_i64x2_lt(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_gt:
+// CHECK: i64x2.gt_s{{$}}
+v128_t test_i64x2_gt(v128_t a, v128_t b) {
+  return wasm_i64x2_gt(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_le:
+// CHECK: i64x2.le_s{{$}}
+v128_t test_i64x2_le(v128_t a, v128_t b) {
+  return wasm_i64x2_le(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_ge:
+// CHECK: i64x2.ge_s{{$}}
+v128_t test_i64x2_ge(v128_t a, v128_t b) {
+  return wasm_i64x2_ge(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_eq:
+// CHECK: f32x4.eq{{$}}
+v128_t test_f32x4_eq(v128_t a, v128_t b) {
+  return wasm_f32x4_eq(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_ne:
+// CHECK: f32x4.ne{{$}}
+v128_t test_f32x4_ne(v128_t a, v128_t b) {
+  return wasm_f32x4_ne(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_lt:
+// CHECK: f32x4.lt{{$}}
+v128_t test_f32x4_lt(v128_t a, v128_t b) {
+  return wasm_f32x4_lt(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_gt:
+// CHECK: f32x4.gt{{$}}
+v128_t test_f32x4_gt(v128_t a, v128_t b) {
+  return wasm_f32x4_gt(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_le:
+// CHECK: f32x4.le{{$}}
+v128_t test_f32x4_le(v128_t a, v128_t b) {
+  return wasm_f32x4_le(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_ge:
+// CHECK: f32x4.ge{{$}}
+v128_t test_f32x4_ge(v128_t a, v128_t b) {
+  return wasm_f32x4_ge(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_eq:
+// CHECK: f64x2.eq{{$}}
+v128_t test_f64x2_eq(v128_t a, v128_t b) {
+  return wasm_f64x2_eq(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_ne:
+// CHECK: f64x2.ne{{$}}
+v128_t test_f64x2_ne(v128_t a, v128_t b) {
+  return wasm_f64x2_ne(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_lt:
+// CHECK: f64x2.lt{{$}}
+v128_t test_f64x2_lt(v128_t a, v128_t b) {
+  return wasm_f64x2_lt(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_gt:
+// CHECK: f64x2.gt{{$}}
+v128_t test_f64x2_gt(v128_t a, v128_t b) {
+  return wasm_f64x2_gt(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_le:
+// CHECK: f64x2.le{{$}}
+v128_t test_f64x2_le(v128_t a, v128_t b) {
+  return wasm_f64x2_le(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_ge:
+// CHECK: f64x2.ge{{$}}
+v128_t test_f64x2_ge(v128_t a, v128_t b) {
+  return wasm_f64x2_ge(a, b);
+}
+
+// CHECK-LABEL: test_v128_not:
+// CHECK: v128.not{{$}}
+v128_t test_v128_not(v128_t a) {
+  return wasm_v128_not(a);
+}
+
+// CHECK-LABEL: test_v128_and:
+// CHECK: v128.and{{$}}
+v128_t test_v128_and(v128_t a, v128_t b) {
+  return wasm_v128_and(a, b);
+}
+
+// CHECK-LABEL: test_v128_or:
+// CHECK: v128.or{{$}}
+v128_t test_v128_or(v128_t a, v128_t b) {
+  return wasm_v128_or(a, b);
+}
+
+// CHECK-LABEL: test_v128_xor:
+// CHECK: v128.xor{{$}}
+v128_t test_v128_xor(v128_t a, v128_t b) {
+  return wasm_v128_xor(a, b);
+}
+
+// CHECK-LABEL: test_v128_andnot:
+// CHECK: v128.andnot{{$}}
+v128_t test_v128_andnot(v128_t a, v128_t b) {
+  return wasm_v128_andnot(a, b);
+}
+
+// CHECK-LABEL: test_v128_any_true:
+// CHECK: v128.any_true{{$}}
+bool test_v128_any_true(v128_t a) {
+  return wasm_v128_any_true(a);
+}
+
+// CHECK-LABEL: test_v128_bitselect:
+// CHECK: v128.bitselect{{$}}
+v128_t test_v128_bitselect(v128_t a, v128_t b, v128_t mask) {
+  return wasm_v128_bitselect(a, b, mask);
+}
+
+// CHECK-LABEL: test_i8x16_abs:
+// CHECK: i8x16.abs{{$}}
+v128_t test_i8x16_abs(v128_t a) {
+  return wasm_i8x16_abs(a);
+}
+
+// CHECK-LABEL: test_i8x16_neg:
+// CHECK: i8x16.neg{{$}}
+v128_t test_i8x16_neg(v128_t a) {
+  return wasm_i8x16_neg(a);
+}
+
+// CHECK-LABEL: test_i8x16_all_true:
+// CHECK: i8x16.all_true{{$}}
+bool test_i8x16_all_true(v128_t a) {
+  return wasm_i8x16_all_true(a);
+}
+
+// CHECK-LABEL: test_i8x16_bitmask:
+// CHECK: i8x16.bitmask{{$}}
+int32_t test_i8x16_bitmask(v128_t a) {
+  return wasm_i8x16_bitmask(a);
+}
+
+// CHECK-LABEL: test_i8x16_popcnt:
+// CHECK: i8x16.popcnt{{$}}
+v128_t test_i8x16_popcnt(v128_t a) {
+  return wasm_i8x16_popcnt(a);
+}
+
+// CHECK-LABEL: test_i8x16_shl:
+// CHECK: i8x16.shl{{$}}
+v128_t test_i8x16_shl(v128_t a, int32_t b) {
+  return wasm_i8x16_shl(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_shr:
+// CHECK: i8x16.shr_s{{$}}
+v128_t test_i8x16_shr(v128_t a, int32_t b) {
+  return wasm_i8x16_shr(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_shr:
+// CHECK: i8x16.shr_u{{$}}
+v128_t test_u8x16_shr(v128_t a, int32_t b) {
+  return wasm_u8x16_shr(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_add:
+// CHECK: i8x16.add{{$}}
+v128_t test_i8x16_add(v128_t a, v128_t b) {
+  return wasm_i8x16_add(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_add_sat:
+// CHECK: i8x16.add_sat_s{{$}}
+v128_t test_i8x16_add_sat(v128_t a, v128_t b) {
+  return wasm_i8x16_add_sat(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_add_sat:
+// CHECK: i8x16.add_sat_u{{$}}
+v128_t test_u8x16_add_sat(v128_t a, v128_t b) {
+  return wasm_u8x16_add_sat(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_sub:
+// CHECK: i8x16.sub{{$}}
+v128_t test_i8x16_sub(v128_t a, v128_t b) {
+  return wasm_i8x16_sub(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_sub_sat:
+// CHECK: i8x16.sub_sat_s{{$}}
+v128_t test_i8x16_sub_sat(v128_t a, v128_t b) {
+  return wasm_i8x16_sub_sat(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_sub_sat:
+// CHECK: i8x16.sub_sat_u{{$}}
+v128_t test_u8x16_sub_sat(v128_t a, v128_t b) {
+  return wasm_u8x16_sub_sat(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_min:
+// CHECK: i8x16.min_s{{$}}
+v128_t test_i8x16_min(v128_t a, v128_t b) {
+  return wasm_i8x16_min(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_min:
+// CHECK: i8x16.min_u{{$}}
+v128_t test_u8x16_min(v128_t a, v128_t b) {
+  return wasm_u8x16_min(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_max:
+// CHECK: i8x16.max_s{{$}}
+v128_t test_i8x16_max(v128_t a, v128_t b) {
+  return wasm_i8x16_max(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_max:
+// CHECK: i8x16.max_u{{$}}
+v128_t test_u8x16_max(v128_t a, v128_t b) {
+  return wasm_u8x16_max(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_avgr:
+// CHECK: i8x16.avgr_u{{$}}
+v128_t test_u8x16_avgr(v128_t a, v128_t b) {
+  return wasm_u8x16_avgr(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_abs:
+// CHECK: i16x8.abs{{$}}
+v128_t test_i16x8_abs(v128_t a) {
+  return wasm_i16x8_abs(a);
+}
+
+// CHECK-LABEL: test_i16x8_neg:
+// CHECK: i16x8.neg{{$}}
+v128_t test_i16x8_neg(v128_t a) {
+  return wasm_i16x8_neg(a);
+}
+
+// CHECK-LABEL: test_i16x8_all_true:
+// CHECK: i16x8.all_true{{$}}
+bool test_i16x8_all_true(v128_t a) {
+  return wasm_i16x8_all_true(a);
+}
+
+// CHECK-LABEL: test_i16x8_bitmask:
+// CHECK: i16x8.bitmask{{$}}
+int32_t test_i16x8_bitmask(v128_t a) {
+  return wasm_i16x8_bitmask(a);
+}
+
+// CHECK-LABEL: test_i16x8_shl:
+// CHECK: i16x8.shl{{$}}
+v128_t test_i16x8_shl(v128_t a, int32_t b) {
+  return wasm_i16x8_shl(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_shr:
+// CHECK: i16x8.shr_s{{$}}
+v128_t test_i16x8_shr(v128_t a, int32_t b) {
+  return wasm_i16x8_shr(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_shr:
+// CHECK: i16x8.shr_u{{$}}
+v128_t test_u16x8_shr(v128_t a, int32_t b) {
+  return wasm_u16x8_shr(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_add:
+// CHECK: i16x8.add{{$}}
+v128_t test_i16x8_add(v128_t a, v128_t b) {
+  return wasm_i16x8_add(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_add_sat:
+// CHECK: i16x8.add_sat_s{{$}}
+v128_t test_i16x8_add_sat(v128_t a, v128_t b) {
+  return wasm_i16x8_add_sat(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_add_sat:
+// CHECK: i16x8.add_sat_u{{$}}
+v128_t test_u16x8_add_sat(v128_t a, v128_t b) {
+  return wasm_u16x8_add_sat(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_sub:
+// CHECK: i16x8.sub{{$}}
+v128_t test_i16x8_sub(v128_t a, v128_t b) {
+  return wasm_i16x8_sub(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_sub_sat:
+// CHECK: i16x8.sub_sat_s{{$}}
+v128_t test_i16x8_sub_sat(v128_t a, v128_t b) {
+  return wasm_i16x8_sub_sat(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_sub_sat:
+// CHECK: i16x8.sub_sat_u{{$}}
+v128_t test_u16x8_sub_sat(v128_t a, v128_t b) {
+  return wasm_u16x8_sub_sat(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_mul:
+// CHECK: i16x8.mul{{$}}
+v128_t test_i16x8_mul(v128_t a, v128_t b) {
+  return wasm_i16x8_mul(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_min:
+// CHECK: i16x8.min_s{{$}}
+v128_t test_i16x8_min(v128_t a, v128_t b) {
+  return wasm_i16x8_min(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_min:
+// CHECK: i16x8.min_u{{$}}
+v128_t test_u16x8_min(v128_t a, v128_t b) {
+  return wasm_u16x8_min(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_max:
+// CHECK: i16x8.max_s{{$}}
+v128_t test_i16x8_max(v128_t a, v128_t b) {
+  return wasm_i16x8_max(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_max:
+// CHECK: i16x8.max_u{{$}}
+v128_t test_u16x8_max(v128_t a, v128_t b) {
+  return wasm_u16x8_max(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_avgr:
+// CHECK: i16x8.avgr_u{{$}}
+v128_t test_u16x8_avgr(v128_t a, v128_t b) {
+  return wasm_u16x8_avgr(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_abs:
+// CHECK: i32x4.abs{{$}}
+v128_t test_i32x4_abs(v128_t a) {
+  return wasm_i32x4_abs(a);
+}
+
+// CHECK-LABEL: test_i32x4_neg:
+// CHECK: i32x4.neg{{$}}
+v128_t test_i32x4_neg(v128_t a) {
+  return wasm_i32x4_neg(a);
+}
+
+// CHECK-LABEL: test_i32x4_all_true:
+// CHECK: i32x4.all_true{{$}}
+bool test_i32x4_all_true(v128_t a) {
+  return wasm_i32x4_all_true(a);
+}
+
+// CHECK-LABEL: test_i32x4_bitmask:
+// CHECK: i32x4.bitmask{{$}}
+int32_t test_i32x4_bitmask(v128_t a) {
+  return wasm_i32x4_bitmask(a);
+}
+
+// CHECK-LABEL: test_i32x4_shl:
+// CHECK: i32x4.shl{{$}}
+v128_t test_i32x4_shl(v128_t a, int32_t b) {
+  return wasm_i32x4_shl(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_shr:
+// CHECK: i32x4.shr_s{{$}}
+v128_t test_i32x4_shr(v128_t a, int32_t b) {
+  return wasm_i32x4_shr(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_shr:
+// CHECK: i32x4.shr_u{{$}}
+v128_t test_u32x4_shr(v128_t a, int32_t b) {
+  return wasm_u32x4_shr(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_add:
+// CHECK: i32x4.add{{$}}
+v128_t test_i32x4_add(v128_t a, v128_t b) {
+  return wasm_i32x4_add(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_sub:
+// CHECK: i32x4.sub{{$}}
+v128_t test_i32x4_sub(v128_t a, v128_t b) {
+  return wasm_i32x4_sub(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_mul:
+// CHECK: i32x4.mul{{$}}
+v128_t test_i32x4_mul(v128_t a, v128_t b) {
+  return wasm_i32x4_mul(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_min:
+// CHECK: i32x4.min_s{{$}}
+v128_t test_i32x4_min(v128_t a, v128_t b) {
+  return wasm_i32x4_min(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_min:
+// CHECK: i32x4.min_u{{$}}
+v128_t test_u32x4_min(v128_t a, v128_t b) {
+  return wasm_u32x4_min(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_max:
+// CHECK: i32x4.max_s{{$}}
+v128_t test_i32x4_max(v128_t a, v128_t b) {
+  return wasm_i32x4_max(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_max:
+// CHECK: i32x4.max_u{{$}}
+v128_t test_u32x4_max(v128_t a, v128_t b) {
+  return wasm_u32x4_max(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_dot_i16x8:
+// CHECK: i32x4.dot_i16x8_s{{$}}
+v128_t test_i32x4_dot_i16x8(v128_t a, v128_t b) {
+  return wasm_i32x4_dot_i16x8(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_abs:
+// CHECK:      local.get 0{{$}}
+// CHECK-NEXT: local.get 0{{$}}
+// CHECK-NEXT: i32.const 63{{$}}
+// CHECK-NEXT: i64x2.shr_s{{$}}
+// CHECK-NEXT: local.tee 1{{$}}
+// CHECK-NEXT: i64x2.add{{$}}
+// CHECK-NEXT: local.get 1{{$}}
+// CHECK-NEXT: v128.xor{{$}}
+// FIXME: i64x2.abs{{$}}
+v128_t test_i64x2_abs(v128_t a) {
+  return wasm_i64x2_abs(a);
+}
+
+// CHECK-LABEL: test_i64x2_neg:
+// CHECK: i64x2.neg{{$}}
+v128_t test_i64x2_neg(v128_t a) {
+  return wasm_i64x2_neg(a);
+}
+
+// CHECK-LABEL: test_i64x2_all_true:
+// CHECK: i64x2.all_true{{$}}
+bool test_i64x2_all_true(v128_t a) {
+  return wasm_i64x2_all_true(a);
+}
+
+// CHECK-LABEL: test_i64x2_bitmask:
+// CHECK: i64x2.bitmask{{$}}
+int32_t test_i64x2_bitmask(v128_t a) {
+  return wasm_i64x2_bitmask(a);
+}
+
+// CHECK-LABEL: test_i64x2_shl:
+// CHECK: i64x2.shl{{$}}
+v128_t test_i64x2_shl(v128_t a, int32_t b) {
+  return wasm_i64x2_shl(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_shr:
+// CHECK: i64x2.shr_s{{$}}
+v128_t test_i64x2_shr(v128_t a, int32_t b) {
+  return wasm_i64x2_shr(a, b);
+}
+
+// CHECK-LABEL: test_u64x2_shr:
+// CHECK: i64x2.shr_u{{$}}
+v128_t test_u64x2_shr(v128_t a, int32_t b) {
+  return wasm_u64x2_shr(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_add:
+// CHECK: i64x2.add{{$}}
+v128_t test_i64x2_add(v128_t a, v128_t b) {
+  return wasm_i64x2_add(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_sub:
+// CHECK: i64x2.sub{{$}}
+v128_t test_i64x2_sub(v128_t a, v128_t b) {
+  return wasm_i64x2_sub(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_mul:
+// CHECK: i64x2.mul{{$}}
+v128_t test_i64x2_mul(v128_t a, v128_t b) {
+  return wasm_i64x2_mul(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_abs:
+// CHECK: f32x4.abs{{$}}
+v128_t test_f32x4_abs(v128_t a) {
+  return wasm_f32x4_abs(a);
+}
+
+// CHECK-LABEL: test_f32x4_neg:
+// CHECK: f32x4.neg{{$}}
+v128_t test_f32x4_neg(v128_t a) {
+  return wasm_f32x4_neg(a);
+}
+
+// CHECK-LABEL: test_f32x4_sqrt:
+// CHECK: f32x4.sqrt{{$}}
+v128_t test_f32x4_sqrt(v128_t a) {
+  return wasm_f32x4_sqrt(a);
+}
+
+// CHECK-LABEL: test_f32x4_ceil:
+// CHECK: f32x4.ceil{{$}}
+v128_t test_f32x4_ceil(v128_t a) {
+  return wasm_f32x4_ceil(a);
+}
+
+// CHECK-LABEL: test_f32x4_floor:
+// CHECK: f32x4.floor{{$}}
+v128_t test_f32x4_floor(v128_t a) {
+  return wasm_f32x4_floor(a);
+}
+
+// CHECK-LABEL: test_f32x4_trunc:
+// CHECK: f32x4.trunc{{$}}
+v128_t test_f32x4_trunc(v128_t a) {
+  return wasm_f32x4_trunc(a);
+}
+
+// CHECK-LABEL: test_f32x4_nearest:
+// CHECK: f32x4.nearest{{$}}
+v128_t test_f32x4_nearest(v128_t a) {
+  return wasm_f32x4_nearest(a);
+}
+
+// CHECK-LABEL: test_f32x4_add:
+// CHECK: f32x4.add{{$}}
+v128_t test_f32x4_add(v128_t a, v128_t b) {
+  return wasm_f32x4_add(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_sub:
+// CHECK: f32x4.sub{{$}}
+v128_t test_f32x4_sub(v128_t a, v128_t b) {
+  return wasm_f32x4_sub(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_mul:
+// CHECK: f32x4.mul{{$}}
+v128_t test_f32x4_mul(v128_t a, v128_t b) {
+  return wasm_f32x4_mul(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_div:
+// CHECK: f32x4.div{{$}}
+v128_t test_f32x4_div(v128_t a, v128_t b) {
+  return wasm_f32x4_div(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_min:
+// CHECK: f32x4.min{{$}}
+v128_t test_f32x4_min(v128_t a, v128_t b) {
+  return wasm_f32x4_min(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_max:
+// CHECK: f32x4.max{{$}}
+v128_t test_f32x4_max(v128_t a, v128_t b) {
+  return wasm_f32x4_max(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_pmin:
+// CHECK: f32x4.pmin{{$}}
+v128_t test_f32x4_pmin(v128_t a, v128_t b) {
+  return wasm_f32x4_pmin(a, b);
+}
+
+// CHECK-LABEL: test_f32x4_pmax:
+// CHECK: f32x4.pmax{{$}}
+v128_t test_f32x4_pmax(v128_t a, v128_t b) {
+  return wasm_f32x4_pmax(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_abs:
+// CHECK: f64x2.abs{{$}}
+v128_t test_f64x2_abs(v128_t a) {
+  return wasm_f64x2_abs(a);
+}
+
+// CHECK-LABEL: test_f64x2_neg:
+// CHECK: f64x2.neg{{$}}
+v128_t test_f64x2_neg(v128_t a) {
+  return wasm_f64x2_neg(a);
+}
+
+// CHECK-LABEL: test_f64x2_sqrt:
+// CHECK: f64x2.sqrt{{$}}
+v128_t test_f64x2_sqrt(v128_t a) {
+  return wasm_f64x2_sqrt(a);
+}
+
+// CHECK-LABEL: test_f64x2_ceil:
+// CHECK: f64x2.ceil{{$}}
+v128_t test_f64x2_ceil(v128_t a) {
+  return wasm_f64x2_ceil(a);
+}
+
+// CHECK-LABEL: test_f64x2_floor:
+// CHECK: f64x2.floor{{$}}
+v128_t test_f64x2_floor(v128_t a) {
+  return wasm_f64x2_floor(a);
+}
+
+// CHECK-LABEL: test_f64x2_trunc:
+// CHECK: f64x2.trunc{{$}}
+v128_t test_f64x2_trunc(v128_t a) {
+  return wasm_f64x2_trunc(a);
+}
+
+// CHECK-LABEL: test_f64x2_nearest:
+// CHECK: f64x2.nearest{{$}}
+v128_t test_f64x2_nearest(v128_t a) {
+  return wasm_f64x2_nearest(a);
+}
+
+// CHECK-LABEL: test_f64x2_add:
+// CHECK: f64x2.add{{$}}
+v128_t test_f64x2_add(v128_t a, v128_t b) {
+  return wasm_f64x2_add(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_sub:
+// CHECK: f64x2.sub{{$}}
+v128_t test_f64x2_sub(v128_t a, v128_t b) {
+  return wasm_f64x2_sub(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_mul:
+// CHECK: f64x2.mul{{$}}
+v128_t test_f64x2_mul(v128_t a, v128_t b) {
+  return wasm_f64x2_mul(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_div:
+// CHECK: f64x2.div{{$}}
+v128_t test_f64x2_div(v128_t a, v128_t b) {
+  return wasm_f64x2_div(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_min:
+// CHECK: f64x2.min{{$}}
+v128_t test_f64x2_min(v128_t a, v128_t b) {
+  return wasm_f64x2_min(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_max:
+// CHECK: f64x2.max{{$}}
+v128_t test_f64x2_max(v128_t a, v128_t b) {
+  return wasm_f64x2_max(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_pmin:
+// CHECK: f64x2.pmin{{$}}
+v128_t test_f64x2_pmin(v128_t a, v128_t b) {
+  return wasm_f64x2_pmin(a, b);
+}
+
+// CHECK-LABEL: test_f64x2_pmax:
+// CHECK: f64x2.pmax{{$}}
+v128_t test_f64x2_pmax(v128_t a, v128_t b) {
+  return wasm_f64x2_pmax(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_trunc_sat_f32x4:
+// CHECK: i32x4.trunc_sat_f32x4_s{{$}}
+v128_t test_i32x4_trunc_sat_f32x4(v128_t a) {
+  return wasm_i32x4_trunc_sat_f32x4(a);
+}
+
+// CHECK-LABEL: test_u32x4_trunc_sat_f32x4:
+// CHECK: i32x4.trunc_sat_f32x4_u{{$}}
+v128_t test_u32x4_trunc_sat_f32x4(v128_t a) {
+  return wasm_u32x4_trunc_sat_f32x4(a);
+}
+
+// CHECK-LABEL: test_f32x4_convert_i32x4:
+// CHECK: f32x4.convert_i32x4_s{{$}}
+v128_t test_f32x4_convert_i32x4(v128_t a) {
+  return wasm_f32x4_convert_i32x4(a);
+}
+
+// CHECK-LABEL: test_f32x4_convert_u32x4:
+// CHECK: f32x4.convert_i32x4_u{{$}}
+v128_t test_f32x4_convert_u32x4(v128_t a) {
+  return wasm_f32x4_convert_u32x4(a);
+}
+
+// CHECK-LABEL: test_f64x2_convert_low_i32x4:
+// CHECK: f64x2.convert_low_i32x4_s{{$}}
+v128_t test_f64x2_convert_low_i32x4(v128_t a) {
+  return wasm_f64x2_convert_low_i32x4(a);
+}
+
+// CHECK-LABEL: test_f64x2_convert_low_u32x4:
+// CHECK: f64x2.convert_low_i32x4_u{{$}}
+v128_t test_f64x2_convert_low_u32x4(v128_t a) {
+  return wasm_f64x2_convert_low_u32x4(a);
+}
+
+// CHECK-LABEL: test_i32x4_trunc_sat_f64x2_zero:
+// CHECK: i32x4.trunc_sat_f64x2_s_zero{{$}}
+v128_t test_i32x4_trunc_sat_f64x2_zero(v128_t a) {
+  return wasm_i32x4_trunc_sat_f64x2_zero(a);
+}
+
+// CHECK-LABEL: test_u32x4_trunc_sat_f64x2_zero:
+// CHECK: i32x4.trunc_sat_f64x2_u_zero{{$}}
+v128_t test_u32x4_trunc_sat_f64x2_zero(v128_t a) {
+  return wasm_u32x4_trunc_sat_f64x2_zero(a);
+}
+
+// CHECK-LABEL: test_f32x4_demote_f64x2_zero:
+// CHECK: f32x4.demote_f64x2_zero{{$}}
+v128_t test_f32x4_demote_f64x2_zero(v128_t a) {
+  return wasm_f32x4_demote_f64x2_zero(a);
+}
+
+// CHECK-LABEL: test_f64x2_promote_low_f32x4:
+// CHECK: f64x2.promote_low_f32x4{{$}}
+v128_t test_f64x2_promote_low_f32x4(v128_t a) {
+  return wasm_f64x2_promote_low_f32x4(a);
+}
+
+// CHECK-LABEL: test_i8x16_shuffle:
+// CHECK: i8x16.shuffle 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0{{$}}
+v128_t test_i8x16_shuffle(v128_t a, v128_t b) {
+  return wasm_i8x16_shuffle(a, b, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+}
+
+// CHECK-LABEL: test_i16x8_shuffle:
+// CHECK: i8x16.shuffle 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1{{$}}
+v128_t test_i16x8_shuffle(v128_t a, v128_t b) {
+  return wasm_i16x8_shuffle(a, b, 7, 6, 5, 4, 3, 2, 1, 0);
+}
+
+// CHECK-LABEL: test_i32x4_shuffle:
+// CHECK: i8x16.shuffle 12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3{{$}}
+v128_t test_i32x4_shuffle(v128_t a, v128_t b) {
+  return wasm_i32x4_shuffle(a, b, 3, 2, 1, 0);
+}
+
+// CHECK-LABEL: test_i64x2_shuffle:
+// CHECK: i8x16.shuffle 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7{{$}}
+v128_t test_i64x2_shuffle(v128_t a, v128_t b) {
+  return wasm_i64x2_shuffle(a, b, 1, 0);
+}
+
+// CHECK-LABEL: test_i8x16_swizzle:
+// CHECK: i8x16.swizzle{{$}}
+v128_t test_i8x16_swizzle(v128_t a, v128_t b) {
+  return wasm_i8x16_swizzle(a, b);
+}
+
+// CHECK-LABEL: test_i8x16_narrow_i16x8:
+// CHECK: i8x16.narrow_i16x8_s{{$}}
+v128_t test_i8x16_narrow_i16x8(v128_t a, v128_t b) {
+  return wasm_i8x16_narrow_i16x8(a, b);
+}
+
+// CHECK-LABEL: test_u8x16_narrow_i16x8:
+// CHECK: i8x16.narrow_i16x8_u{{$}}
+v128_t test_u8x16_narrow_i16x8(v128_t a, v128_t b) {
+  return wasm_u8x16_narrow_i16x8(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_narrow_i32x4:
+// CHECK: i16x8.narrow_i32x4_s{{$}}
+v128_t test_i16x8_narrow_i32x4(v128_t a, v128_t b) {
+  return wasm_i16x8_narrow_i32x4(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_narrow_i32x4:
+// CHECK: i16x8.narrow_i32x4_u{{$}}
+v128_t test_u16x8_narrow_i32x4(v128_t a, v128_t b) {
+  return wasm_u16x8_narrow_i32x4(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_extend_low_i8x16:
+// CHECK: i16x8.extend_low_i8x16_s{{$}}
+v128_t test_i16x8_extend_low_i8x16(v128_t a) {
+  return wasm_i16x8_extend_low_i8x16(a);
+}
+
+// CHECK-LABEL: test_i16x8_extend_high_i8x16:
+// CHECK: i16x8.extend_high_i8x16_s{{$}}
+v128_t test_i16x8_extend_high_i8x16(v128_t a) {
+  return wasm_i16x8_extend_high_i8x16(a);
+}
+
+// CHECK-LABEL: test_u16x8_extend_low_u8x16:
+// CHECK: i16x8.extend_low_i8x16_u{{$}}
+v128_t test_u16x8_extend_low_u8x16(v128_t a) {
+  return wasm_u16x8_extend_low_u8x16(a);
+}
+
+// CHECK-LABEL: test_u16x8_extend_high_u8x16:
+// CHECK: i16x8.extend_high_i8x16_u{{$}}
+v128_t test_u16x8_extend_high_u8x16(v128_t a) {
+  return wasm_u16x8_extend_high_u8x16(a);
+}
+
+// CHECK-LABEL: test_i32x4_extend_low_i16x8:
+// CHECK: i32x4.extend_low_i16x8_s{{$}}
+v128_t test_i32x4_extend_low_i16x8(v128_t a) {
+  return wasm_i32x4_extend_low_i16x8(a);
+}
+
+// CHECK-LABEL: test_i32x4_extend_high_i16x8:
+// CHECK: i32x4.extend_high_i16x8_s{{$}}
+v128_t test_i32x4_extend_high_i16x8(v128_t a) {
+  return wasm_i32x4_extend_high_i16x8(a);
+}
+
+// CHECK-LABEL: test_u32x4_extend_low_u16x8:
+// CHECK: i32x4.extend_low_i16x8_u{{$}}
+v128_t test_u32x4_extend_low_u16x8(v128_t a) {
+  return wasm_u32x4_extend_low_u16x8(a);
+}
+
+// CHECK-LABEL: test_u32x4_extend_high_u16x8:
+// CHECK: i32x4.extend_high_i16x8_u{{$}}
+v128_t test_u32x4_extend_high_u16x8(v128_t a) {
+  return wasm_u32x4_extend_high_u16x8(a);
+}
+
+// CHECK-LABEL: test_i64x2_extend_low_i32x4:
+// CHECK: i64x2.extend_low_i32x4_s{{$}}
+v128_t test_i64x2_extend_low_i32x4(v128_t a) {
+  return wasm_i64x2_extend_low_i32x4(a);
+}
+
+// CHECK-LABEL: test_i64x2_extend_high_i32x4:
+// CHECK: i64x2.extend_high_i32x4_s{{$}}
+v128_t test_i64x2_extend_high_i32x4(v128_t a) {
+  return wasm_i64x2_extend_high_i32x4(a);
+}
+
+// CHECK-LABEL: test_u64x2_extend_low_u32x4:
+// CHECK: i64x2.extend_low_i32x4_u{{$}}
+v128_t test_u64x2_extend_low_u32x4(v128_t a) {
+  return wasm_u64x2_extend_low_u32x4(a);
+}
+
+// CHECK-LABEL: test_u64x2_extend_high_u32x4:
+// CHECK: i64x2.extend_high_i32x4_u{{$}}
+v128_t test_u64x2_extend_high_u32x4(v128_t a) {
+  return wasm_u64x2_extend_high_u32x4(a);
+}
 
-  return 0;
+// CHECK-LABEL: test_i16x8_extadd_pairwise_i8x16:
+// CHECK: i16x8.extadd_pairwise_i8x16_s{{$}}
+v128_t test_i16x8_extadd_pairwise_i8x16(v128_t a) {
+  return wasm_i16x8_extadd_pairwise_i8x16(a);
 }
 
-#endif
+// CHECK-LABEL: test_u16x8_extadd_pairwise_u8x16:
+// CHECK: i16x8.extadd_pairwise_i8x16_u{{$}}
+v128_t test_u16x8_extadd_pairwise_u8x16(v128_t a) {
+  return wasm_u16x8_extadd_pairwise_u8x16(a);
+}
+
+// CHECK-LABEL: test_i32x4_extadd_pairwise_i16x8:
+// CHECK: i32x4.extadd_pairwise_i16x8_s{{$}}
+v128_t test_i32x4_extadd_pairwise_i16x8(v128_t a) {
+  return wasm_i32x4_extadd_pairwise_i16x8(a);
+}
+
+// CHECK-LABEL: test_u32x4_extadd_pairwise_u16x8:
+// CHECK: i32x4.extadd_pairwise_i16x8_u{{$}}
+v128_t test_u32x4_extadd_pairwise_u16x8(v128_t a) {
+  return wasm_u32x4_extadd_pairwise_u16x8(a);
+}
+
+// CHECK-LABEL: test_i16x8_extmul_low_i8x16:
+// CHECK: i16x8.extmul_low_i8x16_s{{$}}
+v128_t test_i16x8_extmul_low_i8x16(v128_t a, v128_t b) {
+  return wasm_i16x8_extmul_low_i8x16(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_extmul_high_i8x16:
+// CHECK: i16x8.extmul_high_i8x16_s{{$}}
+v128_t test_i16x8_extmul_high_i8x16(v128_t a, v128_t b) {
+  return wasm_i16x8_extmul_high_i8x16(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_extmul_low_u8x16:
+// CHECK: i16x8.extmul_low_i8x16_u{{$}}
+v128_t test_u16x8_extmul_low_u8x16(v128_t a, v128_t b) {
+  return wasm_u16x8_extmul_low_u8x16(a, b);
+}
+
+// CHECK-LABEL: test_u16x8_extmul_high_u8x16:
+// CHECK: i16x8.extmul_high_i8x16_u{{$}}
+v128_t test_u16x8_extmul_high_u8x16(v128_t a, v128_t b) {
+  return wasm_u16x8_extmul_high_u8x16(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_extmul_low_i16x8:
+// CHECK: i32x4.extmul_low_i16x8_s{{$}}
+v128_t test_i32x4_extmul_low_i16x8(v128_t a, v128_t b) {
+  return wasm_i32x4_extmul_low_i16x8(a, b);
+}
+
+// CHECK-LABEL: test_i32x4_extmul_high_i16x8:
+// CHECK: i32x4.extmul_high_i16x8_s{{$}}
+v128_t test_i32x4_extmul_high_i16x8(v128_t a, v128_t b) {
+  return wasm_i32x4_extmul_high_i16x8(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_extmul_low_u16x8:
+// CHECK: i32x4.extmul_low_i16x8_u{{$}}
+v128_t test_u32x4_extmul_low_u16x8(v128_t a, v128_t b) {
+  return wasm_u32x4_extmul_low_u16x8(a, b);
+}
+
+// CHECK-LABEL: test_u32x4_extmul_high_u16x8:
+// CHECK: i32x4.extmul_high_i16x8_u{{$}}
+v128_t test_u32x4_extmul_high_u16x8(v128_t a, v128_t b) {
+  return wasm_u32x4_extmul_high_u16x8(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_extmul_low_i32x4:
+// CHECK: i64x2.extmul_low_i32x4_s{{$}}
+v128_t test_i64x2_extmul_low_i32x4(v128_t a, v128_t b) {
+  return wasm_i64x2_extmul_low_i32x4(a, b);
+}
+
+// CHECK-LABEL: test_i64x2_extmul_high_i32x4:
+// CHECK: i64x2.extmul_high_i32x4_s{{$}}
+v128_t test_i64x2_extmul_high_i32x4(v128_t a, v128_t b) {
+  return wasm_i64x2_extmul_high_i32x4(a, b);
+}
+
+// CHECK-LABEL: test_u64x2_extmul_low_u32x4:
+// CHECK: i64x2.extmul_low_i32x4_u{{$}}
+v128_t test_u64x2_extmul_low_u32x4(v128_t a, v128_t b) {
+  return wasm_u64x2_extmul_low_u32x4(a, b);
+}
+
+// CHECK-LABEL: test_u64x2_extmul_high_u32x4:
+// CHECK: i64x2.extmul_high_i32x4_u{{$}}
+v128_t test_u64x2_extmul_high_u32x4(v128_t a, v128_t b) {
+  return wasm_u64x2_extmul_high_u32x4(a, b);
+}
+
+// CHECK-LABEL: test_i16x8_q15mulr_sat:
+// CHECK: i16x8.q15mulr_sat_s{{$}}
+v128_t test_i16x8_q15mulr_sat(v128_t a, v128_t b) {
+  return wasm_i16x8_q15mulr_sat(a, b);
+}

llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td

 def : Pat<(v4i32 (trunc_s_sat32 (v4f32 V128:$src))), (fp_to_sint_I32x4 $src)>;
 def : Pat<(v4i32 (trunc_u_sat32 (v4f32 V128:$src))), (fp_to_uint_I32x4 $src)>;
 
 def trunc_sat_zero_t : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>]>;
 def trunc_sat_zero_s :
   SDNode<"WebAssemblyISD::TRUNC_SAT_ZERO_S", trunc_sat_zero_t>;
 def trunc_sat_zero_u :
   SDNode<"WebAssemblyISD::TRUNC_SAT_ZERO_U", trunc_sat_zero_t>;
-defm "" : SIMDConvert<I32x4, F64x2, trunc_sat_zero_s, "trunc_sat_zero_f64x2_s",
+defm "" : SIMDConvert<I32x4, F64x2, trunc_sat_zero_s, "trunc_sat_f64x2_s_zero",
                       0xfc>;
-defm "" : SIMDConvert<I32x4, F64x2, trunc_sat_zero_u, "trunc_sat_zero_f64x2_u",
+defm "" : SIMDConvert<I32x4, F64x2, trunc_sat_zero_u, "trunc_sat_f64x2_u_zero",
                       0xfd>;
 
 // Integer to floating point: convert
 def convert_low_t : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>]>;
 def convert_low_s : SDNode<"WebAssemblyISD::CONVERT_LOW_S", convert_low_t>;
 def convert_low_u : SDNode<"WebAssemblyISD::CONVERT_LOW_U", convert_low_t>;
 defm "" : SIMDConvert<F32x4, I32x4, sint_to_fp, "convert_i32x4_s", 250>;
 defm "" : SIMDConvert<F32x4, I32x4, uint_to_fp, "convert_i32x4_u", 251>;
defm "" : SIMDConvert<I16x8, I8x16, int_wasm_extadd_pairwise_unsigned,
                       "extadd_pairwise_i8x16_u", 0x7d>;
 defm "" : SIMDConvert<I32x4, I16x8, int_wasm_extadd_pairwise_signed,
                       "extadd_pairwise_i16x8_s", 0x7e>;
 defm "" : SIMDConvert<I32x4, I16x8, int_wasm_extadd_pairwise_unsigned,
                       "extadd_pairwise_i16x8_u", 0x7f>;
 
 // Prototype f64x2 conversions
 defm "" : SIMDConvert<F32x4, F64x2, int_wasm_demote_zero,
-                      "demote_zero_f64x2", 0x5e>;
+                      "demote_f64x2_zero", 0x5e>;
 defm "" : SIMDConvert<F64x2, F32x4, int_wasm_promote_low,
                       "promote_low_f32x4", 0x5f>;
 
 //===----------------------------------------------------------------------===//
 // Saturating Rounding Q-Format Multiplication
 //===----------------------------------------------------------------------===//
 
 defm Q15MULR_SAT_S :
   SIMDBinary<I16x8, int_wasm_q15mulr_sat_signed, "q15mulr_sat_s", 0x82>;

llvm/test/CodeGen/WebAssembly/simd-intrinsics.ll

 ; CHECK-NEXT: i32x4.trunc_sat_f32x4_u $push[[R:[0-9]+]]=, $0
 ; CHECK-NEXT: return $pop[[R]]
 declare <4 x i32> @llvm.fptoui.sat.v4i32.v4f32(<4 x float>)
 define <4 x i32> @trunc_sat_u_v4i32(<4 x float> %x) {
   %a = call <4 x i32> @llvm.fptoui.sat.v4i32.v4f32(<4 x float> %x)
   ret <4 x i32> %a
 }
 
-; CHECK-LABEL: trunc_sat_zero_s_v4i32:
-; CHECK-NEXT: .functype trunc_sat_zero_s_v4i32 (v128) -> (v128){{$}}
-; CHECK-NEXT: i32x4.trunc_sat_zero_f64x2_s $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-LABEL: trunc_sat_s_zero_v4i32:
+; CHECK-NEXT: .functype trunc_sat_s_zero_v4i32 (v128) -> (v128){{$}}
+; CHECK-NEXT: i32x4.trunc_sat_f64x2_s_zero $push[[R:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double>)
-define <4 x i32> @trunc_sat_zero_s_v4i32(<2 x double> %x) {
+define <4 x i32> @trunc_sat_s_zero_v4i32(<2 x double> %x) {
   %v = call <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double> %x)
   %a = shufflevector <2 x i32> %v, <2 x i32> <i32 0, i32 0>,
            <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   ret <4 x i32> %a
 }
 
-; CHECK-LABEL: trunc_sat_zero_u_v4i32:
-; CHECK-NEXT: .functype trunc_sat_zero_u_v4i32 (v128) -> (v128){{$}}
-; CHECK-NEXT: i32x4.trunc_sat_zero_f64x2_u $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-LABEL: trunc_sat_u_zero_v4i32:
+; CHECK-NEXT: .functype trunc_sat_u_zero_v4i32 (v128) -> (v128){{$}}
+; CHECK-NEXT: i32x4.trunc_sat_f64x2_u_zero $push[[R:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double>)
-define <4 x i32> @trunc_sat_zero_u_v4i32(<2 x double> %x) {
+define <4 x i32> @trunc_sat_u_zero_v4i32(<2 x double> %x) {
   %v = call <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double> %x)
   %a = shufflevector <2 x i32> %v, <2 x i32> <i32 0, i32 0>,
            <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   ret <4 x i32> %a
 }
 
 ; ==============================================================================
 ; 2 x i64

 declare <4 x float> @llvm.nearbyint.v4f32(<4 x float>)
 define <4 x float> @nearest_v4f32(<4 x float> %a) {
   %v = call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %a)
   ret <4 x float> %v
 }
 
 ; CHECK-LABEL: demote_zero_v4f32:
 ; CHECK-NEXT: .functype demote_zero_v4f32 (v128) -> (v128){{$}}
-; CHECK-NEXT: f32x4.demote_zero_f64x2 $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: f32x4.demote_f64x2_zero $push[[R:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <4 x float> @llvm.wasm.demote.zero(<2 x double>)
 define <4 x float> @demote_zero_v4f32(<2 x double> %a) {
   %v = call <4 x float> @llvm.wasm.demote.zero(<2 x double> %a)
   ret <4 x float> %v
 }
 
 ; ==============================================================================

llvm/test/MC/WebAssembly/simd-encodings.s

main:
     v128.store64_lane 32, 1
 
     # CHECK: v128.load32_zero 32 # encoding: [0xfd,0x5c,0x02,0x20]
     v128.load32_zero 32
 
     # CHECK: v128.load64_zero 32 # encoding: [0xfd,0x5d,0x03,0x20]
     v128.load64_zero 32
 
-    # CHECK: f32x4.demote_zero_f64x2 # encoding: [0xfd,0x5e]
-    f32x4.demote_zero_f64x2
+    # CHECK: f32x4.demote_f64x2_zero # encoding: [0xfd,0x5e]
+    f32x4.demote_f64x2_zero
 
     # CHECK: f64x2.promote_low_f32x4 # encoding: [0xfd,0x5f]
     f64x2.promote_low_f32x4
 
     # CHECK: i8x16.abs # encoding: [0xfd,0x60]
     i8x16.abs
 
     # CHECK: i8x16.neg # encoding: [0xfd,0x61]
main:
     i32x4.trunc_sat_f32x4_u
 
     # CHECK: f32x4.convert_i32x4_s # encoding: [0xfd,0xfa,0x01]
     f32x4.convert_i32x4_s
 
     # CHECK: f32x4.convert_i32x4_u # encoding: [0xfd,0xfb,0x01]
     f32x4.convert_i32x4_u
 
-    # CHECK: i32x4.trunc_sat_zero_f64x2_s # encoding: [0xfd,0xfc,0x01]
-    i32x4.trunc_sat_zero_f64x2_s
+    # CHECK: i32x4.trunc_sat_f64x2_s_zero # encoding: [0xfd,0xfc,0x01]
+    i32x4.trunc_sat_f64x2_s_zero
 
-    # CHECK: i32x4.trunc_sat_zero_f64x2_u # encoding: [0xfd,0xfd,0x01]
-    i32x4.trunc_sat_zero_f64x2_u
+    # CHECK: i32x4.trunc_sat_f64x2_u_zero # encoding: [0xfd,0xfd,0x01]
+    i32x4.trunc_sat_f64x2_u_zero
 
     # CHECK: f64x2.convert_low_i32x4_s # encoding: [0xfd,0xfe,0x01]
     f64x2.convert_low_i32x4_s
 
     # CHECK: f64x2.convert_low_i32x4_u # encoding: [0xfd,0xff,0x01]
     f64x2.convert_low_i32x4_u
 
     end_function