1 //===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the AlignedCharArray and AlignedCharArrayUnion classes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_SUPPORT_ALIGNOF_H 15 #define LLVM_SUPPORT_ALIGNOF_H 16 17 #include "llvm/Support/Compiler.h" 18 #include <cstddef> 19 20 namespace llvm { 21 22 /// \struct AlignedCharArray 23 /// \brief Helper for building an aligned character array type. 24 /// 25 /// This template is used to explicitly build up a collection of aligned 26 /// character array types. We have to build these up using a macro and explicit 27 /// specialization to cope with MSVC (at least till 2015) where only an 28 /// integer literal can be used to specify an alignment constraint. Once built 29 /// up here, we can then begin to indirect between these using normal C++ 30 /// template parameters. 31 32 // MSVC requires special handling here. 33 #ifndef _MSC_VER 34 35 template<std::size_t Alignment, std::size_t Size> 36 struct AlignedCharArray { 37 LLVM_ALIGNAS(Alignment) char buffer[Size]; 38 }; 39 40 #else // _MSC_VER 41 42 /// \brief Create a type with an aligned char buffer. 43 template<std::size_t Alignment, std::size_t Size> 44 struct AlignedCharArray; 45 46 // We provide special variations of this template for the most common 47 // alignments because __declspec(align(...)) doesn't actually work when it is 48 // a member of a by-value function argument in MSVC, even if the alignment 49 // request is something reasonably like 8-byte or 16-byte. Note that we can't 50 // even include the declspec with the union that forces the alignment because 51 // MSVC warns on the existence of the declspec despite the union member forcing 52 // proper alignment. 53 54 template<std::size_t Size> 55 struct AlignedCharArray<1, Size> { 56 union { 57 char aligned; 58 char buffer[Size]; 59 }; 60 }; 61 62 template<std::size_t Size> 63 struct AlignedCharArray<2, Size> { 64 union { 65 short aligned; 66 char buffer[Size]; 67 }; 68 }; 69 70 template<std::size_t Size> 71 struct AlignedCharArray<4, Size> { 72 union { 73 int aligned; 74 char buffer[Size]; 75 }; 76 }; 77 78 template<std::size_t Size> 79 struct AlignedCharArray<8, Size> { 80 union { 81 double aligned; 82 char buffer[Size]; 83 }; 84 }; 85 86 87 // The rest of these are provided with a __declspec(align(...)) and we simply 88 // can't pass them by-value as function arguments on MSVC. 89 90 #define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \ 91 template<std::size_t Size> \ 92 struct AlignedCharArray<x, Size> { \ 93 __declspec(align(x)) char buffer[Size]; \ 94 }; 95 96 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16) 97 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32) 98 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64) 99 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128) 100 101 #undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT 102 103 #endif // _MSC_VER 104 105 namespace detail { 106 template <typename T1, 107 typename T2 = char, typename T3 = char, typename T4 = char, 108 typename T5 = char, typename T6 = char, typename T7 = char, 109 typename T8 = char, typename T9 = char, typename T10 = char> 110 class AlignerImpl { 111 T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; T10 t10; 112 113 AlignerImpl() = delete; 114 }; 115 116 template <typename T1, 117 typename T2 = char, typename T3 = char, typename T4 = char, 118 typename T5 = char, typename T6 = char, typename T7 = char, 119 typename T8 = char, typename T9 = char, typename T10 = char> 120 union SizerImpl { 121 char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)], 122 arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)], arr8[sizeof(T8)], 123 arr9[sizeof(T9)], arr10[sizeof(T10)]; 124 }; 125 } // end namespace detail 126 127 /// \brief This union template exposes a suitably aligned and sized character 128 /// array member which can hold elements of any of up to ten types. 129 /// 130 /// These types may be arrays, structs, or any other types. The goal is to 131 /// expose a char array buffer member which can be used as suitable storage for 132 /// a placement new of any of these types. Support for more than ten types can 133 /// be added at the cost of more boilerplate. 134 template <typename T1, 135 typename T2 = char, typename T3 = char, typename T4 = char, 136 typename T5 = char, typename T6 = char, typename T7 = char, 137 typename T8 = char, typename T9 = char, typename T10 = char> 138 struct AlignedCharArrayUnion : llvm::AlignedCharArray< 139 alignof(llvm::detail::AlignerImpl<T1, T2, T3, T4, T5, 140 T6, T7, T8, T9, T10>), 141 sizeof(::llvm::detail::SizerImpl<T1, T2, T3, T4, T5, 142 T6, T7, T8, T9, T10>)> { 143 }; 144 } // end namespace llvm 145 146 #endif // LLVM_SUPPORT_ALIGNOF_H 147