// REQUIRES: systemz-registered-target
// RUN: %clang_cc1 -target-cpu z17 -triple s390x-linux-gnu \
// RUN: -O2 -fzvector -flax-vector-conversions=none \
// RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -target-cpu z17 -triple s390x-linux-gnu \
// RUN: -O2 -fzvector -flax-vector-conversions=none \
// RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM

#include <vecintrin.h>

volatile vector signed char vsc;
volatile vector signed short vss;
volatile vector signed int vsi;
volatile vector signed long long vsl;
volatile vector signed __int128 vslll;
volatile vector unsigned char vuc;
volatile vector unsigned short vus;
volatile vector unsigned int vui;
volatile vector unsigned long long vul;
volatile vector unsigned __int128 vulll;
volatile vector bool char vbc;
volatile vector bool short vbs;
volatile vector bool int vbi;
volatile vector bool long long vbl;
volatile vector bool __int128 vblll;
volatile vector float vf;
volatile vector double vd;

volatile int idx;
int cc;

void test_core(void) {
  // CHECK-ASM-LABEL: test_core

  vuc = vec_gen_element_masks_8(vus);
  // CHECK: call <16 x i8> @llvm.s390.vgemb(<8 x i16> %{{.*}})
  // CHECK-ASM: vgemb
  vus = vec_gen_element_masks_16(vuc);
  // CHECK: call <8 x i16> @llvm.s390.vgemh(<16 x i8> %{{.*}})
  // CHECK-ASM: vgemh
  vui = vec_gen_element_masks_32(vuc);
  // CHECK: call <4 x i32> @llvm.s390.vgemf(<16 x i8> %{{.*}})
  // CHECK-ASM: vgemf
  vul = vec_gen_element_masks_64(vuc);
  // CHECK: call <2 x i64> @llvm.s390.vgemg(<16 x i8> %{{.*}})
  // CHECK-ASM: vgemg
  vulll = vec_gen_element_masks_128(vuc);
  // CHECK: call i128 @llvm.s390.vgemq(<16 x i8> %{{.*}})
  // CHECK-ASM: vgemq

  vsc = vec_blend(vsc, vsc, vsc);
  // CHECK-ASM: vblendb
  vbc = vec_blend(vbc, vbc, vsc);
  // CHECK-ASM: vblendb
  vuc = vec_blend(vuc, vuc, vsc);
  // CHECK-ASM: vblendb
  vss = vec_blend(vss, vss, vss);
  // CHECK-ASM: vblendh
  vbs = vec_blend(vbs, vbs, vss);
  // CHECK-ASM: vblendh
  vus = vec_blend(vus, vus, vss);
  // CHECK-ASM: vblendh
  vsi = vec_blend(vsi, vsi, vsi);
  // CHECK-ASM: vblendf
  vbi = vec_blend(vbi, vbi, vsi);
  // CHECK-ASM: vblendf
  vui = vec_blend(vui, vui, vsi);
  // CHECK-ASM: vblendf
  vsl = vec_blend(vsl, vsl, vsl);
  // CHECK-ASM: vblendg
  vul = vec_blend(vul, vul, vsl);
  // CHECK-ASM: vblendg
  vbl = vec_blend(vbl, vbl, vsl);
  // CHECK-ASM: vblendg
  vslll = vec_blend(vslll, vslll, vslll);
  // CHECK-ASM: vblendq
  vblll = vec_blend(vblll, vblll, vslll);
  // CHECK-ASM: vblendq
  vulll = vec_blend(vulll, vulll, vslll);
  // CHECK-ASM: vblendq
  vf = vec_blend(vf, vf, vsi);
  // CHECK-ASM: vblendf
  vd = vec_blend(vd, vd, vsl);
  // CHECK-ASM: vblendg

  vslll = vec_unpackh(vsl);
  // CHECK: call i128 @llvm.s390.vuphg(<2 x i64> %{{.*}})
  // CHECK-ASM: vuphg
  vulll = vec_unpackh(vul);
  // CHECK: call i128 @llvm.s390.vuplhg(<2 x i64> %{{.*}})
  // CHECK-ASM: vuplhg
  vslll = vec_unpackl(vsl);
  // CHECK: call i128 @llvm.s390.vuplg(<2 x i64> %{{.*}})
  // CHECK-ASM: vuplg
  vulll = vec_unpackl(vul);
  // CHECK: call i128 @llvm.s390.vupllg(<2 x i64> %{{.*}})
  // CHECK-ASM: vupllg
}

void test_compare(void) {
  // CHECK-ASM-LABEL: test_compare

  vblll = vec_cmpeq(vslll, vslll);
  // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vceqq
  vblll = vec_cmpeq(vulll, vulll);
  // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vceqq
  vblll = vec_cmpeq(vblll, vblll);
  // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vceqq

  vblll = vec_cmpge(vslll, vslll);
  // CHECK: icmp sge <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchq
  vblll = vec_cmpge(vulll, vulll);
  // CHECK: icmp uge <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchlq

  vblll = vec_cmpgt(vslll, vslll);
  // CHECK: icmp sgt <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchq
  vblll = vec_cmpgt(vulll, vulll);
  // CHECK: icmp ugt <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchlq

  vblll = vec_cmple(vslll, vslll);
  // CHECK: icmp sle <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchq
  vblll = vec_cmple(vulll, vulll);
  // CHECK: icmp ule <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchlq

  vblll = vec_cmplt(vslll, vslll);
  // CHECK: icmp slt <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchq
  vblll = vec_cmplt(vulll, vulll);
  // CHECK: icmp ult <1 x i128> %{{.*}}, %{{.*}}
  // CHECK-ASM: vchlq

  idx = vec_all_eq(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_all_eq(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_all_eq(vblll, vblll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs

  idx = vec_all_ne(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_all_ne(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_all_ne(vblll, vblll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs

  idx = vec_all_ge(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_all_ge(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_all_gt(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_all_gt(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_all_le(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_all_le(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_all_lt(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_all_lt(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_any_eq(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_any_eq(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_any_eq(vblll, vblll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs

  idx = vec_any_ne(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_any_ne(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs
  idx = vec_any_ne(vblll, vblll);
  // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vceqqs

  idx = vec_any_ge(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_any_ge(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_any_gt(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_any_gt(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_any_le(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_any_le(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs

  idx = vec_any_lt(vslll, vslll);
  // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchqs
  idx = vec_any_lt(vulll, vulll);
  // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vchlqs
}

void test_integer(void) {
  // CHECK-ASM-LABEL: test_integer

  vulll = vec_cntlz(vulll);
  // CHECK: call range(i128 0, 129) i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
  // CHECK-ASM: vclzq
  vulll = vec_cnttz(vulll);
  // CHECK: call range(i128 0, 129) i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false)
  // CHECK-ASM: vctzq

  vslll = vec_abs(vslll);
  // CHECK-ASM: vlcq

  vslll = vec_avg(vslll, vslll);
  // CHECK: call i128 @llvm.s390.vavgq(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vavgq
  vulll = vec_avg(vulll, vulll);
  // CHECK: call i128 @llvm.s390.vavglq(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vavglq

  vsc = vec_evaluate(vsc, vsc, vsc, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vsc = vec_evaluate(vsc, vsc, vsc, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vuc = vec_evaluate(vuc, vuc, vuc, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vuc = vec_evaluate(vuc, vuc, vuc, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vbc = vec_evaluate(vbc, vbc, vbc, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vbc = vec_evaluate(vbc, vbc, vbc, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vss = vec_evaluate(vss, vss, vss, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vss = vec_evaluate(vss, vss, vss, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vus = vec_evaluate(vus, vus, vus, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vus = vec_evaluate(vus, vus, vus, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vbs = vec_evaluate(vbs, vbs, vbs, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vbs = vec_evaluate(vbs, vbs, vbs, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vsi = vec_evaluate(vsi, vsi, vsi, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vsi = vec_evaluate(vsi, vsi, vsi, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vui = vec_evaluate(vui, vui, vui, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vui = vec_evaluate(vui, vui, vui, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vbi = vec_evaluate(vbi, vbi, vbi, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vbi = vec_evaluate(vbi, vbi, vbi, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vsl = vec_evaluate(vsl, vsl, vsl, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vsl = vec_evaluate(vsl, vsl, vsl, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vul = vec_evaluate(vul, vul, vul, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vul = vec_evaluate(vul, vul, vul, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vbl = vec_evaluate(vbl, vbl, vbl, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vbl = vec_evaluate(vbl, vbl, vbl, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vslll = vec_evaluate(vslll, vslll, vslll, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vslll = vec_evaluate(vslll, vslll, vslll, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vulll = vec_evaluate(vulll, vulll, vulll, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vulll = vec_evaluate(vulll, vulll, vulll, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval
  vblll = vec_evaluate(vblll, vblll, vblll, 0);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
  // CHECK-ASM: veval
  vblll = vec_evaluate(vblll, vblll, vblll, 255);
  // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
  // CHECK-ASM: veval

  vslll = vec_max(vslll, vslll);
  // CHECK-ASM: vmxq
  vulll = vec_max(vulll, vulll);
  // CHECK-ASM: vmxlq
  vslll = vec_min(vslll, vslll);
  // CHECK-ASM: vmnq
  vulll = vec_min(vulll, vulll);
  // CHECK-ASM: vmnlq

  vsl = vec_mladd(vsl, vsl, vsl);
  // CHECK-ASM: vmalg
  vsl = vec_mladd(vul, vsl, vsl);
  // CHECK-ASM: vmalg
  vsl = vec_mladd(vsl, vul, vul);
  // CHECK-ASM: vmalg
  vul = vec_mladd(vul, vul, vul);
  // CHECK-ASM: vmalg
  vslll = vec_mladd(vslll, vslll, vslll);
  // CHECK-ASM: vmalq
  vslll = vec_mladd(vulll, vslll, vslll);
  // CHECK-ASM: vmalq
  vslll = vec_mladd(vslll, vulll, vulll);
  // CHECK-ASM: vmalq
  vulll = vec_mladd(vulll, vulll, vulll);
  // CHECK-ASM: vmalq

  vsl = vec_mhadd(vsl, vsl, vsl);
  // CHECK: call <2 x i64> @llvm.s390.vmahg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmahg
  vul = vec_mhadd(vul, vul, vul);
  // CHECK: call <2 x i64> @llvm.s390.vmalhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmalhg
  vslll = vec_mhadd(vslll, vslll, vslll);
  // CHECK: call i128 @llvm.s390.vmahq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmahq
  vulll = vec_mhadd(vulll, vulll, vulll);
  // CHECK: call i128 @llvm.s390.vmalhq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmalhq

  vslll = vec_meadd(vsl, vsl, vslll);
  // CHECK: call i128 @llvm.s390.vmaeg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmaeg
  vulll = vec_meadd(vul, vul, vulll);
  // CHECK: call i128 @llvm.s390.vmaleg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmaleg

  vslll = vec_moadd(vsl, vsl, vslll);
  // CHECK: call i128 @llvm.s390.vmaog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmaog
  vulll = vec_moadd(vul, vul, vulll);
  // CHECK: call i128 @llvm.s390.vmalog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmalog

  vsl = vec_mulh(vsl, vsl);
  // CHECK: call <2 x i64> @llvm.s390.vmhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmhg
  vul = vec_mulh(vul, vul);
  // CHECK: call <2 x i64> @llvm.s390.vmlhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmlhg
  vslll = vec_mulh(vslll, vslll);
  // CHECK: call i128 @llvm.s390.vmhq(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmhq
  vulll = vec_mulh(vulll, vulll);
  // CHECK: call i128 @llvm.s390.vmlhq(i128 %{{.*}}, i128 %{{.*}})
  // CHECK-ASM: vmlhq

  vslll = vec_mule(vsl, vsl);
  // CHECK: call i128 @llvm.s390.vmeg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmeg
  vulll = vec_mule(vul, vul);
  // CHECK: call i128 @llvm.s390.vmleg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmleg

  vslll = vec_mulo(vsl, vsl);
  // CHECK: call i128 @llvm.s390.vmog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmog
  vulll = vec_mulo(vul, vul);
  // CHECK: call i128 @llvm.s390.vmlog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
  // CHECK-ASM: vmlog
}