Equality operators
Declared in <llvm/ADT/DirectedGraph.h>
Return true if LHS and RHS name the same table offset.
constexpr
bool
operator==(
Offset const& LHS,
Offset const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<call_iterator, Edge*, forward_iterator_tag> const& LHS,
iterator_adaptor_base<call_iterator, Edge*, forward_iterator_tag> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<iterator, Edge*, forward_iterator_tag> const& LHS,
iterator_adaptor_base<iterator, Edge*, forward_iterator_tag> const& RHS);Return true if A and B wrap the same raw location metadata.
bool
operator==(
RawLocationWrapper const& A,
RawLocationWrapper const& B);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<call_iterator, DenseMapIterator<CallInst*, unsigned int>> const& LHS,
iterator_adaptor_base<call_iterator, DenseMapIterator<CallInst*, unsigned int>> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<GSIHashIterator, FixedStreamArrayIterator<PSHashRecord>, random_access_iterator_tag, unsigned int const> const& LHS,
iterator_adaptor_base<GSIHashIterator, FixedStreamArrayIterator<PSHashRecord>, random_access_iterator_tag, unsigned int const> const& RHS);Compare fallible iterators for equality.
bool
operator==(
fallible_iterator const& LHS,
fallible_iterator const& RHS);Return true if LHS and RHS have the same range and value.
bool
operator==(
AddressRangeValuePair const& LHS,
AddressRangeValuePair const& RHS);Return true if the two values compare equal.
bool
operator==(
DIExpression::FragmentInfo const& A,
DIExpression::FragmentInfo const& B);Return true if the two values compare equal.
bool
operator==(
DIDerivedType::PtrAuthData Lhs,
DIDerivedType::PtrAuthData Rhs);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<MCSubRegIterator, DiffListIterator, forward_iterator_tag, unsigned short const> const& LHS,
iterator_adaptor_base<MCSubRegIterator, DiffListIterator, forward_iterator_tag, unsigned short const> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<MCSuperRegIterator, DiffListIterator, forward_iterator_tag, unsigned short const> const& LHS,
iterator_adaptor_base<MCSuperRegIterator, DiffListIterator, forward_iterator_tag, unsigned short const> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<MCRegUnitIterator, DiffListIterator, forward_iterator_tag, MCRegUnit const> const& LHS,
iterator_adaptor_base<MCRegUnitIterator, DiffListIterator, forward_iterator_tag, MCRegUnit const> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<AACallEdgeIterator, Function const**> const& LHS,
iterator_adaptor_base<AACallEdgeIterator, Function const**> const& RHS);Return true when LHS and RHS refer to the same position.
bool
operator==(
find_iterator const& LHS,
find_iterator const& RHS);Compare two stream references for equality of impl, offset, and length.
bool
operator==(
WritableBinaryStreamRef const& LHS,
WritableBinaryStreamRef const& RHS);Compare two stream references for equality of impl, offset, and length.
bool
operator==(
BinaryStreamRef const& LHS,
BinaryStreamRef const& RHS);Compare two stream references for equality of impl, offset, and length.
bool
operator==(
RefType const& LHS,
RefType const& RHS);Equality comparison for SmallSet.
template<
typename T,
unsigned int LN,
unsigned int RN,
typename C>
[[nodiscard]]
bool
operator==(
SmallSet<T, LN, C> const& LHS,
SmallSet<T, RN, C> const& RHS);Compare two attribute encodings for equality.
bool
operator==(
AttributeEncoding const& LHS,
AttributeEncoding const& RHS);Compare two value iterators for equality.
bool
operator==(
ValueIterator const& A,
ValueIterator const& B);Compare two name iterators for equality.
bool
operator==(
NameIterator const& A,
NameIterator const& B);Compare two same-name iterators for equality.
bool
operator==(
SameNameIterator const& A,
SameNameIterator const& B);Return true if LHS and RHS are the same position in one expression.
bool
operator==(
iterator const& LHS,
iterator const& RHS);Return true if both iterators have the same number of entries left.
bool
operator==(
iterator_base const& X,
iterator_base const& Y);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<value_iterator, iterator, forward_iterator_tag, DIEValue> const& LHS,
iterator_adaptor_base<value_iterator, iterator, forward_iterator_tag, DIEValue> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<WrappedSuccIterator, succ_iterator, random_access_iterator_tag, pair<Loop const*, BasicBlock*>, long, pair<Loop const*, BasicBlock*>*, pair<Loop const*, BasicBlock*>> const& LHS,
iterator_adaptor_base<WrappedSuccIterator, succ_iterator, random_access_iterator_tag, pair<Loop const*, BasicBlock*>, long, pair<Loop const*, BasicBlock*>*, pair<Loop const*, BasicBlock*>> const& RHS);Compare nodes LHS and RHS using derived-class equality.
bool
operator==(
DDGNode const& LHS,
DDGNode const& RHS);Returns true if A is equal to B.
bool
operator==(
DynamicAPInt const& A,
int64_t B);Returns true if A is equal to B.
bool
operator==(
int64_t A,
DynamicAPInt const& B);Equality operator.
bool
operator==(
MaterializedIterator const& LHS,
MaterializedIterator const& RHS);Return true if c1 and c2 reserve the same intervals.
bool
operator==(
ResourceSegments const& c1,
ResourceSegments const& c2);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<value_op_iterator, SDUse*, random_access_iterator_tag, SDValue, long, value_op_iterator*, value_op_iterator*> const& LHS,
iterator_adaptor_base<value_op_iterator, SDUse*, random_access_iterator_tag, SDValue, long, value_op_iterator*, value_op_iterator*> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<const_symbol_iterator, DenseMapIterator<SymbolsMapKey, Symbol*>, forward_iterator_tag, Symbol const*, long, Symbol const*, Symbol const*> const& LHS,
iterator_adaptor_base<const_symbol_iterator, DenseMapIterator<SymbolsMapKey, Symbol*>, forward_iterator_tag, Symbol const*, long, Symbol const*, Symbol const*> const& RHS);Compare two DenseMaps of SymbolsMapKey to Symbol pointers for equality.
template<
typename DerivedT,
typename KeyInfoT,
typename BucketT>
bool
operator==(
DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol*, KeyInfoT, BucketT> const& LHS,
DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol*, KeyInfoT, BucketT> const& RHS);Return true if LHS and RHS are equal expressions.
bool
operator==(
SMTExpr const& LHS,
SMTExpr const& RHS);Return true if LHS and RHS are equal sorts.
bool
operator==(
SMTSort const& LHS,
SMTSort const& RHS);Return true if two HTTP requests describe the same outbound request.
bool
operator==(
HTTPRequest const& A,
HTTPRequest const& B);Return true if LHS and RHS refer to the same line position.
bool
operator==(
line_iterator const& LHS,
line_iterator const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<const_value_iterator, const_iterator, forward_iterator_tag, DIEValue const> const& LHS,
iterator_adaptor_base<const_value_iterator, const_iterator, forward_iterator_tag, DIEValue const> const& RHS);Return true if two memory operands compare equal.
bool
operator==(
MachineMemOperand const& LHS,
MachineMemOperand const& RHS);Return true if L and R refer to the same bundle position.
bool
operator==(
MachineInstrBundleIterator const& L,
MachineInstrBundleIterator const& R);Return true if L equals const instruction iterator R.
bool
operator==(
MachineInstrBundleIterator const& L,
const_instr_iterator const& R);Return true if const instruction iterator L equals R.
bool
operator==(
const_instr_iterator const& L,
MachineInstrBundleIterator const& R);Return true if L equals non-const instruction iterator R.
bool
operator==(
MachineInstrBundleIterator const& L,
nonconst_instr_iterator const& R);Return true if non-const instruction iterator L equals R.
bool
operator==(
nonconst_instr_iterator const& L,
MachineInstrBundleIterator const& R);Compare a bundle iterator to an instruction pointer.
bool
operator==(
MachineInstrBundleIterator const& L,
const_pointer R);Return true if instruction pointer L equals bundle iterator R.
bool
operator==(
const_pointer L,
MachineInstrBundleIterator const& R);Return true if bundle iterator L refers to instruction R.
bool
operator==(
MachineInstrBundleIterator const& L,
const_reference R);Compare a machine instruction reference with a bundle iterator.
bool
operator==(
const_reference L,
MachineInstrBundleIterator const& R);Return true if optional alignments Lhs and Rhs are both unset or equal.
bool
operator==(
MaybeAlign Lhs,
MaybeAlign Rhs);Compare a 64-bit value with an APInt for equality.
bool
operator==(
uint64_t V1,
APInt const& V2);Determine if two version numbers are equivalent. If not provided, minor and subminor version numbers are considered to be zero.
bool
operator==(
VersionTuple const& X,
VersionTuple const& Y);Compare two digests for equality.
bool
operator==(
MD5Result const& LHS,
MD5Result const& RHS);Return true if Err holds error-code enum Code.
template<
class T,
class E>
bool
operator==(
ErrorOr<T> const& Err,
E Code)
requires std::is_error_code_enum<E>::value ||
std::is_error_condition_enum<E>::value;Return true if LHS and RHS contain the same pointers.
template<typename PtrType>
[[nodiscard]]
bool
operator==(
SmallPtrSetImpl<PtrType> const& LHS,
SmallPtrSetImpl<PtrType> const& RHS);Return true if both iterators refer to the same bucket.
bool
operator==(
StringMapIterBase const& LHS,
StringMapIterBase const& RHS);Return true if LHS and RHS refer to the same node.
bool
operator==(
ilist_iterator_w_bits const& LHS,
ilist_iterator_w_bits const& RHS);Return true if LHS and RHS refer to the same node.
bool
operator==(
ilist_iterator const& LHS,
ilist_iterator const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<const_value_op_iterator, Use const*, random_access_iterator_tag, Value const*, long, Value const*, Value const*> const& LHS,
iterator_adaptor_base<const_value_op_iterator, Use const*, random_access_iterator_tag, Value const*, long, Value const*, Value const*> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<value_op_iterator, Use*, random_access_iterator_tag, Value*, long, Value*, Value*> const& LHS,
iterator_adaptor_base<value_op_iterator, Use*, random_access_iterator_tag, Value*, long, Value*, Value*> const& RHS);Return true if optional alignment Rhs is unset.
bool
operator==(
std::nullopt_t None,
MaybeAlign Rhs);Return true if optional alignment Lhs is unset.
bool
operator==(
MaybeAlign Lhs,
std::nullopt_t None);Compare a signed 64-bit value with an APSInt for equality.
bool
operator==(
int64_t V1,
APSInt const& V2);Return true if optional alignment Rhs is set and equals Lhs.
bool
operator==(
Align Lhs,
MaybeAlign Rhs);Return true if optional alignment Lhs is set and equals Rhs.
bool
operator==(
MaybeAlign Lhs,
Align Rhs);Comparisons between Align and scalars. Rhs must be positive.
bool
operator==(
Align Lhs,
uint64_t Rhs);Return true if SmallVector LHS equals ArrayRef RHS.
template<typename T>
[[nodiscard]]
bool
operator==(
SmallVectorImpl<T> const& LHS,
ArrayRef<T> RHS);Return true if LHS and RHS contain equal elements.
template<typename T>
bool
operator==(
ArrayRef<T> LHS,
ArrayRef<T> RHS);Return true if alignments Lhs and Rhs are equal.
bool
operator==(
Align Lhs,
Align Rhs);Return true if LHS and RHS have equal length and contents.
bool
operator==(
StringRef LHS,
StringRef RHS);Compare two hash codes for equality.
constexpr
bool
operator==(
hash_code const& lhs,
hash_code const& rhs);Equality comparison for DenseMap.
template<
typename DerivedT,
typename KeyT,
typename ValueT,
typename KeyInfoT,
typename BucketT>
[[nodiscard]]
bool
operator==(
DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> const& LHS,
DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> const& RHS);Return whether LHS and RHS refer to the same bucket.
[[nodiscard]]
bool
operator==(
DenseMapIterator const& LHS,
DenseMapIterator const& RHS);Compare two early-increment iterators by underlying position.
bool
operator==(
early_inc_iterator_impl const& LHS,
early_inc_iterator_impl const& RHS);Return true if A and B refer to the same map entry.
bool
operator==(
ValueInfo const& A,
ValueInfo const& B);Return true if A is empty.
template<class T>
bool
operator==(
IntrusiveRefCntPtr<T> const& A,
std::nullptr_t B);Return true if B is empty.
template<class T>
bool
operator==(
std::nullptr_t A,
IntrusiveRefCntPtr<T> const& B);Return true if raw pointer A equals B's pointee.
template<
class T,
class U>
bool
operator==(
T* A,
IntrusiveRefCntPtr<U> const& B);Return true if A points to the same object as raw pointer B.
template<
class T,
class U>
bool
operator==(
IntrusiveRefCntPtr<T> const& A,
U* B);Return true if A and B point to the same object.
template<
class T,
class U>
bool
operator==(
IntrusiveRefCntPtr<T> const& A,
IntrusiveRefCntPtr<U> const& B);True if both reverse DIE iterators refer to the same position.
bool
operator==(
std::reverse_iterator<DWARFDie::iterator> const& LHS,
std::reverse_iterator<DWARFDie::iterator> const& RHS);True if LHS and RHS refer to the same unit and debug-info entry.
bool
operator==(
DWARFDie const& LHS,
DWARFDie const& RHS);True if both location expressions have the same range and expression bytes.
bool
operator==(
DWARFLocationExpression const& L,
DWARFLocationExpression const& R);True if both ranges have the same section index, LowPC, and HighPC.
bool
operator==(
DWARFAddressRange const& LHS,
DWARFAddressRange const& RHS);True if both iterators refer to the same DIE.
bool
operator==(
DWARFDie::iterator const& LHS,
DWARFDie::iterator const& RHS);True if both attribute iterators refer to the same DIE and attribute index.
bool
operator==(
attribute_iterator const& LHS,
attribute_iterator const& RHS);Check pointer identity (not value) of identifier and data.
bool
operator==(
MemoryBufferRef const& LHS,
MemoryBufferRef const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base const& LHS,
iterator_adaptor_base const& RHS);Return true if L equals R.
template<class DigitsT>
bool
operator==(
int32_t L,
ScaledNumber<DigitsT> const& R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
ScaledNumber<DigitsT> const& L,
int32_t R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
int64_t L,
ScaledNumber<DigitsT> const& R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
ScaledNumber<DigitsT> const& L,
int64_t R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
uint32_t L,
ScaledNumber<DigitsT> const& R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
ScaledNumber<DigitsT> const& L,
uint32_t R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
uint64_t L,
ScaledNumber<DigitsT> const& R);Return true if L equals R.
template<class DigitsT>
bool
operator==(
ScaledNumber<DigitsT> const& L,
uint64_t R);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<const_succ_iterator, Use const*, random_access_iterator_tag, BasicBlock const*, long, BasicBlock const*, BasicBlock const*> const& LHS,
iterator_adaptor_base<const_succ_iterator, Use const*, random_access_iterator_tag, BasicBlock const*, long, BasicBlock const*, BasicBlock const*> const& RHS);Return true if LHS and RHS wrap equal iterators.
bool
operator==(
iterator_adaptor_base<succ_iterator, Use*, random_access_iterator_tag, BasicBlock*, long, BasicBlock*, BasicBlock*> const& LHS,
iterator_adaptor_base<succ_iterator, Use*, random_access_iterator_tag, BasicBlock*, long, BasicBlock*, BasicBlock*> const& RHS);Compare two unions for equality of their opaque bit patterns.
bool
operator==(
PointerUnion lhs,
PointerUnion rhs);LHS and RHS wrap equal iterators.A and B wrap the same raw location metadata.A equals B.LHS and RHS refer to the same element.LHS and RHS are equal expressions.LHS and RHS are equal sorts.true if the iterators are equal.L and R refer to the same bundle position.L equals const instruction iterator R.L equals R.L equals non-const instruction iterator R.L equals R.L equals instruction pointer R.L equals bundle iterator R.L refers to instruction R.L equals bundle iterator R.V1 equals V2.true if the versions are equivalent.Err's error equals Code.LHS and RHS contain the same pointers.LHS and RHS refer to the same node.Rhs is unset.Lhs is unset.V1 equals V2Rhs is set and equals Lhs.Lhs is set and equals Rhs.Lhs equals Rhs bytes.LHS equals RHS.LHS and RHS contain equal elements.LHS and RHS compare equal.A is empty.B is empty.A equals B's pointee.A points to the same object as B.A and B point to the same object.L and R are equal.LHS and RHS are equal.LHS and RHS refer to the same buffer pointers.L equals R.lhs and rhs have the same opaque bits.| Name | Description |
|---|---|
| LHS | First offset to compare. |
| RHS | Second offset to compare. |
| A | Left-hand raw location wrapper. |
| B | Right-hand raw location wrapper. |
| Lhs | Left-hand pointer-auth data. |
| Rhs | Right-hand pointer-auth data. |
| X | First iterator to compare. |
| Y | Second iterator to compare. |
| c1 | First resource-segment set. |
| c2 | Second resource-segment set. |
| L | Left-hand bundle iterator. |
| R | Right-hand bundle iterator. |
| V1 | Left-hand 64-bit value |
| V2 | Right-hand APInt |
| Err | ErrorOr whose stored error is compared. |
| Code | Error-code or error-condition enum to compare against. |
| None | Tag representing an unset optional. |
| lhs | Left-hand hash code. |
| rhs | Right-hand hash code. |