151 lines
5.2 KiB
C++
151 lines
5.2 KiB
C++
//===---- bitmask_enum.h - Enable bitmask operations on enums ---*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file is a part of the ORC runtime support library.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef ORC_RT_BITMASK_ENUM_H
|
|
#define ORC_RT_BITMASK_ENUM_H
|
|
|
|
#include "stl_extras.h"
|
|
|
|
#include <cassert>
|
|
#include <type_traits>
|
|
|
|
namespace __orc_rt {
|
|
|
|
/// ORC_RT_MARK_AS_BITMASK_ENUM lets you opt in an individual enum type so you
|
|
/// can perform bitwise operations on it without putting static_cast everywhere.
|
|
///
|
|
/// \code
|
|
/// enum MyEnum {
|
|
/// E1 = 1, E2 = 2, E3 = 4, E4 = 8,
|
|
/// ORC_RT_MARK_AS_BITMASK_ENUM(/* LargestValue = */ E4)
|
|
/// };
|
|
///
|
|
/// void Foo() {
|
|
/// MyEnum A = (E1 | E2) & E3 ^ ~E4; // Look, ma: No static_cast!
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// Normally when you do a bitwise operation on an enum value, you get back an
|
|
/// instance of the underlying type (e.g. int). But using this macro, bitwise
|
|
/// ops on your enum will return you back instances of the enum. This is
|
|
/// particularly useful for enums which represent a combination of flags.
|
|
///
|
|
/// The parameter to ORC_RT_MARK_AS_BITMASK_ENUM should be the largest
|
|
/// individual value in your enum.
|
|
///
|
|
/// All of the enum's values must be non-negative.
|
|
#define ORC_RT_MARK_AS_BITMASK_ENUM(LargestValue) \
|
|
ORC_RT_BITMASK_LARGEST_ENUMERATOR = LargestValue
|
|
|
|
/// ORC_RT_DECLARE_ENUM_AS_BITMASK can be used to declare an enum type as a bit
|
|
/// set, so that bitwise operation on such enum does not require static_cast.
|
|
///
|
|
/// \code
|
|
/// enum MyEnum { E1 = 1, E2 = 2, E3 = 4, E4 = 8 };
|
|
/// ORC_RT_DECLARE_ENUM_AS_BITMASK(MyEnum, E4);
|
|
///
|
|
/// void Foo() {
|
|
/// MyEnum A = (E1 | E2) & E3 ^ ~E4; // No static_cast
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// The second parameter to ORC_RT_DECLARE_ENUM_AS_BITMASK specifies the largest
|
|
/// bit value of the enum type.
|
|
///
|
|
/// ORC_RT_DECLARE_ENUM_AS_BITMASK should be used in __orc_rt namespace.
|
|
///
|
|
/// This a non-intrusive alternative for ORC_RT_MARK_AS_BITMASK_ENUM. It allows
|
|
/// declaring more than one non-scoped enumerations as bitmask types in the same
|
|
/// scope. Otherwise it provides the same functionality as
|
|
/// ORC_RT_MARK_AS_BITMASK_ENUM.
|
|
#define ORC_RT_DECLARE_ENUM_AS_BITMASK(Enum, LargestValue) \
|
|
template <> struct is_bitmask_enum<Enum> : std::true_type {}; \
|
|
template <> struct largest_bitmask_enum_bit<Enum> { \
|
|
static constexpr std::underlying_type_t<Enum> value = LargestValue; \
|
|
}
|
|
|
|
/// Traits class to determine whether an enum has been declared as a bitwise
|
|
/// enum via ORC_RT_DECLARE_ENUM_AS_BITMASK.
|
|
template <typename E, typename Enable = void>
|
|
struct is_bitmask_enum : std::false_type {};
|
|
|
|
template <typename E>
|
|
struct is_bitmask_enum<
|
|
E, std::enable_if_t<sizeof(E::ORC_RT_BITMASK_LARGEST_ENUMERATOR) >= 0>>
|
|
: std::true_type {};
|
|
|
|
template <typename E>
|
|
inline constexpr bool is_bitmask_enum_v = is_bitmask_enum<E>::value;
|
|
|
|
/// Traits class to deermine bitmask enum largest bit.
|
|
template <typename E, typename Enable = void> struct largest_bitmask_enum_bit;
|
|
|
|
template <typename E>
|
|
struct largest_bitmask_enum_bit<
|
|
E, std::enable_if_t<sizeof(E::ORC_RT_BITMASK_LARGEST_ENUMERATOR) >= 0>> {
|
|
using UnderlyingTy = std::underlying_type_t<E>;
|
|
static constexpr UnderlyingTy value =
|
|
static_cast<UnderlyingTy>(E::ORC_RT_BITMASK_LARGEST_ENUMERATOR);
|
|
};
|
|
|
|
template <typename E> constexpr std::underlying_type_t<E> Mask() {
|
|
return bit_ceil(largest_bitmask_enum_bit<E>::value) - 1;
|
|
}
|
|
|
|
template <typename E> constexpr std::underlying_type_t<E> Underlying(E Val) {
|
|
auto U = static_cast<std::underlying_type_t<E>>(Val);
|
|
assert(U >= 0 && "Negative enum values are not allowed");
|
|
assert(U <= Mask<E>() && "Enum value too large (or langest val too small");
|
|
return U;
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
constexpr E operator~(E Val) {
|
|
return static_cast<E>(~Underlying(Val) & Mask<E>());
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
constexpr E operator|(E LHS, E RHS) {
|
|
return static_cast<E>(Underlying(LHS) | Underlying(RHS));
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
constexpr E operator&(E LHS, E RHS) {
|
|
return static_cast<E>(Underlying(LHS) & Underlying(RHS));
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
constexpr E operator^(E LHS, E RHS) {
|
|
return static_cast<E>(Underlying(LHS) ^ Underlying(RHS));
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
E &operator|=(E &LHS, E RHS) {
|
|
LHS = LHS | RHS;
|
|
return LHS;
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
E &operator&=(E &LHS, E RHS) {
|
|
LHS = LHS & RHS;
|
|
return LHS;
|
|
}
|
|
|
|
template <typename E, typename = std::enable_if_t<is_bitmask_enum_v<E>>>
|
|
E &operator^=(E &LHS, E RHS) {
|
|
LHS = LHS ^ RHS;
|
|
return LHS;
|
|
}
|
|
|
|
} // end namespace __orc_rt
|
|
|
|
#endif // ORC_RT_BITMASK_ENUM_H
|