| 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 | |
|---|
| 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> |
|---|
| 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 | |
|---|