r349753 - [SystemZ] Improve testing of vecintrin.h intrinsics
Ulrich Weigand via cfe-commits
cfe-commits at lists.llvm.org
Thu Dec 20 05:10:47 PST 2018
Author: uweigand
Date: Thu Dec 20 05:10:47 2018
New Revision: 349753
URL: http://llvm.org/viewvc/llvm-project?rev=349753&view=rev
Log:
[SystemZ] Improve testing of vecintrin.h intrinsics
This adds assembly-level tests to verify that the high-level
intrinsics generate the instructions they're supposed to.
These tests would have caught the codegen bugs I just fixed.
Modified:
cfe/trunk/test/CodeGen/builtins-systemz-zvector.c
cfe/trunk/test/CodeGen/builtins-systemz-zvector2.c
Modified: cfe/trunk/test/CodeGen/builtins-systemz-zvector.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/builtins-systemz-zvector.c?rev=349753&r1=349752&r2=349753&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/builtins-systemz-zvector.c (original)
+++ cfe/trunk/test/CodeGen/builtins-systemz-zvector.c Thu Dec 20 05:10:47 2018
@@ -2,6 +2,9 @@
// 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>
@@ -58,367 +61,598 @@ 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, sl);
- vul = vec_load_pair(ul, ul);
+ 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
@@ -454,56 +688,82 @@ void test_core(void) {
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>
@@ -540,2516 +800,3781 @@ void test_core(void) {
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);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vui = vec_slb(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vsl = vec_slb(vsl, vsl);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vsl = vec_slb(vsl, vul);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vul = vec_slb(vul, vsl);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vul = vec_slb(vul, vul);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vd = vec_slb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vd = vec_slb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vsc = vec_sld(vsc, vsc, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsc = vec_sld(vsc, vsc, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vuc = vec_sld(vuc, vuc, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vuc = vec_sld(vuc, vuc, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vbc = vec_sld(vbc, vbc, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vbc = vec_sld(vbc, vbc, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vss = vec_sld(vss, vss, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vss = vec_sld(vss, vss, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vus = vec_sld(vus, vus, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vus = vec_sld(vus, vus, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vbs = vec_sld(vbs, vbs, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vbs = vec_sld(vbs, vbs, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vsi = vec_sld(vsi, vsi, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsi = vec_sld(vsi, vsi, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vui = vec_sld(vui, vui, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vui = vec_sld(vui, vui, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vbi = vec_sld(vbi, vbi, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vbi = vec_sld(vbi, vbi, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vsl = vec_sld(vsl, vsl, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsl = vec_sld(vsl, vsl, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vul = vec_sld(vul, vul, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vul = vec_sld(vul, vul, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vbl = vec_sld(vbl, vbl, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vbl = vec_sld(vbl, vbl, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vd = vec_sld(vd, vd, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vd = vec_sld(vd, vd, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vsc = vec_sldw(vsc, vsc, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsc = vec_sldw(vsc, vsc, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vuc = vec_sldw(vuc, vuc, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vuc = vec_sldw(vuc, vuc, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vss = vec_sldw(vss, vss, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vss = vec_sldw(vss, vss, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vus = vec_sldw(vus, vus, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vus = vec_sldw(vus, vus, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vsi = vec_sldw(vsi, vsi, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsi = vec_sldw(vsi, vsi, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vui = vec_sldw(vui, vui, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vui = vec_sldw(vui, vui, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vsl = vec_sldw(vsl, vsl, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vsl = vec_sldw(vsl, vsl, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vul = vec_sldw(vul, vul, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vul = vec_sldw(vul, vul, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vd = vec_sldw(vd, vd, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vd = vec_sldw(vd, vd, 3);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vsldb
vsc = vec_sral(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsc = vec_sral(vsc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsc = vec_sral(vsc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vuc = vec_sral(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vuc = vec_sral(vuc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vuc = vec_sral(vuc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbc = vec_sral(vbc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbc = vec_sral(vbc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbc = vec_sral(vbc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vss = vec_sral(vss, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vss = vec_sral(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vss = vec_sral(vss, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vus = vec_sral(vus, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vus = vec_sral(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vus = vec_sral(vus, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbs = vec_sral(vbs, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbs = vec_sral(vbs, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbs = vec_sral(vbs, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsi = vec_sral(vsi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsi = vec_sral(vsi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsi = vec_sral(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vui = vec_sral(vui, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vui = vec_sral(vui, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vui = vec_sral(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbi = vec_sral(vbi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbi = vec_sral(vbi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbi = vec_sral(vbi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsl = vec_sral(vsl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsl = vec_sral(vsl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsl = vec_sral(vsl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vul = vec_sral(vul, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vul = vec_sral(vul, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vul = vec_sral(vul, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbl = vec_sral(vbl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbl = vec_sral(vbl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vbl = vec_sral(vbl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsra
vsc = vec_srab(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsc = vec_srab(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vuc = vec_srab(vuc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vuc = vec_srab(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vss = vec_srab(vss, vss);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vss = vec_srab(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vus = vec_srab(vus, vss);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vus = vec_srab(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsi = vec_srab(vsi, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsi = vec_srab(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vui = vec_srab(vui, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vui = vec_srab(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsl = vec_srab(vsl, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsl = vec_srab(vsl, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vul = vec_srab(vul, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vul = vec_srab(vul, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vd = vec_srab(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vd = vec_srab(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vsc = vec_srl(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsc = vec_srl(vsc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsc = vec_srl(vsc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vuc = vec_srl(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vuc = vec_srl(vuc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vuc = vec_srl(vuc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbc = vec_srl(vbc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbc = vec_srl(vbc, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbc = vec_srl(vbc, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vss = vec_srl(vss, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vss = vec_srl(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vss = vec_srl(vss, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vus = vec_srl(vus, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vus = vec_srl(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vus = vec_srl(vus, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbs = vec_srl(vbs, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbs = vec_srl(vbs, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbs = vec_srl(vbs, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsi = vec_srl(vsi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsi = vec_srl(vsi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsi = vec_srl(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vui = vec_srl(vui, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vui = vec_srl(vui, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vui = vec_srl(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbi = vec_srl(vbi, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbi = vec_srl(vbi, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbi = vec_srl(vbi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsl = vec_srl(vsl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsl = vec_srl(vsl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsl = vec_srl(vsl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vul = vec_srl(vul, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vul = vec_srl(vul, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vul = vec_srl(vul, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbl = vec_srl(vbl, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbl = vec_srl(vbl, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vbl = vec_srl(vbl, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrl
vsc = vec_srb(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsc = vec_srb(vsc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vuc = vec_srb(vuc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vuc = vec_srb(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vss = vec_srb(vss, vss);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vss = vec_srb(vss, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vus = vec_srb(vus, vss);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vus = vec_srb(vus, vus);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsi = vec_srb(vsi, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsi = vec_srb(vsi, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vui = vec_srb(vui, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vui = vec_srb(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsl = vec_srb(vsl, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsl = vec_srb(vsl, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vul = vec_srb(vul, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vul = vec_srb(vul, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vd = vec_srb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vd = vec_srb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vsc = vec_abs(vsc);
+ // CHECK-ASM: vlpb
vss = vec_abs(vss);
+ // CHECK-ASM: vlph
vsi = vec_abs(vsi);
+ // CHECK-ASM: vlpf
vsl = vec_abs(vsl);
+ // CHECK-ASM: vlpg
vsc = vec_max(vsc, vsc);
+ // CHECK-ASM: vmxb
vsc = vec_max(vsc, vbc);
+ // CHECK-ASM: vmxb
vsc = vec_max(vbc, vsc);
+ // CHECK-ASM: vmxb
vuc = vec_max(vuc, vuc);
+ // CHECK-ASM: vmxlb
vuc = vec_max(vuc, vbc);
+ // CHECK-ASM: vmxlb
vuc = vec_max(vbc, vuc);
+ // CHECK-ASM: vmxlb
vss = vec_max(vss, vss);
+ // CHECK-ASM: vmxh
vss = vec_max(vss, vbs);
+ // CHECK-ASM: vmxh
vss = vec_max(vbs, vss);
+ // CHECK-ASM: vmxh
vus = vec_max(vus, vus);
+ // CHECK-ASM: vmxlh
vus = vec_max(vus, vbs);
+ // CHECK-ASM: vmxlh
vus = vec_max(vbs, vus);
+ // CHECK-ASM: vmxlh
vsi = vec_max(vsi, vsi);
+ // CHECK-ASM: vmxf
vsi = vec_max(vsi, vbi);
+ // CHECK-ASM: vmxf
vsi = vec_max(vbi, vsi);
+ // CHECK-ASM: vmxf
vui = vec_max(vui, vui);
+ // CHECK-ASM: vmxlf
vui = vec_max(vui, vbi);
+ // CHECK-ASM: vmxlf
vui = vec_max(vbi, vui);
+ // CHECK-ASM: vmxlf
vsl = vec_max(vsl, vsl);
+ // CHECK-ASM: vmxg
vsl = vec_max(vsl, vbl);
+ // CHECK-ASM: vmxg
vsl = vec_max(vbl, vsl);
+ // CHECK-ASM: vmxg
vul = vec_max(vul, vul);
+ // CHECK-ASM: vmxlg
vul = vec_max(vul, vbl);
+ // CHECK-ASM: vmxlg
vul = vec_max(vbl, vul);
+ // CHECK-ASM: vmxlg
vd = vec_max(vd, vd);
+ // (emulated)
vsc = vec_min(vsc, vsc);
+ // CHECK-ASM: vmnb
vsc = vec_min(vsc, vbc);
+ // CHECK-ASM: vmnb
vsc = vec_min(vbc, vsc);
+ // CHECK-ASM: vmnb
vuc = vec_min(vuc, vuc);
+ // CHECK-ASM: vmnlb
vuc = vec_min(vuc, vbc);
+ // CHECK-ASM: vmnlb
vuc = vec_min(vbc, vuc);
+ // CHECK-ASM: vmnlb
vss = vec_min(vss, vss);
+ // CHECK-ASM: vmnh
vss = vec_min(vss, vbs);
+ // CHECK-ASM: vmnh
vss = vec_min(vbs, vss);
+ // CHECK-ASM: vmnh
vus = vec_min(vus, vus);
+ // CHECK-ASM: vmnlh
vus = vec_min(vus, vbs);
+ // CHECK-ASM: vmnlh
vus = vec_min(vbs, vus);
+ // CHECK-ASM: vmnlh
vsi = vec_min(vsi, vsi);
+ // CHECK-ASM: vmnf
vsi = vec_min(vsi, vbi);
+ // CHECK-ASM: vmnf
vsi = vec_min(vbi, vsi);
+ // CHECK-ASM: vmnf
vui = vec_min(vui, vui);
+ // CHECK-ASM: vmnlf
vui = vec_min(vui, vbi);
+ // CHECK-ASM: vmnlf
vui = vec_min(vbi, vui);
+ // CHECK-ASM: vmnlf
vsl = vec_min(vsl, vsl);
+ // CHECK-ASM: vmng
vsl = vec_min(vsl, vbl);
+ // CHECK-ASM: vmng
vsl = vec_min(vbl, vsl);
+ // CHECK-ASM: vmng
vul = vec_min(vul, vul);
+ // CHECK-ASM: vmnlg
vul = vec_min(vul, vbl);
+ // CHECK-ASM: vmnlg
vul = vec_min(vbl, vul);
+ // CHECK-ASM: vmnlg
vd = vec_min(vd, vd);
+ // (emulated)
vuc = vec_addc(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vaccb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vaccb
vus = vec_addc(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vacch
vui = vec_addc(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vaccf
vul = vec_addc(vul, vul);
// CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vaccg
vuc = vec_add_u128(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vaq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vaq
vuc = vec_addc_u128(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vaccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vaccq
vuc = vec_adde_u128(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vacq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vacq
vuc = vec_addec_u128(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vacccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vacccq
vsc = vec_avg(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vavgb
vuc = vec_avg(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vavglb
vss = vec_avg(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vavgh
vus = vec_avg(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vavglh
vsi = vec_avg(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vavgf
vui = vec_avg(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vavglf
vsl = vec_avg(vsl, vsl);
// CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vavgg
vul = vec_avg(vul, vul);
// CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vavglg
vui = vec_checksum(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vcksm
vus = vec_gfmsum(vuc, vuc);
// CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vgfmb
vui = vec_gfmsum(vus, vus);
// CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vgfmh
vul = vec_gfmsum(vui, vui);
// CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vgfmf
vuc = vec_gfmsum_128(vul, vul);
// CHECK: call <16 x i8> @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vgfmg
vus = vec_gfmsum_accum(vuc, vuc, vus);
// CHECK: call <8 x i16> @llvm.s390.vgfmab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vgfmab
vui = vec_gfmsum_accum(vus, vus, vui);
// CHECK: call <4 x i32> @llvm.s390.vgfmah(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vgfmah
vul = vec_gfmsum_accum(vui, vui, vul);
// CHECK: call <2 x i64> @llvm.s390.vgfmaf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vgfmaf
vuc = vec_gfmsum_accum_128(vul, vul, vuc);
// CHECK: call <16 x i8> @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vgfmag
vsc = vec_mladd(vsc, vsc, vsc);
+ // CHECK-ASM: vmalb
vsc = vec_mladd(vuc, vsc, vsc);
+ // CHECK-ASM: vmalb
vsc = vec_mladd(vsc, vuc, vuc);
+ // CHECK-ASM: vmalb
vuc = vec_mladd(vuc, vuc, vuc);
+ // CHECK-ASM: vmalb
vss = vec_mladd(vss, vss, vss);
+ // CHECK-ASM: vmalhw
vss = vec_mladd(vus, vss, vss);
+ // CHECK-ASM: vmalhw
vss = vec_mladd(vss, vus, vus);
+ // CHECK-ASM: vmalhw
vus = vec_mladd(vus, vus, vus);
+ // CHECK-ASM: vmalhw
vsi = vec_mladd(vsi, vsi, vsi);
+ // CHECK-ASM: vmalf
vsi = vec_mladd(vui, vsi, vsi);
+ // CHECK-ASM: vmalf
vsi = vec_mladd(vsi, vui, vui);
+ // CHECK-ASM: vmalf
vui = vec_mladd(vui, vui, vui);
+ // CHECK-ASM: vmalf
vsc = vec_mhadd(vsc, vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vmahb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmahb
vuc = vec_mhadd(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vmalhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmalhb
vss = vec_mhadd(vss, vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vmahh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmahh
vus = vec_mhadd(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vmalhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmalhh
vsi = vec_mhadd(vsi, vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vmahf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmahf
vui = vec_mhadd(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vmalhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmalhf
vss = vec_meadd(vsc, vsc, vss);
// CHECK: call <8 x i16> @llvm.s390.vmaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmaeb
vus = vec_meadd(vuc, vuc, vus);
// CHECK: call <8 x i16> @llvm.s390.vmaleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmaleb
vsi = vec_meadd(vss, vss, vsi);
// CHECK: call <4 x i32> @llvm.s390.vmaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmaeh
vui = vec_meadd(vus, vus, vui);
// CHECK: call <4 x i32> @llvm.s390.vmaleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmaleh
vsl = vec_meadd(vsi, vsi, vsl);
// CHECK: call <2 x i64> @llvm.s390.vmaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vmaef
vul = vec_meadd(vui, vui, vul);
// CHECK: call <2 x i64> @llvm.s390.vmalef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vmalef
vss = vec_moadd(vsc, vsc, vss);
// CHECK: call <8 x i16> @llvm.s390.vmaob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmaob
vus = vec_moadd(vuc, vuc, vus);
// CHECK: call <8 x i16> @llvm.s390.vmalob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmalob
vsi = vec_moadd(vss, vss, vsi);
// CHECK: call <4 x i32> @llvm.s390.vmaoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmaoh
vui = vec_moadd(vus, vus, vui);
// CHECK: call <4 x i32> @llvm.s390.vmaloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmaloh
vsl = vec_moadd(vsi, vsi, vsl);
// CHECK: call <2 x i64> @llvm.s390.vmaof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vmaof
vul = vec_moadd(vui, vui, vul);
// CHECK: call <2 x i64> @llvm.s390.vmalof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vmalof
vsc = vec_mulh(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmhb
vuc = vec_mulh(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmlhb
vss = vec_mulh(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmhh
vus = vec_mulh(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmlhh
vsi = vec_mulh(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmhf
vui = vec_mulh(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmlhf
vss = vec_mule(vsc, vsc);
// CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmeb
vus = vec_mule(vuc, vuc);
// CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmleb
vsi = vec_mule(vss, vss);
// CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmeh
vui = vec_mule(vus, vus);
// CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmleh
vsl = vec_mule(vsi, vsi);
// CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmef
vul = vec_mule(vui, vui);
// CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmlef
vss = vec_mulo(vsc, vsc);
// CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmob
vus = vec_mulo(vuc, vuc);
// CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vmlob
vsi = vec_mulo(vss, vss);
// CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmoh
vui = vec_mulo(vus, vus);
// CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vmloh
vsl = vec_mulo(vsi, vsi);
// CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmof
vul = vec_mulo(vui, vui);
// CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vmlof
vuc = vec_subc(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vscbib
vus = vec_subc(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vscbih
vui = vec_subc(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vscbif
vul = vec_subc(vul, vul);
// CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vscbig
vuc = vec_sub_u128(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsq
vuc = vec_subc_u128(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vscbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vscbiq
vuc = vec_sube_u128(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsbiq
vuc = vec_subec_u128(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vsbcbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsbcbiq
vui = vec_sum4(vuc, vuc);
// CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsumb
vui = vec_sum4(vus, vus);
// CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vsumh
vul = vec_sum2(vus, vus);
// CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vsumgh
vul = vec_sum2(vui, vui);
// CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vsumgf
vuc = vec_sum_u128(vui, vui);
// CHECK: call <16 x i8> @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vsumqf
vuc = vec_sum_u128(vul, vul);
// CHECK: call <16 x i8> @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
+ // CHECK-ASM: vsumqg
idx = vec_test_mask(vsc, vuc);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vuc, vuc);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vss, vus);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vus, vus);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vsi, vui);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vui, vui);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vsl, vul);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vul, vul);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vd, vul);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
}
void test_string(void) {
+ // CHECK-ASM-LABEL: test_string
+
vsc = vec_cp_until_zero(vsc);
// CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrb
vuc = vec_cp_until_zero(vuc);
// CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrb
vbc = vec_cp_until_zero(vbc);
// CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrb
vss = vec_cp_until_zero(vss);
// CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrh
vus = vec_cp_until_zero(vus);
// CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrh
vbs = vec_cp_until_zero(vbs);
// CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrh
vsi = vec_cp_until_zero(vsi);
// CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrf
vui = vec_cp_until_zero(vui);
// CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrf
vbi = vec_cp_until_zero(vbi);
// CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrf
vsc = vec_cp_until_zero_cc(vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrbs
vuc = vec_cp_until_zero_cc(vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrbs
vbc = vec_cp_until_zero_cc(vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
+ // CHECK-ASM: vistrbs
vss = vec_cp_until_zero_cc(vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrhs
vus = vec_cp_until_zero_cc(vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrhs
vbs = vec_cp_until_zero_cc(vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
+ // CHECK-ASM: vistrhs
vsi = vec_cp_until_zero_cc(vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrfs
vui = vec_cp_until_zero_cc(vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrfs
vbi = vec_cp_until_zero_cc(vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
+ // CHECK-ASM: vistrfs
vsc = vec_cmpeq_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeeb
vuc = vec_cmpeq_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeeb
vuc = vec_cmpeq_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeeb
vss = vec_cmpeq_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeeh
vus = vec_cmpeq_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeeh
vus = vec_cmpeq_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeeh
vsi = vec_cmpeq_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeef
vui = vec_cmpeq_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeef
vui = vec_cmpeq_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeef
vsc = vec_cmpeq_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeebs
vuc = vec_cmpeq_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeebs
vuc = vec_cmpeq_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeebs
vss = vec_cmpeq_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeehs
vus = vec_cmpeq_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeehs
vus = vec_cmpeq_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeehs
vsi = vec_cmpeq_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeefs
vui = vec_cmpeq_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeefs
vui = vec_cmpeq_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeefs
vsc = vec_cmpeq_or_0_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezb
vuc = vec_cmpeq_or_0_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezb
vuc = vec_cmpeq_or_0_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezb
vss = vec_cmpeq_or_0_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezh
vus = vec_cmpeq_or_0_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezh
vus = vec_cmpeq_or_0_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezh
vsi = vec_cmpeq_or_0_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezf
vui = vec_cmpeq_or_0_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezf
vui = vec_cmpeq_or_0_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezf
vsc = vec_cmpeq_or_0_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezbs
vuc = vec_cmpeq_or_0_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezbs
vuc = vec_cmpeq_or_0_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeezbs
vss = vec_cmpeq_or_0_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezhs
vus = vec_cmpeq_or_0_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezhs
vus = vec_cmpeq_or_0_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeezhs
vsi = vec_cmpeq_or_0_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezfs
vui = vec_cmpeq_or_0_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezfs
vui = vec_cmpeq_or_0_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfeezfs
vsc = vec_cmpne_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeneb
vuc = vec_cmpne_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeneb
vuc = vec_cmpne_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfeneb
vss = vec_cmpne_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeneh
vus = vec_cmpne_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeneh
vus = vec_cmpne_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfeneh
vsi = vec_cmpne_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenef
vui = vec_cmpne_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenef
vui = vec_cmpne_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenef
vsc = vec_cmpne_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenebs
vuc = vec_cmpne_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenebs
vuc = vec_cmpne_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenebs
vss = vec_cmpne_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenehs
vus = vec_cmpne_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenehs
vus = vec_cmpne_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenehs
vsi = vec_cmpne_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenefs
vui = vec_cmpne_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenefs
vui = vec_cmpne_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenefs
vsc = vec_cmpne_or_0_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezb
vuc = vec_cmpne_or_0_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezb
vuc = vec_cmpne_or_0_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezb
vss = vec_cmpne_or_0_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezh
vus = vec_cmpne_or_0_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezh
vus = vec_cmpne_or_0_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezh
vsi = vec_cmpne_or_0_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezf
vui = vec_cmpne_or_0_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezf
vui = vec_cmpne_or_0_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezf
vsc = vec_cmpne_or_0_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezbs
vuc = vec_cmpne_or_0_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezbs
vuc = vec_cmpne_or_0_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vfenezbs
vss = vec_cmpne_or_0_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezhs
vus = vec_cmpne_or_0_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezhs
vus = vec_cmpne_or_0_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
+ // CHECK-ASM: vfenezhs
vsi = vec_cmpne_or_0_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezfs
vui = vec_cmpne_or_0_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezfs
vui = vec_cmpne_or_0_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
+ // CHECK-ASM: vfenezfs
vbc = vec_cmprg(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrcb
vbs = vec_cmprg(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrch
vbi = vec_cmprg(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrcf
vbc = vec_cmprg_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrcbs
vbs = vec_cmprg_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrchs
vbi = vec_cmprg_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vstrcfs
vuc = vec_cmprg_idx(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrcb
vus = vec_cmprg_idx(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrch
vui = vec_cmprg_idx(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrcf
vuc = vec_cmprg_idx_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrcbs
vus = vec_cmprg_idx_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrchs
vui = vec_cmprg_idx_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrcfs
vuc = vec_cmprg_or_0_idx(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczb
vus = vec_cmprg_or_0_idx(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczh
vui = vec_cmprg_or_0_idx(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczf
vuc = vec_cmprg_or_0_idx_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczbs
vus = vec_cmprg_or_0_idx_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczhs
vui = vec_cmprg_or_0_idx_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vstrczfs
vbc = vec_cmpnrg(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrcb
vbs = vec_cmpnrg(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrch
vbi = vec_cmpnrg(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrcf
vbc = vec_cmpnrg_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrcbs
vbs = vec_cmpnrg_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrchs
vbi = vec_cmpnrg_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vstrcfs
vuc = vec_cmpnrg_idx(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrcb
vus = vec_cmpnrg_idx(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrch
vui = vec_cmpnrg_idx(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrcf
vuc = vec_cmpnrg_idx_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrcbs
vus = vec_cmpnrg_idx_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrchs
vui = vec_cmpnrg_idx_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrcfs
vuc = vec_cmpnrg_or_0_idx(vuc, vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczb
vus = vec_cmpnrg_or_0_idx(vus, vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczh
vui = vec_cmpnrg_or_0_idx(vui, vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczf
vuc = vec_cmpnrg_or_0_idx_cc(vuc, vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczbs
vus = vec_cmpnrg_or_0_idx_cc(vus, vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczhs
vui = vec_cmpnrg_or_0_idx_cc(vui, vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vstrczfs
vbc = vec_find_any_eq(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeb
vbc = vec_find_any_eq(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeb
vbc = vec_find_any_eq(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeb
vbs = vec_find_any_eq(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeh
vbs = vec_find_any_eq(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeh
vbs = vec_find_any_eq(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaeh
vbi = vec_find_any_eq(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaef
vbi = vec_find_any_eq(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaef
vbi = vec_find_any_eq(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaef
vbc = vec_find_any_eq_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaebs
vbc = vec_find_any_eq_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaebs
vbc = vec_find_any_eq_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaebs
vbs = vec_find_any_eq_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaehs
vbs = vec_find_any_eq_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaehs
vbs = vec_find_any_eq_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaehs
vbi = vec_find_any_eq_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaefs
vbi = vec_find_any_eq_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaefs
vbi = vec_find_any_eq_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
+ // CHECK-ASM: vfaefs
vsc = vec_find_any_eq_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeb
vuc = vec_find_any_eq_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeb
vuc = vec_find_any_eq_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeb
vss = vec_find_any_eq_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeh
vus = vec_find_any_eq_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeh
vus = vec_find_any_eq_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaeh
vsi = vec_find_any_eq_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaef
vui = vec_find_any_eq_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaef
vui = vec_find_any_eq_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaef
vsc = vec_find_any_eq_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaebs
vuc = vec_find_any_eq_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaebs
vuc = vec_find_any_eq_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaebs
vss = vec_find_any_eq_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaehs
vus = vec_find_any_eq_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaehs
vus = vec_find_any_eq_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaehs
vsi = vec_find_any_eq_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaefs
vui = vec_find_any_eq_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaefs
vui = vec_find_any_eq_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaefs
vsc = vec_find_any_eq_or_0_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezb
vuc = vec_find_any_eq_or_0_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezb
vuc = vec_find_any_eq_or_0_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezb
vss = vec_find_any_eq_or_0_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezh
vus = vec_find_any_eq_or_0_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezh
vus = vec_find_any_eq_or_0_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezh
vsi = vec_find_any_eq_or_0_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezf
vui = vec_find_any_eq_or_0_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezf
vui = vec_find_any_eq_or_0_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezf
vsc = vec_find_any_eq_or_0_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezbs
vuc = vec_find_any_eq_or_0_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezbs
vuc = vec_find_any_eq_or_0_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezbs
vss = vec_find_any_eq_or_0_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezhs
vus = vec_find_any_eq_or_0_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezhs
vus = vec_find_any_eq_or_0_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezhs
vsi = vec_find_any_eq_or_0_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezfs
vui = vec_find_any_eq_or_0_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezfs
vui = vec_find_any_eq_or_0_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
+ // CHECK-ASM: vfaezfs
vbc = vec_find_any_ne(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeb
vbc = vec_find_any_ne(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeb
vbc = vec_find_any_ne(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeb
vbs = vec_find_any_ne(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeh
vbs = vec_find_any_ne(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeh
vbs = vec_find_any_ne(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaeh
vbi = vec_find_any_ne(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaef
vbi = vec_find_any_ne(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaef
vbi = vec_find_any_ne(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaef
vbc = vec_find_any_ne_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaebs
vbc = vec_find_any_ne_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaebs
vbc = vec_find_any_ne_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaebs
vbs = vec_find_any_ne_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaehs
vbs = vec_find_any_ne_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaehs
vbs = vec_find_any_ne_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaehs
vbi = vec_find_any_ne_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaefs
vbi = vec_find_any_ne_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaefs
vbi = vec_find_any_ne_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
+ // CHECK-ASM: vfaefs
vsc = vec_find_any_ne_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeb
vuc = vec_find_any_ne_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeb
vuc = vec_find_any_ne_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeb
vss = vec_find_any_ne_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeh
vus = vec_find_any_ne_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeh
vus = vec_find_any_ne_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaeh
vsi = vec_find_any_ne_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaef
vui = vec_find_any_ne_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaef
vui = vec_find_any_ne_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaef
vsc = vec_find_any_ne_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaebs
vuc = vec_find_any_ne_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaebs
vuc = vec_find_any_ne_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaebs
vss = vec_find_any_ne_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaehs
vus = vec_find_any_ne_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaehs
vus = vec_find_any_ne_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaehs
vsi = vec_find_any_ne_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaefs
vui = vec_find_any_ne_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaefs
vui = vec_find_any_ne_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaefs
vsc = vec_find_any_ne_or_0_idx(vsc, vsc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezb
vuc = vec_find_any_ne_or_0_idx(vuc, vuc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezb
vuc = vec_find_any_ne_or_0_idx(vbc, vbc);
// CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezb
vss = vec_find_any_ne_or_0_idx(vss, vss);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezh
vus = vec_find_any_ne_or_0_idx(vus, vus);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezh
vus = vec_find_any_ne_or_0_idx(vbs, vbs);
// CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezh
vsi = vec_find_any_ne_or_0_idx(vsi, vsi);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezf
vui = vec_find_any_ne_or_0_idx(vui, vui);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezf
vui = vec_find_any_ne_or_0_idx(vbi, vbi);
// CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezf
vsc = vec_find_any_ne_or_0_idx_cc(vsc, vsc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezbs
vuc = vec_find_any_ne_or_0_idx_cc(vuc, vuc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezbs
vuc = vec_find_any_ne_or_0_idx_cc(vbc, vbc, &cc);
// CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezbs
vss = vec_find_any_ne_or_0_idx_cc(vss, vss, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezhs
vus = vec_find_any_ne_or_0_idx_cc(vus, vus, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezhs
vus = vec_find_any_ne_or_0_idx_cc(vbs, vbs, &cc);
// CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezhs
vsi = vec_find_any_ne_or_0_idx_cc(vsi, vsi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezfs
vui = vec_find_any_ne_or_0_idx_cc(vui, vui, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezfs
vui = vec_find_any_ne_or_0_idx_cc(vbi, vbi, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
+ // CHECK-ASM: vfaezfs
}
void test_float(void) {
+ // CHECK-ASM-LABEL: test_float
+
vd = vec_abs(vd);
// CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vflpdb
vd = vec_nabs(vd);
// CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
// CHECK-NEXT: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[ABS]]
+ // CHECK-ASM: vflndb
vd = vec_madd(vd, vd, vd);
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
+ // CHECK-ASM: vfmadb
vd = vec_msub(vd, vd, vd);
// CHECK: [[NEG:%[^ ]+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}}
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
+ // CHECK-ASM: vfmsdb
vd = vec_sqrt(vd);
// CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfsqdb
vd = vec_ld2f(cptrf);
// CHECK: [[VAL:%[^ ]+]] = load <2 x float>, <2 x float>* %{{.*}}
// CHECK: fpext <2 x float> [[VAL]] to <2 x double>
+ // (emulated)
vec_st2f(vd, ptrf);
// CHECK: [[VAL:%[^ ]+]] = fptrunc <2 x double> %{{.*}} to <2 x float>
// CHECK: store <2 x float> [[VAL]], <2 x float>* %{{.*}}
+ // (emulated)
vd = vec_ctd(vsl, 0);
// CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
+ // (emulated)
vd = vec_ctd(vul, 0);
// CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
+ // (emulated)
vd = vec_ctd(vsl, 1);
// CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
// CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
+ // (emulated)
vd = vec_ctd(vul, 1);
// CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
// CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
+ // (emulated)
vd = vec_ctd(vsl, 31);
// CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
// CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
+ // (emulated)
vd = vec_ctd(vul, 31);
// CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
// CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
+ // (emulated)
vsl = vec_ctsl(vd, 0);
// CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
+ // (emulated)
vul = vec_ctul(vd, 0);
// CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
+ // (emulated)
vsl = vec_ctsl(vd, 1);
// CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
// CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
+ // (emulated)
vul = vec_ctul(vd, 1);
// CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
// CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
+ // (emulated)
vsl = vec_ctsl(vd, 31);
// CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
// CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
+ // (emulated)
vul = vec_ctul(vd, 31);
// CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
// CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
+ // (emulated)
vd = vec_double(vsl);
// CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
+ // CHECK-ASM: vcdgb
vd = vec_double(vul);
// CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
+ // CHECK-ASM: vcdlgb
vsl = vec_signed(vd);
// CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
+ // CHECK-ASM: vcgdb
vul = vec_unsigned(vd);
// CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
+ // CHECK-ASM: vclgdb
vd = vec_roundp(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
vd = vec_ceil(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
vd = vec_roundm(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
vd = vec_floor(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
vd = vec_roundz(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
vd = vec_trunc(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
vd = vec_roundc(vd);
// CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
vd = vec_rint(vd);
// CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
vd = vec_round(vd);
// CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
vbl = vec_fp_test_data_class(vd, 0, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, 4095, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2048)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1024)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3072)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 512)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 256)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 768)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 128)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 64)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 192)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 32)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 16)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 48)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 8)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 12)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_P, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_N, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NAN, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NOT_NORMAL, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3327)
+ // CHECK-ASM: vftcidb
}
Modified: cfe/trunk/test/CodeGen/builtins-systemz-zvector2.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/builtins-systemz-zvector2.c?rev=349753&r1=349752&r2=349753&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/builtins-systemz-zvector2.c (original)
+++ cfe/trunk/test/CodeGen/builtins-systemz-zvector2.c Thu Dec 20 05:10:47 2018
@@ -2,6 +2,9 @@
// RUN: %clang_cc1 -target-cpu z14 -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 z14 -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>
@@ -60,486 +63,774 @@ volatile int idx;
int cc;
void test_core(void) {
+ // CHECK-ASM-LABEL: test_core
+ vector float vf2;
+ vector double vd2;
+
+ f = vec_extract(vf, 0);
+ // CHECK: extractelement <4 x float> %{{.*}}, i32 0
+ // CHECK-ASM: vstef
f = vec_extract(vf, idx);
// CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlgvf
+ d = vec_extract(vd, 0);
+ // CHECK: extractelement <2 x double> %{{.*}}, i32 0
+ // CHECK-ASM: vsteg
d = vec_extract(vd, idx);
// CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlgvg
+ vf2 = vf;
+ vf = vec_insert(f, vf2, 0);
+ // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0
+ // CHECK-ASM: vlef
+ vf = vec_insert(0.0f, vf, 1);
+ // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i32 1
+ // CHECK-ASM: vleif %{{.*}}, 0, 1
vf = vec_insert(f, vf, idx);
// CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlvgf
+ vd2 = vd;
+ vd = vec_insert(d, vd2, 0);
+ // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
+ // CHECK-ASM: vleg
+ vd = vec_insert(0.0, vd, 1);
+ // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i32 1
+ // CHECK-ASM: vleig %{{.*}}, 0, 1
vd = vec_insert(d, vd, idx);
// CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlvgg
vf = vec_promote(f, idx);
// CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlvgf
vd = vec_promote(d, idx);
// CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
+ // CHECK-ASM: vlvgg
vf = vec_insert_and_zero(cptrf);
// CHECK: insertelement <4 x float> <float 0.000000e+00, float undef, float 0.000000e+00, float 0.000000e+00>, float %{{.*}}, i32 1
+ // CHECK-ASM: vllezf
vd = vec_insert_and_zero(cptrd);
// CHECK: insertelement <2 x double> <double undef, double 0.000000e+00>, double %{{.*}}, i32 0
+ // CHECK-ASM: vllezg
vf = vec_perm(vf, vf, 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
vul = vec_bperm_u128(vuc, vuc);
// CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vbperm
vf = vec_sel(vf, vf, vui);
+ // CHECK-ASM: vsel
vf = vec_sel(vf, vf, vbi);
+ // CHECK-ASM: vsel
vd = vec_sel(vd, vd, vul);
+ // CHECK-ASM: vsel
vd = vec_sel(vd, vd, vbl);
+ // CHECK-ASM: vsel
vf = vec_gather_element(vf, vui, cptrf, 0);
+ // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vf = vec_gather_element(vf, vui, cptrf, 1);
+ // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vf = vec_gather_element(vf, vui, cptrf, 2);
+ // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vf = vec_gather_element(vf, vui, cptrf, 3);
+ // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
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(vf, vui, ptrf, 0);
+ // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vf, vui, ptrf, 1);
+ // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vec_scatter_element(vf, vui, ptrf, 2);
+ // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
vec_scatter_element(vf, vui, ptrf, 3);
+ // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
vec_scatter_element(vd, vul, ptrd, 0);
+ // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
vec_scatter_element(vd, vul, ptrd, 1);
+ // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
vf = vec_xl(idx, cptrf);
+ // CHECK-ASM: vl
vd = vec_xl(idx, cptrd);
+ // CHECK-ASM: vl
vec_xst(vf, idx, ptrf);
+ // CHECK-ASM: vst
vec_xst(vd, idx, ptrd);
+ // CHECK-ASM: vst
vd = vec_load_bndry(cptrd, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 128);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 256);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 512);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 1024);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 2048);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5)
+ // CHECK-ASM: vlbb
vf = vec_load_bndry(cptrf, 4096);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6)
+ // CHECK-ASM: vlbb
vf = vec_load_len(cptrf, 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(vf, ptrf, 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
+ vuc = vec_load_len_r(cptruc, 0);
+ // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, i8* %{{.*}})
+ // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0
vuc = vec_load_len_r(cptruc, idx);
// CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, i8* %{{.*}})
+ // CHECK-ASM: vlrlr
+ vec_store_len_r(vuc, ptruc, 0);
+ // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, i8* %{{.*}})
+ // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0
vec_store_len_r(vuc, ptruc, idx);
// CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
+ // CHECK-ASM: vstrlr
vf = vec_splat(vf, 0);
// CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> zeroinitializer
+ // CHECK-ASM: vrepf
vf = vec_splat(vf, 1);
// CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
+ // CHECK-ASM: vrepf
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
vf = vec_splats(f);
// CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> zeroinitializer
+ // CHECK-ASM: vlrepf
vd = vec_splats(d);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
+ // CHECK-ASM: vlrepg
vf = vec_mergeh(vf, vf);
// shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
+ // CHECK-ASM: vmrhf
vd = vec_mergeh(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
+ // CHECK-ASM: vmrhg
vf = vec_mergel(vf, vf);
// shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
+ // CHECK-ASM: vmrlf
vd = vec_mergel(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
+ // CHECK-ASM: vmrlg
}
void test_compare(void) {
+ // CHECK-ASM-LABEL: test_compare
+
vbi = vec_cmpeq(vf, vf);
// CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfcesb
vbl = vec_cmpeq(vd, vd);
// CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfcedb
vbi = vec_cmpge(vf, vf);
// CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchesb
vbl = vec_cmpge(vd, vd);
// CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchedb
vbi = vec_cmpgt(vf, vf);
// CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchsb
vbl = vec_cmpgt(vd, vd);
// CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchdb
vbi = vec_cmple(vf, vf);
// CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchesb
vbl = vec_cmple(vd, vd);
// CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchedb
vbi = vec_cmplt(vf, vf);
// CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchsb
vbl = vec_cmplt(vd, vd);
// CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
+ // CHECK-ASM: vfchdb
idx = vec_all_eq(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfcesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfcesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
+ // CHECK-ASM: vftcisb
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(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
+ // CHECK-ASM: vftcisb
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfcesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfcesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchesbs
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(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfchsbs
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(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
+ // CHECK-ASM: vftcisb
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(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
+ // CHECK-ASM: vftcisb
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
+
vf = vec_andc(vf, vf);
+ // CHECK-ASM: vnc
vd = vec_andc(vd, vd);
+ // CHECK-ASM: vnc
vf = vec_nor(vf, vf);
+ // CHECK-ASM: vno
vd = vec_nor(vd, vd);
+ // CHECK-ASM: vno
vsc = vec_nand(vsc, vsc);
+ // CHECK-ASM: vnn
vuc = vec_nand(vuc, vuc);
+ // CHECK-ASM: vnn
vbc = vec_nand(vbc, vbc);
+ // CHECK-ASM: vnn
vss = vec_nand(vss, vss);
+ // CHECK-ASM: vnn
vus = vec_nand(vus, vus);
+ // CHECK-ASM: vnn
vbs = vec_nand(vbs, vbs);
+ // CHECK-ASM: vnn
vsi = vec_nand(vsi, vsi);
+ // CHECK-ASM: vnn
vui = vec_nand(vui, vui);
+ // CHECK-ASM: vnn
vbi = vec_nand(vbi, vbi);
+ // CHECK-ASM: vnn
vsl = vec_nand(vsl, vsl);
+ // CHECK-ASM: vnn
vul = vec_nand(vul, vul);
+ // CHECK-ASM: vnn
vbl = vec_nand(vbl, vbl);
+ // CHECK-ASM: vnn
vf = vec_nand(vf, vf);
+ // CHECK-ASM: vnn
vd = vec_nand(vd, vd);
+ // CHECK-ASM: vnn
vsc = vec_orc(vsc, vsc);
+ // CHECK-ASM: voc
vuc = vec_orc(vuc, vuc);
+ // CHECK-ASM: voc
vbc = vec_orc(vbc, vbc);
+ // CHECK-ASM: voc
vss = vec_orc(vss, vss);
+ // CHECK-ASM: voc
vus = vec_orc(vus, vus);
+ // CHECK-ASM: voc
vbs = vec_orc(vbs, vbs);
+ // CHECK-ASM: voc
vsi = vec_orc(vsi, vsi);
+ // CHECK-ASM: voc
vui = vec_orc(vui, vui);
+ // CHECK-ASM: voc
vbi = vec_orc(vbi, vbi);
+ // CHECK-ASM: voc
vsl = vec_orc(vsl, vsl);
+ // CHECK-ASM: voc
vul = vec_orc(vul, vul);
+ // CHECK-ASM: voc
vbl = vec_orc(vbl, vbl);
+ // CHECK-ASM: voc
vf = vec_orc(vf, vf);
+ // CHECK-ASM: voc
vd = vec_orc(vd, vd);
+ // CHECK-ASM: voc
vsc = vec_eqv(vsc, vsc);
+ // CHECK-ASM: vnx
vuc = vec_eqv(vuc, vuc);
+ // CHECK-ASM: vnx
vbc = vec_eqv(vbc, vbc);
+ // CHECK-ASM: vnx
vss = vec_eqv(vss, vss);
+ // CHECK-ASM: vnx
vus = vec_eqv(vus, vus);
+ // CHECK-ASM: vnx
vbs = vec_eqv(vbs, vbs);
+ // CHECK-ASM: vnx
vsi = vec_eqv(vsi, vsi);
+ // CHECK-ASM: vnx
vui = vec_eqv(vui, vui);
+ // CHECK-ASM: vnx
vbi = vec_eqv(vbi, vbi);
+ // CHECK-ASM: vnx
vsl = vec_eqv(vsl, vsl);
+ // CHECK-ASM: vnx
vul = vec_eqv(vul, vul);
+ // CHECK-ASM: vnx
vbl = vec_eqv(vbl, vbl);
+ // CHECK-ASM: vnx
vf = vec_eqv(vf, vf);
+ // CHECK-ASM: vnx
vd = vec_eqv(vd, vd);
+ // CHECK-ASM: vnx
+
+ vuc = vec_popcnt(vsc);
+ // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
+ // CHECK-ASM: vpopctb
+ vuc = vec_popcnt(vuc);
+ // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
+ // CHECK-ASM: vpopctb
+ vus = vec_popcnt(vss);
+ // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
+ // CHECK-ASM: vpopcth
+ vus = vec_popcnt(vus);
+ // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
+ // CHECK-ASM: vpopcth
+ vui = vec_popcnt(vsi);
+ // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
+ // CHECK-ASM: vpopctf
+ vui = vec_popcnt(vui);
+ // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
+ // CHECK-ASM: vpopctf
+ vul = vec_popcnt(vsl);
+ // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
+ // CHECK-ASM: vpopctg
+ vul = vec_popcnt(vul);
+ // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
+ // CHECK-ASM: vpopctg
vf = vec_slb(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vf = vec_slb(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vd = vec_slb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vd = vec_slb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vslb
vf = vec_sld(vf, vf, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vf = vec_sld(vf, vf, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vd = vec_sld(vd, vd, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vsldb
vd = vec_sld(vd, vd, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
+ // CHECK-ASM: vsldb
vf = vec_srab(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vf = vec_srab(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vd = vec_srab(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vd = vec_srab(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrab
vf = vec_srb(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vf = vec_srb(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vd = vec_srb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
vd = vec_srb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vsrlb
idx = vec_test_mask(vf, vui);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
idx = vec_test_mask(vd, vul);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
+ // CHECK-ASM: vtm
vuc = vec_msum_u128(vul, vul, vuc, 0);
// CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
+ // CHECK-ASM: vmslg
vuc = vec_msum_u128(vul, vul, vuc, 4);
// CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
+ // CHECK-ASM: vmslg
vuc = vec_msum_u128(vul, vul, vuc, 8);
// CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
+ // CHECK-ASM: vmslg
vuc = vec_msum_u128(vul, vul, vuc, 12);
// CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
+ // CHECK-ASM: vmslg
}
void test_float(void) {
+ // CHECK-ASM-LABEL: test_float
+
vf = vec_abs(vf);
// CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vflpsb
vd = vec_abs(vd);
// CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vflpdb
vf = vec_nabs(vf);
// CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
// CHECK-NEXT: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[ABS]]
+ // CHECK-ASM: vflnsb
vd = vec_nabs(vd);
// CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
// CHECK-NEXT: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[ABS]]
+ // CHECK-ASM: vflndb
vf = vec_max(vf, vf);
// CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
+ // CHECK-ASM: vfmaxsb
vd = vec_max(vd, vd);
// CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
+ // CHECK-ASM: vfmaxdb
vf = vec_min(vf, vf);
// CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
+ // CHECK-ASM: vfminsb
vd = vec_min(vd, vd);
// CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
+ // CHECK-ASM: vfmindb
vf = vec_madd(vf, vf, vf);
// CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
+ // CHECK-ASM: vfmasb
vd = vec_madd(vd, vd, vd);
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
+ // CHECK-ASM: vfmadb
vf = vec_msub(vf, vf, vf);
// CHECK: [[NEG:%[^ ]+]] = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}}
// CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
+ // CHECK-ASM: vfmssb
vd = vec_msub(vd, vd, vd);
// CHECK: [[NEG:%[^ ]+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}}
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
+ // CHECK-ASM: vfmsdb
vf = vec_nmadd(vf, vf, vf);
// CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
// CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[RES]]
+ // CHECK-ASM: vfnmasb
vd = vec_nmadd(vd, vd, vd);
// CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[RES]]
+ // CHECK-ASM: vfnmadb
vf = vec_nmsub(vf, vf, vf);
// CHECK: [[NEG:%[^ ]+]] = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}}
// CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
// CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[RES]]
+ // CHECK-ASM: vfnmssb
vd = vec_nmsub(vd, vd, vd);
// CHECK: [[NEG:%[^ ]+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}}
// CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
// CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[RES]]
+ // CHECK-ASM: vfnmsdb
vf = vec_sqrt(vf);
// CHECK: call <4 x float> @llvm.sqrt.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfsqsb
vd = vec_sqrt(vd);
// CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfsqdb
vd = vec_doublee(vf);
// CHECK: fpext <2 x float> %{{.*}} to <2 x double>
+ // CHECK-ASM: vldeb
vf = vec_floate(vd);
// CHECK: fptrunc <2 x double> %{{.*}} to <2 x float>
+ // CHECK-ASM: vledb
vd = vec_double(vsl);
// CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
+ // CHECK-ASM: vcdgb
vd = vec_double(vul);
// CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
+ // CHECK-ASM: vcdlgb
vsl = vec_signed(vd);
// CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
+ // CHECK-ASM: vcgdb
vul = vec_unsigned(vd);
// CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
+ // CHECK-ASM: vclgdb
vf = vec_roundp(vf);
// CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
vf = vec_ceil(vf);
// CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
vd = vec_roundp(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
vd = vec_ceil(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
vf = vec_roundm(vf);
// CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
vf = vec_floor(vf);
// CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
vd = vec_roundm(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
vd = vec_floor(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
vf = vec_roundz(vf);
// CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
vf = vec_trunc(vf);
// CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
vd = vec_roundz(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
vd = vec_trunc(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
vf = vec_roundc(vf);
// CHECK: call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
vd = vec_roundc(vd);
// CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
vf = vec_rint(vf);
// CHECK: call <4 x float> @llvm.rint.v4f32(<4 x float> %{{.*}})
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
vd = vec_rint(vd);
// CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
vf = vec_round(vf);
// CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
+ // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
vd = vec_round(vd);
// CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
+ // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
vbi = vec_fp_test_data_class(vf, 0, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
+ // CHECK-ASM: vftcisb
vbi = vec_fp_test_data_class(vf, 4095, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
+ // CHECK-ASM: vftcisb
vbl = vec_fp_test_data_class(vd, 0, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
+ // CHECK-ASM: vftcidb
vbl = vec_fp_test_data_class(vd, 4095, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
+ // CHECK-ASM: vftcidb
}
More information about the cfe-commits
mailing list