Line data Source code
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 : template <typename E> typename std::underlying_type<E>::type Mask() {
82 : // On overflow, NextPowerOf2 returns zero with the type uint64_t, so
83 : // subtracting 1 gives us the mask with all bits set, like we want.
84 : return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>(
85 : E::LLVM_BITMASK_LARGEST_ENUMERATOR)) -
86 : 1;
87 : }
88 :
89 : /// Check that Val is in range for E, and return Val cast to E's underlying
90 : /// type.
91 : template <typename E> typename std::underlying_type<E>::type Underlying(E Val) {
92 : auto U = static_cast<typename std::underlying_type<E>::type>(Val);
93 : assert(U >= 0 && "Negative enum values are not allowed.");
94 : assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)");
95 : return U;
96 : }
97 :
98 : template <typename E,
99 : typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
100 : E operator~(E Val) {
101 9779 : return static_cast<E>(~Underlying(Val) & Mask<E>());
102 : }
103 :
104 : template <typename E,
105 : typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
106 : E operator|(E LHS, E RHS) {
107 15273070 : return static_cast<E>(Underlying(LHS) | Underlying(RHS));
108 : }
109 :
110 : template <typename E,
111 : typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
112 : E operator&(E LHS, E RHS) {
113 23666032 : return static_cast<E>(Underlying(LHS) & Underlying(RHS));
114 : }
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 1 : 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 : E &operator|=(E &LHS, E RHS) {
128 65885 : LHS = LHS | RHS;
129 : return LHS;
130 : }
131 :
132 : template <typename E,
133 : typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
134 : E &operator&=(E &LHS, E RHS) {
135 127 : LHS = LHS & RHS;
136 : return LHS;
137 : }
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 1 : 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
|
