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
|
// RUN: %clang_cc1 %s -fsyntax-only -verify -triple x86_64-pc-linux-gnu -Wno-unevaluated-expression
typedef unsigned __uint32_t;
#define __byte_swap_int_var(x) \
__extension__ ({ register __uint32_t __X = (x); \
__asm ("bswap %0" : "+r" (__X)); \
__X; })
int test(int _x) {
return (__byte_swap_int_var(_x));
}
// PR2374
int test2(void) { return ({L:5;}); }
int test3(void) { return ({ {5;} }); } // expected-error {{returning 'void' from a function with incompatible result type 'int'}}\
// expected-warning {{expression result unused}}
int test4(void) { return ({ ({5;}); }); }
int test5(void) { return ({L1: L2: L3: 5;}); }
int test6(void) { return ({5;}); }
void test7(void) { ({5;}); } // expected-warning {{expression result unused}}
// PR3062
int test8[({10;})]; // expected-error {{statement expression not allowed at file scope}}
// PR3912
void test9(const void *P) {
__builtin_prefetch(P);
}
void *test10(void) {
bar:
return &&bar; // expected-warning {{returning address of label, which is local}}
}
// PR38569: Don't warn when returning a label from a statement expression.
void test10_logpc(void*);
void test10a(void) {
test10_logpc(({
my_pc:
&&my_pc;
}));
}
// PR6034
void test11(int bit) {
switch (bit)
switch (env->fpscr) // expected-error {{use of undeclared identifier 'env'}}
{
}
}
// rdar://3271964
enum Numbers { kOne, kTwo, kThree, kFour};
int test12(enum Numbers num) {
switch (num == kOne) {// expected-warning {{switch condition has boolean value}}
default:
case kThree:
break;
}
}
enum x { a, b, c, d, e, f, g };
void foo(enum x X) {
switch (X) { // expected-warning {{enumeration value 'g' not handled in switch}}
case a:
case b:
case c:
case d:
case e:
case f:
break;
}
switch (X) { // expected-warning {{enumeration values 'f' and 'g' not handled in switch}}
case a:
case b:
case c:
case d:
case e:
break;
}
switch (X) { // expected-warning {{enumeration values 'e', 'f', and 'g' not handled in switch}}
case a:
case b:
case c:
case d:
break;
}
switch (X) { // expected-warning {{5 enumeration values not handled in switch: 'c', 'd', 'e'...}}
case a:
case b:
break;
}
}
int test_pr8880(void) {
int first = 1;
for ( ; ({ if (first) { first = 0; continue; } 0; }); )
return 0;
return 1;
}
// In PR22849, we considered __ptr to be a static data member of the anonymous
// union. Now we declare it in the parent DeclContext.
void test_pr22849(void) {
struct Bug {
typeof(({ unsigned long __ptr; (int *)(0); })) __val;
union Nested {
typeof(({ unsigned long __ptr; (int *)(0); })) __val;
} n;
};
enum E {
SIZE = sizeof(({unsigned long __ptr; __ptr;}))
};
}
// GCC ignores empty statements at the end of compound expressions where the
// result type is concerned.
void test13(void) {
int a;
a = ({ 1; });
a = ({1;; });
a = ({int x = 1; (void)x; }); // expected-error {{assigning to 'int' from incompatible type 'void'}}
a = ({int x = 1; (void)x;; }); // expected-error {{assigning to 'int' from incompatible type 'void'}}
}
void test14(void) { return ({}); }
void test15(void) {
return ({;;;; });
}
void test16(void) {
return ({test:;; });
}
|
