return tmp;
}
- bool operator==(const DERIVED& RHS) const {
- return stmt == RHS.stmt && DGI == RHS.DGI && RawVAPtr == RHS.RawVAPtr;
+ friend bool operator==(const DERIVED &LHS, const DERIVED &RHS) {
+ return LHS.stmt == RHS.stmt && LHS.DGI == RHS.DGI &&
+ LHS.RawVAPtr == RHS.RawVAPtr;
}
- bool operator!=(const DERIVED& RHS) const {
- return stmt != RHS.stmt || DGI != RHS.DGI || RawVAPtr != RHS.RawVAPtr;
+ friend bool operator!=(const DERIVED &LHS, const DERIVED &RHS) {
+ return !(LHS == RHS);
}
REFERENCE operator*() const {
struct OpenMPDirectiveKindExWrapper {
OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}
OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}
+ bool operator==(OpenMPDirectiveKindExWrapper V) const {
+ return Value == V.Value;
+ }
+ bool operator!=(OpenMPDirectiveKindExWrapper V) const {
+ return Value != V.Value;
+ }
bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }
bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }
bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }
struct FunctionData {
FunctionData() = delete;
+ FunctionData(const FunctionDecl *FDecl, StringRef Name,
+ std::string FullName)
+ : FDecl(FDecl), Name(Name), FullName(std::move(FullName)) {}
FunctionData(const FunctionData &) = default;
FunctionData(FunctionData &&) = default;
FunctionData &operator=(const FunctionData &) = delete;
if (Name.empty() || FullName.empty())
return None;
- return FunctionData{FDecl, Name, FullName};
+ return FunctionData{FDecl, Name, std::move(FullName)};
}
bool isInScope(StringRef Scope) const {
reference operator*() const { return base_type::wrapped()->V; }
pointer operator->() const { return &operator*(); }
-
- friend bool operator==(const IteratorImpl &L, const IteratorImpl &R) {
- return L.wrapped() == R.wrapped();
- }
- friend bool operator!=(const IteratorImpl &L, const IteratorImpl &R) {
- return !(L == R);
- }
};
public:
return Ptr;
}
- template <typename T>
- bool operator==(const T &RHS) const {
- assert((!Ptr || isHandleInSync()) && "handle not in sync!");
+ friend bool operator==(const DenseMapIterator &LHS,
+ const DenseMapIterator &RHS) {
+ assert((!LHS.Ptr || LHS.isHandleInSync()) && "handle not in sync!");
assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
- assert(getEpochAddress() == RHS.getEpochAddress() &&
+ assert(LHS.getEpochAddress() == RHS.getEpochAddress() &&
"comparing incomparable iterators!");
- return Ptr == RHS.Ptr;
+ return LHS.Ptr == RHS.Ptr;
}
- template <typename T>
- bool operator!=(const T &RHS) const {
- assert((!Ptr || isHandleInSync()) && "handle not in sync!");
- assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
- assert(getEpochAddress() == RHS.getEpochAddress() &&
- "comparing incomparable iterators!");
- return Ptr != RHS.Ptr;
+ friend bool operator!=(const DenseMapIterator &LHS,
+ const DenseMapIterator &RHS) {
+ return !(LHS == RHS);
}
inline DenseMapIterator& operator++() { // Preincrement
Iterator& operator++() { ++I; return *this; }
Iterator operator++(int) { auto T = *this; ++I; return T; }
- bool operator==(const ConstIterator& X) const { return I == X.I; }
- bool operator!=(const ConstIterator& X) const { return I != X.I; }
+ friend bool operator==(const Iterator &X, const Iterator &Y) {
+ return X.I == Y.I;
+ }
+ friend bool operator!=(const Iterator &X, const Iterator &Y) {
+ return X.I != Y.I;
+ }
};
class ConstIterator {
ConstIterator& operator++() { ++I; return *this; }
ConstIterator operator++(int) { auto T = *this; ++I; return T; }
- bool operator==(const ConstIterator& X) const { return I == X.I; }
- bool operator!=(const ConstIterator& X) const { return I != X.I; }
+ friend bool operator==(const ConstIterator &X, const ConstIterator &Y) {
+ return X.I == Y.I;
+ }
+ friend bool operator!=(const ConstIterator &X, const ConstIterator &Y) {
+ return X.I != Y.I;
+ }
};
using iterator = Iterator;
/// Static polymorphism: delegate implementation (via isEqualTo) to the
/// derived class.
- bool operator==(const EdgeType &E) const { return getDerived().isEqualTo(E); }
- bool operator!=(const EdgeType &E) const { return !operator==(E); }
+ bool operator==(const DGEdge &E) const {
+ return getDerived().isEqualTo(E.getDerived());
+ }
+ bool operator!=(const DGEdge &E) const { return !operator==(E); }
/// Retrieve the target node this edge connects to.
const NodeType &getTargetNode() const { return TargetNode; }
/// Static polymorphism: delegate implementation (via isEqualTo) to the
/// derived class.
- bool operator==(const NodeType &N) const { return getDerived().isEqualTo(N); }
- bool operator!=(const NodeType &N) const { return !operator==(N); }
+ friend bool operator==(const NodeType &M, const NodeType &N) {
+ return M.isEqualTo(N);
+ }
+ friend bool operator!=(const NodeType &M, const NodeType &N) {
+ return !(M == N);
+ }
const_iterator begin() const { return Edges.begin(); }
const_iterator end() const { return Edges.end(); }
return *this;
}
- using BaseT::operator==;
- bool operator==(const early_inc_iterator_impl &RHS) const {
+ friend bool operator==(const early_inc_iterator_impl &LHS,
+ const early_inc_iterator_impl &RHS) {
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
- assert(!IsEarlyIncremented && "Cannot compare after dereferencing!");
+ assert(!LHS.IsEarlyIncremented && "Cannot compare after dereferencing!");
#endif
- return BaseT::operator==(RHS);
+ return (const BaseT &)LHS == (const BaseT &)RHS;
}
};
return static_cast<DerivedTy &>(*this);
}
- bool operator==(const DerivedTy &RHS) const { return Ptr == RHS.Ptr; }
+ friend bool operator==(const DerivedTy &LHS, const DerivedTy &RHS) {
+ return LHS.Ptr == RHS.Ptr;
+ }
DerivedTy &operator++() { // Preincrement
++Ptr;
return tmp;
}
+#ifndef __cpp_impl_three_way_comparison
bool operator!=(const DerivedT &RHS) const {
- return !static_cast<const DerivedT *>(this)->operator==(RHS);
+ return !(static_cast<const DerivedT &>(*this) == RHS);
}
+#endif
bool operator>(const DerivedT &RHS) const {
static_assert(
IsRandomAccess,
"Relational operators are only defined for random access iterators.");
- return !static_cast<const DerivedT *>(this)->operator<(RHS) &&
- !static_cast<const DerivedT *>(this)->operator==(RHS);
+ return !(static_cast<const DerivedT &>(*this) < RHS) &&
+ !(static_cast<const DerivedT &>(*this) == RHS);
}
bool operator<=(const DerivedT &RHS) const {
static_assert(
IsRandomAccess,
"Relational operators are only defined for random access iterators.");
- return !static_cast<const DerivedT *>(this)->operator>(RHS);
+ return !(static_cast<const DerivedT &>(*this) > RHS);
}
bool operator>=(const DerivedT &RHS) const {
static_assert(
IsRandomAccess,
"Relational operators are only defined for random access iterators.");
- return !static_cast<const DerivedT *>(this)->operator<(RHS);
+ return !(static_cast<const DerivedT &>(*this) < RHS);
}
PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
return *static_cast<DerivedT *>(this);
}
- bool operator==(const DerivedT &RHS) const { return I == RHS.I; }
- bool operator<(const DerivedT &RHS) const {
+ friend bool operator==(const iterator_adaptor_base &LHS,
+ const iterator_adaptor_base &RHS) {
+ return LHS.I == RHS.I;
+ }
+ friend bool operator<(const iterator_adaptor_base &LHS,
+ const iterator_adaptor_base &RHS) {
static_assert(
BaseT::IsRandomAccess,
"Relational operators are only defined for random access iterators.");
- return I < RHS.I;
+ return LHS.I < RHS.I;
}
ReferenceT operator*() const { return *I; }
T &operator*() const { return *static_cast<T *>(N); }
bool operator==(const iterator &X) const { return N == X.N; }
- bool operator!=(const iterator &X) const { return N != X.N; }
};
class const_iterator
const T &operator*() const { return *static_cast<const T *>(N); }
bool operator==(const const_iterator &X) const { return N == X.N; }
- bool operator!=(const const_iterator &X) const { return N != X.N; }
};
iterator begin() {
++*this;
return res;
}
- bool operator!=(const SingleLinkedListIterator<T> &Other) {
+ bool operator!=(const SingleLinkedListIterator<T> &Other) const {
return P != Other.operator->();
}
- bool operator==(const SingleLinkedListIterator<T> &Other) {
+ bool operator==(const SingleLinkedListIterator<T> &Other) const {
return P == Other.operator->();
}
T &operator*() const {
return LHS.Die == RHS.Die;
}
-inline bool operator!=(const DWARFDie::iterator &LHS,
- const DWARFDie::iterator &RHS) {
- return !(LHS == RHS);
-}
-
// These inline functions must follow the DWARFDie::iterator definition above
// as they use functions from that class.
inline DWARFDie::iterator DWARFDie::begin() const {
return LHS.equals(RHS);
}
-inline bool operator!=(const std::reverse_iterator<DWARFDie::iterator> &LHS,
- const std::reverse_iterator<DWARFDie::iterator> &RHS) {
- return !(LHS == RHS);
-}
-
inline std::reverse_iterator<DWARFDie::iterator> DWARFDie::rbegin() const {
return llvm::make_reverse_iterator(end());
}
const DWARFExpression::iterator &RHS) {
return LHS.Expr == RHS.Expr && LHS.Offset == RHS.Offset;
}
-
-inline bool operator!=(const DWARFExpression::iterator &LHS,
- const DWARFExpression::iterator &RHS) {
- return !(LHS == RHS);
-}
}
#endif
bool td_empty() const { return TargetDepAttrs.empty(); }
- bool operator==(const AttrBuilder &B);
- bool operator!=(const AttrBuilder &B) {
- return !(*this == B);
- }
+ bool operator==(const AttrBuilder &B) const;
+ bool operator!=(const AttrBuilder &B) const { return !(*this == B); }
};
namespace AttributeFuncs {
phi_iterator_impl() = default;
// Allow conversion between instantiations where valid.
- template <typename PHINodeU, typename BBIteratorU>
+ template <typename PHINodeU, typename BBIteratorU,
+ typename = std::enable_if_t<
+ std::is_convertible<PHINodeU *, PHINodeT *>::value>>
phi_iterator_impl(const phi_iterator_impl<PHINodeU, BBIteratorU> &Arg)
: PN(Arg.PN) {}
return tmp;
}
- bool operator==(const AccessorIterator &Other) {
+ bool operator==(const AccessorIterator &Other) const {
return A.P == Other.A.P;
}
- bool operator!=(const AccessorIterator &Other) { return !(*this == Other); }
+ bool operator!=(const AccessorIterator &Other) const {
+ return !(*this == Other);
+ }
AccessorT& operator*() { return A; }
AccessorT* operator->() { return &A; }
increment();
return *this;
}
- bool operator==(const CoverageMappingIterator &RHS) {
+ bool operator==(const CoverageMappingIterator &RHS) const {
return Reader == RHS.Reader;
}
- bool operator!=(const CoverageMappingIterator &RHS) {
+ bool operator!=(const CoverageMappingIterator &RHS) const {
return Reader != RHS.Reader;
}
Expected<CoverageMappingRecord &> operator*() {
InstrProfIterator(InstrProfReader *Reader) : Reader(Reader) { Increment(); }
InstrProfIterator &operator++() { Increment(); return *this; }
- bool operator==(const InstrProfIterator &RHS) { return Reader == RHS.Reader; }
- bool operator!=(const InstrProfIterator &RHS) { return Reader != RHS.Reader; }
+ bool operator==(const InstrProfIterator &RHS) const {
+ return Reader == RHS.Reader;
+ }
+ bool operator!=(const InstrProfIterator &RHS) const {
+ return Reader != RHS.Reader;
+ }
value_type &operator*() { return Record; }
value_type *operator->() { return &Record; }
};
bool valid() const { return BorrowedImpl != nullptr; }
- bool operator==(const RefType &Other) const {
- if (BorrowedImpl != Other.BorrowedImpl)
+ friend bool operator==(const RefType &LHS, const RefType &RHS) {
+ if (LHS.BorrowedImpl != RHS.BorrowedImpl)
return false;
- if (ViewOffset != Other.ViewOffset)
+ if (LHS.ViewOffset != RHS.ViewOffset)
return false;
- if (Length != Other.Length)
+ if (LHS.Length != RHS.Length)
return false;
return true;
}
return It;
}
- bool operator==(const RepeatedSubstringIterator &Other) {
+ bool operator==(const RepeatedSubstringIterator &Other) const {
return N == Other.N;
}
- bool operator!=(const RepeatedSubstringIterator &Other) {
+ bool operator!=(const RepeatedSubstringIterator &Other) const {
return !(*this == Other);
}
return RegSrcs[Idx].SubReg;
}
- bool operator==(const ValueTrackerResult &Other) {
+ bool operator==(const ValueTrackerResult &Other) const {
if (Other.getInst() != getInst())
return false;
return Alignment != 0;
}
-bool AttrBuilder::operator==(const AttrBuilder &B) {
+bool AttrBuilder::operator==(const AttrBuilder &B) const {
if (Attrs != B.Attrs)
return false;
writeInteger((uint8_t)TableEntry.SegSelectorSize, OS, DI.IsLittleEndian);
for (const SegAddrPair &Pair : TableEntry.SegAddrPairs) {
- if (TableEntry.SegSelectorSize != 0)
+ if (TableEntry.SegSelectorSize != yaml::Hex8{0})
if (Error Err = writeVariableSizedInteger(Pair.Segment,
TableEntry.SegSelectorSize,
OS, DI.IsLittleEndian))
// The instruction (VN) which uses the values flowing out of CHI.
Instruction *I;
- bool operator==(const CHIArg &A) { return VN == A.VN; }
- bool operator!=(const CHIArg &A) { return !(*this == A); }
+ bool operator==(const CHIArg &A) const { return VN == A.VN; }
+ bool operator!=(const CHIArg &A) const { return !(*this == A); }
};
using CHIIt = SmallVectorImpl<CHIArg>::iterator;
bool IsASCII = DbgVariables == DVASCII;
switch (C) {
case LineChar::RangeStart:
- return IsASCII ? "^" : u8"\u2548";
+ return IsASCII ? "^" : (const char *)u8"\u2548";
case LineChar::RangeMid:
- return IsASCII ? "|" : u8"\u2503";
+ return IsASCII ? "|" : (const char *)u8"\u2503";
case LineChar::RangeEnd:
- return IsASCII ? "v" : u8"\u253b";
+ return IsASCII ? "v" : (const char *)u8"\u253b";
case LineChar::LabelVert:
- return IsASCII ? "|" : u8"\u2502";
+ return IsASCII ? "|" : (const char *)u8"\u2502";
case LineChar::LabelCornerNew:
- return IsASCII ? "/" : u8"\u250c";
+ return IsASCII ? "/" : (const char *)u8"\u250c";
case LineChar::LabelCornerActive:
- return IsASCII ? "|" : u8"\u2520";
+ return IsASCII ? "|" : (const char *)u8"\u2520";
case LineChar::LabelHoriz:
- return IsASCII ? "-" : u8"\u2500";
+ return IsASCII ? "-" : (const char *)u8"\u2500";
}
llvm_unreachable("Unhandled LineChar enum");
}
// Check fancy pointer overload for unique_ptr
std::unique_ptr<int> V2 = std::make_unique<int>(0);
- EXPECT_EQ(V2.get(), to_address(V2));
+ EXPECT_EQ(V2.get(), llvm::to_address(V2));
V2.reset(V1);
- EXPECT_EQ(V1, to_address(V2));
+ EXPECT_EQ(V1, llvm::to_address(V2));
V2.release();
// Check fancy pointer overload for shared_ptr
std::shared_ptr<int> V3 = std::make_shared<int>(0);
std::shared_ptr<int> V4 = V3;
EXPECT_EQ(V3.get(), V4.get());
- EXPECT_EQ(V3.get(), to_address(V3));
- EXPECT_EQ(V4.get(), to_address(V4));
+ EXPECT_EQ(V3.get(), llvm::to_address(V3));
+ EXPECT_EQ(V4.get(), llvm::to_address(V4));
V3.reset(V1);
- EXPECT_EQ(V1, to_address(V3));
+ EXPECT_EQ(V1, llvm::to_address(V3));
}
TEST(STLExtrasTest, partition_point) {