[WebAssembly] Implement v128.select

[tlively]

Summary

Although the SIMD spec proposal does not specifically include a
select instruction, the select instruction in MVP WebAssembly is
polymorphic over the selected types, so it is able to work on v128
values when they are enabled. This patch introduces a new variant of
the select instruction for each legal vector type. Additional ISel
patterns are adapted from the SELECT_I32 and SELECT_I64 patterns.

Depends on D83736.

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

for (auto Op : {ISD::EXTRACT_VECTOR_ELT, ISD::INSERT_VECTOR_ELT})
       for (auto T : {MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v4f32, MVT::v2i64,
                      MVT::v2f64})
         setOperationAction(Op, T, Custom);
 
     // There is no i8x16.mul instruction
     setOperationAction(ISD::MUL, MVT::v16i8, Expand);
 
     // There is no vector conditional select instruction
-    // TODO: Implement SELECT_V128
-    for (auto Op : {ISD::SELECT_CC, ISD::SELECT})
-      for (auto T : {MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v4f32, MVT::v2i64,
-                     MVT::v2f64})
-        setOperationAction(Op, T, Expand);
+      setOperationAction(ISD::SELECT_CC, T, Expand);
 
     // Expand integer operations supported for scalars but not SIMD
     for (auto Op : {ISD::CTLZ, ISD::CTTZ, ISD::CTPOP, ISD::SDIV, ISD::UDIV,
                     ISD::SREM, ISD::UREM, ISD::ROTL, ISD::ROTR})
       for (auto T : {MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64})
         setOperationAction(Op, T, Expand);
 
     // But we do have integer min and max operations

llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td

foreach types = [[v16i8, v16i8], [v8i16, v8i16], [v4i32, v4i32], [v2i64, v2i64],
                  [v4f32, v4i32], [v2f64, v2i64]] in
   def : Pat<(types[0] (vselect
               (types[1] V128:$c), (types[0] V128:$v1), (types[0] V128:$v2)
             )),
             (!cast<Instruction>("BITSELECT_"#types[0])
               V128:$v1, V128:$v2, V128:$c
             )>;
 
+// MVP select on v128 values
+foreach vec_t = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in {
+defm SELECT_#vec_t : I<(outs V128:$dst), (ins V128:$lhs, V128:$rhs, I32:$cond),
+                    (outs), (ins),
+                    [(set V128:$dst,
+                       (select I32:$cond,
+                         (vec_t V128:$lhs), (vec_t V128:$rhs)
+                       )
+                    )],
+                    "v128.select\t$dst, $lhs, $rhs, $cond",
+                    "v128.select", 0x1b>;
+
+// ISD::SELECT requires its operand to conform to getBooleanContents, but
+// WebAssembly's select interprets any non-zero value as true, so we can fold
+// a setne with 0 into a select.
+def : Pat<(select
+            (i32 (setne I32:$cond, 0)), (vec_t V128:$lhs), (vec_t V128:$rhs)
+          ),
+          (!cast<Instruction>("SELECT_"#vec_t)
+            V128:$lhs, V128:$rhs, I32:$cond
+          )>;
+
+// And again, this time with seteq instead of setne and the arms reversed.
+def : Pat<(select
+            (i32 (seteq I32:$cond, 0)), (vec_t V128:$lhs), (vec_t V128:$rhs)
+          ),
+          (!cast<Instruction>("SELECT_"#vec_t)
+            V128:$rhs, V128:$lhs, I32:$cond
+          )>;
+} // foreach vec_t
+
 //===----------------------------------------------------------------------===//
 // Integer unary arithmetic
 //===----------------------------------------------------------------------===//
 
 multiclass SIMDUnaryInt<SDNode node, string name, bits<32> baseInst> {
   defm "" : SIMDUnary<v16i8, "i8x16", node, name, baseInst>;
   defm "" : SIMDUnary<v8i16, "i16x8", node, name, !add(baseInst, 32)>;
   defm "" : SIMDUnary<v4i32, "i32x4", node, name, !add(baseInst, 64)>;

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

 }
 
 define <16 x i8> @select_v16i8(i1 zeroext %c, <16 x i8> %x, <16 x i8> %y) {
 ; CHECK-LABEL: select_v16i8:
 ; CHECK:         .functype select_v16i8 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i8x16.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <16 x i8> %x, <16 x i8> %y
   ret <16 x i8> %res
 }
 
 define <16 x i8> @select_cmp_v16i8(i32 %i, <16 x i8> %x, <16 x i8> %y) {
 ; CHECK-LABEL: select_cmp_v16i8:
 ; CHECK:         .functype select_cmp_v16i8 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.const 31
-; CHECK-NEXT:    i32.shr_s
-; CHECK-NEXT:    i8x16.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    i32.const 0
+; CHECK-NEXT:    i32.lt_s
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <16 x i8> %x, <16 x i8> %y
   ret <16 x i8> %res
 }
 
 define <16 x i8> @select_ne_v16i8(i32 %i, <16 x i8> %x, <16 x i8> %y) {
 ; CHECK-LABEL: select_ne_v16i8:
 ; CHECK:         .functype select_ne_v16i8 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i8x16.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <16 x i8> %x, <16 x i8> %y
   ret <16 x i8> %res
 }
 
 define <16 x i8> @select_eq_v16i8(i32 %i, <16 x i8> %x, <16 x i8> %y) {
 ; CHECK-LABEL: select_eq_v16i8:
 ; CHECK:         .functype select_eq_v16i8 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    i32.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i8x16.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <16 x i8> %x, <16 x i8> %y
   ret <16 x i8> %res
 }
 
 define <8 x i16> @vselect_v8i16(<8 x i1> %c, <8 x i16> %x, <8 x i16> %y) {
 ; CHECK-LABEL: vselect_v8i16:

 }
 
 define <8 x i16> @select_v8i16(i1 zeroext %c, <8 x i16> %x, <8 x i16> %y) {
 ; CHECK-LABEL: select_v8i16:
 ; CHECK:         .functype select_v8i16 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i16x8.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <8 x i16> %x, <8 x i16> %y
   ret <8 x i16> %res
 }
 
 define <8 x i16> @select_cmp_v8i16(i32 %i, <8 x i16> %x, <8 x i16> %y) {
 ; CHECK-LABEL: select_cmp_v8i16:
 ; CHECK:         .functype select_cmp_v8i16 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.const 31
-; CHECK-NEXT:    i32.shr_s
-; CHECK-NEXT:    i16x8.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    i32.const 0
+; CHECK-NEXT:    i32.lt_s
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <8 x i16> %x, <8 x i16> %y
   ret <8 x i16> %res
 }
 
 define <8 x i16> @select_ne_v8i16(i32 %i, <8 x i16> %x, <8 x i16> %y) {
 ; CHECK-LABEL: select_ne_v8i16:
 ; CHECK:         .functype select_ne_v8i16 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i16x8.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <8 x i16> %x, <8 x i16> %y
   ret <8 x i16> %res
 }
 
 define <8 x i16> @select_eq_v8i16(i32 %i, <8 x i16> %x, <8 x i16> %y) {
 ; CHECK-LABEL: select_eq_v8i16:
 ; CHECK:         .functype select_eq_v8i16 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    i32.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i16x8.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <8 x i16> %x, <8 x i16> %y
   ret <8 x i16> %res
 }
 
 define <4 x i32> @vselect_v4i32(<4 x i1> %c, <4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: vselect_v4i32:

 }
 
 define <4 x i32> @select_v4i32(i1 zeroext %c, <4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: select_v4i32:
 ; CHECK:         .functype select_v4i32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <4 x i32> %x, <4 x i32> %y
   ret <4 x i32> %res
 }
 
 define <4 x i32> @select_cmp_v4i32(i32 %i, <4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: select_cmp_v4i32:
 ; CHECK:         .functype select_cmp_v4i32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.const 31
-; CHECK-NEXT:    i32.shr_s
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    i32.const 0
+; CHECK-NEXT:    i32.lt_s
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <4 x i32> %x, <4 x i32> %y
   ret <4 x i32> %res
 }
 
 define <4 x i32> @select_ne_v4i32(i32 %i, <4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: select_ne_v4i32:
 ; CHECK:         .functype select_ne_v4i32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <4 x i32> %x, <4 x i32> %y
   ret <4 x i32> %res
 }
 
 define <4 x i32> @select_eq_v4i32(i32 %i, <4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: select_eq_v4i32:
 ; CHECK:         .functype select_eq_v4i32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    i32.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <4 x i32> %x, <4 x i32> %y
   ret <4 x i32> %res
 }
 
 define <2 x i64> @vselect_v2i64(<2 x i1> %c, <2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: vselect_v2i64:

 }
 
 define <2 x i64> @select_v2i64(i1 zeroext %c, <2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: select_v2i64:
 ; CHECK:         .functype select_v2i64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <2 x i64> %x, <2 x i64> %y
   ret <2 x i64> %res
 }
 
 define <2 x i64> @select_cmp_v2i64(i32 %i, <2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: select_cmp_v2i64:
 ; CHECK:         .functype select_cmp_v2i64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    i32.lt_s
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <2 x i64> %x, <2 x i64> %y
   ret <2 x i64> %res
 }
 
 define <2 x i64> @select_ne_v2i64(i32 %i, <2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: select_ne_v2i64:
 ; CHECK:         .functype select_ne_v2i64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <2 x i64> %x, <2 x i64> %y
   ret <2 x i64> %res
 }
 
 define <2 x i64> @select_eq_v2i64(i32 %i, <2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: select_eq_v2i64:
 ; CHECK:         .functype select_eq_v2i64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const 0
-; CHECK-NEXT:    i64.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <2 x i64> %x, <2 x i64> %y
   ret <2 x i64> %res
 }
 
 define <4 x float> @vselect_v4f32(<4 x i1> %c, <4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: vselect_v4f32:

 }
 
 define <4 x float> @select_v4f32(i1 zeroext %c, <4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: select_v4f32:
 ; CHECK:         .functype select_v4f32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <4 x float> %x, <4 x float> %y
   ret <4 x float> %res
 }
 
 define <4 x float> @select_cmp_v4f32(i32 %i, <4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: select_cmp_v4f32:
 ; CHECK:         .functype select_cmp_v4f32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.const 31
-; CHECK-NEXT:    i32.shr_s
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    i32.const 0
+; CHECK-NEXT:    i32.lt_s
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <4 x float> %x, <4 x float> %y
   ret <4 x float> %res
 }
 
 define <4 x float> @select_ne_v4f32(i32 %i, <4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: select_ne_v4f32:
 ; CHECK:         .functype select_ne_v4f32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const -1
-; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <4 x float> %x, <4 x float> %y
   ret <4 x float> %res
 }
 
 define <4 x float> @select_eq_v4f32(i32 %i, <4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: select_eq_v4f32:
 ; CHECK:         .functype select_eq_v4f32 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    i32.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.select
-; CHECK-NEXT:    i32x4.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <4 x float> %x, <4 x float> %y
   ret <4 x float> %res
 }
 
 define <2 x double> @vselect_v2f64(<2 x i1> %c, <2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: vselect_v2f64:

 }
 
 define <2 x double> @select_v2f64(i1 zeroext %c, <2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: select_v2f64:
 ; CHECK:         .functype select_v2f64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %res = select i1 %c, <2 x double> %x, <2 x double> %y
   ret <2 x double> %res
 }
 
 define <2 x double> @select_cmp_v2f64(i32 %i, <2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: select_cmp_v2f64:
 ; CHECK:         .functype select_cmp_v2f64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 0
 ; CHECK-NEXT:    i32.lt_s
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp slt i32 %i, 0
   %res = select i1 %c, <2 x double> %x, <2 x double> %y
   ret <2 x double> %res
 }
 
 define <2 x double> @select_ne_v2f64(i32 %i, <2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: select_ne_v2f64:
 ; CHECK:         .functype select_ne_v2f64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const -1
-; CHECK-NEXT:    i64.const 0
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp ne i32 %i, 0
   %res = select i1 %c, <2 x double> %x, <2 x double> %y
   ret <2 x double> %res
 }
 
 define <2 x double> @select_eq_v2f64(i32 %i, <2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: select_eq_v2f64:
 ; CHECK:         .functype select_eq_v2f64 (i32, v128, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i64.const 0
-; CHECK-NEXT:    i64.const -1
+; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i64.select
-; CHECK-NEXT:    i64x2.splat
-; CHECK-NEXT:    v128.bitselect
+; CHECK-NEXT:    v128.select
 ; CHECK-NEXT:    # fallthrough-return
   %c = icmp eq i32 %i, 0
   %res = select i1 %c, <2 x double> %x, <2 x double> %y
   ret <2 x double> %res
 }