blob: f8e5aa3f40d50acd0d8a11a17bdb2f85e22f5ce8 [file] [log] [blame]
// REQUIRES: systemz-registered-target
// RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
// RUN: -O -fzvector -fno-lax-vector-conversions \
// RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
// RUN: -O -fzvector -fno-lax-vector-conversions \
// 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 unsigned char vuc;
volatile vector unsigned short vus;
volatile vector unsigned int vui;
volatile vector unsigned long long vul;
volatile vector bool char vbc;
volatile vector bool short vbs;
volatile vector bool int vbi;
volatile vector bool long long vbl;
volatile vector double vd;
volatile signed char sc;
volatile signed short ss;
volatile signed int si;
volatile signed long long sl;
volatile unsigned char uc;
volatile unsigned short us;
volatile unsigned int ui;
volatile unsigned long long ul;
volatile double d;
const void * volatile cptr;
const signed char * volatile cptrsc;
const signed short * volatile cptrss;
const signed int * volatile cptrsi;
const signed long long * volatile cptrsl;
const unsigned char * volatile cptruc;
const unsigned short * volatile cptrus;
const unsigned int * volatile cptrui;
const unsigned long long * volatile cptrul;
const float * volatile cptrf;
const double * volatile cptrd;
void * volatile ptr;
signed char * volatile ptrsc;
signed short * volatile ptrss;
signed int * volatile ptrsi;
signed long long * volatile ptrsl;
unsigned char * volatile ptruc;
unsigned short * volatile ptrus;
unsigned int * volatile ptrui;
unsigned long long * volatile ptrul;
float * volatile ptrf;
double * volatile ptrd;
volatile unsigned int len;
volatile int idx;
int cc;
void test_core(void) {
// CHECK-ASM-LABEL: test_core
len = __lcbb(cptr, 64);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 128);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 1)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 256);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 2)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 512);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 3)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 1024);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 4)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 2048);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 5)
// CHECK-ASM: lcbb
len = __lcbb(cptr, 4096);
// CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 6)
// CHECK-ASM: lcbb
sc = vec_extract(vsc, idx);
// CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvb
uc = vec_extract(vuc, idx);
// CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvb
uc = vec_extract(vbc, idx);
// CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvb
ss = vec_extract(vss, idx);
// CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvh
us = vec_extract(vus, idx);
// CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvh
us = vec_extract(vbs, idx);
// CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvh
si = vec_extract(vsi, idx);
// CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvf
ui = vec_extract(vui, idx);
// CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvf
ui = vec_extract(vbi, idx);
// CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvf
sl = vec_extract(vsl, idx);
// CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvg
ul = vec_extract(vul, idx);
// CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvg
ul = vec_extract(vbl, idx);
// CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvg
d = vec_extract(vd, idx);
// CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlgvg
vsc = vec_insert(sc, vsc, idx);
// CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgb
vuc = vec_insert(uc, vuc, idx);
// CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgb
vuc = vec_insert(uc, vbc, idx);
// CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgb
vss = vec_insert(ss, vss, idx);
// CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgh
vus = vec_insert(us, vus, idx);
// CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgh
vus = vec_insert(us, vbs, idx);
// CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgh
vsi = vec_insert(si, vsi, idx);
// CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgf
vui = vec_insert(ui, vui, idx);
// CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgf
vui = vec_insert(ui, vbi, idx);
// CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgf
vsl = vec_insert(sl, vsl, idx);
// CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vul = vec_insert(ul, vul, idx);
// CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vul = vec_insert(ul, vbl, idx);
// CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vd = vec_insert(d, vd, idx);
// CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vsc = vec_promote(sc, idx);
// CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgb
vuc = vec_promote(uc, idx);
// CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgb
vss = vec_promote(ss, idx);
// CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgh
vus = vec_promote(us, idx);
// CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgh
vsi = vec_promote(si, idx);
// CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgf
vui = vec_promote(ui, idx);
// CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgf
vsl = vec_promote(sl, idx);
// CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vul = vec_promote(ul, idx);
// CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vd = vec_promote(d, idx);
// CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
// CHECK-ASM: vlvgg
vsc = vec_insert_and_zero(cptrsc);
// CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7
// CHECK-ASM: vllezb
vuc = vec_insert_and_zero(cptruc);
// CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7
// CHECK-ASM: vllezb
vss = vec_insert_and_zero(cptrss);
// CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3
// CHECK-ASM: vllezh
vus = vec_insert_and_zero(cptrus);
// CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3
// CHECK-ASM: vllezh
vsi = vec_insert_and_zero(cptrsi);
// CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1
// CHECK-ASM: vllezf
vui = vec_insert_and_zero(cptrui);
// CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1
// CHECK-ASM: vllezf
vsl = vec_insert_and_zero(cptrsl);
// CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0
// CHECK-ASM: vllezg
vul = vec_insert_and_zero(cptrul);
// CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0
// CHECK-ASM: vllezg
vd = vec_insert_and_zero(cptrd);
// CHECK: insertelement <2 x double> <double undef, double 0.000000e+00>, double %{{.*}}, i32 0
// CHECK-ASM: vllezg
vsc = vec_perm(vsc, vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vuc = vec_perm(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vbc = vec_perm(vbc, vbc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vss = vec_perm(vss, vss, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vus = vec_perm(vus, vus, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vbs = vec_perm(vbs, vbs, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vsi = vec_perm(vsi, vsi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vui = vec_perm(vui, vui, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vbi = vec_perm(vbi, vbi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vsl = vec_perm(vsl, vsl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vul = vec_perm(vul, vul, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vbl = vec_perm(vbl, vbl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vd = vec_perm(vd, vd, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vperm
vsl = vec_permi(vsl, vsl, 0);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: vpdi
vsl = vec_permi(vsl, vsl, 1);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
// CHECK-ASM: vpdi
vsl = vec_permi(vsl, vsl, 2);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
// CHECK-ASM: vpdi
vsl = vec_permi(vsl, vsl, 3);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
// CHECK-ASM: vpdi
vul = vec_permi(vul, vul, 0);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: vpdi
vul = vec_permi(vul, vul, 1);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
// CHECK-ASM: vpdi
vul = vec_permi(vul, vul, 2);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
// CHECK-ASM: vpdi
vul = vec_permi(vul, vul, 3);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
// CHECK-ASM: vpdi
vbl = vec_permi(vbl, vbl, 0);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: vpdi
vbl = vec_permi(vbl, vbl, 1);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
// CHECK-ASM: vpdi
vbl = vec_permi(vbl, vbl, 2);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
// CHECK-ASM: vpdi
vbl = vec_permi(vbl, vbl, 3);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
// CHECK-ASM: vpdi
vd = vec_permi(vd, vd, 0);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: vpdi
vd = vec_permi(vd, vd, 1);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
// CHECK-ASM: vpdi
vd = vec_permi(vd, vd, 2);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
// CHECK-ASM: vpdi
vd = vec_permi(vd, vd, 3);
// CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
// CHECK-ASM: vpdi
vsc = vec_sel(vsc, vsc, vuc);
// CHECK-ASM: vsel
vsc = vec_sel(vsc, vsc, vbc);
// CHECK-ASM: vsel
vuc = vec_sel(vuc, vuc, vuc);
// CHECK-ASM: vsel
vuc = vec_sel(vuc, vuc, vbc);
// CHECK-ASM: vsel
vbc = vec_sel(vbc, vbc, vuc);
// CHECK-ASM: vsel
vbc = vec_sel(vbc, vbc, vbc);
// CHECK-ASM: vsel
vss = vec_sel(vss, vss, vus);
// CHECK-ASM: vsel
vss = vec_sel(vss, vss, vbs);
// CHECK-ASM: vsel
vus = vec_sel(vus, vus, vus);
// CHECK-ASM: vsel
vus = vec_sel(vus, vus, vbs);
// CHECK-ASM: vsel
vbs = vec_sel(vbs, vbs, vus);
// CHECK-ASM: vsel
vbs = vec_sel(vbs, vbs, vbs);
// CHECK-ASM: vsel
vsi = vec_sel(vsi, vsi, vui);
// CHECK-ASM: vsel
vsi = vec_sel(vsi, vsi, vbi);
// CHECK-ASM: vsel
vui = vec_sel(vui, vui, vui);
// CHECK-ASM: vsel
vui = vec_sel(vui, vui, vbi);
// CHECK-ASM: vsel
vbi = vec_sel(vbi, vbi, vui);
// CHECK-ASM: vsel
vbi = vec_sel(vbi, vbi, vbi);
// CHECK-ASM: vsel
vsl = vec_sel(vsl, vsl, vul);
// CHECK-ASM: vsel
vsl = vec_sel(vsl, vsl, vbl);
// CHECK-ASM: vsel
vul = vec_sel(vul, vul, vul);
// CHECK-ASM: vsel
vul = vec_sel(vul, vul, vbl);
// CHECK-ASM: vsel
vbl = vec_sel(vbl, vbl, vul);
// CHECK-ASM: vsel
vbl = vec_sel(vbl, vbl, vbl);
// CHECK-ASM: vsel
vd = vec_sel(vd, vd, vul);
// CHECK-ASM: vsel
vd = vec_sel(vd, vd, vbl);
// CHECK-ASM: vsel
vsi = vec_gather_element(vsi, vui, cptrsi, 0);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vsi = vec_gather_element(vsi, vui, cptrsi, 1);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vsi = vec_gather_element(vsi, vui, cptrsi, 2);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vsi = vec_gather_element(vsi, vui, cptrsi, 3);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vui = vec_gather_element(vui, vui, cptrui, 0);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vui = vec_gather_element(vui, vui, cptrui, 1);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vui = vec_gather_element(vui, vui, cptrui, 2);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vui = vec_gather_element(vui, vui, cptrui, 3);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vbi = vec_gather_element(vbi, vui, cptrui, 0);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vbi = vec_gather_element(vbi, vui, cptrui, 1);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vbi = vec_gather_element(vbi, vui, cptrui, 2);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vbi = vec_gather_element(vbi, vui, cptrui, 3);
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vsl = vec_gather_element(vsl, vul, cptrsl, 0);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vsl = vec_gather_element(vsl, vul, cptrsl, 1);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vul = vec_gather_element(vul, vul, cptrul, 0);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vul = vec_gather_element(vul, vul, cptrul, 1);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vbl = vec_gather_element(vbl, vul, cptrul, 0);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vbl = vec_gather_element(vbl, vul, cptrul, 1);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vd = vec_gather_element(vd, vul, cptrd, 0);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vd = vec_gather_element(vd, vul, cptrd, 1);
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vsi, vui, ptrsi, 0);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vsi, vui, ptrsi, 1);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vsi, vui, ptrsi, 2);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vec_scatter_element(vsi, vui, ptrsi, 3);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vec_scatter_element(vui, vui, ptrui, 0);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vui, vui, ptrui, 1);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vui, vui, ptrui, 2);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vec_scatter_element(vui, vui, ptrui, 3);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vec_scatter_element(vbi, vui, ptrui, 0);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vbi, vui, ptrui, 1);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vbi, vui, ptrui, 2);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vec_scatter_element(vbi, vui, ptrui, 3);
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vec_scatter_element(vsl, vul, ptrsl, 0);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vsl, vul, ptrsl, 1);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vul, vul, ptrul, 0);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vul, vul, ptrul, 1);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vbl, vul, ptrul, 0);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vbl, vul, ptrul, 1);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vd, vul, ptrd, 0);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vd, vul, ptrd, 1);
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vsc = vec_xl(idx, cptrsc);
// CHECK-ASM: vl
vuc = vec_xl(idx, cptruc);
// CHECK-ASM: vl
vss = vec_xl(idx, cptrss);
// CHECK-ASM: vl
vus = vec_xl(idx, cptrus);
// CHECK-ASM: vl
vsi = vec_xl(idx, cptrsi);
// CHECK-ASM: vl
vui = vec_xl(idx, cptrui);
// CHECK-ASM: vl
vsl = vec_xl(idx, cptrsl);
// CHECK-ASM: vl
vul = vec_xl(idx, cptrul);
// CHECK-ASM: vl
vd = vec_xl(idx, cptrd);
// CHECK-ASM: vl
vsc = vec_xld2(idx, cptrsc);
// CHECK-ASM: vl
vuc = vec_xld2(idx, cptruc);
// CHECK-ASM: vl
vss = vec_xld2(idx, cptrss);
// CHECK-ASM: vl
vus = vec_xld2(idx, cptrus);
// CHECK-ASM: vl
vsi = vec_xld2(idx, cptrsi);
// CHECK-ASM: vl
vui = vec_xld2(idx, cptrui);
// CHECK-ASM: vl
vsl = vec_xld2(idx, cptrsl);
// CHECK-ASM: vl
vul = vec_xld2(idx, cptrul);
// CHECK-ASM: vl
vd = vec_xld2(idx, cptrd);
// CHECK-ASM: vl
vsc = vec_xlw4(idx, cptrsc);
// CHECK-ASM: vl
vuc = vec_xlw4(idx, cptruc);
// CHECK-ASM: vl
vss = vec_xlw4(idx, cptrss);
// CHECK-ASM: vl
vus = vec_xlw4(idx, cptrus);
// CHECK-ASM: vl
vsi = vec_xlw4(idx, cptrsi);
// CHECK-ASM: vl
vui = vec_xlw4(idx, cptrui);
// CHECK-ASM: vl
vec_xst(vsc, idx, ptrsc);
// CHECK-ASM: vst
vec_xst(vuc, idx, ptruc);
// CHECK-ASM: vst
vec_xst(vss, idx, ptrss);
// CHECK-ASM: vst
vec_xst(vus, idx, ptrus);
// CHECK-ASM: vst
vec_xst(vsi, idx, ptrsi);
// CHECK-ASM: vst
vec_xst(vui, idx, ptrui);
// CHECK-ASM: vst
vec_xst(vsl, idx, ptrsl);
// CHECK-ASM: vst
vec_xst(vul, idx, ptrul);
// CHECK-ASM: vst
vec_xst(vd, idx, ptrd);
// CHECK-ASM: vst
vec_xstd2(vsc, idx, ptrsc);
// CHECK-ASM: vst
vec_xstd2(vuc, idx, ptruc);
// CHECK-ASM: vst
vec_xstd2(vss, idx, ptrss);
// CHECK-ASM: vst
vec_xstd2(vus, idx, ptrus);
// CHECK-ASM: vst
vec_xstd2(vsi, idx, ptrsi);
// CHECK-ASM: vst
vec_xstd2(vui, idx, ptrui);
// CHECK-ASM: vst
vec_xstd2(vsl, idx, ptrsl);
// CHECK-ASM: vst
vec_xstd2(vul, idx, ptrul);
// CHECK-ASM: vst
vec_xstd2(vd, idx, ptrd);
// CHECK-ASM: vst
vec_xstw4(vsc, idx, ptrsc);
// CHECK-ASM: vst
vec_xstw4(vuc, idx, ptruc);
// CHECK-ASM: vst
vec_xstw4(vss, idx, ptrss);
// CHECK-ASM: vst
vec_xstw4(vus, idx, ptrus);
// CHECK-ASM: vst
vec_xstw4(vsi, idx, ptrsi);
// CHECK-ASM: vst
vec_xstw4(vui, idx, ptrui);
// CHECK-ASM: vst
vsc = vec_load_bndry(cptrsc, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vuc = vec_load_bndry(cptruc, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vss = vec_load_bndry(cptrss, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vus = vec_load_bndry(cptrus, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vsi = vec_load_bndry(cptrsi, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vui = vec_load_bndry(cptrui, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vsl = vec_load_bndry(cptrsl, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vul = vec_load_bndry(cptrul, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vd = vec_load_bndry(cptrd, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 128);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 256);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 512);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 1024);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 2048);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5)
// CHECK-ASM: vlbb
vsc = vec_load_bndry(cptrsc, 4096);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6)
// CHECK-ASM: vlbb
vsc = vec_load_len(cptrsc, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vuc = vec_load_len(cptruc, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vss = vec_load_len(cptrss, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vus = vec_load_len(cptrus, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vsi = vec_load_len(cptrsi, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vui = vec_load_len(cptrui, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vsl = vec_load_len(cptrsl, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vul = vec_load_len(cptrul, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vd = vec_load_len(cptrd, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vll
vec_store_len(vsc, ptrsc, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vuc, ptruc, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vss, ptrss, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vus, ptrus, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vsi, ptrsi, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vui, ptrui, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vsl, ptrsl, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vul, ptrul, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vec_store_len(vd, ptrd, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
// CHECK-ASM: vstl
vsl = vec_load_pair(sl + 1, sl - 1);
// CHECK-ASM: vlvgp
vul = vec_load_pair(ul + 1, ul - 1);
// CHECK-ASM: vlvgp
vuc = vec_genmask(0);
// CHECK: <16 x i8> zeroinitializer
vuc = vec_genmask(0x8000);
// CHECK: <16 x i8> <i8 -1, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>
vuc = vec_genmask(0xffff);
// CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
vuc = vec_genmasks_8(0, 7);
// CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
vuc = vec_genmasks_8(1, 4);
// CHECK: <16 x i8> <i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120>
vuc = vec_genmasks_8(6, 2);
// CHECK: <16 x i8> <i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29>
vus = vec_genmasks_16(0, 15);
// CHECK: <8 x i16> <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
vus = vec_genmasks_16(2, 11);
// CHECK: <8 x i16> <i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368>
vus = vec_genmasks_16(9, 2);
// CHECK: <8 x i16> <i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065>
vui = vec_genmasks_32(0, 31);
// CHECK: <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>
vui = vec_genmasks_32(7, 20);
// CHECK: <4 x i32> <i32 33552384, i32 33552384, i32 33552384, i32 33552384>
vui = vec_genmasks_32(25, 4);
// CHECK: <4 x i32> <i32 -134217601, i32 -134217601, i32 -134217601, i32 -134217601>
vul = vec_genmasks_64(0, 63);
// CHECK: <2 x i64> <i64 -1, i64 -1>
vul = vec_genmasks_64(3, 40);
// CHECK: <2 x i64> <i64 2305843009205305344, i64 2305843009205305344>
vul = vec_genmasks_64(30, 11);
// CHECK: <2 x i64> <i64 -4503582447501313, i64 -4503582447501313>
vsc = vec_splat(vsc, 0);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
// CHECK-ASM: vrepb
vsc = vec_splat(vsc, 15);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
// CHECK-ASM: vrepb
vuc = vec_splat(vuc, 0);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
// CHECK-ASM: vrepb
vuc = vec_splat(vuc, 15);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
// CHECK-ASM: vrepb
vbc = vec_splat(vbc, 0);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
// CHECK-ASM: vrepb
vbc = vec_splat(vbc, 15);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
// CHECK-ASM: vrepb
vss = vec_splat(vss, 0);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
// CHECK-ASM: vreph
vss = vec_splat(vss, 7);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
// CHECK-ASM: vreph
vus = vec_splat(vus, 0);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
// CHECK-ASM: vreph
vus = vec_splat(vus, 7);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
// CHECK-ASM: vreph
vbs = vec_splat(vbs, 0);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
// CHECK-ASM: vreph
vbs = vec_splat(vbs, 7);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
// CHECK-ASM: vreph
vsi = vec_splat(vsi, 0);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
// CHECK-ASM: vrepf
vsi = vec_splat(vsi, 3);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
// CHECK-ASM: vrepf
vui = vec_splat(vui, 0);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
// CHECK-ASM: vrepf
vui = vec_splat(vui, 3);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
// CHECK-ASM: vrepf
vbi = vec_splat(vbi, 0);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
// CHECK-ASM: vrepf
vbi = vec_splat(vbi, 3);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
// CHECK-ASM: vrepf
vsl = vec_splat(vsl, 0);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vrepg
vsl = vec_splat(vsl, 1);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
// CHECK-ASM: vrepg
vul = vec_splat(vul, 0);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vrepg
vul = vec_splat(vul, 1);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
// CHECK-ASM: vrepg
vbl = vec_splat(vbl, 0);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vrepg
vbl = vec_splat(vbl, 1);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
// CHECK-ASM: vrepg
vd = vec_splat(vd, 0);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vrepg
vd = vec_splat(vd, 1);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
// CHECK-ASM: vrepg
vsc = vec_splat_s8(-128);
// CHECK: <16 x i8> <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
vsc = vec_splat_s8(127);
// CHECK: <16 x i8> <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
vuc = vec_splat_u8(1);
// CHECK: <16 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
vuc = vec_splat_u8(254);
// CHECK: <16 x i8> <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2>
vss = vec_splat_s16(-32768);
// CHECK: <8 x i16> <i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768>
vss = vec_splat_s16(32767);
// CHECK: <8 x i16> <i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767>
vus = vec_splat_u16(1);
// CHECK: <8 x i16> <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
vus = vec_splat_u16(65534);
// CHECK: <8 x i16> <i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2>
vsi = vec_splat_s32(-32768);
// CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
vsi = vec_splat_s32(32767);
// CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
vui = vec_splat_u32(-32768);
// CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
vui = vec_splat_u32(32767);
// CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
vsl = vec_splat_s64(-32768);
// CHECK: <2 x i64> <i64 -32768, i64 -32768>
vsl = vec_splat_s64(32767);
// CHECK: <2 x i64> <i64 32767, i64 32767>
vul = vec_splat_u64(-32768);
// CHECK: <2 x i64> <i64 -32768, i64 -32768>
vul = vec_splat_u64(32767);
// CHECK: <2 x i64> <i64 32767, i64 32767>
vsc = vec_splats(sc);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
// CHECK-ASM: vlrepb
vuc = vec_splats(uc);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
// CHECK-ASM: vlrepb
vss = vec_splats(ss);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
// CHECK-ASM: vlreph
vus = vec_splats(us);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
// CHECK-ASM: vlreph
vsi = vec_splats(si);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
// CHECK-ASM: vlrepf
vui = vec_splats(ui);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
// CHECK-ASM: vlrepf
vsl = vec_splats(sl);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vlrepg
vul = vec_splats(ul);
// CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vlrepg
vd = vec_splats(d);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
// CHECK-ASM: vlrepg
vsl = vec_extend_s64(vsc);
// CHECK-ASM: vsegb
vsl = vec_extend_s64(vss);
// CHECK-ASM: vsegh
vsl = vec_extend_s64(vsi);
// CHECK-ASM: vsegf
vsc = vec_mergeh(vsc, vsc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
// CHECK-ASM: vmrhb
vuc = vec_mergeh(vuc, vuc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
// CHECK-ASM: vmrhb
vbc = vec_mergeh(vbc, vbc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
// CHECK-ASM: vmrhb
vss = vec_mergeh(vss, vss);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
// CHECK-ASM: vmrhh
vus = vec_mergeh(vus, vus);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
// CHECK-ASM: vmrhh
vbs = vec_mergeh(vbs, vbs);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
// CHECK-ASM: vmrhh
vsi = vec_mergeh(vsi, vsi);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
// CHECK-ASM: vmrhf
vui = vec_mergeh(vui, vui);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
// CHECK-ASM: vmrhf
vbi = vec_mergeh(vbi, vbi);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
// CHECK-ASM: vmrhf
vsl = vec_mergeh(vsl, vsl);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
// CHECK-ASM: vmrhg
vul = vec_mergeh(vul, vul);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
// CHECK-ASM: vmrhg
vbl = vec_mergeh(vbl, vbl);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
// CHECK-ASM: vmrhg
vd = vec_mergeh(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
// CHECK-ASM: vmrhg
vsc = vec_mergel(vsc, vsc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
// CHECK-ASM: vmrlb
vuc = vec_mergel(vuc, vuc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
// CHECK-ASM: vmrlb
vbc = vec_mergel(vbc, vbc);
// shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
// CHECK-ASM: vmrlb
vss = vec_mergel(vss, vss);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
// CHECK-ASM: vmrlh
vus = vec_mergel(vus, vus);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
// CHECK-ASM: vmrlh
vbs = vec_mergel(vbs, vbs);
// shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
// CHECK-ASM: vmrlh
vsi = vec_mergel(vsi, vsi);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
// CHECK-ASM: vmrlf
vui = vec_mergel(vui, vui);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
// CHECK-ASM: vmrlf
vbi = vec_mergel(vbi, vbi);
// shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
// CHECK-ASM: vmrlf
vsl = vec_mergel(vsl, vsl);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
// CHECK-ASM: vmrlg
vul = vec_mergel(vul, vul);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
// CHECK-ASM: vmrlg
vbl = vec_mergel(vbl, vbl);
// shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
// CHECK-ASM: vmrlg
vd = vec_mergel(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
// CHECK-ASM: vmrlg
vsc = vec_pack(vss, vss);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
// CHECK-ASM: vpkh
vuc = vec_pack(vus, vus);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
// CHECK-ASM: vpkh
vbc = vec_pack(vbs, vbs);
// CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
// CHECK-ASM: vpkh
vss = vec_pack(vsi, vsi);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
// CHECK-ASM: vpkf
vus = vec_pack(vui, vui);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
// CHECK-ASM: vpkf
vbs = vec_pack(vbi, vbi);
// CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
// CHECK-ASM: vpkf
vsi = vec_pack(vsl, vsl);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
// CHECK-ASM: vpkg
vui = vec_pack(vul, vul);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
// CHECK-ASM: vpkg
vbi = vec_pack(vbl, vbl);
// CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
// CHECK-ASM: vpkg
vsc = vec_packs(vss, vss);
// CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpksh
vuc = vec_packs(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpklsh
vss = vec_packs(vsi, vsi);
// CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpksf
vus = vec_packs(vui, vui);
// CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpklsf
vsi = vec_packs(vsl, vsl);
// CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpksg
vui = vec_packs(vul, vul);
// CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpklsg
vsc = vec_packs_cc(vss, vss, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vpkshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpkshs
vuc = vec_packs_cc(vus, vus, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpklshs
vss = vec_packs_cc(vsi, vsi, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vpksfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpksfs
vus = vec_packs_cc(vui, vui, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpklsfs
vsi = vec_packs_cc(vsl, vsl, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vpksgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpksgs
vui = vec_packs_cc(vul, vul, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpklsgs
vuc = vec_packsu(vss, vss);
// CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpklsh
vuc = vec_packsu(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpklsh
vus = vec_packsu(vsi, vsi);
// CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpklsf
vus = vec_packsu(vui, vui);
// CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpklsf
vui = vec_packsu(vsl, vsl);
// CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpklsg
vui = vec_packsu(vul, vul);
// CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpklsg
vuc = vec_packsu_cc(vus, vus, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vpklshs
vus = vec_packsu_cc(vui, vui, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vpklsfs
vui = vec_packsu_cc(vul, vul, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vpklsgs
vss = vec_unpackh(vsc);
// CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
// CHECK-ASM: vuphb
vus = vec_unpackh(vuc);
// CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}})
// CHECK-ASM: vuplhb
vbs = vec_unpackh(vbc);
// CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
// CHECK-ASM: vuphb
vsi = vec_unpackh(vss);
// CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
// CHECK-ASM: vuphh
vui = vec_unpackh(vus);
// CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}})
// CHECK-ASM: vuplhh
vbi = vec_unpackh(vbs);
// CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
// CHECK-ASM: vuphh
vsl = vec_unpackh(vsi);
// CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
// CHECK-ASM: vuphf
vul = vec_unpackh(vui);
// CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}})
// CHECK-ASM: vuplhf
vbl = vec_unpackh(vbi);
// CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
// CHECK-ASM: vuphf
vss = vec_unpackl(vsc);
// CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
// CHECK-ASM: vuplb
vus = vec_unpackl(vuc);
// CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}})
// CHECK-ASM: vupllb
vbs = vec_unpackl(vbc);
// CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
// CHECK-ASM: vuplb
vsi = vec_unpackl(vss);
// CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
// CHECK-ASM: vuplhw
vui = vec_unpackl(vus);
// CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}})
// CHECK-ASM: vupllh
vbi = vec_unpackl(vbs);
// CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
// CHECK-ASM: vuplhw
vsl = vec_unpackl(vsi);
// CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
// CHECK-ASM: vuplf
vul = vec_unpackl(vui);
// CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}})
// CHECK-ASM: vupllf
vbl = vec_unpackl(vbi);
// CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
// CHECK-ASM: vuplf
}
void test_compare(void) {
// CHECK-ASM-LABEL: test_compare
vbc = vec_cmpeq(vsc, vsc);
// CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqb
vbc = vec_cmpeq(vuc, vuc);
// CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqb
vbc = vec_cmpeq(vbc, vbc);
// CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqb
vbs = vec_cmpeq(vss, vss);
// CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqh
vbs = vec_cmpeq(vus, vus);
// CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqh
vbs = vec_cmpeq(vbs, vbs);
// CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqh
vbi = vec_cmpeq(vsi, vsi);
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqf
vbi = vec_cmpeq(vui, vui);
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqf
vbi = vec_cmpeq(vbi, vbi);
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqf
vbl = vec_cmpeq(vsl, vsl);
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqg
vbl = vec_cmpeq(vul, vul);
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqg
vbl = vec_cmpeq(vbl, vbl);
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vceqg
vbl = vec_cmpeq(vd, vd);
// CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
// CHECK-ASM: vfcedb
vbc = vec_cmpge(vsc, vsc);
// CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchb
vbc = vec_cmpge(vuc, vuc);
// CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlb
vbs = vec_cmpge(vss, vss);
// CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchh
vbs = vec_cmpge(vus, vus);
// CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlh
vbi = vec_cmpge(vsi, vsi);
// CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchf
vbi = vec_cmpge(vui, vui);
// CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlf
vbl = vec_cmpge(vsl, vsl);
// CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchg
vbl = vec_cmpge(vul, vul);
// CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlg
vbl = vec_cmpge(vd, vd);
// CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
// CHECK-ASM: vfchedb
vbc = vec_cmpgt(vsc, vsc);
// CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchb
vbc = vec_cmpgt(vuc, vuc);
// CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlb
vbs = vec_cmpgt(vss, vss);
// CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchh
vbs = vec_cmpgt(vus, vus);
// CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlh
vbi = vec_cmpgt(vsi, vsi);
// CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchf
vbi = vec_cmpgt(vui, vui);
// CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlf
vbl = vec_cmpgt(vsl, vsl);
// CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchg
vbl = vec_cmpgt(vul, vul);
// CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlg
vbl = vec_cmpgt(vd, vd);
// CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
// CHECK-ASM: vfchdb
vbc = vec_cmple(vsc, vsc);
// CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchb
vbc = vec_cmple(vuc, vuc);
// CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlb
vbs = vec_cmple(vss, vss);
// CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchh
vbs = vec_cmple(vus, vus);
// CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlh
vbi = vec_cmple(vsi, vsi);
// CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchf
vbi = vec_cmple(vui, vui);
// CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlf
vbl = vec_cmple(vsl, vsl);
// CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchg
vbl = vec_cmple(vul, vul);
// CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlg
vbl = vec_cmple(vd, vd);
// CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
// CHECK-ASM: vfchedb
vbc = vec_cmplt(vsc, vsc);
// CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchb
vbc = vec_cmplt(vuc, vuc);
// CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlb
vbs = vec_cmplt(vss, vss);
// CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchh
vbs = vec_cmplt(vus, vus);
// CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlh
vbi = vec_cmplt(vsi, vsi);
// CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchf
vbi = vec_cmplt(vui, vui);
// CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlf
vbl = vec_cmplt(vsl, vsl);
// CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchg
vbl = vec_cmplt(vul, vul);
// CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
// CHECK-ASM: vchlg
vbl = vec_cmplt(vd, vd);
// CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
// CHECK-ASM: vfchdb
idx = vec_all_eq(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_eq(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_eq(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_eq(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_eq(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfcedbs
idx = vec_all_ne(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_all_ne(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_all_ne(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_all_ne(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_all_ne(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfcedbs
idx = vec_all_ge(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_ge(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_ge(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_ge(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_ge(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_ge(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_ge(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_ge(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_ge(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_ge(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_ge(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_ge(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_ge(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_ge(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_ge(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_ge(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_ge(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_ge(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_ge(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_ge(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_ge(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_ge(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_ge(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_ge(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_ge(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_ge(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_ge(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_ge(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_ge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_all_gt(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_gt(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_gt(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_gt(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_gt(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_gt(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_gt(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_gt(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_gt(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_gt(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_gt(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_gt(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_gt(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_gt(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_gt(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_gt(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_gt(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_gt(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_gt(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_gt(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_gt(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_gt(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_gt(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_gt(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_gt(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_gt(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_gt(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_gt(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_gt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_all_le(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_le(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_le(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_le(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_le(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_le(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_le(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_le(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_le(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_le(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_le(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_le(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_le(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_le(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_le(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_le(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_le(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_le(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_le(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_le(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_le(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_le(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_le(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_le(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_le(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_le(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_le(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_le(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_le(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_all_lt(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_lt(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_lt(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_all_lt(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_lt(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_lt(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_lt(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_all_lt(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_lt(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_lt(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_all_lt(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_lt(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_lt(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_lt(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_all_lt(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_lt(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_lt(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_all_lt(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_lt(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_lt(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_lt(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_all_lt(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_lt(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_lt(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_all_lt(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_lt(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_lt(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_lt(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_all_lt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_all_nge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_all_ngt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_all_nle(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_all_nlt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_all_nan(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
// CHECK-ASM: vftcidb
idx = vec_all_numeric(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
// CHECK-ASM: vftcidb
idx = vec_any_eq(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_eq(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_eq(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_eq(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_eq(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfcedbs
idx = vec_any_ne(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vceqbs
idx = vec_any_ne(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vceqhs
idx = vec_any_ne(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vceqfs
idx = vec_any_ne(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vceqgs
idx = vec_any_ne(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfcedbs
idx = vec_any_ge(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_ge(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_ge(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_ge(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_ge(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_ge(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_ge(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_ge(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_ge(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_ge(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_ge(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_ge(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_ge(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_ge(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_ge(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_ge(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_ge(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_ge(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_ge(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_ge(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_ge(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_ge(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_ge(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_ge(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_ge(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_ge(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_ge(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_ge(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_ge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_any_gt(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_gt(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_gt(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_gt(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_gt(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_gt(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_gt(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_gt(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_gt(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_gt(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_gt(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_gt(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_gt(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_gt(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_gt(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_gt(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_gt(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_gt(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_gt(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_gt(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_gt(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_gt(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_gt(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_gt(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_gt(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_gt(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_gt(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_gt(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_gt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_any_le(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_le(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_le(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_le(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_le(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_le(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_le(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_le(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_le(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_le(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_le(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_le(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_le(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_le(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_le(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_le(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_le(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_le(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_le(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_le(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_le(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_le(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_le(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_le(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_le(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_le(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_le(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_le(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_le(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_any_lt(vsc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_lt(vsc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_lt(vbc, vsc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchbs
idx = vec_any_lt(vuc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_lt(vuc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_lt(vbc, vuc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_lt(vbc, vbc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vchlbs
idx = vec_any_lt(vss, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_lt(vss, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_lt(vbs, vss);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchhs
idx = vec_any_lt(vus, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_lt(vus, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_lt(vbs, vus);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_lt(vbs, vbs);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: vchlhs
idx = vec_any_lt(vsi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_lt(vsi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_lt(vbi, vsi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchfs
idx = vec_any_lt(vui, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_lt(vui, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_lt(vbi, vui);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_lt(vbi, vbi);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: vchlfs
idx = vec_any_lt(vsl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_lt(vsl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_lt(vbl, vsl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchgs
idx = vec_any_lt(vul, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_lt(vul, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_lt(vbl, vul);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_lt(vbl, vbl);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: vchlgs
idx = vec_any_lt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_any_nge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_any_ngt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_any_nle(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchedbs
idx = vec_any_nlt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK-ASM: vfchdbs
idx = vec_any_nan(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
// CHECK-ASM: vftcidb
idx = vec_any_numeric(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
// CHECK-ASM: vftcidb
}
void test_integer(void) {
// CHECK-ASM-LABEL: test_integer
vsc = vec_andc(vsc, vsc);
// CHECK-ASM: vnc
vsc = vec_andc(vsc, vbc);
// CHECK-ASM: vnc
vsc = vec_andc(vbc, vsc);
// CHECK-ASM: vnc
vuc = vec_andc(vuc, vuc);
// CHECK-ASM: vnc
vuc = vec_andc(vuc, vbc);
// CHECK-ASM: vnc
vuc = vec_andc(vbc, vuc);
// CHECK-ASM: vnc
vbc = vec_andc(vbc, vbc);
// CHECK-ASM: vnc
vss = vec_andc(vss, vss);
// CHECK-ASM: vnc
vss = vec_andc(vss, vbs);
// CHECK-ASM: vnc
vss = vec_andc(vbs, vss);
// CHECK-ASM: vnc
vus = vec_andc(vus, vus);
// CHECK-ASM: vnc
vus = vec_andc(vus, vbs);
// CHECK-ASM: vnc
vus = vec_andc(vbs, vus);
// CHECK-ASM: vnc
vbs = vec_andc(vbs, vbs);
// CHECK-ASM: vnc
vsi = vec_andc(vsi, vsi);
// CHECK-ASM: vnc
vsi = vec_andc(vsi, vbi);
// CHECK-ASM: vnc
vsi = vec_andc(vbi, vsi);
// CHECK-ASM: vnc
vui = vec_andc(vui, vui);
// CHECK-ASM: vnc
vui = vec_andc(vui, vbi);
// CHECK-ASM: vnc
vui = vec_andc(vbi, vui);
// CHECK-ASM: vnc
vbi = vec_andc(vbi, vbi);
// CHECK-ASM: vnc
vsl = vec_andc(vsl, vsl);
// CHECK-ASM: vnc
vsl = vec_andc(vsl, vbl);
// CHECK-ASM: vnc
vsl = vec_andc(vbl, vsl);
// CHECK-ASM: vnc
vul = vec_andc(vul, vul);
// CHECK-ASM: vnc
vul = vec_andc(vul, vbl);
// CHECK-ASM: vnc
vul = vec_andc(vbl, vul);
// CHECK-ASM: vnc
vbl = vec_andc(vbl, vbl);
// CHECK-ASM: vnc
vd = vec_andc(vd, vd);
// CHECK-ASM: vnc
vd = vec_andc(vd, vbl);
// CHECK-ASM: vnc
vd = vec_andc(vbl, vd);
// CHECK-ASM: vnc
vsc = vec_nor(vsc, vsc);
// CHECK-ASM: vno
vsc = vec_nor(vsc, vbc);
// CHECK-ASM: vno
vsc = vec_nor(vbc, vsc);
// CHECK-ASM: vno
vuc = vec_nor(vuc, vuc);
// CHECK-ASM: vno
vuc = vec_nor(vuc, vbc);
// CHECK-ASM: vno
vuc = vec_nor(vbc, vuc);
// CHECK-ASM: vno
vbc = vec_nor(vbc, vbc);
// CHECK-ASM: vno
vss = vec_nor(vss, vss);
// CHECK-ASM: vno
vss = vec_nor(vss, vbs);
// CHECK-ASM: vno
vss = vec_nor(vbs, vss);
// CHECK-ASM: vno
vus = vec_nor(vus, vus);
// CHECK-ASM: vno
vus = vec_nor(vus, vbs);
// CHECK-ASM: vno
vus = vec_nor(vbs, vus);
// CHECK-ASM: vno
vbs = vec_nor(vbs, vbs);
// CHECK-ASM: vno
vsi = vec_nor(vsi, vsi);
// CHECK-ASM: vno
vsi = vec_nor(vsi, vbi);
// CHECK-ASM: vno
vsi = vec_nor(vbi, vsi);
// CHECK-ASM: vno
vui = vec_nor(vui, vui);
// CHECK-ASM: vno
vui = vec_nor(vui, vbi);
// CHECK-ASM: vno
vui = vec_nor(vbi, vui);
// CHECK-ASM: vno
vbi = vec_nor(vbi, vbi);
// CHECK-ASM: vno
vsl = vec_nor(vsl, vsl);
// CHECK-ASM: vno
vsl = vec_nor(vsl, vbl);
// CHECK-ASM: vno
vsl = vec_nor(vbl, vsl);
// CHECK-ASM: vno
vul = vec_nor(vul, vul);
// CHECK-ASM: vno
vul = vec_nor(vul, vbl);
// CHECK-ASM: vno
vul = vec_nor(vbl, vul);
// CHECK-ASM: vno
vbl = vec_nor(vbl, vbl);
// CHECK-ASM: vno
vd = vec_nor(vd, vd);
// CHECK-ASM: vno
vd = vec_nor(vd, vbl);
// CHECK-ASM: vno
vd = vec_nor(vbl, vd);
// CHECK-ASM: vno
vuc = vec_cntlz(vsc);
// CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
// CHECK-ASM: vclzb
vuc = vec_cntlz(vuc);
// CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
// CHECK-ASM: vclzb
vus = vec_cntlz(vss);
// CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
// CHECK-ASM: vclzh
vus = vec_cntlz(vus);
// CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
// CHECK-ASM: vclzh
vui = vec_cntlz(vsi);
// CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
// CHECK-ASM: vclzf
vui = vec_cntlz(vui);
// CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
// CHECK-ASM: vclzf
vul = vec_cntlz(vsl);
// CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
// CHECK-ASM: vclzg
vul = vec_cntlz(vul);
// CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
// CHECK-ASM: vclzg
vuc = vec_cnttz(vsc);
// CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
// CHECK-ASM: vctzb
vuc = vec_cnttz(vuc);
// CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
// CHECK-ASM: vctzb
vus = vec_cnttz(vss);
// CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
// CHECK-ASM: vctzh
vus = vec_cnttz(vus);
// CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
// CHECK-ASM: vctzh
vui = vec_cnttz(vsi);
// CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
// CHECK-ASM: vctzf
vui = vec_cnttz(vui);
// CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
// CHECK-ASM: vctzf
vul = vec_cnttz(vsl);
// CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
// CHECK-ASM: vctzg
vul = vec_cnttz(vul);
// CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
// CHECK-ASM: vctzg
vuc = vec_popcnt(vsc);
// CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
// CHECK-ASM: vpopct
vuc = vec_popcnt(vuc);
// CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
// CHECK-ASM: vpopct
vus = vec_popcnt(vss);
// CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
// (emulated)
vus = vec_popcnt(vus);
// CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
// (emulated)
vui = vec_popcnt(vsi);
// CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
// (emulated)
vui = vec_popcnt(vui);
// CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
// (emulated)
vul = vec_popcnt(vsl);
// CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
// (emulated)
vul = vec_popcnt(vul);
// CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
// (emulated)
vsc = vec_rl(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: verllvb
vuc = vec_rl(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: verllvb
vss = vec_rl(vss, vus);
// CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: verllvh
vus = vec_rl(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
// CHECK-ASM: verllvh
vsi = vec_rl(vsi, vui);
// CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: verllvf
vui = vec_rl(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
// CHECK-ASM: verllvf
vsl = vec_rl(vsl, vul);
// CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: verllvg
vul = vec_rl(vul, vul);
// CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
// CHECK-ASM: verllvg
vsc = vec_rli(vsc, ul);
// CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllb
vuc = vec_rli(vuc, ul);
// CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllb
vss = vec_rli(vss, ul);
// CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllh
vus = vec_rli(vus, ul);
// CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllh
vsi = vec_rli(vsi, ul);
// CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllf
vui = vec_rli(vui, ul);
// CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllf
vsl = vec_rli(vsl, ul);
// CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllg
vul = vec_rli(vul, ul);
// CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
// CHECK-ASM: verllg
vsc = vec_rl_mask(vsc, vuc, 0);
// CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
// CHECK-ASM: verimb
vsc = vec_rl_mask(vsc, vuc, 255);
// CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
// CHECK-ASM: verimb
vuc = vec_rl_mask(vuc, vuc, 0);
// CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
// CHECK-ASM: verimb
vuc = vec_rl_mask(vuc, vuc, 255);
// CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
// CHECK-ASM: verimb
vss = vec_rl_mask(vss, vus, 0);
// CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
// CHECK-ASM: verimh
vss = vec_rl_mask(vss, vus, 255);
// CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
// CHECK-ASM: verimh
vus = vec_rl_mask(vus, vus, 0);
// CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
// CHECK-ASM: verimh
vus = vec_rl_mask(vus, vus, 255);
// CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
// CHECK-ASM: verimh
vsi = vec_rl_mask(vsi, vui, 0);
// CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
// CHECK-ASM: verimf
vsi = vec_rl_mask(vsi, vui, 255);
// CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
// CHECK-ASM: verimf
vui = vec_rl_mask(vui, vui, 0);
// CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
// CHECK-ASM: verimf
vui = vec_rl_mask(vui, vui, 255);
// CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
// CHECK-ASM: verimf
vsl = vec_rl_mask(vsl, vul, 0);
// CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: verimg
vsl = vec_rl_mask(vsl, vul, 255);
// CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
// CHECK-ASM: verimg
vul = vec_rl_mask(vul, vul, 0);
// CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
// CHECK-ASM: verimg
vul = vec_rl_mask(vul, vul, 255);
// CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
// CHECK-ASM: verimg
vsc = vec_sll(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsc = vec_sll(vsc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsc = vec_sll(vsc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vuc = vec_sll(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vuc = vec_sll(vuc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vuc = vec_sll(vuc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbc = vec_sll(vbc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbc = vec_sll(vbc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbc = vec_sll(vbc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vss = vec_sll(vss, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vss = vec_sll(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vss = vec_sll(vss, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vus = vec_sll(vus, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vus = vec_sll(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vus = vec_sll(vus, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbs = vec_sll(vbs, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbs = vec_sll(vbs, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbs = vec_sll(vbs, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsi = vec_sll(vsi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsi = vec_sll(vsi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsi = vec_sll(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vui = vec_sll(vui, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vui = vec_sll(vui, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vui = vec_sll(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbi = vec_sll(vbi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbi = vec_sll(vbi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbi = vec_sll(vbi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsl = vec_sll(vsl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsl = vec_sll(vsl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsl = vec_sll(vsl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vul = vec_sll(vul, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vul = vec_sll(vul, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vul = vec_sll(vul, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbl = vec_sll(vbl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbl = vec_sll(vbl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vbl = vec_sll(vbl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vsl
vsc = vec_slb(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vsc = vec_slb(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vuc = vec_slb(vuc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vuc = vec_slb(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vss = vec_slb(vss, vss);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vss = vec_slb(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vus = vec_slb(vus, vss);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vus = vec_slb(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vsi = vec_slb(vsi, vsi);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vsi = vec_slb(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
// CHECK-ASM: vslb
vui = vec_slb(vui, vsi);