AlignOf.h revision 9d695d5f7d31e912a2be74229b3e2baab2564820 
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 AlignOf function that computes alignments for
11// arbitrary types.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_SUPPORT_ALIGNOF_H
16#define LLVM_SUPPORT_ALIGNOF_H
17
18namespace llvm {
19
20template <typename T>
21struct AlignmentCalcImpl {
22  char x;
23  T t;
24private:
25  AlignmentCalcImpl() {} // Never instantiate.
26};
27
28/// AlignOf - A templated class that contains an enum value representing
29///  the alignment of the template argument.  For example,
30///  AlignOf<int>::Alignment represents the alignment of type "int".  The
31///  alignment calculated is the minimum alignment, and not necessarily
32///  the "desired" alignment returned by GCC's __alignof__ (for example).  Note
33///  that because the alignment is an enum value, it can be used as a
34///  compile-time constant (e.g., for template instantiation).
35template <typename T>
36struct AlignOf {
37  enum { Alignment = sizeof(AlignmentCalcImpl<T>) - sizeof(T) };
38
39  enum { Alignment_GreaterEqual_2Bytes = Alignment >= 2 ? 1 : 0 };
40  enum { Alignment_GreaterEqual_4Bytes = Alignment >= 4 ? 1 : 0 };
41  enum { Alignment_GreaterEqual_8Bytes = Alignment >= 8 ? 1 : 0 };
42  enum { Alignment_GreaterEqual_16Bytes = Alignment >= 16 ? 1 : 0 };
43
44  enum { Alignment_LessEqual_2Bytes = Alignment <= 2 ? 1 : 0 };
45  enum { Alignment_LessEqual_4Bytes = Alignment <= 4 ? 1 : 0 };
46  enum { Alignment_LessEqual_8Bytes = Alignment <= 8 ? 1 : 0 };
47  enum { Alignment_LessEqual_16Bytes = Alignment <= 16 ? 1 : 0 };
48
49};
50
51/// alignof - A templated function that returns the mininum alignment of
52///  of a type.  This provides no extra functionality beyond the AlignOf
53///  class besides some cosmetic cleanliness.  Example usage:
54///  alignof<int>() returns the alignment of an int.
55template <typename T>
56static inline unsigned alignof() { return AlignOf<T>::Alignment; }
57
58} // end namespace llvm
59#endif
60