contrib/llvm/include/llvm/ADT/BitmaskEnum.h

   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   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   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   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   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   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   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   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