Equality operators

Synopses

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);

» more...

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);

» more...

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);

» more...

Return true if A and B wrap the same raw location metadata.

bool
operator==(
    RawLocationWrapper const& A,
    RawLocationWrapper const& B);

» more...

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);

» more...

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);

» more...

Compare fallible iterators for equality.

bool
operator==(
    fallible_iterator const& LHS,
    fallible_iterator const& RHS);

» more...

Return true if LHS and RHS have the same range and value.

bool
operator==(
    AddressRangeValuePair const& LHS,
    AddressRangeValuePair const& RHS);

» more...

Return true if the two values compare equal.

bool
operator==(
    DIExpression::FragmentInfo const& A,
    DIExpression::FragmentInfo const& B);

» more...

Return true if the two values compare equal.

bool
operator==(
    DIDerivedType::PtrAuthData Lhs,
    DIDerivedType::PtrAuthData Rhs);

» more...

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);

» more...

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);

» more...

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);

» more...

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);

» more...

Return true when LHS and RHS refer to the same position.

bool
operator==(
    find_iterator const& LHS,
    find_iterator const& RHS);

» more...

Compare two stream references for equality of impl, offset, and length.

bool
operator==(
    WritableBinaryStreamRef const& LHS,
    WritableBinaryStreamRef const& RHS);

» more...

Compare two stream references for equality of impl, offset, and length.

bool
operator==(
    BinaryStreamRef const& LHS,
    BinaryStreamRef const& RHS);

» more...

Compare two stream references for equality of impl, offset, and length.

bool
operator==(
    RefType const& LHS,
    RefType const& RHS);

» more...

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);

» more...

Compare two attribute encodings for equality.

bool
operator==(
    AttributeEncoding const& LHS,
    AttributeEncoding const& RHS);

» more...

Compare two value iterators for equality.

bool
operator==(
    ValueIterator const& A,
    ValueIterator const& B);

» more...

Compare two name iterators for equality.

bool
operator==(
    NameIterator const& A,
    NameIterator const& B);

» more...

Compare two same‐name iterators for equality.

bool
operator==(
    SameNameIterator const& A,
    SameNameIterator const& B);

» more...

Return true if LHS and RHS are the same position in one expression.

bool
operator==(
    iterator const& LHS,
    iterator const& RHS);

» more...

Return true if both iterators have the same number of entries left.

bool
operator==(
    iterator_base const& X,
    iterator_base const& Y);

» more...

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);

» more...

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);

» more...

Compare nodes LHS and RHS using derived‐class equality.

bool
operator==(
    DDGNode const& LHS,
    DDGNode const& RHS);

» more...

Returns true if A is equal to B.

bool
operator==(
    DynamicAPInt const& A,
    int64_t B);

» more...

Returns true if A is equal to B.

bool
operator==(
    int64_t A,
    DynamicAPInt const& B);

» more...

Equality operator.

bool
operator==(
    MaterializedIterator const& LHS,
    MaterializedIterator const& RHS);

» more...

Return true if c1 and c2 reserve the same intervals.

bool
operator==(
    ResourceSegments const& c1,
    ResourceSegments const& c2);

» more...

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);

» more...

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);

» more...

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);

» more...

Return true if LHS and RHS are equal expressions.

bool
operator==(
    SMTExpr const& LHS,
    SMTExpr const& RHS);

» more...

Return true if LHS and RHS are equal sorts.

bool
operator==(
    SMTSort const& LHS,
    SMTSort const& RHS);

» more...

Return true if two HTTP requests describe the same outbound request.

bool
operator==(
    HTTPRequest const& A,
    HTTPRequest const& B);

» more...

Return true if LHS and RHS refer to the same line position.

bool
operator==(
    line_iterator const& LHS,
    line_iterator const& RHS);

» more...

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);

» more...

Return true if two memory operands compare equal.

bool
operator==(
    MachineMemOperand const& LHS,
    MachineMemOperand const& RHS);

» more...

Return true if L and R refer to the same bundle position.

bool
operator==(
    MachineInstrBundleIterator const& L,
    MachineInstrBundleIterator const& R);

» more...

Return true if L equals const instruction iterator R.

bool
operator==(
    MachineInstrBundleIterator const& L,
    const_instr_iterator const& R);

» more...

Return true if const instruction iterator L equals R.

bool
operator==(
    const_instr_iterator const& L,
    MachineInstrBundleIterator const& R);

» more...

Return true if L equals non‐const instruction iterator R.

bool
operator==(
    MachineInstrBundleIterator const& L,
    nonconst_instr_iterator const& R);

» more...

Return true if non‐const instruction iterator L equals R.

bool
operator==(
    nonconst_instr_iterator const& L,
    MachineInstrBundleIterator const& R);

» more...

Compare a bundle iterator to an instruction pointer.

bool
operator==(
    MachineInstrBundleIterator const& L,
    const_pointer R);

» more...

Return true if instruction pointer L equals bundle iterator R.

bool
operator==(
    const_pointer L,
    MachineInstrBundleIterator const& R);

» more...

Return true if bundle iterator L refers to instruction R.

bool
operator==(
    MachineInstrBundleIterator const& L,
    const_reference R);

» more...

Compare a machine instruction reference with a bundle iterator.

bool
operator==(
    const_reference L,
    MachineInstrBundleIterator const& R);

» more...

Return true if optional alignments Lhs and Rhs are both unset or equal.

bool
operator==(
    MaybeAlign Lhs,
    MaybeAlign Rhs);

» more...

Compare a 64‐bit value with an APInt for equality.

bool
operator==(
    uint64_t V1,
    APInt const& V2);

» more...

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);

» more...

Compare two digests for equality.

bool
operator==(
    MD5Result const& LHS,
    MD5Result const& RHS);

» more...

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;

» more...

Return true if LHS and RHS contain the same pointers.

template<typename PtrType>
[[nodiscard]]
bool
operator==(
    SmallPtrSetImpl<PtrType> const& LHS,
    SmallPtrSetImpl<PtrType> const& RHS);

» more...

Return true if both iterators refer to the same bucket.

bool
operator==(
    StringMapIterBase const& LHS,
    StringMapIterBase const& RHS);

» more...

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);

» more...

Return true if LHS and RHS refer to the same node.

bool
operator==(
    ilist_iterator const& LHS,
    ilist_iterator const& RHS);

» more...

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);

» more...

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);

» more...

Return true if optional alignment Rhs is unset.

bool
operator==(
    std::nullopt_t None,
    MaybeAlign Rhs);

» more...

Return true if optional alignment Lhs is unset.

bool
operator==(
    MaybeAlign Lhs,
    std::nullopt_t None);

» more...

Compare a signed 64‐bit value with an APSInt for equality.

bool
operator==(
    int64_t V1,
    APSInt const& V2);

» more...

Return true if optional alignment Rhs is set and equals Lhs.

bool
operator==(
    Align Lhs,
    MaybeAlign Rhs);

» more...

Return true if optional alignment Lhs is set and equals Rhs.

bool
operator==(
    MaybeAlign Lhs,
    Align Rhs);

» more...

Comparisons between Align and scalars. Rhs must be positive.

bool
operator==(
    Align Lhs,
    uint64_t Rhs);

» more...

Return true if SmallVector LHS equals ArrayRef RHS.

template<typename T>
[[nodiscard]]
bool
operator==(
    SmallVectorImpl<T> const& LHS,
    ArrayRef<T> RHS);

» more...

Return true if LHS and RHS contain equal elements.

template<typename T>
bool
operator==(
    ArrayRef<T> LHS,
    ArrayRef<T> RHS);

» more...

Return true if alignments Lhs and Rhs are equal.

bool
operator==(
    Align Lhs,
    Align Rhs);

» more...

Return true if LHS and RHS have equal length and contents.

bool
operator==(
    StringRef LHS,
    StringRef RHS);

» more...

Compare two hash codes for equality.

constexpr
bool
operator==(
    hash_code const& lhs,
    hash_code const& rhs);

» more...

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);

» more...

Return whether LHS and RHS refer to the same bucket.

[[nodiscard]]
bool
operator==(
    DenseMapIterator const& LHS,
    DenseMapIterator const& RHS);

» more...

Compare two early‐increment iterators by underlying position.

bool
operator==(
    early_inc_iterator_impl const& LHS,
    early_inc_iterator_impl const& RHS);

» more...

Return true if A and B refer to the same map entry.

bool
operator==(
    ValueInfo const& A,
    ValueInfo const& B);

» more...

Return true if A is empty.

template<class T>
bool
operator==(
    IntrusiveRefCntPtr<T> const& A,
    std::nullptr_t B);

» more...

Return true if B is empty.

template<class T>
bool
operator==(
    std::nullptr_t A,
    IntrusiveRefCntPtr<T> const& B);

» more...

Return true if raw pointer A equals B's pointee.

template<
    class T,
    class U>
bool
operator==(
    T* A,
    IntrusiveRefCntPtr<U> const& B);

» more...

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);

» more...

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);

» more...

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);

» more...

True if LHS and RHS refer to the same unit and debug‐info entry.

bool
operator==(
    DWARFDie const& LHS,
    DWARFDie const& RHS);

» more...

True if both location expressions have the same range and expression bytes.

bool
operator==(
    DWARFLocationExpression const& L,
    DWARFLocationExpression const& R);

» more...

True if both ranges have the same section index, LowPC, and HighPC.

bool
operator==(
    DWARFAddressRange const& LHS,
    DWARFAddressRange const& RHS);

» more...

True if both iterators refer to the same DIE.

bool
operator==(
    DWARFDie::iterator const& LHS,
    DWARFDie::iterator const& RHS);

» more...

True if both attribute iterators refer to the same DIE and attribute index.

bool
operator==(
    attribute_iterator const& LHS,
    attribute_iterator const& RHS);

» more...

Check pointer identity (not value) of identifier and data.

bool
operator==(
    MemoryBufferRef const& LHS,
    MemoryBufferRef const& RHS);

» more...

Return true if LHS and RHS wrap equal iterators.

bool
operator==(
    iterator_adaptor_base const& LHS,
    iterator_adaptor_base const& RHS);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    int32_t L,
    ScaledNumber<DigitsT> const& R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    ScaledNumber<DigitsT> const& L,
    int32_t R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    int64_t L,
    ScaledNumber<DigitsT> const& R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    ScaledNumber<DigitsT> const& L,
    int64_t R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    uint32_t L,
    ScaledNumber<DigitsT> const& R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    ScaledNumber<DigitsT> const& L,
    uint32_t R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    uint64_t L,
    ScaledNumber<DigitsT> const& R);

» more...

Return true if L equals R.

template<class DigitsT>
bool
operator==(
    ScaledNumber<DigitsT> const& L,
    uint64_t R);

» more...

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);

» more...

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);

» more...

Compare two unions for equality of their opaque bit patterns.

bool
operator==(
    PointerUnion lhs,
    PointerUnion rhs);

» more...

Return Value

  • True if both offsets have the same value.

  • True if LHS and RHS wrap equal iterators.

  • True if A and B wrap the same raw location metadata.

  • True if both are end values, or both are non‐end values whose underlying iterators compare equal

  • True if both pairs have the same range and value.

  • true if the two values compare equal.

  • True if the iterators refer to the same position.

  • true if both references have the same impl, offset, and length.

  • True if both sets contain the same elements.

  • True if both encodings have the same index and form.

  • True if both iterators refer to the same index and offset.

  • True if both iterators refer to the same name index position.

  • True if both iterators refer to the same data offset.

  • True if both iterators refer to the same expression and offset.

  • True if both iterators have the same number of entries left.

  • True if the nodes compare equal.

  • True if A equals B.

  • True if LHS and RHS refer to the same element.

  • True if c1 and c2 reserve the same intervals.

  • True if both maps have the same size and equal symbol values.

  • True if LHS and RHS are equal expressions.

  • True if LHS and RHS are equal sorts.

  • True if the requests describe the same outbound request.

  • true if the iterators are equal.

  • True if the operands compare equal.

  • True if L and R refer to the same bundle position.

  • True if L equals const instruction iterator R.

  • True if const instruction iterator L equals R.

  • True if L equals non‐const instruction iterator R.

  • True if non‐const instruction iterator L equals R.

  • True if L equals instruction pointer R.

  • True if instruction pointer L equals bundle iterator R.

  • True if bundle iterator L refers to instruction R.

  • True if instruction reference L equals bundle iterator R.

  • True if both are unset or both are set and equal.

  • True if V1 equals V2.

  • true if the versions are equivalent.

  • True if both digests contain the same bytes.

  • True if Err's error equals Code.

  • True if LHS and RHS contain the same pointers.

  • True if both iterators refer to the same bucket.

  • True if LHS and RHS refer to the same node.

  • True if Rhs is unset.

  • True if Lhs is unset.

  • true if V1 equals V2

  • True if Rhs is set and equals Lhs.

  • True if Lhs is set and equals Rhs.

  • True if Lhs equals Rhs bytes.

  • True if LHS equals RHS.

  • True if LHS and RHS contain equal elements.

  • True if the alignments are equal.

  • True if LHS and RHS compare equal.

  • True if both hash codes wrap the same value.

  • True if both maps have the same size and contents.

  • True if both iterators share the same underlying position.

  • True if the operands refer to the same map entry.

  • True if A is empty.

  • True if B is empty.

  • True if A equals B's pointee.

  • True if A points to the same object as B.

  • True if A and B point to the same object.

  • True if both reverse iterators refer to the same position.

  • True if both DIEs refer to the same unit and debug‐info entry.

  • true if L and R are equal.

  • true if LHS and RHS are equal.

  • True if both iterators refer to the same DIE.

  • True if both iterators refer to the same DIE and attribute index.

  • True if LHS and RHS refer to the same buffer pointers.

  • True if L equals R.

  • True if lhs and rhs have the same opaque bits.

Parameters

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.

Created with MrDocs