Coverage Report

Created: 2019-07-24 05:18

/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