llvm/test/CodeGen/WebAssembly/simd-min-vec-reg-32.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6
; RUN: opt < %s -passes=slp-vectorizer -S -mtriple=wasm32-unknown-unknown -mattr=+simd128 | llc --mtriple=wasm32-unknown-unknown -mattr=+simd128 -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s

; Test that SLP vectorizer can vectorize consecutive sub-128-bit operations
; into SIMD when getMinVectorRegisterBitWidth is overriden to 32.

target triple = "wasm32-unknown-unknown"

define void @add_2xi32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_2xi32:
; CHECK:         .functype add_2xi32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($0):p2align=2
; CHECK-NEXT:    v128.load64_zero $push0=, 0($1):p2align=2
; CHECK-NEXT:    i32x4.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i32, ptr %a
  %a1p = getelementptr i32, ptr %a, i32 1
  %a1 = load i32, ptr %a1p
  %b0 = load i32, ptr %b
  %b1p = getelementptr i32, ptr %b, i32 1
  %b1 = load i32, ptr %b1p
  %r0 = add i32 %a0, %b0
  %r1 = add i32 %a1, %b1
  store i32 %r0, ptr %out
  %o1 = getelementptr i32, ptr %out, i32 1
  store i32 %r1, ptr %o1
  ret void
}

define void @add_4xi16(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_4xi16:
; CHECK:         .functype add_4xi16 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($0):p2align=1
; CHECK-NEXT:    v128.load64_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i16x8.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=1, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %a2p = getelementptr i16, ptr %a, i32 2
  %a2 = load i16, ptr %a2p
  %a3p = getelementptr i16, ptr %a, i32 3
  %a3 = load i16, ptr %a3p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %b2p = getelementptr i16, ptr %b, i32 2
  %b2 = load i16, ptr %b2p
  %b3p = getelementptr i16, ptr %b, i32 3
  %b3 = load i16, ptr %b3p
  %r0 = add i16 %a0, %b0
  %r1 = add i16 %a1, %b1
  %r2 = add i16 %a2, %b2
  %r3 = add i16 %a3, %b3
  store i16 %r0, ptr %out
  %o1 = getelementptr i16, ptr %out, i32 1
  store i16 %r1, ptr %o1
  %o2 = getelementptr i16, ptr %out, i32 2
  store i16 %r2, ptr %o2
  %o3 = getelementptr i16, ptr %out, i32 3
  store i16 %r3, ptr %o3
  ret void
}

define void @add_8xi8(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_8xi8:
; CHECK:         .functype add_8xi8 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($0):p2align=0
; CHECK-NEXT:    v128.load64_zero $push0=, 0($1):p2align=0
; CHECK-NEXT:    i8x16.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=0, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i8, ptr %a
  %a1p = getelementptr i8, ptr %a, i32 1
  %a1 = load i8, ptr %a1p
  %a2p = getelementptr i8, ptr %a, i32 2
  %a2 = load i8, ptr %a2p
  %a3p = getelementptr i8, ptr %a, i32 3
  %a3 = load i8, ptr %a3p
  %a4p = getelementptr i8, ptr %a, i32 4
  %a4 = load i8, ptr %a4p
  %a5p = getelementptr i8, ptr %a, i32 5
  %a5 = load i8, ptr %a5p
  %a6p = getelementptr i8, ptr %a, i32 6
  %a6 = load i8, ptr %a6p
  %a7p = getelementptr i8, ptr %a, i32 7
  %a7 = load i8, ptr %a7p
  %b0 = load i8, ptr %b
  %b1p = getelementptr i8, ptr %b, i32 1
  %b1 = load i8, ptr %b1p
  %b2p = getelementptr i8, ptr %b, i32 2
  %b2 = load i8, ptr %b2p
  %b3p = getelementptr i8, ptr %b, i32 3
  %b3 = load i8, ptr %b3p
  %b4p = getelementptr i8, ptr %b, i32 4
  %b4 = load i8, ptr %b4p
  %b5p = getelementptr i8, ptr %b, i32 5
  %b5 = load i8, ptr %b5p
  %b6p = getelementptr i8, ptr %b, i32 6
  %b6 = load i8, ptr %b6p
  %b7p = getelementptr i8, ptr %b, i32 7
  %b7 = load i8, ptr %b7p
  %r0 = add i8 %a0, %b0
  %r1 = add i8 %a1, %b1
  %r2 = add i8 %a2, %b2
  %r3 = add i8 %a3, %b3
  %r4 = add i8 %a4, %b4
  %r5 = add i8 %a5, %b5
  %r6 = add i8 %a6, %b6
  %r7 = add i8 %a7, %b7
  store i8 %r0, ptr %out
  %o1 = getelementptr i8, ptr %out, i32 1
  store i8 %r1, ptr %o1
  %o2 = getelementptr i8, ptr %out, i32 2
  store i8 %r2, ptr %o2
  %o3 = getelementptr i8, ptr %out, i32 3
  store i8 %r3, ptr %o3
  %o4 = getelementptr i8, ptr %out, i32 4
  store i8 %r4, ptr %o4
  %o5 = getelementptr i8, ptr %out, i32 5
  store i8 %r5, ptr %o5
  %o6 = getelementptr i8, ptr %out, i32 6
  store i8 %r6, ptr %o6
  %o7 = getelementptr i8, ptr %out, i32 7
  store i8 %r7, ptr %o7
  ret void
}

define void @add_2xf32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_2xf32:
; CHECK:         .functype add_2xf32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($0):p2align=2
; CHECK-NEXT:    v128.load64_zero $push0=, 0($1):p2align=2
; CHECK-NEXT:    f32x4.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load float, ptr %a
  %a1p = getelementptr float, ptr %a, i32 1
  %a1 = load float, ptr %a1p
  %b0 = load float, ptr %b
  %b1p = getelementptr float, ptr %b, i32 1
  %b1 = load float, ptr %b1p
  %r0 = fadd float %a0, %b0
  %r1 = fadd float %a1, %b1
  store float %r0, ptr %out
  %o1 = getelementptr float, ptr %out, i32 1
  store float %r1, ptr %o1
  ret void
}

define void @add_2xi16(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_2xi16:
; CHECK:         .functype add_2xi16 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=1
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i16x8.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store32_lane 0($2):p2align=1, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %r0 = add i16 %a0, %b0
  %r1 = add i16 %a1, %b1
  store i16 %r0, ptr %out
  %o1 = getelementptr i16, ptr %out, i32 1
  store i16 %r1, ptr %o1
  ret void
}

define void @add_4xi8(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: add_4xi8:
; CHECK:         .functype add_4xi8 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=0
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=0
; CHECK-NEXT:    i8x16.add $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store32_lane 0($2):p2align=0, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i8, ptr %a
  %a1p = getelementptr i8, ptr %a, i32 1
  %a1 = load i8, ptr %a1p
  %a2p = getelementptr i8, ptr %a, i32 2
  %a2 = load i8, ptr %a2p
  %a3p = getelementptr i8, ptr %a, i32 3
  %a3 = load i8, ptr %a3p
  %b0 = load i8, ptr %b
  %b1p = getelementptr i8, ptr %b, i32 1
  %b1 = load i8, ptr %b1p
  %b2p = getelementptr i8, ptr %b, i32 2
  %b2 = load i8, ptr %b2p
  %b3p = getelementptr i8, ptr %b, i32 3
  %b3 = load i8, ptr %b3p
  %r0 = add i8 %a0, %b0
  %r1 = add i8 %a1, %b1
  %r2 = add i8 %a2, %b2
  %r3 = add i8 %a3, %b3
  store i8 %r0, ptr %out
  %o1 = getelementptr i8, ptr %out, i32 1
  store i8 %r1, ptr %o1
  %o2 = getelementptr i8, ptr %out, i32 2
  store i8 %r2, ptr %o2
  %o3 = getelementptr i8, ptr %out, i32 3
  store i8 %r3, ptr %o3
  ret void
}

define void @sext_add_2xi16_to_i32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: sext_add_2xi16_to_i32:
; CHECK:         .functype sext_add_2xi16_to_i32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push2=, 0($0):p2align=1
; CHECK-NEXT:    i32x4.extend_low_i16x8_s $push3=, $pop2
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i32x4.extend_low_i16x8_s $push1=, $pop0
; CHECK-NEXT:    i32x4.add $push4=, $pop3, $pop1
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop4, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %ea0 = sext i16 %a0 to i32
  %ea1 = sext i16 %a1 to i32
  %eb0 = sext i16 %b0 to i32
  %eb1 = sext i16 %b1 to i32
  %r0 = add i32 %ea0, %eb0
  %r1 = add i32 %ea1, %eb1
  store i32 %r0, ptr %out
  %o1 = getelementptr i32, ptr %out, i32 1
  store i32 %r1, ptr %o1
  ret void
}

define void @and_2xi32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: and_2xi32:
; CHECK:         .functype and_2xi32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    i64.load $push1=, 0($0):p2align=2
; CHECK-NEXT:    i64.load $push0=, 0($1):p2align=2
; CHECK-NEXT:    i64.and $push2=, $pop1, $pop0
; CHECK-NEXT:    i64.store 0($2):p2align=2, $pop2
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i32, ptr %a
  %a1p = getelementptr i32, ptr %a, i32 1
  %a1 = load i32, ptr %a1p
  %b0 = load i32, ptr %b
  %b1p = getelementptr i32, ptr %b, i32 1
  %b1 = load i32, ptr %b1p
  %r0 = and i32 %a0, %b0
  %r1 = and i32 %a1, %b1
  store i32 %r0, ptr %out
  %o1 = getelementptr i32, ptr %out, i32 1
  store i32 %r1, ptr %o1
  ret void
}

define void @eq_2xi32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: eq_2xi32:
; CHECK:         .functype eq_2xi32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($0):p2align=2
; CHECK-NEXT:    v128.load64_zero $push0=, 0($1):p2align=2
; CHECK-NEXT:    i32x4.eq $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i32, ptr %a
  %a1p = getelementptr i32, ptr %a, i32 1
  %a1 = load i32, ptr %a1p
  %b0 = load i32, ptr %b
  %b1p = getelementptr i32, ptr %b, i32 1
  %b1 = load i32, ptr %b1p
  %c0 = icmp eq i32 %a0, %b0
  %c1 = icmp eq i32 %a1, %b1
  %r0 = sext i1 %c0 to i32
  %r1 = sext i1 %c1 to i32
  store i32 %r0, ptr %out
  %o1 = getelementptr i32, ptr %out, i32 1
  store i32 %r1, ptr %o1
  ret void
}

define void @neg_2xf32(ptr %a, ptr %out) {
; CHECK-LABEL: neg_2xf32:
; CHECK:         .functype neg_2xf32 (i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push0=, 0($0):p2align=2
; CHECK-NEXT:    f32x4.neg $push1=, $pop0
; CHECK-NEXT:    v128.store64_lane 0($1):p2align=2, $pop1, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load float, ptr %a
  %a1p = getelementptr float, ptr %a, i32 1
  %a1 = load float, ptr %a1p
  %r0 = fneg float %a0
  %r1 = fneg float %a1
  store float %r0, ptr %out
  %o1 = getelementptr float, ptr %out, i32 1
  store float %r1, ptr %o1
  ret void
}

define void @min_2xf32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: min_2xf32:
; CHECK:         .functype min_2xf32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load64_zero $push1=, 0($1):p2align=2
; CHECK-NEXT:    v128.load64_zero $push0=, 0($0):p2align=2
; CHECK-NEXT:    f32x4.pmin $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load float, ptr %a
  %a1p = getelementptr float, ptr %a, i32 1
  %a1 = load float, ptr %a1p
  %b0 = load float, ptr %b
  %b1p = getelementptr float, ptr %b, i32 1
  %b1 = load float, ptr %b1p
  %c0 = fcmp olt float %a0, %b0
  %c1 = fcmp olt float %a1, %b1
  %r0 = select i1 %c0, float %a0, float %b0
  %r1 = select i1 %c1, float %a1, float %b1
  store float %r0, ptr %out
  %o1 = getelementptr float, ptr %out, i32 1
  store float %r1, ptr %o1
  ret void
}

; Widening multiply: v128.load32_zero + i32x4.extmul_low_i16x8_s
define void @extmul_2xi16_to_i32(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: extmul_2xi16_to_i32:
; CHECK:         .functype extmul_2xi16_to_i32 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=1
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i32x4.extmul_low_i16x8_s $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store64_lane 0($2):p2align=2, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %ea0 = sext i16 %a0 to i32
  %ea1 = sext i16 %a1 to i32
  %eb0 = sext i16 %b0 to i32
  %eb1 = sext i16 %b1 to i32
  %r0 = mul i32 %ea0, %eb0
  %r1 = mul i32 %ea1, %eb1
  store i32 %r0, ptr %out
  %o1 = getelementptr i32, ptr %out, i32 1
  store i32 %r1, ptr %o1
  ret void
}

define void @sub_2xi16(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: sub_2xi16:
; CHECK:         .functype sub_2xi16 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=1
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i16x8.sub $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store32_lane 0($2):p2align=1, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %r0 = sub i16 %a0, %b0
  %r1 = sub i16 %a1, %b1
  store i16 %r0, ptr %out
  %o1 = getelementptr i16, ptr %out, i32 1
  store i16 %r1, ptr %o1
  ret void
}

define void @and_2xi16(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: and_2xi16:
; CHECK:         .functype and_2xi16 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    i32.load $push1=, 0($0):p2align=1
; CHECK-NEXT:    i32.load $push0=, 0($1):p2align=1
; CHECK-NEXT:    i32.and $push2=, $pop1, $pop0
; CHECK-NEXT:    i32.store 0($2):p2align=1, $pop2
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %r0 = and i16 %a0, %b0
  %r1 = and i16 %a1, %b1
  store i16 %r0, ptr %out
  %o1 = getelementptr i16, ptr %out, i32 1
  store i16 %r1, ptr %o1
  ret void
}

define void @or_4xi8(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: or_4xi8:
; CHECK:         .functype or_4xi8 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    i32.load $push1=, 0($0):p2align=0
; CHECK-NEXT:    i32.load $push0=, 0($1):p2align=0
; CHECK-NEXT:    i32.or $push2=, $pop1, $pop0
; CHECK-NEXT:    i32.store 0($2):p2align=0, $pop2
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i8, ptr %a
  %a1p = getelementptr i8, ptr %a, i32 1
  %a1 = load i8, ptr %a1p
  %a2p = getelementptr i8, ptr %a, i32 2
  %a2 = load i8, ptr %a2p
  %a3p = getelementptr i8, ptr %a, i32 3
  %a3 = load i8, ptr %a3p
  %b0 = load i8, ptr %b
  %b1p = getelementptr i8, ptr %b, i32 1
  %b1 = load i8, ptr %b1p
  %b2p = getelementptr i8, ptr %b, i32 2
  %b2 = load i8, ptr %b2p
  %b3p = getelementptr i8, ptr %b, i32 3
  %b3 = load i8, ptr %b3p
  %r0 = or i8 %a0, %b0
  %r1 = or i8 %a1, %b1
  %r2 = or i8 %a2, %b2
  %r3 = or i8 %a3, %b3
  store i8 %r0, ptr %out
  %o1 = getelementptr i8, ptr %out, i32 1
  store i8 %r1, ptr %o1
  %o2 = getelementptr i8, ptr %out, i32 2
  store i8 %r2, ptr %o2
  %o3 = getelementptr i8, ptr %out, i32 3
  store i8 %r3, ptr %o3
  ret void
}

define void @sub_4xi8(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: sub_4xi8:
; CHECK:         .functype sub_4xi8 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=0
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=0
; CHECK-NEXT:    i8x16.sub $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store32_lane 0($2):p2align=0, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i8, ptr %a
  %a1p = getelementptr i8, ptr %a, i32 1
  %a1 = load i8, ptr %a1p
  %a2p = getelementptr i8, ptr %a, i32 2
  %a2 = load i8, ptr %a2p
  %a3p = getelementptr i8, ptr %a, i32 3
  %a3 = load i8, ptr %a3p
  %b0 = load i8, ptr %b
  %b1p = getelementptr i8, ptr %b, i32 1
  %b1 = load i8, ptr %b1p
  %b2p = getelementptr i8, ptr %b, i32 2
  %b2 = load i8, ptr %b2p
  %b3p = getelementptr i8, ptr %b, i32 3
  %b3 = load i8, ptr %b3p
  %r0 = sub i8 %a0, %b0
  %r1 = sub i8 %a1, %b1
  %r2 = sub i8 %a2, %b2
  %r3 = sub i8 %a3, %b3
  store i8 %r0, ptr %out
  %o1 = getelementptr i8, ptr %out, i32 1
  store i8 %r1, ptr %o1
  %o2 = getelementptr i8, ptr %out, i32 2
  store i8 %r2, ptr %o2
  %o3 = getelementptr i8, ptr %out, i32 3
  store i8 %r3, ptr %o3
  ret void
}

define void @eq_2xi16(ptr %a, ptr %b, ptr %out) {
; CHECK-LABEL: eq_2xi16:
; CHECK:         .functype eq_2xi16 (i32, i32, i32) -> ()
; CHECK-NEXT:  # %bb.0:
; CHECK-NEXT:    v128.load32_zero $push1=, 0($0):p2align=1
; CHECK-NEXT:    v128.load32_zero $push0=, 0($1):p2align=1
; CHECK-NEXT:    i16x8.eq $push2=, $pop1, $pop0
; CHECK-NEXT:    v128.store32_lane 0($2):p2align=1, $pop2, 0
; CHECK-NEXT:    # fallthrough-return
  %a0 = load i16, ptr %a
  %a1p = getelementptr i16, ptr %a, i32 1
  %a1 = load i16, ptr %a1p
  %b0 = load i16, ptr %b
  %b1p = getelementptr i16, ptr %b, i32 1
  %b1 = load i16, ptr %b1p
  %c0 = icmp eq i16 %a0, %b0
  %c1 = icmp eq i16 %a1, %b1
  %r0 = sext i1 %c0 to i16
  %r1 = sext i1 %c1 to i16
  store i16 %r0, ptr %out
  %o1 = getelementptr i16, ptr %out, i32 1
  store i16 %r1, ptr %o1
  ret void
}