LLVM: include/llvm/Analysis/ValueTracking.h File Reference (original) (raw)
Namespaces
namespace
This is an optimization pass for GlobalISel generic memory operations.
Enumerations
enum class
llvm::OverflowResult { llvm::AlwaysOverflowsLow, llvm::AlwaysOverflowsHigh, llvm::MayOverflow, llvm::NeverOverflows }
enum
llvm::SelectPatternFlavor {
llvm::SPF_UNKNOWN = 0 , llvm::SPF_SMIN, llvm::SPF_UMIN, llvm::SPF_SMAX,
llvm::SPF_UMAX, llvm::SPF_FMINNUM, llvm::SPF_FMAXNUM, llvm::SPF_ABS,
llvm::SPF_NABS
}
Specific patterns of select instructions we can match. More...
enum
llvm::SelectPatternNaNBehavior { llvm::SPNB_NA = 0 , llvm::SPNB_RETURNS_NAN, llvm::SPNB_RETURNS_OTHER, llvm::SPNB_RETURNS_ANY }
Behavior when a floating point min/max is given one NaN and one non-NaN as input. More...
Functions
void
llvm::computeKnownBits (const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOne bit sets.
llvm::computeKnownBits (const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Returns the known bits rather than passing by reference.
llvm::computeKnownBits (const Value *V, const APInt &DemandedElts, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Returns the known bits rather than passing by reference.
llvm::computeKnownBits (const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Determine which bits of V are known to be either zero or one and return them.
llvm::computeKnownBits (const Value *V, unsigned Depth, const SimplifyQuery &Q)
Determine which bits of V are known to be either zero or one and return them.
void
llvm::computeKnownBits (const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
void
llvm::computeKnownBitsFromRangeMetadata (const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
void
llvm::computeKnownBitsFromContext (const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Merge bits known from context-dependent facts into Known.
llvm::analyzeKnownBitsFromAndXorOr (const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &SQ)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
void
llvm::adjustKnownBitsForSelectArm (KnownBits &Known, Value *Cond, Value *Arm, bool Invert, unsigned Depth, const SimplifyQuery &Q)
Adjust Known for the given select Arm to include information from the select Cond.
llvm::haveNoCommonBitsSet (const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)
Return true if LHS and RHS have no common bits set.
llvm::isKnownToBeAPowerOfTwo (const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined.
llvm::isKnownToBeAPowerOfTwo (const Value *V, bool OrZero, unsigned Depth, const SimplifyQuery &Q)
Return true if the given value is known to have exactly one bit set when defined.
llvm::isOnlyUsedInZeroComparison (const Instruction *CxtI)
llvm::isOnlyUsedInZeroEqualityComparison (const Instruction *CxtI)
llvm::isKnownNonZero (const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
llvm::isKnownNegation (const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
llvm::isKnownInversion (const Value *X, const Value *Y)
Return true iff:
llvm::isKnownNonNegative (const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
llvm::isKnownPositive (const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
llvm::isKnownNegative (const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
llvm::isKnownNonEqual (const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given values are known to be non-equal when defined.
llvm::MaskedValueIsZero (const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
llvm::ComputeNumSignBits (const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits.
llvm::ComputeMaxSignificantBits (const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Get the upper bound on bit size for this Value Op as a signed integer.
llvm::getIntrinsicForCallSite (const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
llvm::isSignBitCheck (ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
std::pair< Value *, FPClassTest >
llvm::fcmpToClassTest (CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Returns a pair of values, which if passed to llvm.is.fpclass, returns the same result as an fcmp with the given operands.
std::pair< Value *, FPClassTest >
llvm::fcmpToClassTest (CmpInst::Predicate Pred, const Function &F, Value *LHS, const APFloat *ConstRHS, bool LookThroughSrc=true)
std::tuple< Value *, FPClassTest, FPClassTest >
llvm::fcmpImpliesClass (CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Compute the possible floating-point classes that LHS could be based on fcmp \Pred LHS, RHS.
std::tuple< Value *, FPClassTest, FPClassTest >
llvm::fcmpImpliesClass (CmpInst::Predicate Pred, const Function &F, Value *LHS, FPClassTest RHS, bool LookThroughSrc=true)
std::tuple< Value *, FPClassTest, FPClassTest >
llvm::fcmpImpliesClass (CmpInst::Predicate Pred, const Function &F, Value *LHS, const APFloat &RHS, bool LookThroughSrc=true)
KnownFPClass
llvm::operator| (KnownFPClass LHS, const KnownFPClass &RHS)
KnownFPClass
llvm::operator| (const KnownFPClass &LHS, KnownFPClass &&RHS)
llvm::computeKnownFPClass (const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
llvm::computeKnownFPClass (const Value *V, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
KnownFPClass
llvm::computeKnownFPClass (const Value *V, const DataLayout &DL, FPClassTest InterestedClasses=fcAllFlags, unsigned Depth=0, const TargetLibraryInfo *TLI=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
KnownFPClass
llvm::computeKnownFPClass (const Value *V, const APInt &DemandedElts, FastMathFlags FMF, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Wrapper to account for known fast math flags at the use instruction.
KnownFPClass
llvm::computeKnownFPClass (const Value *V, FastMathFlags FMF, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
llvm::cannotBeNegativeZero (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if we can prove that the specified FP value is never equal to -0.0.
llvm::cannotBeOrderedLessThanZero (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if we can prove that the specified FP value is either NaN or never less than -0.0.
llvm::isKnownNeverInfinity (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector value has no infinities.
llvm::isKnownNeverInfOrNaN (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point value can never contain a NaN or infinity.
llvm::isKnownNeverNaN (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has no NaN elements.
std::optional< bool >
llvm::computeKnownFPSignBit (const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return false if we can prove that the specified FP value's sign bit is 0.
Value *
llvm::isBytewiseValue (Value *V, const DataLayout &DL)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with.
Value *
llvm::FindInsertedValue (Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a register, for example if it were inserted directly into the aggregate.
Value *
llvm::GetPointerBaseWithConstantOffset (Value *Ptr, int64_t &Offset, const DataLayout &DL, bool AllowNonInbounds=true)
Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset.
const Value *
llvm::GetPointerBaseWithConstantOffset (const Value *Ptr, int64_t &Offset, const DataLayout &DL, bool AllowNonInbounds=true)
llvm::isGEPBasedOnPointerToString (const GEPOperator *GEP, unsigned CharSize=8)
Returns true if the GEP is based on a pointer to a string (array of.
llvm::getConstantDataArrayInfo (const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)
Returns true if the value V is a pointer into a ConstantDataArray.
llvm::getConstantStringInfo (const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
llvm::GetStringLength (const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
llvm::getArgumentAliasingToReturnedPointer (const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
Value *
llvm::getArgumentAliasingToReturnedPointer (CallBase *Call, bool MustPreserveNullness)
llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing (const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures pointer by returning it.
llvm::getUnderlyingObject (const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal.address from the specified value V, returning the original object being addressed.
Value *
llvm::getUnderlyingObject (Value *V, unsigned MaxLookup=6)
llvm::getUnderlyingObjectAggressive (const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
void
llvm::getUnderlyingObjects (const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects.
llvm::getUnderlyingObjectsForCodeGen (const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr sequences.
llvm::findAllocaForValue (Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
const AllocaInst *
llvm::findAllocaForValue (const Value *V, bool OffsetZero=false)
llvm::onlyUsedByLifetimeMarkers (const Value *V)
Return true if the only users of this pointer are lifetime markers.
llvm::onlyUsedByLifetimeMarkersOrDroppableInsts (const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
llvm::isNotCrossLaneOperation (const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
llvm::isSafeToSpeculativelyExecute (const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
Return true if the instruction does not have any effects besides calculating the result and does not have undefined behavior.
llvm::isSafeToSpeculativelyExecute (const Instruction *I, BasicBlock::iterator CtxI, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
llvm::isSafeToSpeculativelyExecuteWithVariableReplaced (const Instruction *I)
Don't use information from its non-constant operands.
llvm::isSafeToSpeculativelyExecuteWithOpcode (unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
llvm::mayHaveNonDefUseDependency (const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through the def use graph.
llvm::isAssumeLikeIntrinsic (const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
llvm::isValidAssumeForContext (const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control-flow identified by the context instruction, CxtI.
llvm::computeOverflowForUnsignedMul (const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
llvm::computeOverflowForSignedMul (const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
llvm::computeOverflowForUnsignedAdd (const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
llvm::computeOverflowForSignedAdd (const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
llvm::computeOverflowForSignedAdd (const AddOperator *Add, const SimplifyQuery &SQ)
This version also leverages the sign bit of Add if known.
llvm::computeOverflowForUnsignedSub (const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
llvm::computeOverflowForSignedSub (const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
llvm::isOverflowIntrinsicNoWrap (const WithOverflowInst *WO, const DominatorTree &DT)
Returns true if the arithmetic part of the WO 's result is used only along the paths control dependent on the computation not overflowing, WO being an .with.overflow intrinsic.
llvm::getVScaleRange (const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range function attribute.
llvm::computeConstantRange (const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
llvm::computeConstantRangeIncludingKnownBits (const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
llvm::isGuaranteedToTransferExecutionToSuccessor (const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one of its successors (including the next instruction that follows within a basic block).
llvm::isGuaranteedToTransferExecutionToSuccessor (const BasicBlock *BB)
Returns true if this block does not contain a potential implicit exit.
llvm::isGuaranteedToTransferExecutionToSuccessor (BasicBlock::const_iterator Begin, BasicBlock::const_iterator End, unsigned ScanLimit=32)
Return true if every instruction in the range (Begin, End) is guaranteed to transfer execution to its static successor.
llvm::isGuaranteedToTransferExecutionToSuccessor (iterator_range< BasicBlock::const_iterator > Range, unsigned ScanLimit=32)
Same as previous, but with range expressed via iterator_range.
llvm::isGuaranteedToExecuteForEveryIteration (const Instruction *I, const Loop *L)
Return true if this function can prove that the instruction I is executed for every iteration of the loop L.
llvm::propagatesPoison (const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
void
llvm::getGuaranteedNonPoisonOps (const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that operand has a poison value.
void
llvm::getGuaranteedWellDefinedOps (const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that operand is not a well-defined value (i.e.
llvm::mustTriggerUB (const Instruction *I, const SmallPtrSetImpl< const Value * > &KnownPoison)
Return true if the given instruction must trigger undefined behavior when I is executed with any operands which appear in KnownPoison holding a poison value at the point of execution.
llvm::programUndefinedIfUndefOrPoison (const Instruction *Inst)
Return true if this function can prove that if Inst is executed and yields a poison value or undef bits, then that will trigger undefined behavior.
llvm::programUndefinedIfPoison (const Instruction *Inst)
llvm::canCreateUndefOrPoison (const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison operands.
llvm::canCreatePoison (const Operator *Op, bool ConsiderFlagsAndMetadata=true)
llvm::impliesPoison (const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
llvm::isGuaranteedNotToBeUndefOrPoison (const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
llvm::isGuaranteedNotToBePoison (const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
llvm::isGuaranteedNotToBePoison (const Value *V, AssumptionCache *AC, BasicBlock::iterator CtxI, const DominatorTree *DT=nullptr, unsigned Depth=0)
llvm::isGuaranteedNotToBeUndef (const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
llvm::mustExecuteUBIfPoisonOnPathTo (Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced a posion result.
std::optional< std::pair< CmpPredicate, Constant * > >
llvm::getFlippedStrictnessPredicateAndConstant (CmpPredicate Pred, Constant *C)
Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped predicate.
llvm::matchSelectPattern (Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match.
SelectPatternResult
llvm::matchSelectPattern (const Value *V, const Value *&LHS, const Value *&RHS)
llvm::matchDecomposedSelectPattern (CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Determine the pattern that a select with the given compare as its predicate and given values as its true/false operands would match.
llvm::getSelectPattern (CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)
Determine the pattern for predicate X Pred Y ? X : Y.
llvm::getMinMaxPred (SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
llvm::getMinMaxIntrinsic (SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
llvm::getInverseMinMaxFlavor (SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
llvm::getInverseMinMaxIntrinsic (Intrinsic::ID MinMaxID)
llvm::getMinMaxLimit (SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
std::pair< Intrinsic::ID, bool >
llvm::canConvertToMinOrMaxIntrinsic (ArrayRef< Value * > VL)
Check if the values in VL are select instructions that can be converted to a min or max (vector) intrinsic.
llvm::matchSimpleRecurrence (const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start, Entry], [Inc, backedge] inc = binop iv, step OR iv = phi Ty [Start, Entry], [Inc, backedge] inc = binop step, iv.
llvm::matchSimpleRecurrence (const BinaryOperator *I, PHINode *&P, Value *&Start, Value *&Step)
Analogous to the above, but starting from the binary operator.
std::optional< bool >
llvm::isImpliedCondition (const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
Return true if RHS is known to be implied true by LHS.
std::optional< bool >
llvm::isImpliedCondition (const Value *LHS, CmpPredicate RHSPred, const Value *RHSOp0, const Value *RHSOp1, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
std::optional< bool >
llvm::isImpliedByDomCondition (const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions.
std::optional< bool >
llvm::isImpliedByDomCondition (CmpPredicate Pred, const Value *LHS, const Value *RHS, const Instruction *ContextI, const DataLayout &DL)
void
llvm::findValuesAffectedByCondition (Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)
Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.