1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
2
3 // rdar://13784901
4
5 struct S0 {
6 int x;
7 static const int test0 = __alignof__(x); // expected-error {{invalid application of 'alignof' to a field of a class still being defined}}
8 static const int test1 = __alignof__(S0::x); // expected-error {{invalid application of 'alignof' to a field of a class still being defined}}
9 auto test2() -> char(&)[__alignof__(x)]; // expected-error {{invalid application of 'alignof' to a field of a class still being defined}}
10 };
11
12 struct S1; // expected-note 6 {{forward declaration}}
13 extern S1 s1;
14 const int test3 = __alignof__(s1); // expected-error {{invalid application of '__alignof' to an incomplete type 'S1'}}
15
16 struct S2 {
17 S2();
18 S1 &s;
19 int x;
20
21 int test4 = __alignof__(x); // ok
22 int test5 = __alignof__(s); // expected-error {{invalid application of '__alignof' to an incomplete type 'S1'}}
23 };
24
25 const int test6 = __alignof__(S2::x);
26 const int test7 = __alignof__(S2::s); // expected-error {{invalid application of '__alignof' to an incomplete type 'S1'}}
27
28 // Arguably, these should fail like the S1 cases do: the alignment of
29 // 's2.x' should depend on the alignment of both x-within-S2 and
30 // s2-within-S3 and thus require 'S3' to be complete. If we start
31 // doing the appropriate recursive walk to do that, we should make
32 // sure that these cases don't explode.
33 struct S3 {
34 S2 s2;
35
36 static const int test8 = __alignof__(s2.x);
37 static const int test9 = __alignof__(s2.s); // expected-error {{invalid application of '__alignof' to an incomplete type 'S1'}}
38 auto test10() -> char(&)[__alignof__(s2.x)];
39 static const int test11 = __alignof__(S3::s2.x);
40 static const int test12 = __alignof__(S3::s2.s); // expected-error {{invalid application of '__alignof' to an incomplete type 'S1'}}
41 auto test13() -> char(&)[__alignof__(s2.x)];
42 };
43
44 // Same reasoning as S3.
45 struct S4 {
46 union {
47 int x;
48 };
49 static const int test0 = __alignof__(x);
50 static const int test1 = __alignof__(S0::x);
51 auto test2() -> char(&)[__alignof__(x)];
52 };
53
54 // Regression test for asking for the alignment of a field within an invalid
55 // record.
56 struct S5 {
57 S1 s; // expected-error {{incomplete type}}
58 int x;
59 };
60 const int test8 = __alignof__(S5::x);
61
62 int test14[2];
63
64 static_assert(alignof(test14) == 4, "foo"); // expected-warning {{'alignof' applied to an expression is a GNU extension}}
65
66 // PR19992
67 static_assert(alignof(int[]) == alignof(int), ""); // ok
68
69 namespace alignof_array_expr {
70 alignas(32) extern int n[];
71 static_assert(alignof(n) == 32, ""); // expected-warning {{GNU extension}}
72
73 template<int> struct S {
74 static int a[];
75 };
76 template<int N> int S<N>::a[N];
77 // ok, does not complete type of S<-1>::a
78 static_assert(alignof(S<-1>::a) == alignof(int), ""); // expected-warning {{GNU extension}}
79 }
80
n(T)81 template <typename T> void n(T) {
82 alignas(T) int T1;
83 char k[__alignof__(T1)];
84 static_assert(sizeof(k) == alignof(long long), "");
85 }
86 template void n(long long);
87
88 namespace PR22042 {
89 template <typename T>
Fun(T A)90 void Fun(T A) {
91 typedef int __attribute__((__aligned__(A))) T1; // expected-error {{requested alignment is dependent but declaration is not dependent}}
92 int k1[__alignof__(T1)];
93 }
94
95 template <int N>
96 struct S {
97 typedef __attribute__((aligned(N))) int Field[sizeof(N)]; // expected-error {{requested alignment is dependent but declaration is not dependent}}
98 };
99 }
100
101 typedef int __attribute__((aligned(16))) aligned_int;
102 template <typename>
103 using template_alias = aligned_int;
104 static_assert(alignof(template_alias<void>) == 16, "Expected alignment of 16" );
105
106 struct PR47138 {
107 invalid_type a; // expected-error {{unknown type}}
108 };
109 static_assert(__alignof__(PR47138) == 1, ""); // Don't crash.
110