| // REQUIRES: systemz-registered-target |
| // RUN: %clang_cc1 -target-cpu z17 -triple s390x-linux-gnu \ |
| // RUN: -O2 -fzvector -flax-vector-conversions=none \ |
| // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s |
| // RUN: %clang_cc1 -target-cpu z17 -triple s390x-linux-gnu \ |
| // RUN: -O2 -fzvector -flax-vector-conversions=none \ |
| // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM |
| |
| #include <vecintrin.h> |
| |
| volatile vector signed char vsc; |
| volatile vector signed short vss; |
| volatile vector signed int vsi; |
| volatile vector signed long long vsl; |
| volatile vector signed __int128 vslll; |
| volatile vector unsigned char vuc; |
| volatile vector unsigned short vus; |
| volatile vector unsigned int vui; |
| volatile vector unsigned long long vul; |
| volatile vector unsigned __int128 vulll; |
| volatile vector bool char vbc; |
| volatile vector bool short vbs; |
| volatile vector bool int vbi; |
| volatile vector bool long long vbl; |
| volatile vector bool __int128 vblll; |
| volatile vector float vf; |
| volatile vector double vd; |
| |
| volatile int idx; |
| int cc; |
| |
| void test_core(void) { |
| // CHECK-ASM-LABEL: test_core |
| |
| vuc = vec_gen_element_masks_8(vus); |
| // CHECK: call <16 x i8> @llvm.s390.vgemb(<8 x i16> %{{.*}}) |
| // CHECK-ASM: vgemb |
| vus = vec_gen_element_masks_16(vuc); |
| // CHECK: call <8 x i16> @llvm.s390.vgemh(<16 x i8> %{{.*}}) |
| // CHECK-ASM: vgemh |
| vui = vec_gen_element_masks_32(vuc); |
| // CHECK: call <4 x i32> @llvm.s390.vgemf(<16 x i8> %{{.*}}) |
| // CHECK-ASM: vgemf |
| vul = vec_gen_element_masks_64(vuc); |
| // CHECK: call <2 x i64> @llvm.s390.vgemg(<16 x i8> %{{.*}}) |
| // CHECK-ASM: vgemg |
| vulll = vec_gen_element_masks_128(vuc); |
| // CHECK: call i128 @llvm.s390.vgemq(<16 x i8> %{{.*}}) |
| // CHECK-ASM: vgemq |
| |
| vsc = vec_blend(vsc, vsc, vsc); |
| // CHECK-ASM: vblendb |
| vbc = vec_blend(vbc, vbc, vsc); |
| // CHECK-ASM: vblendb |
| vuc = vec_blend(vuc, vuc, vsc); |
| // CHECK-ASM: vblendb |
| vss = vec_blend(vss, vss, vss); |
| // CHECK-ASM: vblendh |
| vbs = vec_blend(vbs, vbs, vss); |
| // CHECK-ASM: vblendh |
| vus = vec_blend(vus, vus, vss); |
| // CHECK-ASM: vblendh |
| vsi = vec_blend(vsi, vsi, vsi); |
| // CHECK-ASM: vblendf |
| vbi = vec_blend(vbi, vbi, vsi); |
| // CHECK-ASM: vblendf |
| vui = vec_blend(vui, vui, vsi); |
| // CHECK-ASM: vblendf |
| vsl = vec_blend(vsl, vsl, vsl); |
| // CHECK-ASM: vblendg |
| vul = vec_blend(vul, vul, vsl); |
| // CHECK-ASM: vblendg |
| vbl = vec_blend(vbl, vbl, vsl); |
| // CHECK-ASM: vblendg |
| vslll = vec_blend(vslll, vslll, vslll); |
| // CHECK-ASM: vblendq |
| vblll = vec_blend(vblll, vblll, vslll); |
| // CHECK-ASM: vblendq |
| vulll = vec_blend(vulll, vulll, vslll); |
| // CHECK-ASM: vblendq |
| vf = vec_blend(vf, vf, vsi); |
| // CHECK-ASM: vblendf |
| vd = vec_blend(vd, vd, vsl); |
| // CHECK-ASM: vblendg |
| |
| vslll = vec_unpackh(vsl); |
| // CHECK: call i128 @llvm.s390.vuphg(<2 x i64> %{{.*}}) |
| // CHECK-ASM: vuphg |
| vulll = vec_unpackh(vul); |
| // CHECK: call i128 @llvm.s390.vuplhg(<2 x i64> %{{.*}}) |
| // CHECK-ASM: vuplhg |
| vslll = vec_unpackl(vsl); |
| // CHECK: call i128 @llvm.s390.vuplg(<2 x i64> %{{.*}}) |
| // CHECK-ASM: vuplg |
| vulll = vec_unpackl(vul); |
| // CHECK: call i128 @llvm.s390.vupllg(<2 x i64> %{{.*}}) |
| // CHECK-ASM: vupllg |
| } |
| |
| void test_compare(void) { |
| // CHECK-ASM-LABEL: test_compare |
| |
| vblll = vec_cmpeq(vslll, vslll); |
| // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vceqq |
| vblll = vec_cmpeq(vulll, vulll); |
| // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vceqq |
| vblll = vec_cmpeq(vblll, vblll); |
| // CHECK: icmp eq <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vceqq |
| |
| vblll = vec_cmpge(vslll, vslll); |
| // CHECK: icmp sge <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchq |
| vblll = vec_cmpge(vulll, vulll); |
| // CHECK: icmp uge <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchlq |
| |
| vblll = vec_cmpgt(vslll, vslll); |
| // CHECK: icmp sgt <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchq |
| vblll = vec_cmpgt(vulll, vulll); |
| // CHECK: icmp ugt <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchlq |
| |
| vblll = vec_cmple(vslll, vslll); |
| // CHECK: icmp sle <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchq |
| vblll = vec_cmple(vulll, vulll); |
| // CHECK: icmp ule <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchlq |
| |
| vblll = vec_cmplt(vslll, vslll); |
| // CHECK: icmp slt <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchq |
| vblll = vec_cmplt(vulll, vulll); |
| // CHECK: icmp ult <1 x i128> %{{.*}}, %{{.*}} |
| // CHECK-ASM: vchlq |
| |
| idx = vec_all_eq(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_all_eq(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_all_eq(vblll, vblll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| |
| idx = vec_all_ne(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_all_ne(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_all_ne(vblll, vblll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| |
| idx = vec_all_ge(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_all_ge(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_all_gt(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_all_gt(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_all_le(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_all_le(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_all_lt(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_all_lt(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_any_eq(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_any_eq(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_any_eq(vblll, vblll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| |
| idx = vec_any_ne(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_any_ne(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| idx = vec_any_ne(vblll, vblll); |
| // CHECK: call { i128, i32 } @llvm.s390.vceqqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vceqqs |
| |
| idx = vec_any_ge(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_any_ge(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_any_gt(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_any_gt(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_any_le(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_any_le(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| |
| idx = vec_any_lt(vslll, vslll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchqs |
| idx = vec_any_lt(vulll, vulll); |
| // CHECK: call { i128, i32 } @llvm.s390.vchlqs(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vchlqs |
| } |
| |
| void test_integer(void) { |
| // CHECK-ASM-LABEL: test_integer |
| |
| vulll = vec_cntlz(vulll); |
| // CHECK: call range(i128 0, 129) i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false) |
| // CHECK-ASM: vclzq |
| vulll = vec_cnttz(vulll); |
| // CHECK: call range(i128 0, 129) i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false) |
| // CHECK-ASM: vctzq |
| |
| vslll = vec_abs(vslll); |
| // CHECK-ASM: vlcq |
| |
| vslll = vec_avg(vslll, vslll); |
| // CHECK: call i128 @llvm.s390.vavgq(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vavgq |
| vulll = vec_avg(vulll, vulll); |
| // CHECK: call i128 @llvm.s390.vavglq(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vavglq |
| |
| vsc = vec_evaluate(vsc, vsc, vsc, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vsc = vec_evaluate(vsc, vsc, vsc, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vuc = vec_evaluate(vuc, vuc, vuc, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vuc = vec_evaluate(vuc, vuc, vuc, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vbc = vec_evaluate(vbc, vbc, vbc, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vbc = vec_evaluate(vbc, vbc, vbc, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vss = vec_evaluate(vss, vss, vss, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vss = vec_evaluate(vss, vss, vss, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vus = vec_evaluate(vus, vus, vus, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vus = vec_evaluate(vus, vus, vus, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vbs = vec_evaluate(vbs, vbs, vbs, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vbs = vec_evaluate(vbs, vbs, vbs, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vsi = vec_evaluate(vsi, vsi, vsi, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vsi = vec_evaluate(vsi, vsi, vsi, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vui = vec_evaluate(vui, vui, vui, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vui = vec_evaluate(vui, vui, vui, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vbi = vec_evaluate(vbi, vbi, vbi, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vbi = vec_evaluate(vbi, vbi, vbi, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vsl = vec_evaluate(vsl, vsl, vsl, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vsl = vec_evaluate(vsl, vsl, vsl, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vul = vec_evaluate(vul, vul, vul, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vul = vec_evaluate(vul, vul, vul, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vbl = vec_evaluate(vbl, vbl, vbl, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vbl = vec_evaluate(vbl, vbl, vbl, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vslll = vec_evaluate(vslll, vslll, vslll, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vslll = vec_evaluate(vslll, vslll, vslll, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vulll = vec_evaluate(vulll, vulll, vulll, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vulll = vec_evaluate(vulll, vulll, vulll, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| vblll = vec_evaluate(vblll, vblll, vblll, 0); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) |
| // CHECK-ASM: veval |
| vblll = vec_evaluate(vblll, vblll, vblll, 255); |
| // CHECK: call <16 x i8> @llvm.s390.veval(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) |
| // CHECK-ASM: veval |
| |
| vslll = vec_max(vslll, vslll); |
| // CHECK-ASM: vmxq |
| vulll = vec_max(vulll, vulll); |
| // CHECK-ASM: vmxlq |
| vslll = vec_min(vslll, vslll); |
| // CHECK-ASM: vmnq |
| vulll = vec_min(vulll, vulll); |
| // CHECK-ASM: vmnlq |
| |
| vsl = vec_mladd(vsl, vsl, vsl); |
| // CHECK-ASM: vmalg |
| vsl = vec_mladd(vul, vsl, vsl); |
| // CHECK-ASM: vmalg |
| vsl = vec_mladd(vsl, vul, vul); |
| // CHECK-ASM: vmalg |
| vul = vec_mladd(vul, vul, vul); |
| // CHECK-ASM: vmalg |
| vslll = vec_mladd(vslll, vslll, vslll); |
| // CHECK-ASM: vmalq |
| vslll = vec_mladd(vulll, vslll, vslll); |
| // CHECK-ASM: vmalq |
| vslll = vec_mladd(vslll, vulll, vulll); |
| // CHECK-ASM: vmalq |
| vulll = vec_mladd(vulll, vulll, vulll); |
| // CHECK-ASM: vmalq |
| |
| vsl = vec_mhadd(vsl, vsl, vsl); |
| // CHECK: call <2 x i64> @llvm.s390.vmahg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmahg |
| vul = vec_mhadd(vul, vul, vul); |
| // CHECK: call <2 x i64> @llvm.s390.vmalhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmalhg |
| vslll = vec_mhadd(vslll, vslll, vslll); |
| // CHECK: call i128 @llvm.s390.vmahq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmahq |
| vulll = vec_mhadd(vulll, vulll, vulll); |
| // CHECK: call i128 @llvm.s390.vmalhq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmalhq |
| |
| vslll = vec_meadd(vsl, vsl, vslll); |
| // CHECK: call i128 @llvm.s390.vmaeg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmaeg |
| vulll = vec_meadd(vul, vul, vulll); |
| // CHECK: call i128 @llvm.s390.vmaleg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmaleg |
| |
| vslll = vec_moadd(vsl, vsl, vslll); |
| // CHECK: call i128 @llvm.s390.vmaog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmaog |
| vulll = vec_moadd(vul, vul, vulll); |
| // CHECK: call i128 @llvm.s390.vmalog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmalog |
| |
| vsl = vec_mulh(vsl, vsl); |
| // CHECK: call <2 x i64> @llvm.s390.vmhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmhg |
| vul = vec_mulh(vul, vul); |
| // CHECK: call <2 x i64> @llvm.s390.vmlhg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmlhg |
| vslll = vec_mulh(vslll, vslll); |
| // CHECK: call i128 @llvm.s390.vmhq(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmhq |
| vulll = vec_mulh(vulll, vulll); |
| // CHECK: call i128 @llvm.s390.vmlhq(i128 %{{.*}}, i128 %{{.*}}) |
| // CHECK-ASM: vmlhq |
| |
| vslll = vec_mule(vsl, vsl); |
| // CHECK: call i128 @llvm.s390.vmeg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmeg |
| vulll = vec_mule(vul, vul); |
| // CHECK: call i128 @llvm.s390.vmleg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmleg |
| |
| vslll = vec_mulo(vsl, vsl); |
| // CHECK: call i128 @llvm.s390.vmog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmog |
| vulll = vec_mulo(vul, vul); |
| // CHECK: call i128 @llvm.s390.vmlog(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) |
| // CHECK-ASM: vmlog |
| } |
| |
