1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wno-string-plus-int -triple=i686-apple-darwin9
// This test needs to set the target because it uses __builtin_ia32_vec_ext_v4si
int test1(float a, int b) {
return __builtin_isless(a, b);
}
int test2(int a, int b) {
return __builtin_islessequal(a, b); // expected-error {{floating point type}}
}
int test3(double a, float b) {
return __builtin_isless(a, b);
}
int test4(int* a, double b) {
return __builtin_islessequal(a, b); // expected-error {{floating point type}}
}
int test5(float a, long double b) {
return __builtin_isless(a, b, b); // expected-error {{too many arguments}}
}
int test6(float a, long double b) {
return __builtin_islessequal(a); // expected-error {{too few arguments}}
}
#define CFSTR __builtin___CFStringMakeConstantString
void test7() {
const void *X;
X = CFSTR("\242"); // expected-warning {{input conversion stopped}}
X = CFSTR("\0"); // no-warning
X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-warning {{incompatible integer to pointer conversion}}
X = CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}}
}
// atomics.
void test9(short v) {
unsigned i, old;
old = __sync_fetch_and_add(); // expected-error {{too few arguments to function call}}
old = __sync_fetch_and_add(&old); // expected-error {{too few arguments to function call}}
old = __sync_fetch_and_add((unsigned*)0, 42i); // expected-warning {{imaginary constants are a GNU extension}}
// PR7600: Pointers are implicitly casted to integers and back.
void *old_ptr = __sync_val_compare_and_swap((void**)0, 0, 0);
// Ensure the return type is correct even when implicit casts are stripped
// away. This triggers an assertion while checking the comparison otherwise.
if (__sync_fetch_and_add(&old, 1) == 1) {
}
}
// overloaded atomics should be declared only once.
void test9_1(volatile int* ptr, int val) {
__sync_fetch_and_add_4(ptr, val);
}
void test9_2(volatile int* ptr, int val) {
__sync_fetch_and_add(ptr, val);
}
void test9_3(volatile int* ptr, int val) {
__sync_fetch_and_add_4(ptr, val);
__sync_fetch_and_add(ptr, val);
__sync_fetch_and_add(ptr, val);
__sync_fetch_and_add_4(ptr, val);
__sync_fetch_and_add_4(ptr, val);
}
// rdar://7236819
void test10(void) __attribute__((noreturn));
void test10(void) {
__asm__("int3");
__builtin_unreachable();
// No warning about falling off the end of a noreturn function.
}
void test11(int X) {
switch (X) {
case __builtin_eh_return_data_regno(0): // constant foldable.
break;
}
__builtin_eh_return_data_regno(X); // expected-error {{argument to '__builtin_eh_return_data_regno' must be a constant integer}}
}
// PR5062
void test12(void) __attribute__((__noreturn__));
void test12(void) {
__builtin_trap(); // no warning because trap is noreturn.
}
void test_unknown_builtin(int a, int b) {
__builtin_isles(a, b); // expected-error{{use of unknown builtin}} \
// expected-note{{did you mean '__builtin_isless'?}}
}
int test13() {
__builtin_eh_return(0, 0); // no warning, eh_return never returns.
}
// <rdar://problem/8228293>
void test14() {
int old;
old = __sync_fetch_and_min((volatile int *)&old, 1);
}
// <rdar://problem/8336581>
void test15(const char *s) {
__builtin_printf("string is %s\n", s);
}
// PR7885
int test16() {
return __builtin_constant_p() + // expected-error{{too few arguments}}
__builtin_constant_p(1, 2); // expected-error {{too many arguments}}
}
const int test17_n = 0;
const char test17_c[] = {1, 2, 3, 0};
const char test17_d[] = {1, 2, 3, 4};
typedef int __attribute__((vector_size(16))) IntVector;
struct Aggregate { int n; char c; };
enum Enum { EnumValue1, EnumValue2 };
typedef __typeof(sizeof(int)) size_t;
size_t strlen(const char *);
void test17() {
#define ASSERT(...) { int arr[(__VA_ARGS__) ? 1 : -1]; }
#define T(...) ASSERT(__builtin_constant_p(__VA_ARGS__))
#define F(...) ASSERT(!__builtin_constant_p(__VA_ARGS__))
// __builtin_constant_p returns 1 if the argument folds to:
// - an arithmetic constant with value which is known at compile time
T(test17_n);
T(&test17_c[3] - test17_c);
T(3i + 5); // expected-warning {{imaginary constant}}
T(4.2 * 7.6);
T(EnumValue1);
T((enum Enum)(int)EnumValue2);
// - the address of the first character of a string literal, losslessly cast
// to any type
T("string literal");
T((double*)"string literal");
T("string literal" + 0);
T((long)"string literal");
// ... and otherwise returns 0.
F("string literal" + 1);
F(&test17_n);
F(test17_c);
F(&test17_c);
F(&test17_d);
F((struct Aggregate){0, 1});
F((IntVector){0, 1, 2, 3});
// Ensure that a technique used in glibc is handled correctly.
#define OPT(...) (__builtin_constant_p(__VA_ARGS__) && strlen(__VA_ARGS__) < 4)
// FIXME: These are incorrectly treated as ICEs because strlen is treated as
// a builtin.
ASSERT(OPT("abc"));
ASSERT(!OPT("abcd"));
// In these cases, the strlen is non-constant, but the __builtin_constant_p
// is 0: the array size is not an ICE but is foldable.
ASSERT(!OPT(test17_c)); // expected-warning {{folded}}
ASSERT(!OPT(&test17_c[0])); // expected-warning {{folded}}
ASSERT(!OPT((char*)test17_c)); // expected-warning {{folded}}
ASSERT(!OPT(test17_d)); // expected-warning {{folded}}
ASSERT(!OPT(&test17_d[0])); // expected-warning {{folded}}
ASSERT(!OPT((char*)test17_d)); // expected-warning {{folded}}
#undef OPT
#undef T
#undef F
}
void test18() {
char src[1024];
char dst[2048];
size_t result;
void *ptr;
ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src), sizeof(dst));
result = __builtin___strlcpy_chk(dst, src, sizeof(src), sizeof(dst));
result = __builtin___strlcat_chk(dst, src, sizeof(src), sizeof(dst));
ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src)); // expected-error {{too few arguments to function call}}
ptr = __builtin___strlcpy_chk(dst, src, sizeof(src), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
ptr = __builtin___strlcat_chk(dst, src, sizeof(src), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
}
|
