361 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// type_traits10 11// aligned_storage12//13// Issue 3034 added:14// The member typedef type shall be a trivial standard-layout type.15 16// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS17 18#include <type_traits>19#include <cstddef> // for std::max_align_t20#include "test_macros.h"21 22// The following tests assume naturally aligned types exist23// up to 64bit (double). For larger types, max_align_t should24// give the correct alignment. For pre-C++11 testing, only25// the lower bound is checked.26 27#if TEST_STD_VER < 1128struct natural_alignment {29 long t1;30 long long t2;31 double t3;32 long double t4;33};34#endif35 36int main(int, char**)37{38 {39 typedef std::aligned_storage<10, 1 >::type T1;40#if TEST_STD_VER > 1141 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 1>);42#endif43#if TEST_STD_VER <= 1744 static_assert(std::is_pod<T1>::value, "");45#endif46 static_assert(std::is_trivially_copyable<T1>::value, "");47 static_assert(std::is_trivially_default_constructible<T1>::value, "");48 static_assert(std::is_standard_layout<T1>::value, "");49 static_assert(std::alignment_of<T1>::value == 1, "");50 static_assert(sizeof(T1) == 10, "");51 }52 {53 typedef std::aligned_storage<10, 2 >::type T1;54#if TEST_STD_VER > 1155 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 2>);56#endif57#if TEST_STD_VER <= 1758 static_assert(std::is_pod<T1>::value, "");59#endif60 static_assert(std::is_trivially_copyable<T1>::value, "");61 static_assert(std::is_trivially_default_constructible<T1>::value, "");62 static_assert(std::is_standard_layout<T1>::value, "");63 static_assert(std::alignment_of<T1>::value == 2, "");64 static_assert(sizeof(T1) == 10, "");65 }66 {67 typedef std::aligned_storage<10, 4 >::type T1;68#if TEST_STD_VER > 1169 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 4>);70#endif71#if TEST_STD_VER <= 1772 static_assert(std::is_pod<T1>::value, "");73#endif74 static_assert(std::is_trivially_copyable<T1>::value, "");75 static_assert(std::is_trivially_default_constructible<T1>::value, "");76 static_assert(std::is_standard_layout<T1>::value, "");77 static_assert(std::alignment_of<T1>::value == 4, "");78 static_assert(sizeof(T1) == 12, "");79 }80 {81 typedef std::aligned_storage<10, 8 >::type T1;82#if TEST_STD_VER > 1183 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 8>);84#endif85#if TEST_STD_VER <= 1786 static_assert(std::is_pod<T1>::value, "");87#endif88 static_assert(std::is_trivially_copyable<T1>::value, "");89 static_assert(std::is_trivially_default_constructible<T1>::value, "");90 static_assert(std::is_standard_layout<T1>::value, "");91 static_assert(std::alignment_of<T1>::value == 8, "");92 static_assert(sizeof(T1) == 16, "");93 }94 {95 typedef std::aligned_storage<10, 16 >::type T1;96#if TEST_STD_VER > 1197 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 16>);98#endif99#if TEST_STD_VER <= 17100 static_assert(std::is_pod<T1>::value, "");101#endif102 static_assert(std::is_trivially_copyable<T1>::value, "");103 static_assert(std::is_trivially_default_constructible<T1>::value, "");104 static_assert(std::is_standard_layout<T1>::value, "");105 static_assert(std::alignment_of<T1>::value == 16, "");106 static_assert(sizeof(T1) == 16, "");107 }108 {109 typedef std::aligned_storage<10, 32 >::type T1;110#if TEST_STD_VER > 11111 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10, 32>);112#endif113#if TEST_STD_VER <= 17114 static_assert(std::is_pod<T1>::value, "");115#endif116 static_assert(std::is_trivially_copyable<T1>::value, "");117 static_assert(std::is_trivially_default_constructible<T1>::value, "");118 static_assert(std::is_standard_layout<T1>::value, "");119 static_assert(std::alignment_of<T1>::value == 32, "");120 static_assert(sizeof(T1) == 32, "");121 }122 {123 typedef std::aligned_storage<20, 32 >::type T1;124#if TEST_STD_VER > 11125 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<20, 32>);126#endif127#if TEST_STD_VER <= 17128 static_assert(std::is_pod<T1>::value, "");129#endif130 static_assert(std::is_trivially_copyable<T1>::value, "");131 static_assert(std::is_trivially_default_constructible<T1>::value, "");132 static_assert(std::is_standard_layout<T1>::value, "");133 static_assert(std::alignment_of<T1>::value == 32, "");134 static_assert(sizeof(T1) == 32, "");135 }136 {137 typedef std::aligned_storage<40, 32 >::type T1;138#if TEST_STD_VER > 11139 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<40, 32>);140#endif141#if TEST_STD_VER <= 17142 static_assert(std::is_pod<T1>::value, "");143#endif144 static_assert(std::is_trivially_copyable<T1>::value, "");145 static_assert(std::is_trivially_default_constructible<T1>::value, "");146 static_assert(std::is_standard_layout<T1>::value, "");147 static_assert(std::alignment_of<T1>::value == 32, "");148 static_assert(sizeof(T1) == 64, "");149 }150 {151 typedef std::aligned_storage<12, 16 >::type T1;152#if TEST_STD_VER > 11153 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<12, 16>);154#endif155#if TEST_STD_VER <= 17156 static_assert(std::is_pod<T1>::value, "");157#endif158 static_assert(std::is_trivially_copyable<T1>::value, "");159 static_assert(std::is_trivially_default_constructible<T1>::value, "");160 static_assert(std::is_standard_layout<T1>::value, "");161 static_assert(std::alignment_of<T1>::value == 16, "");162 static_assert(sizeof(T1) == 16, "");163 }164 {165 typedef std::aligned_storage<1>::type T1;166#if TEST_STD_VER > 11167 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<1>);168#endif169#if TEST_STD_VER <= 17170 static_assert(std::is_pod<T1>::value, "");171#endif172 static_assert(std::is_trivially_copyable<T1>::value, "");173 static_assert(std::is_trivially_default_constructible<T1>::value, "");174 static_assert(std::is_standard_layout<T1>::value, "");175 static_assert(std::alignment_of<T1>::value == 1, "");176 static_assert(sizeof(T1) == 1, "");177 }178 {179 typedef std::aligned_storage<2>::type T1;180#if TEST_STD_VER > 11181 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<2>);182#endif183#if TEST_STD_VER <= 17184 static_assert(std::is_pod<T1>::value, "");185#endif186 static_assert(std::is_trivially_copyable<T1>::value, "");187 static_assert(std::is_trivially_default_constructible<T1>::value, "");188 static_assert(std::is_standard_layout<T1>::value, "");189 static_assert(std::alignment_of<T1>::value == 2, "");190 static_assert(sizeof(T1) == 2, "");191 }192 {193 typedef std::aligned_storage<3>::type T1;194#if TEST_STD_VER > 11195 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<3>);196#endif197#if TEST_STD_VER <= 17198 static_assert(std::is_pod<T1>::value, "");199#endif200 static_assert(std::is_trivially_copyable<T1>::value, "");201 static_assert(std::is_trivially_default_constructible<T1>::value, "");202 static_assert(std::is_standard_layout<T1>::value, "");203 static_assert(std::alignment_of<T1>::value == 2, "");204 static_assert(sizeof(T1) == 4, "");205 }206 {207 typedef std::aligned_storage<4>::type T1;208#if TEST_STD_VER > 11209 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<4>);210#endif211#if TEST_STD_VER <= 17212 static_assert(std::is_pod<T1>::value, "");213#endif214 static_assert(std::is_trivially_copyable<T1>::value, "");215 static_assert(std::is_trivially_default_constructible<T1>::value, "");216 static_assert(std::is_standard_layout<T1>::value, "");217 static_assert(std::alignment_of<T1>::value == 4, "");218 static_assert(sizeof(T1) == 4, "");219 }220 {221 typedef std::aligned_storage<5>::type T1;222#if TEST_STD_VER > 11223 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<5>);224#endif225#if TEST_STD_VER <= 17226 static_assert(std::is_pod<T1>::value, "");227#endif228 static_assert(std::is_trivially_copyable<T1>::value, "");229 static_assert(std::is_trivially_default_constructible<T1>::value, "");230 static_assert(std::is_standard_layout<T1>::value, "");231 static_assert(std::alignment_of<T1>::value == 4, "");232 static_assert(sizeof(T1) == 8, "");233 }234 {235 typedef std::aligned_storage<7>::type T1;236#if TEST_STD_VER > 11237 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<7>);238#endif239 static_assert(std::is_trivially_copyable<T1>::value, "");240 static_assert(std::is_trivially_default_constructible<T1>::value, "");241 static_assert(std::is_standard_layout<T1>::value, "");242 static_assert(std::alignment_of<T1>::value == 4, "");243 static_assert(sizeof(T1) == 8, "");244 }245 {246 typedef std::aligned_storage<8>::type T1;247#if TEST_STD_VER > 11248 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<8>);249#endif250#if TEST_STD_VER <= 17251 static_assert(std::is_pod<T1>::value, "");252#endif253 static_assert(std::is_trivially_copyable<T1>::value, "");254 static_assert(std::is_trivially_default_constructible<T1>::value, "");255 static_assert(std::is_standard_layout<T1>::value, "");256 static_assert(std::alignment_of<T1>::value == 8, "");257 static_assert(sizeof(T1) == 8, "");258 }259 {260 typedef std::aligned_storage<9>::type T1;261#if TEST_STD_VER > 11262 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<9>);263#endif264#if TEST_STD_VER <= 17265 static_assert(std::is_pod<T1>::value, "");266#endif267 static_assert(std::is_trivially_copyable<T1>::value, "");268 static_assert(std::is_trivially_default_constructible<T1>::value, "");269 static_assert(std::is_standard_layout<T1>::value, "");270 static_assert(std::alignment_of<T1>::value == 8, "");271 static_assert(sizeof(T1) == 16, "");272 }273 {274 typedef std::aligned_storage<15>::type T1;275#if TEST_STD_VER > 11276 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<15>);277#endif278#if TEST_STD_VER <= 17279 static_assert(std::is_pod<T1>::value, "");280#endif281 static_assert(std::is_trivially_copyable<T1>::value, "");282 static_assert(std::is_trivially_default_constructible<T1>::value, "");283 static_assert(std::is_standard_layout<T1>::value, "");284 static_assert(std::alignment_of<T1>::value == 8, "");285 static_assert(sizeof(T1) == 16, "");286 }287 {288 typedef std::aligned_storage<16>::type T1;289#if TEST_STD_VER > 11290 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<16>);291#endif292 static_assert(std::is_trivially_copyable<T1>::value, "");293 static_assert(std::is_trivially_default_constructible<T1>::value, "");294 static_assert(std::is_standard_layout<T1>::value, "");295#if TEST_STD_VER >= 11296 const std::size_t alignment = TEST_ALIGNOF(std::max_align_t) > 16 ?297 16 : TEST_ALIGNOF(std::max_align_t);298 static_assert(std::alignment_of<T1>::value == alignment, "");299#else300 static_assert(std::alignment_of<T1>::value >=301 TEST_ALIGNOF(natural_alignment), "");302 static_assert(std::alignment_of<T1>::value <= 16, "");303#endif304 static_assert(sizeof(T1) == 16, "");305 }306 {307 typedef std::aligned_storage<17>::type T1;308#if TEST_STD_VER > 11309 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<17>);310#endif311 static_assert(std::is_trivially_copyable<T1>::value, "");312 static_assert(std::is_trivially_default_constructible<T1>::value, "");313 static_assert(std::is_standard_layout<T1>::value, "");314#if TEST_STD_VER >= 11315 const std::size_t alignment = TEST_ALIGNOF(std::max_align_t) > 16 ?316 16 : TEST_ALIGNOF(std::max_align_t);317 static_assert(std::alignment_of<T1>::value == alignment, "");318 static_assert(sizeof(T1) == 16 + alignment, "");319#else320 static_assert(std::alignment_of<T1>::value >=321 TEST_ALIGNOF(natural_alignment), "");322 static_assert(std::alignment_of<T1>::value <= 16, "");323 static_assert(sizeof(T1) % TEST_ALIGNOF(natural_alignment) == 0, "");324#endif325 }326 {327 typedef std::aligned_storage<10>::type T1;328#if TEST_STD_VER > 11329 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10>);330#endif331 static_assert(std::is_trivially_copyable<T1>::value, "");332 static_assert(std::is_trivially_default_constructible<T1>::value, "");333 static_assert(std::is_standard_layout<T1>::value, "");334 static_assert(std::alignment_of<T1>::value == 8, "");335 static_assert(sizeof(T1) == 16, "");336 }337 {338 const int Align = 8192;339 typedef typename std::aligned_storage<1, Align>::type T1;340 static_assert(std::is_trivially_copyable<T1>::value, "");341 static_assert(std::is_trivially_default_constructible<T1>::value, "");342 static_assert(std::is_standard_layout<T1>::value, "");343 static_assert(std::alignment_of<T1>::value == Align, "");344 static_assert(sizeof(T1) == Align, "");345 }346#ifndef _WIN32347 // Windows only supports alignment up to 8192 bytes.348 {349 const int Align = 65536;350 typedef typename std::aligned_storage<1, Align>::type T1;351 static_assert(std::is_trivially_copyable<T1>::value, "");352 static_assert(std::is_trivially_default_constructible<T1>::value, "");353 static_assert(std::is_standard_layout<T1>::value, "");354 static_assert(std::alignment_of<T1>::value == Align, "");355 static_assert(sizeof(T1) == Align, "");356 }357#endif358 359 return 0;360}361