maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGen/builtins-systemz-zvector2.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

847 lines
31 KiB
C
Raw Normal View History

[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
// REQUIRES: systemz-registered-target
// RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
Revert "For PR17164: split -fno-lax-vector-conversion into three different" This breaks the LLDB build. I tried reaching out to Richard, but haven't gotten a reply yet. llvm-svn: 371813
2019-09-13 13:16:59 +08:00
// RUN: -O -fzvector -fno-lax-vector-conversions \
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
// RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
Revert "For PR17164: split -fno-lax-vector-conversion into three different" This breaks the LLDB build. I tried reaching out to Richard, but haven't gotten a reply yet. llvm-svn: 371813
2019-09-13 13:16:59 +08:00
// RUN: -O -fzvector -fno-lax-vector-conversions \
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
#include <vecintrin.h>
volatile vector signed char vsc;
volatile vector signed short vss;
volatile vector signed int vsi;
volatile vector signed long long vsl;
volatile vector unsigned char vuc;
volatile vector unsigned short vus;
volatile vector unsigned int vui;
volatile vector unsigned long long vul;
volatile vector bool char vbc;
volatile vector bool short vbs;
volatile vector bool int vbi;
volatile vector bool long long vbl;
volatile vector float vf;
volatile vector double vd;
volatile signed char sc;
volatile signed short ss;
volatile signed int si;
volatile signed long long sl;
volatile unsigned char uc;
volatile unsigned short us;
volatile unsigned int ui;
volatile unsigned long long ul;
volatile float f;
volatile double d;
const void * volatile cptr;
const signed char * volatile cptrsc;
const signed short * volatile cptrss;
const signed int * volatile cptrsi;
const signed long long * volatile cptrsl;
const unsigned char * volatile cptruc;
const unsigned short * volatile cptrus;
const unsigned int * volatile cptrui;
const unsigned long long * volatile cptrul;
const float * volatile cptrf;
const double * volatile cptrd;
void * volatile ptr;
signed char * volatile ptrsc;
signed short * volatile ptrss;
signed int * volatile ptrsi;
signed long long * volatile ptrsl;
unsigned char * volatile ptruc;
unsigned short * volatile ptrus;
unsigned int * volatile ptrui;
unsigned long long * volatile ptrul;
float * volatile ptrf;
double * volatile ptrd;
volatile unsigned int len;
volatile int idx;
int cc;
void test_core(void) {
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// 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
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
f = vec_extract(vf, idx);
// CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlgvf
d = vec_extract(vd, 0);
// CHECK: extractelement <2 x double> %{{.*}}, i32 0
// CHECK-ASM: vsteg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
d = vec_extract(vd, idx);
// CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// 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
[SystemZ] Fix wrong codegen caused by typos in vecintrin.h The following two bugs in SystemZ high-level vector intrinsics are fixes by this patch: - The float case of vec_insert_and_zero should generate a VLLEZF pattern, but currently erroneously generates VLLEZLF. - The float and double versions of vec_orc erroneously generate and-with-complement instead of or-with-complement. The patch also fixes a couple of typos in the associated test. llvm-svn: 349751
2018-12-20 21:09:09 +08:00
vf = vec_insert(f, vf, idx);
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
// CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// 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
[SystemZ] Fix wrong codegen caused by typos in vecintrin.h The following two bugs in SystemZ high-level vector intrinsics are fixes by this patch: - The float case of vec_insert_and_zero should generate a VLLEZF pattern, but currently erroneously generates VLLEZLF. - The float and double versions of vec_orc erroneously generate and-with-complement instead of or-with-complement. The patch also fixes a couple of typos in the associated test. llvm-svn: 349751
2018-12-20 21:09:09 +08:00
vd = vec_insert(d, vd, idx);
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
// CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlvgg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_promote(f, idx);
// CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlvgf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_promote(d, idx);
// CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlvgg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_insert_and_zero(cptrf);
[SystemZ] Fix wrong codegen caused by typos in vecintrin.h The following two bugs in SystemZ high-level vector intrinsics are fixes by this patch: - The float case of vec_insert_and_zero should generate a VLLEZF pattern, but currently erroneously generates VLLEZLF. - The float and double versions of vec_orc erroneously generate and-with-complement instead of or-with-complement. The patch also fixes a couple of typos in the associated test. llvm-svn: 349751
2018-12-20 21:09:09 +08:00
// CHECK: insertelement <4 x float> <float 0.000000e+00, float undef, float 0.000000e+00, float 0.000000e+00>, float %{{.*}}, i32 1
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vllezf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_insert_and_zero(cptrd);
// CHECK: insertelement <2 x double> <double undef, double 0.000000e+00>, double %{{.*}}, i32 0
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vllezg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_perm(vf, vf, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vperm
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_perm(vd, vd, vuc);
// CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vperm
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vul = vec_bperm_u128(vuc, vuc);
// CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vbperm
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
[SystemZ] Add support for new cpu architecture - arch13 This patch series adds support for the next-generation arch13 CPU architecture to the SystemZ backend. This includes: - Basic support for the new processor and its features. - Support for low-level builtins mapped to new LLVM intrinsics. - New high-level intrinsics in vecintrin.h. - Indicate support by defining __VEC__ == 10303. Note: No currently available Z system supports the arch13 architecture. Once new systems become available, the official system name will be added as supported -march name. llvm-svn: 365933
2019-07-13 02:14:51 +08:00
vf = vec_revb(vf);
// CHECK-ASM: vperm
vd = vec_revb(vd);
// CHECK-ASM: vperm
vf = vec_reve(vf);
// CHECK-ASM: vperm
vd = vec_reve(vd);
// CHECK-ASM: {{vperm|vpdi}}
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_sel(vf, vf, vui);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsel
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_sel(vf, vf, vbi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsel
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_sel(vd, vd, vul);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsel
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_sel(vd, vd, vbl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsel
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_gather_element(vf, vui, cptrf, 0);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_gather_element(vf, vui, cptrf, 1);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_gather_element(vf, vui, cptrf, 2);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_gather_element(vf, vui, cptrf, 3);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_gather_element(vd, vul, cptrd, 0);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_gather_element(vd, vul, cptrd, 1);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vf, vui, ptrf, 0);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vf, vui, ptrf, 1);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vf, vui, ptrf, 2);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vf, vui, ptrf, 3);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vd, vul, ptrd, 0);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_scatter_element(vd, vul, ptrd, 1);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_xl(idx, cptrf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vl
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_xl(idx, cptrd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vl
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_xst(vf, idx, ptrf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vst
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_xst(vd, idx, ptrd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vst
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_load_bndry(cptrd, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 64);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 128);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 256);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 512);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 1024);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 2048);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_bndry(cptrf, 4096);
// CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlbb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_load_len(cptrf, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vll
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_load_len(cptrd, idx);
// CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vll
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_store_len(vf, ptrf, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vstl
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_store_len(vd, ptrd, idx);
// CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vstl
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
vuc = vec_load_len_r(cptruc, 0);
// CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, i8* %{{.*}})
// CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vuc = vec_load_len_r(cptruc, idx);
// CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlrlr
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
vec_store_len_r(vuc, ptruc, 0);
// CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, i8* %{{.*}})
// CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vec_store_len_r(vuc, ptruc, idx);
// CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vstrlr
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_splat(vf, 0);
// CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> zeroinitializer
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vrepf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vrepf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_splat(vd, 0);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vrepg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_splat(vd, 1);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vrepg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_splats(f);
// CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> zeroinitializer
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlrepf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_splats(d);
// CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vlrepg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_mergeh(vf, vf);
// shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmrhf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_mergeh(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmrhg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_mergel(vf, vf);
// shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmrlf
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_mergel(vd, vd);
// shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmrlg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
}
void test_compare(void) {
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM-LABEL: test_compare
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_cmpeq(vf, vf);
// CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcesb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_cmpeq(vd, vd);
// CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcedb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_cmpge(vf, vf);
// CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_cmpge(vd, vd);
// CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_cmpgt(vf, vf);
// CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_cmpgt(vd, vd);
// CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_cmple(vf, vf);
// CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_cmple(vd, vd);
// CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_cmplt(vf, vf);
// CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_cmplt(vd, vd);
// CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_eq(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_eq(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ne(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ne(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ge(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_gt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_gt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_le(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_le(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_lt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_lt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
[SystemZ] Fix wrong codegen caused by typos in vecintrin.h The following two bugs in SystemZ high-level vector intrinsics are fixes by this patch: - The float case of vec_insert_and_zero should generate a VLLEZF pattern, but currently erroneously generates VLLEZLF. - The float and double versions of vec_orc erroneously generate and-with-complement instead of or-with-complement. The patch also fixes a couple of typos in the associated test. llvm-svn: 349751
2018-12-20 21:09:09 +08:00
idx = vec_all_nge(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ngt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_ngt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nle(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nle(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nlt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nlt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nan(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_nan(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_numeric(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_all_numeric(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_eq(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_eq(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ne(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ne(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfcedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ge(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_gt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_gt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_le(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_le(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_lt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_lt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nge(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nge(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ngt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_ngt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nle(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchesbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nle(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchedbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nlt(vf, vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchsbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nlt(vd, vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfchdbs
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nan(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_nan(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_numeric(vf);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_any_numeric(vd);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
}
void test_integer(void) {
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM-LABEL: test_integer
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_andc(vf, vf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_andc(vd, vd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_nor(vf, vf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vno
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_nor(vd, vd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vno
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsc = vec_nand(vsc, vsc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vuc = vec_nand(vuc, vuc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbc = vec_nand(vbc, vbc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vss = vec_nand(vss, vss);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vus = vec_nand(vus, vus);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbs = vec_nand(vbs, vbs);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsi = vec_nand(vsi, vsi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vui = vec_nand(vui, vui);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_nand(vbi, vbi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsl = vec_nand(vsl, vsl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vul = vec_nand(vul, vul);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_nand(vbl, vbl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_nand(vf, vf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_nand(vd, vd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnn
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsc = vec_orc(vsc, vsc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vuc = vec_orc(vuc, vuc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbc = vec_orc(vbc, vbc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vss = vec_orc(vss, vss);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vus = vec_orc(vus, vus);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbs = vec_orc(vbs, vbs);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsi = vec_orc(vsi, vsi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vui = vec_orc(vui, vui);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_orc(vbi, vbi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsl = vec_orc(vsl, vsl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vul = vec_orc(vul, vul);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_orc(vbl, vbl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_orc(vf, vf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_orc(vd, vd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: voc
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsc = vec_eqv(vsc, vsc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vuc = vec_eqv(vuc, vuc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbc = vec_eqv(vbc, vbc);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vss = vec_eqv(vss, vss);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vus = vec_eqv(vus, vus);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbs = vec_eqv(vbs, vbs);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsi = vec_eqv(vsi, vsi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vui = vec_eqv(vui, vui);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_eqv(vbi, vbi);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsl = vec_eqv(vsl, vsl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vul = vec_eqv(vul, vul);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_eqv(vbl, vbl);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_eqv(vf, vf);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vnx
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_eqv(vd, vd);
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// 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
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_slb(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vslb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_slb(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vslb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_slb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vslb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_slb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vslb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_sld(vf, vf, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsldb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_sld(vf, vf, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsldb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_sld(vd, vd, 0);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsldb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_sld(vd, vd, 15);
// CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsldb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_srab(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrab
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_srab(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrab
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_srab(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrab
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_srab(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrab
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_srb(vf, vsi);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrlb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_srb(vf, vui);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrlb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_srb(vd, vsl);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrlb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_srb(vd, vul);
// CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vsrlb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_test_mask(vf, vui);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vtm
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
idx = vec_test_mask(vd, vul);
// CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vtm
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmslg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmslg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmslg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vmslg
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
}
void test_float(void) {
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM-LABEL: test_float
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_abs(vf);
// CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vflpsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_abs(vd);
// CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vflpdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vflnsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vflndb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_max(vf, vf);
// CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmaxsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_max(vd, vd);
// CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmaxdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_min(vf, vf);
// CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfminsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_min(vd, vd);
// CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmindb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_madd(vf, vf, vf);
// CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmasb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_madd(vd, vd, vd);
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmadb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]])
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmssb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]])
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfmsdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfnmasb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfnmadb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfnmssb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
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]]
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfnmsdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_sqrt(vf);
// CHECK: call <4 x float> @llvm.sqrt.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfsqsb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_sqrt(vd);
// CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfsqdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_doublee(vf);
// CHECK: fpext <2 x float> %{{.*}} to <2 x double>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vldeb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_floate(vd);
// CHECK: fptrunc <2 x double> %{{.*}} to <2 x float>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vledb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_double(vsl);
// CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vcdgb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_double(vul);
// CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vcdlgb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vsl = vec_signed(vd);
// CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vcgdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vul = vec_unsigned(vd);
// CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vclgdb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_roundp(vf);
// CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_ceil(vf);
// CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_roundp(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_ceil(vd);
// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_roundm(vf);
// CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_floor(vf);
// CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_roundm(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_floor(vd);
// CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_roundz(vf);
// CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_trunc(vf);
// CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_roundz(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_trunc(vd);
// CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_roundc(vf);
// CHECK: call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_roundc(vd);
// CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_rint(vf);
// CHECK: call <4 x float> @llvm.rint.v4f32(<4 x float> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_rint(vd);
// CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vf = vec_round(vf);
// CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vd = vec_round(vd);
// CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_fp_test_data_class(vf, 0, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbi = vec_fp_test_data_class(vf, 4095, &cc);
// CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcisb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_fp_test_data_class(vd, 0, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
vbl = vec_fp_test_data_class(vd, 4095, &cc);
// CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
[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. llvm-svn: 349753
2018-12-20 21:10:47 +08:00
// CHECK-ASM: vftcidb
[SystemZ] Add support for IBM z14 processor (3/3) This patch updates the vecintrin.h header file to provide the new set of high-level vector built-in functions. This matches the updated definition implemented by other compilers for the platform, indicated by the pre-defined macro __VEC__ == 10302. Note that some of the new functions (notably those involving the vector float data type) are only available with -march=z14 (indicated by __ARCH__ == 12). llvm-svn: 308199
2017-07-18 01:47:35 +08:00
}