/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/BitmaskEnum.h
Line | Count | Source |
1 | | //===-- llvm/ADT/BitmaskEnum.h ----------------------------------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | |
9 | | #ifndef LLVM_ADT_BITMASKENUM_H |
10 | | #define LLVM_ADT_BITMASKENUM_H |
11 | | |
12 | | #include <cassert> |
13 | | #include <type_traits> |
14 | | #include <utility> |
15 | | |
16 | | #include "llvm/Support/MathExtras.h" |
17 | | |
18 | | /// LLVM_MARK_AS_BITMASK_ENUM lets you opt in an individual enum type so you can |
19 | | /// perform bitwise operations on it without putting static_cast everywhere. |
20 | | /// |
21 | | /// \code |
22 | | /// enum MyEnum { |
23 | | /// E1 = 1, E2 = 2, E3 = 4, E4 = 8, |
24 | | /// LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ E4) |
25 | | /// }; |
26 | | /// |
27 | | /// void Foo() { |
28 | | /// MyEnum A = (E1 | E2) & E3 ^ ~E4; // Look, ma: No static_cast! |
29 | | /// } |
30 | | /// \endcode |
31 | | /// |
32 | | /// Normally when you do a bitwise operation on an enum value, you get back an |
33 | | /// instance of the underlying type (e.g. int). But using this macro, bitwise |
34 | | /// ops on your enum will return you back instances of the enum. This is |
35 | | /// particularly useful for enums which represent a combination of flags. |
36 | | /// |
37 | | /// The parameter to LLVM_MARK_AS_BITMASK_ENUM should be the largest individual |
38 | | /// value in your enum. |
39 | | /// |
40 | | /// All of the enum's values must be non-negative. |
41 | | #define LLVM_MARK_AS_BITMASK_ENUM(LargestValue) \ |
42 | | LLVM_BITMASK_LARGEST_ENUMERATOR = LargestValue |
43 | | |
44 | | /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() pulls the operator overloads used |
45 | | /// by LLVM_MARK_AS_BITMASK_ENUM into the current namespace. |
46 | | /// |
47 | | /// Suppose you have an enum foo::bar::MyEnum. Before using |
48 | | /// LLVM_MARK_AS_BITMASK_ENUM on MyEnum, you must put |
49 | | /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() somewhere inside namespace foo or |
50 | | /// namespace foo::bar. This allows the relevant operator overloads to be found |
51 | | /// by ADL. |
52 | | /// |
53 | | /// You don't need to use this macro in namespace llvm; it's done at the bottom |
54 | | /// of this file. |
55 | | #define LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() \ |
56 | | using ::llvm::BitmaskEnumDetail::operator~; \ |
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 | | /* Force a semicolon at the end of this macro. */ \ |
63 | | using ::llvm::BitmaskEnumDetail::operator^= |
64 | | |
65 | | namespace llvm { |
66 | | |
67 | | /// Traits class to determine whether an enum has a |
68 | | /// LLVM_BITMASK_LARGEST_ENUMERATOR enumerator. |
69 | | template <typename E, typename Enable = void> |
70 | | struct is_bitmask_enum : std::false_type {}; |
71 | | |
72 | | template <typename E> |
73 | | struct is_bitmask_enum< |
74 | | E, typename std::enable_if<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= |
75 | | 0>::type> : std::true_type {}; |
76 | | namespace BitmaskEnumDetail { |
77 | | |
78 | | /// Get a bitmask with 1s in all places up to the high-order bit of E's largest |
79 | | /// value. |
80 | 156k | template <typename E> typename std::underlying_type<E>::type Mask() { |
81 | 156k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so |
82 | 156k | // subtracting 1 gives us the mask with all bits set, like we want. |
83 | 156k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( |
84 | 156k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - |
85 | 156k | 1; |
86 | 156k | } std::__1::underlying_type<llvm::MachineMemOperand::Flags>::type llvm::BitmaskEnumDetail::Mask<llvm::MachineMemOperand::Flags>() Line | Count | Source | 80 | 13.5k | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 13.5k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 13.5k | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 13.5k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 13.5k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 13.5k | 1; | 86 | 13.5k | } |
std::__1::underlying_type<llvm::DINode::DIFlags>::type llvm::BitmaskEnumDetail::Mask<llvm::DINode::DIFlags>() Line | Count | Source | 80 | 10.7k | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 10.7k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 10.7k | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 10.7k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 10.7k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 10.7k | 1; | 86 | 10.7k | } |
std::__1::underlying_type<llvm::DISubprogram::DISPFlags>::type llvm::BitmaskEnumDetail::Mask<llvm::DISubprogram::DISPFlags>() Line | Count | Source | 80 | 5.84k | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 5.84k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 5.84k | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 5.84k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 5.84k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 5.84k | 1; | 86 | 5.84k | } |
CGOpenMPRuntime.cpp:std::__1::underlying_type<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags>::type llvm::BitmaskEnumDetail::Mask<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags>() Line | Count | Source | 80 | 886 | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 886 | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 886 | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 886 | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 886 | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 886 | 1; | 86 | 886 | } |
CGOpenMPRuntimeNVPTX.cpp:std::__1::underlying_type<(anonymous namespace)::ModeFlagsTy>::type llvm::BitmaskEnumDetail::Mask<(anonymous namespace)::ModeFlagsTy>() Line | Count | Source | 80 | 63.0k | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 63.0k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 63.0k | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 63.0k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 63.0k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 63.0k | 1; | 86 | 63.0k | } |
std::__1::underlying_type<clang::Parser::ParsedStmtContext>::type llvm::BitmaskEnumDetail::Mask<clang::Parser::ParsedStmtContext>() Line | Count | Source | 80 | 62.4k | template <typename E> typename std::underlying_type<E>::type Mask() { | 81 | 62.4k | // On overflow, NextPowerOf2 returns zero with the type uint64_t, so | 82 | 62.4k | // subtracting 1 gives us the mask with all bits set, like we want. | 83 | 62.4k | return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>( | 84 | 62.4k | E::LLVM_BITMASK_LARGEST_ENUMERATOR)) - | 85 | 62.4k | 1; | 86 | 62.4k | } |
|
87 | | |
88 | | /// Check that Val is in range for E, and return Val cast to E's underlying |
89 | | /// type. |
90 | 387M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { |
91 | 387M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); |
92 | 387M | assert(U >= 0 && "Negative enum values are not allowed."); |
93 | 387M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); |
94 | 387M | return U; |
95 | 387M | } std::__1::underlying_type<llvm::MachineMemOperand::Flags>::type llvm::BitmaskEnumDetail::Underlying<llvm::MachineMemOperand::Flags>(llvm::MachineMemOperand::Flags) Line | Count | Source | 90 | 361M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 361M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 361M | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 361M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 361M | return U; | 95 | 361M | } |
std::__1::underlying_type<llvm::DINode::DIFlags>::type llvm::BitmaskEnumDetail::Underlying<llvm::DINode::DIFlags>(llvm::DINode::DIFlags) Line | Count | Source | 90 | 5.96M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 5.96M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 5.96M | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 5.96M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 5.96M | return U; | 95 | 5.96M | } |
std::__1::underlying_type<llvm::DISubprogram::DISPFlags>::type llvm::BitmaskEnumDetail::Underlying<llvm::DISubprogram::DISPFlags>(llvm::DISubprogram::DISPFlags) Line | Count | Source | 90 | 1.90M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 1.90M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 1.90M | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 1.90M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 1.90M | return U; | 95 | 1.90M | } |
SIMemoryLegalizer.cpp:std::__1::underlying_type<(anonymous namespace)::SIAtomicAddrSpace>::type llvm::BitmaskEnumDetail::Underlying<(anonymous namespace)::SIAtomicAddrSpace>((anonymous namespace)::SIAtomicAddrSpace) Line | Count | Source | 90 | 192k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 192k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 192k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 192k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 192k | return U; | 95 | 192k | } |
SIMemoryLegalizer.cpp:std::__1::underlying_type<(anonymous namespace)::SIMemOp>::type llvm::BitmaskEnumDetail::Underlying<(anonymous namespace)::SIMemOp>((anonymous namespace)::SIMemOp) Line | Count | Source | 90 | 8.91k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 8.91k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 8.91k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 8.91k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 8.91k | return U; | 95 | 8.91k | } |
std::__1::underlying_type<llvm::BinaryStreamFlags>::type llvm::BitmaskEnumDetail::Underlying<llvm::BinaryStreamFlags>(llvm::BinaryStreamFlags) Line | Count | Source | 90 | 719k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 719k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 719k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 719k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 719k | return U; | 95 | 719k | } |
CGOpenMPRuntime.cpp:std::__1::underlying_type<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags>::type llvm::BitmaskEnumDetail::Underlying<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 90 | 94.1k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 94.1k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 94.1k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 94.1k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 94.1k | return U; | 95 | 94.1k | } |
CGOpenMPRuntimeNVPTX.cpp:std::__1::underlying_type<(anonymous namespace)::ModeFlagsTy>::type llvm::BitmaskEnumDetail::Underlying<(anonymous namespace)::ModeFlagsTy>((anonymous namespace)::ModeFlagsTy) Line | Count | Source | 90 | 189k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 189k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 189k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 189k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 189k | return U; | 95 | 189k | } |
std::__1::underlying_type<clang::Parser::ParsedStmtContext>::type llvm::BitmaskEnumDetail::Underlying<clang::Parser::ParsedStmtContext>(clang::Parser::ParsedStmtContext) Line | Count | Source | 90 | 16.4M | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 16.4M | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 16.4M | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 16.4M | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 16.4M | return U; | 95 | 16.4M | } |
std::__1::underlying_type<clang::Parser::AngleBracketTracker::Priority>::type llvm::BitmaskEnumDetail::Underlying<clang::Parser::AngleBracketTracker::Priority>(clang::Parser::AngleBracketTracker::Priority) Line | Count | Source | 90 | 474k | template <typename E> typename std::underlying_type<E>::type Underlying(E Val) { | 91 | 474k | auto U = static_cast<typename std::underlying_type<E>::type>(Val); | 92 | 474k | assert(U >= 0 && "Negative enum values are not allowed."); | 93 | 474k | assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)"); | 94 | 474k | return U; | 95 | 474k | } |
|
96 | | |
97 | | template <typename E, |
98 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
99 | 156k | E operator~(E Val) { |
100 | 156k | return static_cast<E>(~Underlying(Val) & Mask<E>()); |
101 | 156k | } llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator~<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags) Line | Count | Source | 99 | 13.5k | E operator~(E Val) { | 100 | 13.5k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 13.5k | } |
llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator~<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags) Line | Count | Source | 99 | 10.7k | E operator~(E Val) { | 100 | 10.7k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 10.7k | } |
llvm::DISubprogram::DISPFlags llvm::BitmaskEnumDetail::operator~<llvm::DISubprogram::DISPFlags, void>(llvm::DISubprogram::DISPFlags) Line | Count | Source | 99 | 5.84k | E operator~(E Val) { | 100 | 5.84k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 5.84k | } |
CGOpenMPRuntime.cpp:(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags llvm::BitmaskEnumDetail::operator~<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, void>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 99 | 886 | E operator~(E Val) { | 100 | 886 | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 886 | } |
CGOpenMPRuntimeNVPTX.cpp:(anonymous namespace)::ModeFlagsTy llvm::BitmaskEnumDetail::operator~<(anonymous namespace)::ModeFlagsTy, void>((anonymous namespace)::ModeFlagsTy) Line | Count | Source | 99 | 63.0k | E operator~(E Val) { | 100 | 63.0k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 63.0k | } |
clang::Parser::ParsedStmtContext llvm::BitmaskEnumDetail::operator~<clang::Parser::ParsedStmtContext, void>(clang::Parser::ParsedStmtContext) Line | Count | Source | 99 | 62.4k | E operator~(E Val) { | 100 | 62.4k | return static_cast<E>(~Underlying(Val) & Mask<E>()); | 101 | 62.4k | } |
|
102 | | |
103 | | template <typename E, |
104 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
105 | 11.2M | E operator|(E LHS, E RHS) { |
106 | 11.2M | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); |
107 | 11.2M | } llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator|<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags, llvm::MachineMemOperand::Flags) Line | Count | Source | 105 | 6.25M | E operator|(E LHS, E RHS) { | 106 | 6.25M | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 6.25M | } |
llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator|<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags, llvm::DINode::DIFlags) Line | Count | Source | 105 | 251k | E operator|(E LHS, E RHS) { | 106 | 251k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 251k | } |
SIMemoryLegalizer.cpp:(anonymous namespace)::SIAtomicAddrSpace llvm::BitmaskEnumDetail::operator|<(anonymous namespace)::SIAtomicAddrSpace, void>((anonymous namespace)::SIAtomicAddrSpace, (anonymous namespace)::SIAtomicAddrSpace) Line | Count | Source | 105 | 70.1k | E operator|(E LHS, E RHS) { | 106 | 70.1k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 70.1k | } |
SIMemoryLegalizer.cpp:(anonymous namespace)::SIMemOp llvm::BitmaskEnumDetail::operator|<(anonymous namespace)::SIMemOp, void>((anonymous namespace)::SIMemOp, (anonymous namespace)::SIMemOp) Line | Count | Source | 105 | 3.38k | E operator|(E LHS, E RHS) { | 106 | 3.38k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 3.38k | } |
llvm::DISubprogram::DISPFlags llvm::BitmaskEnumDetail::operator|<llvm::DISubprogram::DISPFlags, void>(llvm::DISubprogram::DISPFlags, llvm::DISubprogram::DISPFlags) Line | Count | Source | 105 | 242k | E operator|(E LHS, E RHS) { | 106 | 242k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 242k | } |
llvm::BinaryStreamFlags llvm::BitmaskEnumDetail::operator|<llvm::BinaryStreamFlags, void>(llvm::BinaryStreamFlags, llvm::BinaryStreamFlags) Line | Count | Source | 105 | 67.8k | E operator|(E LHS, E RHS) { | 106 | 67.8k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 67.8k | } |
CGOpenMPRuntime.cpp:(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags llvm::BitmaskEnumDetail::operator|<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, void>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, (anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 105 | 45.0k | E operator|(E LHS, E RHS) { | 106 | 45.0k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 45.0k | } |
CGOpenMPRuntimeNVPTX.cpp:(anonymous namespace)::ModeFlagsTy llvm::BitmaskEnumDetail::operator|<(anonymous namespace)::ModeFlagsTy, void>((anonymous namespace)::ModeFlagsTy, (anonymous namespace)::ModeFlagsTy) Line | Count | Source | 105 | 591 | E operator|(E LHS, E RHS) { | 106 | 591 | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 591 | } |
clang::Parser::ParsedStmtContext llvm::BitmaskEnumDetail::operator|<clang::Parser::ParsedStmtContext, void>(clang::Parser::ParsedStmtContext, clang::Parser::ParsedStmtContext) Line | Count | Source | 105 | 4.05M | E operator|(E LHS, E RHS) { | 106 | 4.05M | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 4.05M | } |
clang::Parser::AngleBracketTracker::Priority llvm::BitmaskEnumDetail::operator|<clang::Parser::AngleBracketTracker::Priority, void>(clang::Parser::AngleBracketTracker::Priority, clang::Parser::AngleBracketTracker::Priority) Line | Count | Source | 105 | 237k | E operator|(E LHS, E RHS) { | 106 | 237k | return static_cast<E>(Underlying(LHS) | Underlying(RHS)); | 107 | 237k | } |
|
108 | | |
109 | | template <typename E, |
110 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
111 | 182M | E operator&(E LHS, E RHS) { |
112 | 182M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); |
113 | 182M | } llvm::MachineMemOperand::Flags llvm::BitmaskEnumDetail::operator&<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags, llvm::MachineMemOperand::Flags) Line | Count | Source | 111 | 174M | E operator&(E LHS, E RHS) { | 112 | 174M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 174M | } |
llvm::DINode::DIFlags llvm::BitmaskEnumDetail::operator&<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags, llvm::DINode::DIFlags) Line | Count | Source | 111 | 2.72M | E operator&(E LHS, E RHS) { | 112 | 2.72M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 2.72M | } |
llvm::DISubprogram::DISPFlags llvm::BitmaskEnumDetail::operator&<llvm::DISubprogram::DISPFlags, void>(llvm::DISubprogram::DISPFlags, llvm::DISubprogram::DISPFlags) Line | Count | Source | 111 | 707k | E operator&(E LHS, E RHS) { | 112 | 707k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 707k | } |
SIMemoryLegalizer.cpp:(anonymous namespace)::SIAtomicAddrSpace llvm::BitmaskEnumDetail::operator&<(anonymous namespace)::SIAtomicAddrSpace, void>((anonymous namespace)::SIAtomicAddrSpace, (anonymous namespace)::SIAtomicAddrSpace) Line | Count | Source | 111 | 26.1k | E operator&(E LHS, E RHS) { | 112 | 26.1k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 26.1k | } |
SIMemoryLegalizer.cpp:(anonymous namespace)::SIMemOp llvm::BitmaskEnumDetail::operator&<(anonymous namespace)::SIMemOp, void>((anonymous namespace)::SIMemOp, (anonymous namespace)::SIMemOp) Line | Count | Source | 111 | 1.07k | E operator&(E LHS, E RHS) { | 112 | 1.07k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 1.07k | } |
llvm::BinaryStreamFlags llvm::BitmaskEnumDetail::operator&<llvm::BinaryStreamFlags, void>(llvm::BinaryStreamFlags, llvm::BinaryStreamFlags) Line | Count | Source | 111 | 291k | E operator&(E LHS, E RHS) { | 112 | 291k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 291k | } |
CGOpenMPRuntime.cpp:(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags llvm::BitmaskEnumDetail::operator&<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, void>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, (anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 111 | 1.55k | E operator&(E LHS, E RHS) { | 112 | 1.55k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 1.55k | } |
CGOpenMPRuntimeNVPTX.cpp:(anonymous namespace)::ModeFlagsTy llvm::BitmaskEnumDetail::operator&<(anonymous namespace)::ModeFlagsTy, void>((anonymous namespace)::ModeFlagsTy, (anonymous namespace)::ModeFlagsTy) Line | Count | Source | 111 | 62.8k | E operator&(E LHS, E RHS) { | 112 | 62.8k | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 62.8k | } |
clang::Parser::ParsedStmtContext llvm::BitmaskEnumDetail::operator&<clang::Parser::ParsedStmtContext, void>(clang::Parser::ParsedStmtContext, clang::Parser::ParsedStmtContext) Line | Count | Source | 111 | 4.12M | E operator&(E LHS, E RHS) { | 112 | 4.12M | return static_cast<E>(Underlying(LHS) & Underlying(RHS)); | 113 | 4.12M | } |
|
114 | | |
115 | | template <typename E, |
116 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
117 | | E operator^(E LHS, E RHS) { |
118 | | return static_cast<E>(Underlying(LHS) ^ Underlying(RHS)); |
119 | | } |
120 | | |
121 | | // |=, &=, and ^= return a reference to LHS, to match the behavior of the |
122 | | // operators on builtin types. |
123 | | |
124 | | template <typename E, |
125 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
126 | 6.32M | E &operator|=(E &LHS, E RHS) { |
127 | 6.32M | LHS = LHS | RHS; |
128 | 6.32M | return LHS; |
129 | 6.32M | } llvm::MachineMemOperand::Flags& llvm::BitmaskEnumDetail::operator|=<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags&, llvm::MachineMemOperand::Flags) Line | Count | Source | 126 | 5.98M | E &operator|=(E &LHS, E RHS) { | 127 | 5.98M | LHS = LHS | RHS; | 128 | 5.98M | return LHS; | 129 | 5.98M | } |
llvm::DINode::DIFlags& llvm::BitmaskEnumDetail::operator|=<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags&, llvm::DINode::DIFlags) Line | Count | Source | 126 | 130k | E &operator|=(E &LHS, E RHS) { | 127 | 130k | LHS = LHS | RHS; | 128 | 130k | return LHS; | 129 | 130k | } |
SIMemoryLegalizer.cpp:(anonymous namespace)::SIAtomicAddrSpace& llvm::BitmaskEnumDetail::operator|=<(anonymous namespace)::SIAtomicAddrSpace, void>((anonymous namespace)::SIAtomicAddrSpace&, (anonymous namespace)::SIAtomicAddrSpace) Line | Count | Source | 126 | 70.1k | E &operator|=(E &LHS, E RHS) { | 127 | 70.1k | LHS = LHS | RHS; | 128 | 70.1k | return LHS; | 129 | 70.1k | } |
llvm::DISubprogram::DISPFlags& llvm::BitmaskEnumDetail::operator|=<llvm::DISubprogram::DISPFlags, void>(llvm::DISubprogram::DISPFlags&, llvm::DISubprogram::DISPFlags) Line | Count | Source | 126 | 124k | E &operator|=(E &LHS, E RHS) { | 127 | 124k | LHS = LHS | RHS; | 128 | 124k | return LHS; | 129 | 124k | } |
CGOpenMPRuntime.cpp:(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags& llvm::BitmaskEnumDetail::operator|=<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, void>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags&, (anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 126 | 15.2k | E &operator|=(E &LHS, E RHS) { | 127 | 15.2k | LHS = LHS | RHS; | 128 | 15.2k | return LHS; | 129 | 15.2k | } |
|
130 | | |
131 | | template <typename E, |
132 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
133 | 80.1k | E &operator&=(E &LHS, E RHS) { |
134 | 80.1k | LHS = LHS & RHS; |
135 | 80.1k | return LHS; |
136 | 80.1k | } llvm::DINode::DIFlags& llvm::BitmaskEnumDetail::operator&=<llvm::DINode::DIFlags, void>(llvm::DINode::DIFlags&, llvm::DINode::DIFlags) Line | Count | Source | 133 | 10.7k | E &operator&=(E &LHS, E RHS) { | 134 | 10.7k | LHS = LHS & RHS; | 135 | 10.7k | return LHS; | 136 | 10.7k | } |
llvm::DISubprogram::DISPFlags& llvm::BitmaskEnumDetail::operator&=<llvm::DISubprogram::DISPFlags, void>(llvm::DISubprogram::DISPFlags&, llvm::DISubprogram::DISPFlags) Line | Count | Source | 133 | 5.84k | E &operator&=(E &LHS, E RHS) { | 134 | 5.84k | LHS = LHS & RHS; | 135 | 5.84k | return LHS; | 136 | 5.84k | } |
CGOpenMPRuntime.cpp:(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags& llvm::BitmaskEnumDetail::operator&=<(anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags, void>((anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags&, (anonymous namespace)::MappableExprsHandler::OpenMPOffloadMappingFlags) Line | Count | Source | 133 | 886 | E &operator&=(E &LHS, E RHS) { | 134 | 886 | LHS = LHS & RHS; | 135 | 886 | return LHS; | 136 | 886 | } |
llvm::MachineMemOperand::Flags& llvm::BitmaskEnumDetail::operator&=<llvm::MachineMemOperand::Flags, void>(llvm::MachineMemOperand::Flags&, llvm::MachineMemOperand::Flags) Line | Count | Source | 133 | 248 | E &operator&=(E &LHS, E RHS) { | 134 | 248 | LHS = LHS & RHS; | 135 | 248 | return LHS; | 136 | 248 | } |
clang::Parser::ParsedStmtContext& llvm::BitmaskEnumDetail::operator&=<clang::Parser::ParsedStmtContext, void>(clang::Parser::ParsedStmtContext&, clang::Parser::ParsedStmtContext) Line | Count | Source | 133 | 62.4k | E &operator&=(E &LHS, E RHS) { | 134 | 62.4k | LHS = LHS & RHS; | 135 | 62.4k | return LHS; | 136 | 62.4k | } |
|
137 | | |
138 | | template <typename E, |
139 | | typename = typename std::enable_if<is_bitmask_enum<E>::value>::type> |
140 | | E &operator^=(E &LHS, E RHS) { |
141 | | LHS = LHS ^ RHS; |
142 | | return LHS; |
143 | | } |
144 | | |
145 | | } // namespace BitmaskEnumDetail |
146 | | |
147 | | // Enable bitmask enums in namespace ::llvm and all nested namespaces. |
148 | | LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); |
149 | | |
150 | | } // namespace llvm |
151 | | |
152 | | #endif |