1//===- llvm/Analysis/ValueTracking.h - Walk computations --------*- C++ -*-===//
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
7//===----------------------------------------------------------------------===//
9// This file contains routines that help analyze properties that chains of
12//===----------------------------------------------------------------------===//
14#ifndef LLVM_ANALYSIS_VALUETRACKING_H
15#define LLVM_ANALYSIS_VALUETRACKING_H
49/// The max limit of the search depth in DecomposeGEPExpression() and
50/// getUnderlyingObject().
53/// Determine which bits of V are known to be either zero or one and return
54/// them in the KnownZero/KnownOne bit sets.
56/// This function is defined on values with integer type, values with pointer
57/// type, and vectors of integers. In the case
58/// where V is a vector, the known zero and known one values are the
59/// same width as the vector element, and the bit is set only if it is true
60/// for all of the elements in the vector.
66 bool UseInstrInfo =
true,
unsigned Depth = 0);
68/// Returns the known bits rather than passing by reference.
73 bool UseInstrInfo =
true,
76/// Returns the known bits rather than passing by reference.
82 bool UseInstrInfo =
true,
94/// Compute known bits from the range metadata.
95/// \p KnownZero the set of bits that are known to be zero
96/// \p KnownOne the set of bits that are known to be one
100/// Merge bits known from context-dependent facts into Known.
105/// Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
112/// Adjust \p Known for the given select \p Arm to include information from the
115 Value *Arm,
bool Invert,
119/// Return true if LHS and RHS have no common bits set.
124/// Return true if the given value is known to have exactly one bit set when
125/// defined. For vectors return true if every element is known to be a power
126/// of two when defined. Supports values with integer or pointer type and
127/// vectors of integers. If 'OrZero' is set, then return true if the given
128/// value is either a power of two or zero.
134 bool UseInstrInfo =
true,
145/// Return true if the given value is known to be non-zero when defined. For
146/// vectors, return true if every element is known to be non-zero when
147/// defined. For pointers, if the context instruction and dominator tree are
148/// specified, perform context-sensitive analysis and return true if the
149/// pointer couldn't possibly be null at the specified instruction.
150/// Supports values with integer or pointer type and vectors of integers.
154/// Return true if the two given values are negation.
155/// Currently can recoginze Value pair:
156/// 1: <X, Y> if X = sub (0, Y) or Y = sub (0, X)
157/// 2: <X, Y> if X = sub (A, B) and Y = sub (B, A)
159 bool NeedNSW =
false,
bool AllowPoison =
true);
162/// 1. X is poison implies Y is poison.
163/// 2. X is true implies Y is false.
164/// 3. X is false implies Y is true.
165/// Otherwise, return false.
168/// Returns true if the give value is known to be non-negative.
172/// Returns true if the given value is known be positive (i.e. non-negative
177/// Returns true if the given value is known be negative (i.e. non-positive
182/// Return true if the given values are known to be non-equal when defined.
183/// Supports scalar integer types only.
187/// Return true if 'V & Mask' is known to be zero. We use this predicate to
188/// simplify operations downstream. Mask is known to be zero for bits that V
191/// This function is defined on values with integer type, values with pointer
192/// type, and vectors of integers. In the case
193/// where V is a vector, the mask, known zero, and known one values are the
194/// same width as the vector element, and the bit is set only if it is true
195/// for all of the elements in the vector.
199/// Return the number of times the sign bit of the register is replicated into
200/// the other bits. We know that at least 1 bit is always equal to the sign
201/// bit (itself), but other cases can give us information. For example,
202/// immediately after an "ashr X, 2", we know that the top 3 bits are all
203/// equal to each other, so we return 3. For vectors, return the number of
204/// sign bits for the vector element with the mininum number of known sign
210 bool UseInstrInfo =
true,
213/// Get the upper bound on bit size for this Value \p Op as a signed integer.
214/// i.e. x == sext(trunc(x to MaxSignificantBits) to bitwidth(x)).
215/// Similar to the APInt::getSignificantBits function.
223/// Map a call instruction to an intrinsic ID. Libcalls which have equivalent
224/// intrinsics are treated as-if they were intrinsics.
228/// Given an exploded icmp instruction, return true if the comparison only
229/// checks the sign bit. If it only checks the sign bit, set TrueIfSigned if
230/// the result of the comparison is true when the input value is signed.
234/// Determine which floating-point classes are valid for \p V, and return them
235/// in KnownFPClass bit sets.
237/// This function is defined on values with floating-point type, values vectors
238/// of floating-point type, and arrays of floating-point type.
240/// \p InterestedClasses is a compile time optimization hint for which floating
241/// point classes should be queried. Queries not specified in \p
242/// InterestedClasses should be reliable if they are determined during the
245 const APInt &DemandedElts,
260 bool UseInstrInfo =
true,
unsigned Depth = 0);
262/// Wrapper to account for known fast math flags at the use instruction.
272/// Return true if we can prove that the specified FP value is never equal to
273/// -0.0. Users should use caution when considering PreserveSign
278/// Return true if we can prove that the specified FP value is either NaN or
279/// never less than -0.0.
290/// Return true if the floating-point scalar value is not an infinity or if
291/// the floating-point vector value has no infinities. Return false if a value
292/// could ever be infinity.
296/// Return true if the floating-point value can never contain a NaN or infinity.
300/// Return true if the floating-point scalar value is not a NaN or if the
301/// floating-point vector value has no NaN elements. Return false if a value
302/// could ever be NaN.
306/// Return false if we can prove that the specified FP value's sign bit is 0.
307/// Return true if we can prove that the specified FP value's sign bit is 1.
308/// Otherwise return std::nullopt.
313/// Return true if the sign bit of the FP value can be ignored by the user when
314/// the value is zero.
317/// Return true if the sign bit of the FP value can be ignored by the user when
321/// If the specified value can be set by repeating the same byte in memory,
322/// return the i8 value that it is represented with. This is true for all i8
323/// values obviously, but is also true for i32 0, i32 -1, i16 0xF0F0, double
324/// 0.0 etc. If the value can't be handled with a repeated byte store (e.g.
325/// i16 0x1234), return null. If the value is entirely undef and padding,
329/// Given an aggregate and an sequence of indices, see if the scalar value
330/// indexed is already around as a register, for example if it were inserted
331/// directly into the aggregate.
333/// If InsertBefore is not empty, this function will duplicate (modified)
334/// insertvalues when a part of a nested struct is extracted.
337 std::optional<BasicBlock::iterator> InsertBefore = std::nullopt);
339/// Analyze the specified pointer to see if it can be expressed as a base
340/// pointer plus a constant offset. Return the base and offset to the caller.
342/// This is a wrapper around Value::stripAndAccumulateConstantOffsets that
343/// creates and later unpacks the required APInt.
346 bool AllowNonInbounds =
true) {
347 APInt OffsetAPInt(
DL.getIndexTypeSizeInBits(
Ptr->getType()), 0);
349 Ptr->stripAndAccumulateConstantOffsets(
DL, OffsetAPInt, AllowNonInbounds);
357 bool AllowNonInbounds =
true) {
362/// Represents offset+length into a ConstantDataArray.
364 /// ConstantDataArray pointer. nullptr indicates a zeroinitializer (a valid
365 /// initializer, it just doesn't fit the ConstantDataArray interface).
368 /// Slice starts at this Offset.
371 /// Length of the slice.
374 /// Moves the Offset and adjusts Length accordingly.
381 /// Convenience accessor for elements in the slice.
387/// Returns true if the value \p V is a pointer into a ConstantDataArray.
388/// If successful \p Slice will point to a ConstantDataArray info object
389/// with an appropriate offset.
391 ConstantDataArraySlice &Slice,
392 unsigned ElementSize,
395/// This function computes the length of a null-terminated C string pointed to
396/// by V. If successful, it returns true and returns the string in Str. If
397/// unsuccessful, it returns false. This does not include the trailing null
398/// character by default. If TrimAtNul is set to false, then this returns any
399/// trailing null characters as well as any other characters that come after
402 bool TrimAtNul =
true);
404/// If we can compute the length of the string pointed to by the specified
405/// pointer, return 'len+1'. If we can't, return 0.
408/// This function returns call pointer argument that is considered the same by
409/// aliasing rules. You CAN'T use it to replace one value with another. If
410/// \p MustPreserveNullness is true, the call must preserve the nullness of
414 bool MustPreserveNullness);
416 bool MustPreserveNullness) {
418 const_cast<const CallBase *
>(
Call), MustPreserveNullness));
421/// {launder,strip}.invariant.group returns pointer that aliases its argument,
422/// and it only captures pointer by returning it.
423/// These intrinsics are not marked as nocapture, because returning is
424/// considered as capture. The arguments are not marked as returned neither,
425/// because it would make it useless. If \p MustPreserveNullness is true,
426/// the intrinsic must preserve the nullness of the pointer.
428 const CallBase *
Call,
bool MustPreserveNullness);
430/// This method strips off any GEP address adjustments, pointer casts
431/// or `llvm.threadlocal.address` from the specified value \p V, returning the
432/// original object being addressed. Note that the returned value has pointer
433/// type if the specified value does. If the \p MaxLookup value is non-zero, it
434/// limits the number of instructions to be stripped off.
439 // Force const to avoid infinite recursion.
440 const Value *VConst = V;
444/// Like getUnderlyingObject(), but will try harder to find a single underlying
445/// object. In particular, this function also looks through selects and phis.
448/// This method is similar to getUnderlyingObject except that it can
449/// look through phi and select instructions and return multiple objects.
451/// If LoopInfo is passed, loop phis are further analyzed. If a pointer
452/// accesses different objects in each iteration, we don't look through the
453/// phi node. E.g. consider this loop nest:
458/// A[i][j] = A[i-1][j] * B[j]
461/// This is transformed by Load-PRE to stash away A[i] for the next iteration
462/// of the outer loop:
464/// Curr = A[0]; // Prev_0
466/// Prev = Curr; // Prev = PHI (Prev_0, Curr)
469/// Curr[j] = Prev[j] * B[j]
473/// Since A[i] and A[i-1] are independent pointers, getUnderlyingObjects
474/// should not assume that Curr and Prev share the same underlying object thus
475/// it shouldn't look through the phi above.
477 SmallVectorImpl<const Value *> &Objects,
478 const LoopInfo *LI =
nullptr,
481/// This is a wrapper around getUnderlyingObjects and adds support for basic
482/// ptrtoint+arithmetic+inttoptr sequences.
484 SmallVectorImpl<Value *> &Objects);
486/// Returns unique alloca where the value comes from, or nullptr.
487/// If OffsetZero is true check that V points to the begining of the alloca.
490 bool OffsetZero =
false) {
494/// Return true if the only users of this pointer are lifetime markers.
497/// Return true if the only users of this pointer are lifetime markers or
498/// droppable instructions.
501/// Return true if the instruction doesn't potentially cross vector lanes. This
502/// condition is weaker than checking that the instruction is lanewise: lanewise
503/// means that the same operation is splatted across all lanes, but we also
504/// include the case where there is a different operation on each lane, as long
505/// as the operation only uses data from that lane. An example of an operation
506/// that is not lanewise, but doesn't cross vector lanes is insertelement.
509/// Return true if the instruction does not have any effects besides
510/// calculating the result and does not have undefined behavior.
512/// This method never returns true for an instruction that returns true for
513/// mayHaveSideEffects; however, this method also does some other checks in
514/// addition. It checks for undefined behavior, like dividing by zero or
515/// loading from an invalid pointer (but not for undefined results, like a
516/// shift with a shift amount larger than the width of the result). It checks
517/// for malloc and alloca because speculatively executing them might cause a
518/// memory leak. It also returns false for instructions related to control
519/// flow, specifically terminators and PHI nodes.
521/// If the CtxI is specified this method performs context-sensitive analysis
522/// and returns true if it is safe to execute the instruction immediately
523/// before the CtxI. If the instruction has (transitive) operands that don't
524/// dominate CtxI, the analysis is performed under the assumption that these
525/// operands will also be speculated to a point before CxtI.
527/// If the CtxI is NOT specified this method only looks at the instruction
528/// itself and its operands, so if this method returns true, it is safe to
529/// move the instruction as long as the correct dominance relationships for
530/// the operands and users hold.
532/// If \p UseVariableInfo is true, the information from non-constant operands
533/// will be taken into account.
535/// If \p IgnoreUBImplyingAttrs is true, UB-implying attributes will be ignored.
536/// The caller is responsible for correctly propagating them after hoisting.
538/// This method can return true for instructions that read memory;
539/// for such instructions, moving them may change the resulting value.
541 const Instruction *
I,
const Instruction *CtxI =
nullptr,
542 AssumptionCache *AC =
nullptr,
const DominatorTree *DT =
nullptr,
543 const TargetLibraryInfo *TLI =
nullptr,
bool UseVariableInfo =
true,
544 bool IgnoreUBImplyingAttrs =
true);
551 bool UseVariableInfo =
true,
552 bool IgnoreUBImplyingAttrs =
true) {
553 // Take an iterator, and unwrap it into an Instruction *.
555 IgnoreUBImplyingAttrs);
558/// Don't use information from its non-constant operands. This helper is used
559/// when its operands are going to be replaced.
561 const Instruction *
I,
bool IgnoreUBImplyingAttrs =
true) {
563 /*UseVariableInfo=*/false,
564 IgnoreUBImplyingAttrs);
567/// This returns the same result as isSafeToSpeculativelyExecute if Opcode is
568/// the actual opcode of Inst. If the provided and actual opcode differ, the
569/// function (virtually) overrides the opcode of Inst with the provided
570/// Opcode. There are come constraints in this case:
571/// * If Opcode has a fixed number of operands (eg, as binary operators do),
572/// then Inst has to have at least as many leading operands. The function
573/// will ignore all trailing operands beyond that number.
574/// * If Opcode allows for an arbitrary number of operands (eg, as CallInsts
575/// do), then all operands are considered.
576/// * The virtual instruction has to satisfy all typing rules of the provided
578/// * This function is pessimistic in the following sense: If one actually
579/// materialized the virtual instruction, then isSafeToSpeculativelyExecute
580/// may say that the materialized instruction is speculatable whereas this
581/// function may have said that the instruction wouldn't be speculatable.
582/// This behavior is a shortcoming in the current implementation and not
585 unsigned Opcode,
const Instruction *Inst,
const Instruction *CtxI =
nullptr,
586 AssumptionCache *AC =
nullptr,
const DominatorTree *DT =
nullptr,
587 const TargetLibraryInfo *TLI =
nullptr,
bool UseVariableInfo =
true,
588 bool IgnoreUBImplyingAttrs =
true);
590/// Returns true if the result or effects of the given instructions \p I
591/// depend values not reachable through the def use graph.
592/// * Memory dependence arises for example if the instruction reads from
593/// memory or may produce effects or undefined behaviour. Memory dependent
594/// instructions generally cannot be reorderd with respect to other memory
595/// dependent instructions.
596/// * Control dependence arises for example if the instruction may fault
597/// if lifted above a throwing call or infinite loop.
600/// Return true if it is an intrinsic that cannot be speculated but also
604/// Return true if it is valid to use the assumptions provided by an
605/// assume intrinsic, I, at the point in the control-flow identified by the
606/// context instruction, CxtI. By default, ephemeral values of the assumption
607/// are treated as an invalid context, to prevent the assumption from being used
608/// to optimize away its argument. If the caller can ensure that this won't
609/// happen, it can call with AllowEphemerals set to true to get more valid
612 const Instruction *CxtI,
613 const DominatorTree *DT =
nullptr,
614 bool AllowEphemerals =
false);
616/// Returns true, if no instruction between \p Assume and \p CtxI may free
617/// memory and the function is marked as NoSync. The latter ensures the current
618/// function cannot arrange for another thread to free on its behalf.
620 const Instruction *CtxI);
623 /// Always overflows in the direction of signed/unsigned min value.
625 /// Always overflows in the direction of signed/unsigned max value.
627 /// May or may not overflow.
635 const SimplifyQuery &SQ,
639 const SimplifyQuery &SQ);
641 const WithCache<const Value *> &
LHS,
const WithCache<const Value *> &
RHS,
642 const SimplifyQuery &SQ);
644 const WithCache<const Value *> &
LHS,
const WithCache<const Value *> &
RHS,
645 const SimplifyQuery &SQ);
646/// This version also leverages the sign bit of Add if known.
648 const SimplifyQuery &SQ);
651 const SimplifyQuery &SQ);
654 const SimplifyQuery &SQ);
656/// Returns true if the arithmetic part of the \p WO 's result is
657/// used only along the paths control dependent on the computation
658/// not overflowing, \p WO being an <op>.with.overflow intrinsic.
660 const DominatorTree &DT);
662/// Determine the possible constant range of vscale with the given bit width,
663/// based on the vscale_range function attribute.
666/// Determine the possible constant range of an integer or vector of integer
667/// value. This is intended as a cheap, non-recursive check.
669 bool UseInstrInfo =
true,
670 AssumptionCache *AC =
nullptr,
671 const Instruction *CtxI =
nullptr,
672 const DominatorTree *DT =
nullptr,
675/// Combine constant ranges from computeConstantRange() and computeKnownBits().
677 const WithCache<const Value *> &V,
bool ForSigned,
const SimplifyQuery &SQ);
679/// Return true if this function can prove that the instruction I will
680/// always transfer execution to one of its successors (including the next
681/// instruction that follows within a basic block). E.g. this is not
682/// guaranteed for function calls that could loop infinitely.
684/// In other words, this function returns false for instructions that may
685/// transfer execution or fail to transfer execution in a way that is not
686/// captured in the CFG nor in the sequence of instructions within a basic
689/// Undefined behavior is assumed not to happen, so e.g. division is
690/// guaranteed to transfer execution to the following instruction even
691/// though division by zero might cause undefined behavior.
694/// Returns true if this block does not contain a potential implicit exit.
695/// This is equivelent to saying that all instructions within the basic block
696/// are guaranteed to transfer execution to their successor within the basic
697/// block. This has the same assumptions w.r.t. undefined behavior as the
698/// instruction variant of this function.
701/// Return true if every instruction in the range (Begin, End) is
702/// guaranteed to transfer execution to its static successor. \p ScanLimit
703/// bounds the search to avoid scanning huge blocks.
707 unsigned ScanLimit = 32);
709/// Same as previous, but with range expressed via iterator_range.
713/// Return true if this function can prove that the instruction I
714/// is executed for every iteration of the loop L.
716/// Note that this currently only considers the loop header.
720/// Return true if \p PoisonOp's user yields poison or raises UB if its
721/// operand \p PoisonOp is poison.
723/// If \p PoisonOp is a vector or an aggregate and the operation's result is a
724/// single value, any poison element in /p PoisonOp should make the result
725/// poison or raise UB.
727/// To filter out operands that raise UB on poison, you can use
728/// getGuaranteedNonPoisonOp.
731/// Return whether this intrinsic propagates poison for all operands.
734/// Return true if the given instruction must trigger undefined behavior
735/// when I is executed with any operands which appear in KnownPoison holding
736/// a poison value at the point of execution.
738 const SmallPtrSetImpl<const Value *> &KnownPoison);
740/// Return true if this function can prove that if Inst is executed
741/// and yields a poison value or undef bits, then that will trigger
742/// undefined behavior.
744/// Note that this currently only considers the basic block that is
745/// the parent of Inst.
749/// canCreateUndefOrPoison returns true if Op can create undef or poison from
750/// non-undef & non-poison operands.
751/// For vectors, canCreateUndefOrPoison returns true if there is potential
752/// poison or undef in any element of the result when vectors without
753/// undef/poison poison are given as operands.
754/// For example, given `Op = shl <2 x i32> %x, <0, 32>`, this function returns
755/// true. If Op raises immediate UB but never creates poison or undef
756/// (e.g. sdiv I, 0), canCreatePoison returns false.
758/// \p ConsiderFlagsAndMetadata controls whether poison producing flags and
759/// metadata on the instruction are considered. This can be used to see if the
760/// instruction could still introduce undef or poison even without poison
761/// generating flags and metadata which might be on the instruction.
762/// (i.e. could the result of Op->dropPoisonGeneratingFlags() still create
765/// canCreatePoison returns true if Op can create poison from non-poison
768 bool ConsiderFlagsAndMetadata =
true);
770 bool ConsiderFlagsAndMetadata =
true);
772/// Return true if V is poison given that ValAssumedPoison is already poison.
773/// For example, if ValAssumedPoison is `icmp X, 10` and V is `icmp X, 5`,
774/// impliesPoison returns true.
777/// Return true if this function can prove that V does not have undef bits
778/// and is never poison. If V is an aggregate value or vector, check whether
779/// all elements (except padding) are not undef or poison.
780/// Note that this is different from canCreateUndefOrPoison because the
781/// function assumes Op's operands are not poison/undef.
783/// If CtxI and DT are specified this method performs flow-sensitive analysis
784/// and returns true if it is guaranteed to be never undef or poison
785/// immediately before the CtxI.
788 const Instruction *CtxI =
nullptr,
789 const DominatorTree *DT =
nullptr,
792/// Returns true if V cannot be poison, but may be undef.
794 AssumptionCache *AC =
nullptr,
795 const Instruction *CtxI =
nullptr,
796 const DominatorTree *DT =
nullptr,
802 unsigned Depth = 0) {
803 // Takes an iterator as a position, passes down to Instruction *
808/// Returns true if V cannot be undef, but may be poison.
810 AssumptionCache *AC =
nullptr,
811 const Instruction *CtxI =
nullptr,
812 const DominatorTree *DT =
nullptr,
815/// Return true if undefined behavior would provable be executed on the path to
816/// OnPathTo if Root produced a posion result. Note that this doesn't say
817/// anything about whether OnPathTo is actually executed or whether Root is
818/// actually poison. This can be used to assess whether a new use of Root can
819/// be added at a location which is control equivalent with OnPathTo (such as
820/// immediately before it) without introducing UB which didn't previously
821/// exist. Note that a false result conveys no information.
823 Instruction *OnPathTo,
826/// Convert an integer comparison with a constant RHS into an equivalent
827/// form with the strictness flipped predicate. Return the new predicate and
828/// corresponding constant RHS if possible. Otherwise return std::nullopt.
829/// E.g., (icmp sgt X, 0) -> (icmp sle X, 1).
830LLVM_ABI std::optional<std::pair<CmpPredicate, Constant *>>
833/// Specific patterns of select instructions we can match.
846/// Behavior when a floating point min/max is given one NaN and one
853 /// it has been determined that no operands can
860 /// SPF_FMINNUM or SPF_FMAXNUM.
861 bool Ordered;
/// When implementing this min/max pattern as
862 /// fcmp; select, does the fcmp have to be
865 /// Return true if \p SPF is a min or a max pattern.
871/// Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind
872/// and providing the out parameter results if we successfully match.
874/// For ABS/NABS, LHS will be set to the input to the abs idiom. RHS will be
875/// the negation instruction from the idiom.
877/// If CastOp is not nullptr, also match MIN/MAX idioms where the type does
878/// not match that of the original select. If this is the case, the cast
879/// operation (one of Trunc,SExt,Zext) that must be done to transform the
880/// type of LHS and RHS into the type of V is returned in CastOp.
883/// %1 = icmp slt i32 %a, i32 4
884/// %2 = sext i32 %a to i64
885/// %3 = select i1 %1, i64 %2, i64 4
887/// -> LHS = %a, RHS = i32 4, *CastOp = Instruction::SExt
903/// Determine the pattern that a select with the given compare as its
904/// predicate and given values as its true/false operands would match.
906 CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&
LHS, Value *&
RHS,
910/// Determine the pattern for predicate `X Pred Y ? X : Y`.
913 bool Ordered =
false);
915/// Return the canonical comparison predicate for the specified
916/// minimum/maximum flavor.
918 bool Ordered =
false);
920/// Convert given `SPF` to equivalent min/max intrinsic.
921/// Caller must ensure `SPF` is an integer min or max pattern.
924/// Return the inverse minimum/maximum flavor of the specified flavor.
925/// For example, signed minimum is the inverse of signed maximum.
930/// Return the minimum or maximum constant value for the specified integer
931/// min/max flavor and type.
934/// Check if the values in \p VL are select instructions that can be converted
935/// to a min or max (vector) intrinsic. Returns the intrinsic ID, if such a
936/// conversion is possible, together with a bool indicating whether all select
937/// conditions are only used by the selects. Otherwise return
938/// Intrinsic::not_intrinsic.
939LLVM_ABI std::pair<Intrinsic::ID, bool>
942/// Attempt to match a simple first order recurrence cycle of the form:
943/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge]
944/// %inc = binop %iv, %step
946/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge]
947/// %inc = binop %step, %iv
949/// A first order recurrence is a formula with the form: X_n = f(X_(n-1))
951/// A couple of notes on subtleties in that definition:
952/// * The Step does not have to be loop invariant. In math terms, it can
953/// be a free variable. We allow recurrences with both constant and
954/// variable coefficients. Callers may wish to filter cases where Step
955/// does not dominate P.
956/// * For non-commutative operators, we will match both forms. This
957/// results in some odd recurrence structures. Callers may wish to filter
958/// out recurrences where the phi is not the LHS of the returned operator.
959/// * Because of the structure matched, the caller can assume as a post
960/// condition of the match the presence of a Loop with P's parent as it's
961/// header *except* in unreachable code. (Dominance decays in unreachable
964/// NOTE: This is intentional simple. If you want the ability to analyze
965/// non-trivial loop conditons, see ScalarEvolution instead.
967 Value *&Start, Value *&Step);
969/// Analogous to the above, but starting from the binary operator
971 Value *&Start, Value *&Step);
973/// Attempt to match a simple value-accumulating recurrence of the form:
974/// %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge]
975/// %llvm.intrinsic = call Ty @llvm.intrinsic(%OtherOp, %llvm.intrinsic.acc)
977/// %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge]
978/// %llvm.intrinsic = call Ty @llvm.intrinsic(%llvm.intrinsic.acc, %OtherOp)
980/// The recurrence relation is of kind:
981/// X_0 = %a (initial value),
982/// X_i = call @llvm.binary.intrinsic(X_i-1, %b)
983/// Where %b is not required to be loop-invariant.
985 PHINode *&
P, Value *&Init,
988/// Return true if RHS is known to be implied true by LHS. Return false if
989/// RHS is known to be implied false by LHS. Otherwise, return std::nullopt if
990/// no implication can be made. A & B must be i1 (boolean) values or a vector of
991/// such values. Note that the truth table for implication is the same as <=u on
992/// i1 values (but not
993/// <=s!). The truth table for both is:
1000 bool LHSIsTrue =
true,
unsigned Depth = 0);
1003 const Value *RHSOp1,
const DataLayout &
DL,
1004 bool LHSIsTrue =
true,
unsigned Depth = 0);
1006/// Return the boolean condition value in the context of the given instruction
1007/// if it is known based on dominating conditions.
1010 const DataLayout &
DL);
1013 const Instruction *ContextI,
const DataLayout &
DL);
1015/// Call \p InsertAffected on all Values whose known bits / value may be
1016/// affected by the condition \p Cond. Used by AssumptionCache and
1017/// DomConditionCache.
1020 function_ref<
void(Value *)> InsertAffected);
1022/// Returns the inner value X if the expression has the form f(X)
1023/// where f(X) == 0 if and only if X == 0, otherwise returns nullptr.
1027/// Enumerates all possible values of V and inserts them into the set \p
1028/// Constants. If \p AllowUndefOrPoison is false, it fails when V may contain
1029/// undef/poison elements. Returns true if the result is complete. Otherwise,
1030/// the result is incomplete (more than MaxCount values).
1031/// NOTE: The constant values are not distinct.
1034 SmallPtrSetImpl<const Constant *> &Constants,
1035 unsigned MaxCount,
bool AllowUndefOrPoison =
true);
1037}
// end namespace llvm
1039#endif // LLVM_ANALYSIS_VALUETRACKING_H
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
const SmallVectorImpl< MachineOperand > & Cond
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
Class for arbitrary precision integers.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
A cache of @llvm.assume calls within a function.
InstListType::const_iterator const_iterator
InstListType::iterator iterator
Instruction iterators...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
A parsed version of the target data layout string in and methods for querying it.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Convenience struct for specifying and reasoning about fast-math flags.
A wrapper class for inspecting calls to intrinsic functions.
Represents a single loop in the control flow graph.
This is a utility class that provides an abstraction for the common functionality between Instruction...
StringRef - Represent a constant reference to a string, i.e.
Provides information about what library functions are available for the current target.
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Represents an op.with.overflow intrinsic.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI bool 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_ABI bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced...
LLVM_ABI Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
LLVM_ABI bool willNotFreeBetween(const Instruction *Assume, const Instruction *CtxI)
Returns true, if no instruction between Assume and CtxI may free memory and the function is marked as...
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
LLVM_ABI KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, const SimplifyQuery &SQ, unsigned Depth=0)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
LLVM_ABI bool 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,...
LLVM_ABI bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
LLVM_ABI bool 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 oper...
LLVM_ABI bool isKnownNeverInfinity(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...
LLVM_ABI void computeKnownBitsFromContext(const Value *V, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth=0)
Merge bits known from context-dependent facts into Known.
LLVM_ABI bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)
LLVM_ABI bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
LLVM_ABI const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
LLVM_ABI bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
LLVM_ABI AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
LLVM_ABI APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
LLVM_ABI bool isOnlyUsedInZeroComparison(const Instruction *CxtI)
LLVM_ABI bool 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_ABI bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
LLVM_ABI Value * stripNullTest(Value *V)
Returns the inner value X if the expression has the form f(X) where f(X) == 0 if and only if X == 0,...
LLVM_ABI bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
LLVM_ABI std::pair< Intrinsic::ID, bool > canConvertToMinOrMaxIntrinsic(ArrayRef< Value * > VL)
Check if the values in VL are select instructions that can be converted to a min or max (vector) intr...
LLVM_ABI bool 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_ABI bool 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 ...
Value * 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.
LLVM_ABI bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
LLVM_ABI CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
LLVM_ABI bool canIgnoreSignBitOfZero(const Use &U)
Return true if the sign bit of the FP value can be ignored by the user when the value is zero.
LLVM_ABI bool 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_ABI ConstantRange 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_ABI bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
LLVM_ABI bool 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 dependen...
LLVM_ABI bool 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,...
LLVM_ABI OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
LLVM_ABI SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
LLVM_ABI void adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond, Value *Arm, bool Invert, const SimplifyQuery &Q, unsigned Depth=0)
Adjust Known for the given select Arm to include information from the select Cond.
LLVM_ABI bool isKnownNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
LLVM_ABI OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
@ SPF_FMAXNUM
Floating point minnum.
@ SPF_UMIN
Signed minimum.
@ SPF_UMAX
Signed maximum.
@ SPF_SMAX
Unsigned minimum.
@ SPF_FMINNUM
Unsigned maximum.
LLVM_ABI bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
LLVM_ABI bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
LLVM_ABI SelectPatternResult getSelectPattern(CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)
Determine the pattern for predicate X Pred Y ? X : Y.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI bool programUndefinedIfPoison(const Instruction *Inst)
LLVM_ABI SelectPatternResult 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 param...
LLVM_ABI bool matchSimpleBinaryIntrinsicRecurrence(const IntrinsicInst *I, PHINode *&P, Value *&Init, Value *&OtherOp)
Attempt to match a simple value-accumulating recurrence of the form: llvm.intrinsic....
LLVM_ABI bool cannotBeNegativeZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if we can prove that the specified FP value is never equal to -0.0.
LLVM_ABI bool programUndefinedIfUndefOrPoison(const Instruction *Inst)
Return true if this function can prove that if Inst is executed and yields a poison value or undef bi...
LLVM_ABI bool collectPossibleValues(const Value *V, SmallPtrSetImpl< const Constant * > &Constants, unsigned MaxCount, bool AllowUndefOrPoison=true)
Enumerates all possible values of V and inserts them into the set Constants.
constexpr unsigned MaxLookupSearchDepth
The max limit of the search depth in DecomposeGEPExpression() and getUnderlyingObject().
LLVM_ABI uint64_t 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_ABI OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
LLVM_ABI ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
LLVM_ABI bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
LLVM_ABI bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
LLVM_ABI bool intrinsicPropagatesPoison(Intrinsic::ID IID)
Return whether this intrinsic propagates poison for all operands.
LLVM_ABI bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
LLVM_ABI bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
iterator_range(Container &&) -> iterator_range< llvm::detail::IterOfRange< Container > >
LLVM_ABI bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
LLVM_ABI bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
LLVM_ABI Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
LLVM_ABI const Value * getUnderlyingObjectAggressive(const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
LLVM_ABI Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
LLVM_ABI SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, FastMathFlags FMF=FastMathFlags(), 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 t...
LLVM_ABI OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
LLVM_ABI bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
LLVM_ABI ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
SelectPatternNaNBehavior
Behavior when a floating point min/max is given one NaN and one non-NaN as input.
@ SPNB_RETURNS_NAN
NaN behavior not applicable.
@ SPNB_RETURNS_OTHER
Given one NaN input, returns the NaN.
@ SPNB_RETURNS_ANY
Given one NaN input, returns the non-NaN.
LLVM_ABI bool isKnownNonEqual(const Value *V1, const Value *V2, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the given values are known to be non-equal when defined.
DWARFExpression::Operation Op
bool isSafeToSpeculativelyExecuteWithVariableReplaced(const Instruction *I, bool IgnoreUBImplyingAttrs=true)
Don't use information from its non-constant operands.
LLVM_ABI bool 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.
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Return the number of times the sign bit of the register is replicated into the other bits.
LLVM_ABI KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, const SimplifyQuery &SQ, unsigned Depth=0)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
LLVM_ABI OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
LLVM_ABI bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
LLVM_ABI bool isKnownNeverInfOrNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point value can never contain a NaN or infinity.
LLVM_ABI bool isKnownNeverNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
LLVM_ABI Value * 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 i...
LLVM_ABI std::optional< std::pair< CmpPredicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpPredicate Pred, Constant *C)
Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped...
LLVM_ABI unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Get the upper bound on bit size for this Value Op as a signed integer.
LLVM_ABI OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
LLVM_ABI bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Return true if the given value is known to have exactly one bit set when defined.
LLVM_ABI std::optional< bool > 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 do...
LLVM_ABI bool 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_ABI void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
LLVM_ABI Value * 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...
LLVM_ABI bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
LLVM_ABI bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
LLVM_ABI bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
LLVM_ABI bool cannotBeOrderedLessThanZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if we can prove that the specified FP value is either NaN or never less than -0....
LLVM_ABI void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=MaxLookupSearchDepth)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
LLVM_ABI bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
LLVM_ABI std::optional< bool > 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.
LLVM_ABI std::optional< bool > computeKnownFPSignBit(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return false if we can prove that the specified FP value's sign bit is 0.
LLVM_ABI bool canIgnoreSignBitOfNaN(const Use &U)
Return true if the sign bit of the FP value can be ignored by the user when the value is NaN.
LLVM_ABI void 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.
Represents offset+length into a ConstantDataArray.
uint64_t Length
Length of the slice.
uint64_t Offset
Slice starts at this Offset.
uint64_t operator[](unsigned I) const
Convenience accessor for elements in the slice.
void move(uint64_t Delta)
Moves the Offset and adjusts Length accordingly.
const ConstantDataArray * Array
ConstantDataArray pointer.
SelectPatternFlavor Flavor
bool Ordered
Only applicable if Flavor is SPF_FMINNUM or SPF_FMAXNUM.
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
SelectPatternNaNBehavior NaNBehavior