/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/ADT/BitmaskEnum.h
Line | Count | Source |
1 | | //===-- llvm/ADT/BitmaskEnum.h ----------------------------------*- 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 | | #ifndef LLVM_ADT_BITMASKENUM_H |
11 | | #define LLVM_ADT_BITMASKENUM_H |
12 | | |
13 | | #include <cassert> |
14 | | #include <type_traits> |
15 | | #include <utility> |
16 | | |
17 | | #include "llvm/Support/MathExtras.h" |
18 | | |
19 | | /// LLVM_MARK_AS_BITMASK_ENUM lets you opt in an individual enum type so you can |
20 | | /// perform bitwise operations on it without putting static_cast everywhere. |
21 | | /// |
22 | | /// \code |
23 | | /// enum MyEnum { |
24 | | /// E1 = 1, E2 = 2, E3 = 4, E4 = 8, |
25 | | /// LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ E4) |
26 | | /// }; |
27 | | /// |
28 | | /// void Foo() { |
29 | | /// MyEnum A = (E1 | E2) & E3 ^ ~E4; // Look, ma: No static_cast! |
30 | | /// } |
31 | | /// \endcode |
32 | | /// |
33 | | /// Normally when you do a bitwise operation on an enum value, you get back an |
34 | | /// instance of the underlying type (e.g. int). But using this macro, bitwise |
35 | | /// ops on your enum will return you back instances of the enum. This is |
36 | | /// particularly useful for enums which represent a combination of flags. |
37 | | /// |
38 | | /// The parameter to LLVM_MARK_AS_BITMASK_ENUM should be the largest individual |
39 | | /// value in your enum. |
40 | | /// |
41 | | /// All of the enum's values must be non-negative. |
42 | | #define LLVM_MARK_AS_BITMASK_ENUM(LargestValue) \ |
43 | | LLVM_BITMASK_LARGEST_ENUMERATOR = LargestValue |
44 | | |
45 | | /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() pulls the operator overloads used |
46 | | /// by LLVM_MARK_AS_BITMASK_ENUM into the current namespace. |
47 | | /// |
48 | | /// Suppose you have an enum foo::bar::MyEnum. Before using |
49 | | /// LLVM_MARK_AS_BITMASK_ENUM on MyEnum, you must put |
50 | | /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() somewhere inside namespace foo or |
51 | | /// namespace foo::bar. This allows the relevant operator overloads to be found |
52 | | /// by ADL. |
53 | | /// |
54 | | /// You don't need to use this macro in namespace llvm; it's done at the bottom |
55 | | /// of this file. |
56 | | #define LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() \ |
57 | | using ::llvm::BitmaskEnumDetail::operator~; \ |
58 | | using ::llvm::BitmaskEnumDetail::operator|; \ |
59 | | using ::llvm::BitmaskEnumDetail::operator&; \ |
60 | | using ::llvm::BitmaskEnumDetail::operator^; \ |
61 | | using ::llvm::BitmaskEnumDetail::operator|=; \ |
62 | | using ::llvm::BitmaskEnumDetail::operator&=; \ |
63 | | /* Force a semicolon at the end of this macro. */ \ |
64 | | using ::llvm::BitmaskEnumDetail::operator^= |
65 | | |
66 | | namespace llvm { |
67 | | |
68 | | /// Traits class to determine whether an enum has a |
69 | | /// LLVM_BITMASK_LARGEST_ENUMERATOR enumerator. |
70 | | template <typename E, typename Enable = void> |
71 | | struct is_bitmask_enum : std::false_type {}; |
72 | | |
73 | | template <typename E> |
74 | | struct is_bitmask_enum< |
75 | | E, typename std::enable_if<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= |
76 | | 0>::type> : std::true_type {}; |
77 | | namespace BitmaskEnumDetail { |
78 | | |
79 | | /// Get a bitmask with 1s in all places up to the high-order bit of E's largest |
80 | | /// value. |
81 | 73.9k | template <typename E> typename std::underlying_type<E>::type Mask() { |
82 | 73.9k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so |
83 | 73.9k | // subtracting 1 gives us the mask with all bits set, like we want. |
84 | 73.9k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( |
85 | 73.9k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - |
86 | 73.9k | 1; |
87 | 73.9k | } std::__1::underlying_type<llvm::DINode::DIFlags>::type llvm::BitmaskEnumDetail::Mask<llvm::DINode::DIFlags>() Line | Count | Source | 81 | 7.22k | template <typename E> typename std::underlying_type<E>::type Mask() { | 82 | 7.22k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 83 | 7.22k | // subtracting 1 gives us the mask with all bits set, like we want. | 84 | 7.22k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 85 | 7.22k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 86 | 7.22k | 1; | 87 | 7.22k | } |
std::__1::underlying_type<llvm::MachineMemOperand::Flags>::type llvm::BitmaskEnumDetail::Mask<llvm::MachineMemOperand::Flags>() Line | Count | Source | 81 | 66.7k | template <typename E> typename std::underlying_type<E>::type Mask() { | 82 | 66.7k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 83 | 66.7k | // subtracting 1 gives us the mask with all bits set, like we want. | 84 | 66.7k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 85 | 66.7k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 86 | 66.7k | 1; | 87 | 66.7k | } |
|
88 | | |
89 | | /// Check that Val is in range for E, and return Val cast to E's underlying |
90 | | /// type. |
91 | 453M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { |
92 | 453M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); |
93 | 453M | assert(U >= 0 && "Negative enum values are not allowed."); |
94 | 453M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); |
95 | 453M | return U; |
96 | 453M | } std::__1::underlying_type<llvm::DINode::DIFlags>::type llvm::BitmaskEnumDetail::Underlying<llvm::DINode::DIFlags>(llvm::DINode::DIFlags) Line | Count | Source | 91 | 462k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 92 | 462k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 93 | 462k | assert(U >= 0 && "Negative enum values are not allowed."); | 94 | 462k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 95 | 462k | return U; | 96 | 462k | } |
std::__1::underlying_type<llvm::MachineMemOperand::Flags>::type llvm::BitmaskEnumDetail::Underlying<llvm::MachineMemOperand::Flags>(llvm::MachineMemOperand::Flags) Line | Count | Source | 91 | 452M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 92 | 452M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 93 | 452M | assert(U >= 0 && "Negative enum values are not allowed."); | 94 | 452M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 95 | 452M | return U; | 96 | 452M | } |
|
97 | | |
98 | | template <typename E, |
99 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
100 | 73.9k | E operator~(E Val) { |
101 | 73.9k | return static_cast<E>(~Underlying(Val) & Mask<E>()); |
102 | 73.9k | } llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator~<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags) Line | Count | Source | 100 | 7.22k | E operator~(E Val) { | 101 | 7.22k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 102 | 7.22k | } |
llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator~<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags) Line | Count | Source | 100 | 66.7k | E operator~(E Val) { | 101 | 66.7k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 102 | 66.7k | } |
|
103 | | |
104 | | template <typename E, |
105 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
106 | 11.2M | E operator|(E LHS, E RHS) { |
107 | 11.2M | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); |
108 | 11.2M | } llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator|<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags, llvm::DINode::DIFlags) Line | Count | Source | 106 | 33.4k | E operator|(E LHS, E RHS) { | 107 | 33.4k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 108 | 33.4k | } |
llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator|<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags, llvm::MachineMemOperand::Flags) Line | Count | Source | 106 | 11.1M | E operator|(E LHS, E RHS) { | 107 | 11.1M | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 108 | 11.1M | } |
|
109 | | |
110 | | template <typename E, |
111 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
112 | 215M | E operator&(E LHS, E RHS) { |
113 | 215M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); |
114 | 215M | } llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator&<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags, llvm::DINode::DIFlags) Line | Count | Source | 112 | 194k | E operator&(E LHS, E RHS) { | 113 | 194k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 114 | 194k | } |
llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator&<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags, llvm::MachineMemOperand::Flags) Line | Count | Source | 112 | 215M | E operator&(E LHS, E RHS) { | 113 | 215M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 114 | 215M | } |
|
115 | | |
116 | | template <typename E, |
117 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
118 | | E operator^(E LHS, E RHS) { |
119 | | return static_cast<E>(Underlying(LHS) ^ Underlying(RHS)); |
120 | | } |
121 | | |
122 | | // |=, &=, and ^= return a reference to LHS, to match the behavior of the |
123 | | // operators on builtin types. |
124 | | |
125 | | template <typename E, |
126 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
127 | 11.0M | E &operator|=(E &LHS, E RHS) { |
128 | 11.0M | LHS = LHS | RHS; |
129 | 11.0M | return LHS; |
130 | 11.0M | } llvm::DINode::DIFlags& llvm::BitmaskEnumDetail::operator|=<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags&, llvm::DINode::DIFlags) Line | Count | Source | 127 | 30.0k | E &operator|=(E &LHS, E RHS) { | 128 | 30.0k | LHS = LHS | RHS; | 129 | 30.0k | return LHS; | 130 | 30.0k | } |
llvm::MachineMemOperand::Flags& llvm::BitmaskEnumDetail::operator|=<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags&, llvm::MachineMemOperand::Flags) Line | Count | Source | 127 | 10.9M | E &operator|=(E &LHS, E RHS) { | 128 | 10.9M | LHS = LHS | RHS; | 129 | 10.9M | return LHS; | 130 | 10.9M | } |
|
131 | | |
132 | | template <typename E, |
133 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
134 | 7.44k | E &operator&=(E &LHS, E RHS) { |
135 | 7.44k | LHS = LHS & RHS; |
136 | 7.44k | return LHS; |
137 | 7.44k | } llvm::MachineMemOperand::Flags& llvm::BitmaskEnumDetail::operator&=<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags&, llvm::MachineMemOperand::Flags) Line | Count | Source | 134 | 214 | E &operator&=(E &LHS, E RHS) { | 135 | 214 | LHS = LHS & RHS; | 136 | 214 | return LHS; | 137 | 214 | } |
llvm::DINode::DIFlags& llvm::BitmaskEnumDetail::operator&=<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags&, llvm::DINode::DIFlags) Line | Count | Source | 134 | 7.22k | E &operator&=(E &LHS, E RHS) { | 135 | 7.22k | LHS = LHS & RHS; | 136 | 7.22k | return LHS; | 137 | 7.22k | } |
|
138 | | |
139 | | template <typename E, |
140 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
141 | | E &operator^=(E &LHS, E RHS) { |
142 | | LHS = LHS ^ RHS; |
143 | | return LHS; |
144 | | } |
145 | | |
146 | | } // namespace BitmaskEnumDetail |
147 | | |
148 | | // Enable bitmask enums in namespace ::llvm and all nested namespaces. |
149 | | LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); |
150 | | |
151 | | } // namespace llvm |
152 | | |
153 | | #endif |