|
150
|
1 // RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++11 -fcxx-exceptions
|
|
|
2 // RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++1z -fcxx-exceptions
|
|
|
3 typedef const struct __CFString * CFStringRef;
|
|
|
4 #define CFSTR __builtin___CFStringMakeConstantString
|
|
|
5
|
|
|
6 void f() {
|
|
236
|
7 #if !defined(__MVS__) && !defined(_AIX)
|
|
|
8 // Builtin function __builtin___CFStringMakeConstantString is currently
|
|
|
9 // unsupported on z/OS and AIX.
|
|
150
|
10 (void)CFStringRef(CFSTR("Hello"));
|
|
236
|
11 #endif
|
|
150
|
12 }
|
|
|
13
|
|
|
14 void a() { __builtin_va_list x, y; ::__builtin_va_copy(x, y); }
|
|
|
15
|
|
|
16 // <rdar://problem/10063539>
|
|
|
17 template<int (*Compare)(const char *s1, const char *s2)>
|
|
|
18 int equal(const char *s1, const char *s2) {
|
|
|
19 return Compare(s1, s2) == 0;
|
|
|
20 }
|
|
173
|
21 template int equal<&__builtin_strcmp>(const char*, const char*); // expected-error {{builtin functions must be directly called}}
|
|
150
|
22
|
|
|
23 // PR13195
|
|
|
24 void f2() {
|
|
|
25 __builtin_isnan; // expected-error {{builtin functions must be directly called}}
|
|
|
26 }
|
|
|
27
|
|
|
28 // pr14895
|
|
|
29 typedef __typeof(sizeof(int)) size_t;
|
|
|
30 extern "C" void *__builtin_alloca (size_t);
|
|
|
31
|
|
|
32 namespace addressof {
|
|
|
33 struct S {} s;
|
|
|
34 static_assert(__builtin_addressof(s) == &s, "");
|
|
|
35
|
|
|
36 struct T { constexpr T *operator&() const { return nullptr; } int n; } t;
|
|
|
37 constexpr T *pt = __builtin_addressof(t);
|
|
|
38 static_assert(&pt->n == &t.n, "");
|
|
|
39
|
|
|
40 struct U { int n : 5; } u;
|
|
|
41 int *pbf = __builtin_addressof(u.n); // expected-error {{address of bit-field requested}}
|
|
|
42
|
|
|
43 S *ptmp = __builtin_addressof(S{}); // expected-error {{taking the address of a temporary}}
|
|
|
44 }
|
|
|
45
|
|
236
|
46 namespace function_start {
|
|
|
47 void a(void) {}
|
|
|
48 int n;
|
|
|
49 void *p = __builtin_function_start(n); // expected-error {{argument must be a function}}
|
|
|
50 static_assert(__builtin_function_start(a) == a, ""); // expected-error {{static assertion expression is not an integral constant expression}}
|
|
|
51 } // namespace function_start
|
|
|
52
|
|
150
|
53 void no_ms_builtins() {
|
|
|
54 __assume(1); // expected-error {{use of undeclared}}
|
|
|
55 __noop(1); // expected-error {{use of undeclared}}
|
|
|
56 __debugbreak(); // expected-error {{use of undeclared}}
|
|
|
57 }
|
|
|
58
|
|
|
59 struct FILE;
|
|
|
60 extern "C" int vfprintf(FILE *__restrict, const char *__restrict,
|
|
|
61 __builtin_va_list va);
|
|
|
62
|
|
|
63 void synchronize_args() {
|
|
|
64 __sync_synchronize(0); // expected-error {{too many arguments}}
|
|
|
65 }
|
|
|
66
|
|
|
67 namespace test_launder {
|
|
|
68 #define TEST_TYPE(Ptr, Type) \
|
|
|
69 static_assert(__is_same(decltype(__builtin_launder(Ptr)), Type), "expected same type")
|
|
|
70
|
|
|
71 struct Dummy {};
|
|
|
72
|
|
|
73 using FnType = int(char);
|
|
|
74 using MemFnType = int (Dummy::*)(char);
|
|
|
75 using ConstMemFnType = int (Dummy::*)() const;
|
|
|
76
|
|
|
77 void foo() {}
|
|
|
78
|
|
|
79 void test_builtin_launder_diags(void *vp, const void *cvp, FnType *fnp,
|
|
|
80 MemFnType mfp, ConstMemFnType cmfp, int (&Arr)[5]) {
|
|
|
81 __builtin_launder(vp); // expected-error {{void pointer argument to '__builtin_launder' is not allowed}}
|
|
|
82 __builtin_launder(cvp); // expected-error {{void pointer argument to '__builtin_launder' is not allowed}}
|
|
|
83 __builtin_launder(fnp); // expected-error {{function pointer argument to '__builtin_launder' is not allowed}}
|
|
|
84 __builtin_launder(mfp); // expected-error {{non-pointer argument to '__builtin_launder' is not allowed}}
|
|
|
85 __builtin_launder(cmfp); // expected-error {{non-pointer argument to '__builtin_launder' is not allowed}}
|
|
|
86 (void)__builtin_launder(&fnp);
|
|
|
87 __builtin_launder(42); // expected-error {{non-pointer argument to '__builtin_launder' is not allowed}}
|
|
|
88 __builtin_launder(nullptr); // expected-error {{non-pointer argument to '__builtin_launder' is not allowed}}
|
|
|
89 __builtin_launder(foo); // expected-error {{function pointer argument to '__builtin_launder' is not allowed}}
|
|
|
90 (void)__builtin_launder(Arr);
|
|
|
91 }
|
|
|
92
|
|
|
93 void test_builtin_launder(char *p, const volatile int *ip, const float *&fp,
|
|
|
94 double *__restrict dp) {
|
|
|
95 int x;
|
|
|
96 __builtin_launder(x); // expected-error {{non-pointer argument to '__builtin_launder' is not allowed}}
|
|
|
97
|
|
|
98 TEST_TYPE(p, char*);
|
|
|
99 TEST_TYPE(ip, const volatile int*);
|
|
|
100 TEST_TYPE(fp, const float*);
|
|
|
101 TEST_TYPE(dp, double *__restrict);
|
|
|
102
|
|
|
103 char *d = __builtin_launder(p);
|
|
|
104 const volatile int *id = __builtin_launder(ip);
|
|
|
105 int *id2 = __builtin_launder(ip); // expected-error {{cannot initialize a variable of type 'int *' with an rvalue of type 'const volatile int *'}}
|
|
|
106 const float* fd = __builtin_launder(fp);
|
|
|
107 }
|
|
|
108
|
|
|
109 void test_launder_return_type(const int (&ArrayRef)[101], int (&MArrRef)[42][13],
|
|
|
110 void (**&FuncPtrRef)()) {
|
|
|
111 TEST_TYPE(ArrayRef, const int *);
|
|
|
112 TEST_TYPE(MArrRef, int(*)[13]);
|
|
|
113 TEST_TYPE(FuncPtrRef, void (**)());
|
|
|
114 }
|
|
|
115
|
|
|
116 template <class Tp>
|
|
|
117 constexpr Tp *test_constexpr_launder(Tp *tp) {
|
|
|
118 return __builtin_launder(tp);
|
|
|
119 }
|
|
|
120 constexpr int const_int = 42;
|
|
|
121 constexpr int const_int2 = 101;
|
|
|
122 constexpr const int *const_ptr = test_constexpr_launder(&const_int);
|
|
|
123 static_assert(&const_int == const_ptr, "");
|
|
|
124 static_assert(const_ptr != test_constexpr_launder(&const_int2), "");
|
|
|
125
|
|
|
126 void test_non_constexpr() {
|
|
221
|
127 constexpr int i = 42; // expected-note {{address of non-static constexpr variable 'i' may differ on each invocation}}
|
|
150
|
128 constexpr const int *ip = __builtin_launder(&i); // expected-error {{constexpr variable 'ip' must be initialized by a constant expression}}
|
|
|
129 // expected-note@-1 {{pointer to 'i' is not a constant expression}}
|
|
|
130 }
|
|
|
131
|
|
|
132 constexpr bool test_in_constexpr(const int &i) {
|
|
|
133 return (__builtin_launder(&i) == &i);
|
|
|
134 }
|
|
|
135
|
|
|
136 static_assert(test_in_constexpr(const_int), "");
|
|
|
137 void f() {
|
|
|
138 constexpr int i = 42;
|
|
|
139 static_assert(test_in_constexpr(i), "");
|
|
|
140 }
|
|
|
141
|
|
|
142 struct Incomplete; // expected-note {{forward declaration}}
|
|
|
143 struct IncompleteMember {
|
|
|
144 Incomplete &i;
|
|
|
145 };
|
|
|
146 void test_incomplete(Incomplete *i, IncompleteMember *im) {
|
|
236
|
147 // expected-error@+1 {{incomplete type 'Incomplete' where a complete type is required}}
|
|
150
|
148 __builtin_launder(i);
|
|
|
149 __builtin_launder(&i); // OK
|
|
|
150 __builtin_launder(im); // OK
|
|
|
151 }
|
|
|
152
|
|
|
153 void test_noexcept(int *i) {
|
|
|
154 static_assert(noexcept(__builtin_launder(i)), "");
|
|
|
155 }
|
|
|
156 #undef TEST_TYPE
|
|
|
157 } // end namespace test_launder
|
|
221
|
158
|
|
|
159 template<typename T> void test_builtin_complex(T v, double d) {
|
|
|
160 (void)__builtin_complex(v, d); // expected-error {{different types}} expected-error {{not a real floating}}
|
|
|
161 (void)__builtin_complex(d, v); // expected-error {{different types}} expected-error {{not a real floating}}
|
|
|
162 (void)__builtin_complex(v, v); // expected-error {{not a real floating}}
|
|
|
163 }
|
|
|
164 template void test_builtin_complex(double, double);
|
|
|
165 template void test_builtin_complex(float, double); // expected-note {{instantiation of}}
|
|
|
166 template void test_builtin_complex(int, double); // expected-note {{instantiation of}}
|
