1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // type_traits
11 
12 // aligned_storage
13 
14 #include <type_traits>
15 
main()16 int main()
17 {
18     {
19     typedef std::aligned_storage<10, 1 >::type T1;
20 #if _LIBCPP_STD_VER > 11
21     static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "" );
22 #endif
23     static_assert(std::alignment_of<T1>::value == 1, "");
24     static_assert(sizeof(T1) == 10, "");
25     }
26     {
27     typedef std::aligned_storage<10, 2 >::type T1;
28 #if _LIBCPP_STD_VER > 11
29     static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "" );
30 #endif
31     static_assert(std::alignment_of<T1>::value == 2, "");
32     static_assert(sizeof(T1) == 10, "");
33     }
34     {
35     typedef std::aligned_storage<10, 4 >::type T1;
36 #if _LIBCPP_STD_VER > 11
37     static_assert(std::is_same<std::aligned_storage_t<10, 4>, T1>::value, "" );
38 #endif
39     static_assert(std::alignment_of<T1>::value == 4, "");
40     static_assert(sizeof(T1) == 12, "");
41     }
42     {
43     typedef std::aligned_storage<10, 8 >::type T1;
44 #if _LIBCPP_STD_VER > 11
45     static_assert(std::is_same<std::aligned_storage_t<10, 8>, T1>::value, "" );
46 #endif
47     static_assert(std::alignment_of<T1>::value == 8, "");
48     static_assert(sizeof(T1) == 16, "");
49     }
50     {
51     typedef std::aligned_storage<10, 16 >::type T1;
52 #if _LIBCPP_STD_VER > 11
53     static_assert(std::is_same<std::aligned_storage_t<10, 16>, T1>::value, "" );
54 #endif
55     static_assert(std::alignment_of<T1>::value == 16, "");
56     static_assert(sizeof(T1) == 16, "");
57     }
58     {
59     typedef std::aligned_storage<10, 32 >::type T1;
60 #if _LIBCPP_STD_VER > 11
61     static_assert(std::is_same<std::aligned_storage_t<10, 32>, T1>::value, "" );
62 #endif
63     static_assert(std::alignment_of<T1>::value == 32, "");
64     static_assert(sizeof(T1) == 32, "");
65     }
66     {
67     typedef std::aligned_storage<20, 32 >::type T1;
68 #if _LIBCPP_STD_VER > 11
69     static_assert(std::is_same<std::aligned_storage_t<20, 32>, T1>::value, "" );
70 #endif
71     static_assert(std::alignment_of<T1>::value == 32, "");
72     static_assert(sizeof(T1) == 32, "");
73     }
74     {
75     typedef std::aligned_storage<40, 32 >::type T1;
76 #if _LIBCPP_STD_VER > 11
77     static_assert(std::is_same<std::aligned_storage_t<40, 32>, T1>::value, "" );
78 #endif
79     static_assert(std::alignment_of<T1>::value == 32, "");
80     static_assert(sizeof(T1) == 64, "");
81     }
82     {
83     typedef std::aligned_storage<12, 16 >::type T1;
84 #if _LIBCPP_STD_VER > 11
85     static_assert(std::is_same<std::aligned_storage_t<12, 16>, T1>::value, "" );
86 #endif
87     static_assert(std::alignment_of<T1>::value == 16, "");
88     static_assert(sizeof(T1) == 16, "");
89     }
90     {
91     typedef std::aligned_storage<1>::type T1;
92 #if _LIBCPP_STD_VER > 11
93     static_assert(std::is_same<std::aligned_storage_t<1>, T1>::value, "" );
94 #endif
95     static_assert(std::alignment_of<T1>::value == 1, "");
96     static_assert(sizeof(T1) == 1, "");
97     }
98     {
99     typedef std::aligned_storage<2>::type T1;
100 #if _LIBCPP_STD_VER > 11
101     static_assert(std::is_same<std::aligned_storage_t<2>, T1>::value, "" );
102 #endif
103     static_assert(std::alignment_of<T1>::value == 2, "");
104     static_assert(sizeof(T1) == 2, "");
105     }
106     {
107     typedef std::aligned_storage<3>::type T1;
108 #if _LIBCPP_STD_VER > 11
109     static_assert(std::is_same<std::aligned_storage_t<3>, T1>::value, "" );
110 #endif
111     static_assert(std::alignment_of<T1>::value == 2, "");
112     static_assert(sizeof(T1) == 4, "");
113     }
114     {
115     typedef std::aligned_storage<4>::type T1;
116 #if _LIBCPP_STD_VER > 11
117     static_assert(std::is_same<std::aligned_storage_t<4>, T1>::value, "" );
118 #endif
119     static_assert(std::alignment_of<T1>::value == 4, "");
120     static_assert(sizeof(T1) == 4, "");
121     }
122     {
123     typedef std::aligned_storage<5>::type T1;
124 #if _LIBCPP_STD_VER > 11
125     static_assert(std::is_same<std::aligned_storage_t<5>, T1>::value, "" );
126 #endif
127     static_assert(std::alignment_of<T1>::value == 4, "");
128     static_assert(sizeof(T1) == 8, "");
129     }
130     {
131     typedef std::aligned_storage<7>::type T1;
132 #if _LIBCPP_STD_VER > 11
133     static_assert(std::is_same<std::aligned_storage_t<7>, T1>::value, "" );
134 #endif
135     static_assert(std::alignment_of<T1>::value == 4, "");
136     static_assert(sizeof(T1) == 8, "");
137     }
138     {
139     typedef std::aligned_storage<8>::type T1;
140 #if _LIBCPP_STD_VER > 11
141     static_assert(std::is_same<std::aligned_storage_t<8>, T1>::value, "" );
142 #endif
143     static_assert(std::alignment_of<T1>::value == 8, "");
144     static_assert(sizeof(T1) == 8, "");
145     }
146     {
147     typedef std::aligned_storage<9>::type T1;
148 #if _LIBCPP_STD_VER > 11
149     static_assert(std::is_same<std::aligned_storage_t<9>, T1>::value, "" );
150 #endif
151     static_assert(std::alignment_of<T1>::value == 8, "");
152     static_assert(sizeof(T1) == 16, "");
153     }
154     {
155     typedef std::aligned_storage<15>::type T1;
156 #if _LIBCPP_STD_VER > 11
157     static_assert(std::is_same<std::aligned_storage_t<15>, T1>::value, "" );
158 #endif
159     static_assert(std::alignment_of<T1>::value == 8, "");
160     static_assert(sizeof(T1) == 16, "");
161     }
162     // Use alignof(std::max_align_t) below to find the max alignment instead of
163     // hardcoding it, because it's different on different platforms.
164     // (For example 8 on arm and 16 on x86.)
165 #if __cplusplus < 201103L
166 #define alignof __alignof__
167 #endif
168     {
169     typedef std::aligned_storage<16>::type T1;
170 #if _LIBCPP_STD_VER > 11
171     static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "" );
172 #endif
173     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
174                   "");
175     static_assert(sizeof(T1) == 16, "");
176     }
177     {
178     typedef std::aligned_storage<17>::type T1;
179 #if _LIBCPP_STD_VER > 11
180     static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "" );
181 #endif
182     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
183                   "");
184     static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
185     }
186     {
187     typedef std::aligned_storage<10>::type T1;
188 #if _LIBCPP_STD_VER > 11
189     static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "" );
190 #endif
191     static_assert(std::alignment_of<T1>::value == 8, "");
192     static_assert(sizeof(T1) == 16, "");
193     }
194 }
195