1 //===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the AlignOf function that computes alignments for
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_SUPPORT_ALIGNOF_H
16 #define LLVM_SUPPORT_ALIGNOF_H
18 #include "llvm/Support/Compiler.h"
24 struct AlignmentCalcImpl {
28 AlignmentCalcImpl() {} // Never instantiate.
31 /// AlignOf - A templated class that contains an enum value representing
32 /// the alignment of the template argument. For example,
33 /// AlignOf<int>::Alignment represents the alignment of type "int". The
34 /// alignment calculated is the minimum alignment, and not necessarily
35 /// the "desired" alignment returned by GCC's __alignof__ (for example). Note
36 /// that because the alignment is an enum value, it can be used as a
37 /// compile-time constant (e.g., for template instantiation).
41 static_cast<unsigned int>(sizeof(AlignmentCalcImpl<T>) - sizeof(T)) };
43 enum { Alignment_GreaterEqual_2Bytes = Alignment >= 2 ? 1 : 0 };
44 enum { Alignment_GreaterEqual_4Bytes = Alignment >= 4 ? 1 : 0 };
45 enum { Alignment_GreaterEqual_8Bytes = Alignment >= 8 ? 1 : 0 };
46 enum { Alignment_GreaterEqual_16Bytes = Alignment >= 16 ? 1 : 0 };
48 enum { Alignment_LessEqual_2Bytes = Alignment <= 2 ? 1 : 0 };
49 enum { Alignment_LessEqual_4Bytes = Alignment <= 4 ? 1 : 0 };
50 enum { Alignment_LessEqual_8Bytes = Alignment <= 8 ? 1 : 0 };
51 enum { Alignment_LessEqual_16Bytes = Alignment <= 16 ? 1 : 0 };
55 /// alignOf - A templated function that returns the minimum alignment of
56 /// of a type. This provides no extra functionality beyond the AlignOf
57 /// class besides some cosmetic cleanliness. Example usage:
58 /// alignOf<int>() returns the alignment of an int.
60 inline unsigned alignOf() { return AlignOf<T>::Alignment; }
63 /// \brief Helper for building an aligned character array type.
65 /// This template is used to explicitly build up a collection of aligned
66 /// character types. We have to build these up using a macro and explicit
67 /// specialization to cope with old versions of MSVC and GCC where only an
68 /// integer literal can be used to specify an alignment constraint. Once built
69 /// up here, we can then begin to indirect between these using normal C++
70 /// template parameters.
71 template <size_t Alignment> struct AlignedCharArrayImpl;
73 // MSVC requires special handling here.
76 #if __has_feature(cxx_alignas)
77 #define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
78 template <> struct AlignedCharArrayImpl<x> { \
79 char alignas(x) aligned; \
81 #elif defined(__GNUC__) || defined(__IBM_ATTRIBUTES)
82 #define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
83 template <> struct AlignedCharArrayImpl<x> { \
84 char aligned __attribute__((aligned(x))); \
87 # error No supported align as directive.
90 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1);
91 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2);
92 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4);
93 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8);
94 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16);
95 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32);
96 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64);
97 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128);
98 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(512);
99 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1024);
100 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2048);
101 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4096);
102 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8192);
104 #undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
108 // We provide special variations of this template for the most common
109 // alignments because __declspec(align(...)) doesn't actually work when it is
110 // a member of a by-value function argument in MSVC, even if the alignment
111 // request is something reasonably like 8-byte or 16-byte.
112 template <> struct AlignedCharArrayImpl<1> { char aligned; };
113 template <> struct AlignedCharArrayImpl<2> { short aligned; };
114 template <> struct AlignedCharArrayImpl<4> { int aligned; };
115 template <> struct AlignedCharArrayImpl<8> { double aligned; };
117 #define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
118 template <> struct AlignedCharArrayImpl<x> { \
119 __declspec(align(x)) char aligned; \
121 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16);
122 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32);
123 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64);
124 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128);
125 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(512);
126 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1024);
127 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2048);
128 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4096);
129 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8192);
130 // Any larger and MSVC complains.
131 #undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
135 /// \brief This union template exposes a suitably aligned and sized character
136 /// array member which can hold elements of any of up to four types.
138 /// These types may be arrays, structs, or any other types. The goal is to
139 /// produce a union type containing a character array which, when used, forms
140 /// storage suitable to placement new any of these types over. Support for more
141 /// than four types can be added at the cost of more boiler plate.
142 template <typename T1,
143 typename T2 = char, typename T3 = char, typename T4 = char>
144 union AlignedCharArrayUnion {
147 T1 t1; T2 t2; T3 t3; T4 t4;
149 AlignerImpl(); // Never defined or instantiated.
152 char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)];
156 /// \brief The character array buffer for use by clients.
158 /// No other member of this union should be referenced. The exist purely to
159 /// constrain the layout of this character array.
160 char buffer[sizeof(SizerImpl)];
163 // Tests seem to indicate that both Clang and GCC will properly register the
164 // alignment of a struct containing an aligned member, and this alignment
165 // should carry over to the character array in the union.
166 llvm::AlignedCharArrayImpl<AlignOf<AlignerImpl>::Alignment> nonce_member;
169 } // end namespace llvm