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 long long int test14[2]; 63 64 static_assert(alignof(test14) == 8, "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)81template <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)90void 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