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-zvector-er...

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

566 lines
48 KiB
C
Raw Normal View History

[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// REQUIRES: systemz-registered-target
// RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
For PR17164: split -fno-lax-vector-conversion into three different levels: -- none: no lax vector conversions [new GCC default] -- integer: only conversions between integer vectors [old GCC default] -- all: all conversions between same-size vectors [Clang default] For now, Clang still defaults to "all" mode, but per my proposal on cfe-dev (2019-04-10) the default will be changed to "integer" as soon as that doesn't break lots of testcases. (Eventually I'd like to change the default to "none" to match GCC and general sanity.) Following GCC's behavior, the driver flag -flax-vector-conversions is translated to -flax-vector-conversions=integer. This reinstates r371805, reverted in r371813, with an additional fix for lldb. llvm-svn: 371817
2019-09-13 14:02:15 +08:00
// RUN: -fzvector -flax-vector-conversions=none \
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// RUN: -Wall -Wno-unused -Werror -fsyntax-only -verify %s
#include <vecintrin.h>
volatile vector signed char vsc;
volatile vector signed short vss;
volatile vector signed int vsi;
volatile vector signed long long vsl;
volatile vector unsigned char vuc;
volatile vector unsigned short vus;
volatile vector unsigned int vui;
volatile vector unsigned long long vul;
volatile vector bool char vbc;
volatile vector bool short vbs;
volatile vector bool int vbi;
volatile vector bool long long vbl;
volatile vector double vd;
volatile signed char sc;
volatile signed short ss;
volatile signed int si;
volatile signed long long sl;
volatile unsigned char uc;
volatile unsigned short us;
volatile unsigned int ui;
volatile unsigned long long ul;
volatile double d;
const void * volatile cptr;
const signed char * volatile cptrsc;
const signed short * volatile cptrss;
const signed int * volatile cptrsi;
const signed long long * volatile cptrsl;
const unsigned char * volatile cptruc;
const unsigned short * volatile cptrus;
const unsigned int * volatile cptrui;
const unsigned long long * volatile cptrul;
const float * volatile cptrf;
const double * volatile cptrd;
void * volatile ptr;
signed char * volatile ptrsc;
signed short * volatile ptrss;
signed int * volatile ptrsi;
signed long long * volatile ptrsl;
unsigned char * volatile ptruc;
unsigned short * volatile ptrus;
unsigned int * volatile ptrui;
unsigned long long * volatile ptrul;
float * volatile ptrf;
double * volatile ptrd;
volatile unsigned int len;
volatile int idx;
int cc;
void test_core(void) {
len = __lcbb(cptr, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
len = __lcbb(cptr, 200); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
len = __lcbb(cptr, 32); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
len = __lcbb(cptr, 8192); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
vsl = vec_permi(vsl, vsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsl = vec_permi(vsl, vsl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsl = vec_permi(vsl, vsl, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vul = vec_permi(vul, vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vul = vec_permi(vul, vul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vul = vec_permi(vul, vul, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbl = vec_permi(vbl, vbl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbl = vec_permi(vbl, vbl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbl = vec_permi(vbl, vbl, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 2 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vd = vec_permi(vd, vd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vd = vec_permi(vd, vd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vd = vec_permi(vd, vd, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 3 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_gather_element(vsi, vui, cptrsi, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_gather_element(vsi, vui, cptrsi, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_gather_element(vsi, vui, cptrsi, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vui = vec_gather_element(vui, vui, cptrui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vui = vec_gather_element(vui, vui, cptrui, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vui = vec_gather_element(vui, vui, cptrui, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_gather_element(vbi, vui, cptrui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_gather_element(vbi, vui, cptrui, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_gather_element(vbi, vui, cptrui, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vsl = vec_gather_element(vsl, vul, cptrsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsl = vec_gather_element(vsl, vul, cptrsl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsl = vec_gather_element(vsl, vul, cptrsl, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vul = vec_gather_element(vul, vul, cptrul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vul = vec_gather_element(vul, vul, cptrul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vul = vec_gather_element(vul, vul, cptrul, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_gather_element(vbl, vul, cptrul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_gather_element(vbl, vul, cptrul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_gather_element(vbl, vul, cptrul, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vd = vec_gather_element(vd, vul, cptrd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vd = vec_gather_element(vd, vul, cptrd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vd = vec_gather_element(vd, vul, cptrd, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vsi, vui, ptrsi, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vsi, vui, ptrsi, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vsi, vui, ptrsi, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vui, vui, ptrui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vui, vui, ptrui, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vui, vui, ptrui, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vbi, vui, ptrui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vbi, vui, ptrui, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vbi, vui, ptrui, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vsl, vul, ptrsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vsl, vul, ptrsl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vsl, vul, ptrsl, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vul, vul, ptrul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vul, vul, ptrul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vul, vul, ptrul, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vbl, vul, ptrul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vbl, vul, ptrul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vbl, vul, ptrul, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 5 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vd, vul, ptrd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vd, vul, ptrd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vec_scatter_element(vd, vul, ptrd, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 6 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsc = vec_load_bndry(cptrsc, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsc = vec_load_bndry(cptrsc, 200); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsc = vec_load_bndry(cptrsc, 32); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsc = vec_load_bndry(cptrsc, 8192); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vuc = vec_load_bndry(cptruc, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vss = vec_load_bndry(cptrss, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vus = vec_load_bndry(cptrus, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsi = vec_load_bndry(cptrsi, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vui = vec_load_bndry(cptrui, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsl = vec_load_bndry(cptrsl, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vul = vec_load_bndry(cptrul, idx); // expected-error {{no matching function}}
[Sema] Relax overloading restrictions in C. This patch allows us to perform incompatible pointer conversions when resolving overloads in C. So, the following code will no longer fail to compile (though it will still emit warnings, assuming the user hasn't opted out of them): ``` void foo(char *) __attribute__((overloadable)); void foo(int) __attribute__((overloadable)); void callFoo() { unsigned char bar[128]; foo(bar); // selects the char* overload. } ``` These conversions are ranked below all others, so: A. Any other viable conversion will win out B. If we had another incompatible pointer conversion in the example above (e.g. `void foo(int *)`), we would complain about an ambiguity. Differential Revision: https://reviews.llvm.org/D24113 llvm-svn: 280553
2016-09-03 06:59:57 +08:00
// expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vuc = vec_genmask(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vuc = vec_genmasks_8(0, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vuc = vec_genmasks_8(idx, 0); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vuc = vec_genmasks_8(idx, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vus = vec_genmasks_16(0, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vus = vec_genmasks_16(idx, 0); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vus = vec_genmasks_16(idx, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vui = vec_genmasks_32(0, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vui = vec_genmasks_32(idx, 0); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vui = vec_genmasks_32(idx, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vul = vec_genmasks_64(0, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vul = vec_genmasks_64(idx, 0); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vul = vec_genmasks_64(idx, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vsc = vec_splat(vsc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vsc = vec_splat(vsc, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vsc = vec_splat(vsc, 16); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vuc = vec_splat(vuc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vuc = vec_splat(vuc, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vuc = vec_splat(vuc, 16); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vbc = vec_splat(vbc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vbc = vec_splat(vbc, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vbc = vec_splat(vbc, 16); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
vss = vec_splat(vss, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
vss = vec_splat(vss, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
vss = vec_splat(vss, 8); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
vus = vec_splat(vus, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vus = vec_splat(vus, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vus = vec_splat(vus, 8); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vbs = vec_splat(vbs, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vbs = vec_splat(vbs, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vbs = vec_splat(vbs, 8); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
vsi = vec_splat(vsi, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_splat(vsi, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_splat(vsi, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vui = vec_splat(vui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vui = vec_splat(vui, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vui = vec_splat(vui, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_splat(vbi, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_splat(vbi, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vbi = vec_splat(vbi, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
vsl = vec_splat(vsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsl = vec_splat(vsl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsl = vec_splat(vsl, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vul = vec_splat(vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vul = vec_splat(vul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vul = vec_splat(vul, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_splat(vbl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_splat(vbl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vbl = vec_splat(vbl, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
vd = vec_splat(vd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vd = vec_splat(vd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vd = vec_splat(vd, 2); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
vsc = vec_splat_s8(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vuc = vec_splat_u8(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vss = vec_splat_s16(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vus = vec_splat_u16(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vsi = vec_splat_s32(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vui = vec_splat_u32(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vsl = vec_splat_s64(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
vul = vec_splat_u64(idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* {{must be a constant integer}}
}
void test_integer(void) {
vsc = vec_rl_mask(vsc, vuc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vuc = vec_rl_mask(vuc, vuc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vss = vec_rl_mask(vss, vus, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vus = vec_rl_mask(vus, vus, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vsi = vec_rl_mask(vsi, vui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vui = vec_rl_mask(vui, vui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vsl = vec_rl_mask(vsl, vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vul = vec_rl_mask(vul, vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 7 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer}}
vsc = vec_sld(vsc, vsc, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vsc = vec_sld(vsc, vsc, -1); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vsc = vec_sld(vsc, vsc, 16); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vuc = vec_sld(vuc, vuc, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vuc = vec_sld(vuc, vuc, -1); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vuc = vec_sld(vuc, vuc, 16); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vss = vec_sld(vss, vss, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vus = vec_sld(vus, vus, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsi = vec_sld(vsi, vsi, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vui = vec_sld(vui, vui, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vsl = vec_sld(vsl, vsl, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vul = vec_sld(vul, vul, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 11 {{candidate function not viable}}
// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
vd = vec_sld(vd, vd, idx); // expected-error {{no matching function}}
[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
// expected-note@vecintrin.h:* 12 {{candidate function not viable}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
vsc = vec_sldw(vsc, vsc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsc = vec_sldw(vsc, vsc, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsc = vec_sldw(vsc, vsc, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vuc = vec_sldw(vuc, vuc, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vuc = vec_sldw(vuc, vuc, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vuc = vec_sldw(vuc, vuc, 4); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vss = vec_sldw(vss, vss, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vus = vec_sldw(vus, vus, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsi = vec_sldw(vsi, vsi, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vui = vec_sldw(vui, vui, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vsl = vec_sldw(vsl, vsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vul = vec_sldw(vul, vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vd = vec_sldw(vd, vd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 8 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
}
void test_float(void) {
vd = vec_ctd(vsl, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vd = vec_ctd(vsl, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vd = vec_ctd(vsl, 32); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vd = vec_ctd(vul, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vd = vec_ctd(vul, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vd = vec_ctd(vul, 32); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{candidate function not viable}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vsl = vec_ctsl(vd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vsl = vec_ctsl(vd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vsl = vec_ctsl(vd, 32); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vul = vec_ctul(vd, idx); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vul = vec_ctul(vd, -1); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vul = vec_ctul(vd, 32); // expected-error {{no matching function}}
// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
vbl = vec_fp_test_data_class(vd, idx, &cc); // expected-error {{must be a constant integer}}
[x86] Teach the builtin argument range check to allow invalid ranges in dead code. This is important for C++ templates that essentially compute the valid input in a way that is constant and will cause all the invalid cases to be dead code that is deleted. Code in the wild actually does this and GCC also accepts these kinds of patterns so it is important to support it. To make this work, we provide a non-error path to diagnose these issues, and use a default-error warning instead. This keeps the relatively strict handling but prevents nastiness like SFINAE on these errors. It also allows us to safely use the system to diagnose this only when it occurs at runtime (in emitted code). Entertainingly, this required fixing the syntax in various other ways for the x86 test because we never bothered to diagnose that the returns were invalid. Since debugging these compile failures was super confusing, I've also improved the diagnostic to actually say what the value was. Most of the checks I've made ignore this to simplify maintenance, but I've checked it in a few places to make sure the diagnsotic is working. Depends on D48462. Without that, we might actually crash some part of the compiler after bypassing the error here. Thanks to Richard, Ben Kramer, and especially Craig Topper for all the help here. Differential Revision: https://reviews.llvm.org/D48464 llvm-svn: 335309
2018-06-22 07:46:09 +08:00
vbl = vec_fp_test_data_class(vd, -1, &cc); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vbl = vec_fp_test_data_class(vd, 4096, &cc); // expected-error-re {{argument value {{.*}} is outside the valid range}}
[SystemZ] Add support for vecintrin.h vector built-in functions This patch adds support for the System Z vector built-in functions. The API-defined header file has the name vecintrin.h. The user-level functions are defined in the same style as the clang version of altivec.h, making heavy use of the __overloadable__ and __always_inline__ attributes. Where possible the functions expand to generic operations rather than specific built-in functions, in the hope that that form can be optimised better. Where a built-in routine is specified to require an immediate integer argument, the __enable_if__ attribute is used to verify the argument is in fact constant and in the appropriate range. Based on a patch by Richard Sandiford. llvm-svn: 243643
2015-07-30 22:10:43 +08:00
}