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 41classTargetLibraryInfo;
46/// Determine which bits of V are known to be either zero or one and return 47/// them in the KnownZero/KnownOne bit sets. 49/// This function is defined on values with integer type, values with pointer 50/// type, and vectors of integers. In the case 51/// where V is a vector, the known zero and known one values are the 52/// same width as the vector element, and the bit is set only if it is true 53/// for all of the elements in the vector. 58bool UseInstrInfo =
true);
60/// Returns the known bits rather than passing by reference. 65bool UseInstrInfo =
true);
67/// Returns the known bits rather than passing by reference. 73bool UseInstrInfo =
true);
84/// Compute known bits from the range metadata. 85/// \p KnownZero the set of bits that are known to be zero 86/// \p KnownOne the set of bits that are known to be one 89/// Merge bits known from context-dependent facts into Known. 93/// Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or). 99/// Adjust \p Known for the given select \p Arm to include information from the 102bool Invert,
unsignedDepth,
105/// Return true if LHS and RHS have no common bits set. 110/// Return true if the given value is known to have exactly one bit set when 111/// defined. For vectors return true if every element is known to be a power 112/// of two when defined. Supports values with integer or pointer type and 113/// vectors of integers. If 'OrZero' is set, then return true if the given 114/// value is either a power of two or zero. 116bool OrZero =
false,
unsignedDepth = 0,
120bool UseInstrInfo =
true);
129/// Return true if the given value is known to be non-zero when defined. For 130/// vectors, return true if every element is known to be non-zero when 131/// defined. For pointers, if the context instruction and dominator tree are 132/// specified, perform context-sensitive analysis and return true if the 133/// pointer couldn't possibly be null at the specified instruction. 134/// Supports values with integer or pointer type and vectors of integers. 137/// Return true if the two given values are negation. 138/// Currently can recoginze Value pair: 139/// 1: <X, Y> if X = sub (0, Y) or Y = sub (0, X) 140/// 2: <X, Y> if X = sub (A, B) and Y = sub (B, A) 142bool AllowPoison =
true);
145/// 1. X is poison implies Y is poison. 146/// 2. X is true implies Y is false. 147/// 3. X is false implies Y is true. 148/// Otherwise, return false. 151/// Returns true if the give value is known to be non-negative. 155/// Returns true if the given value is known be positive (i.e. non-negative 160/// Returns true if the given value is known be negative (i.e. non-positive 165/// Return true if the given values are known to be non-equal when defined. 166/// Supports scalar integer types only. 171bool UseInstrInfo =
true);
173/// Return true if 'V & Mask' is known to be zero. We use this predicate to 174/// simplify operations downstream. Mask is known to be zero for bits that V 177/// This function is defined on values with integer type, values with pointer 178/// type, and vectors of integers. In the case 179/// where V is a vector, the mask, known zero, and known one values are the 180/// same width as the vector element, and the bit is set only if it is true 181/// for all of the elements in the vector. 185/// Return the number of times the sign bit of the register is replicated into 186/// the other bits. We know that at least 1 bit is always equal to the sign 187/// bit (itself), but other cases can give us information. For example, 188/// immediately after an "ashr X, 2", we know that the top 3 bits are all 189/// equal to each other, so we return 3. For vectors, return the number of 190/// sign bits for the vector element with the mininum number of known sign 196bool UseInstrInfo =
true);
198/// Get the upper bound on bit size for this Value \p Op as a signed integer. 199/// i.e. x == sext(trunc(x to MaxSignificantBits) to bitwidth(x)). 200/// Similar to the APInt::getSignificantBits function. 207/// Map a call instruction to an intrinsic ID. Libcalls which have equivalent 208/// intrinsics are treated as-if they were intrinsics. 212/// Given an exploded icmp instruction, return true if the comparison only 213/// checks the sign bit. If it only checks the sign bit, set TrueIfSigned if 214/// the result of the comparison is true when the input value is signed. 218/// Returns a pair of values, which if passed to llvm.is.fpclass, returns the 219/// same result as an fcmp with the given operands. 221/// If \p LookThroughSrc is true, consider the input value when computing the 224/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair 225/// element will always be LHS. 229bool LookThroughSrc =
true);
233bool LookThroughSrc =
true);
235/// Compute the possible floating-point classes that \p LHS could be based on 236/// fcmp \Pred \p LHS, \p RHS. 238/// \returns { TestedValue, ClassesIfTrue, ClassesIfFalse } 240/// If the compare returns an exact class test, ClassesIfTrue == ~ClassesIfFalse 242/// This is a less exact version of fcmpToClassTest (e.g. fcmpToClassTest will 243/// only succeed for a test of x > 0 implies positive, but not x > 1). 245/// If \p LookThroughSrc is true, consider the input value when computing the 246/// mask. This may look through sign bit operations. 248/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair 249/// element will always be LHS. 251std::tuple<Value *, FPClassTest, FPClassTest>
253Value *
RHS,
bool LookThroughSrc =
true);
254std::tuple<Value *, FPClassTest, FPClassTest>
257std::tuple<Value *, FPClassTest, FPClassTest>
262 /// Floating-point classes the value could be one of. 265 /// std::nullopt if the sign bit is unknown, true if the sign bit is 266 /// definitely set or false if the sign bit is definitely unset. 273 /// Return true if it's known this can never be one of the mask entries. 284 /// Return true if it's known this can never be a nan. 289 /// Return true if it's known this must always be a nan. 292 /// Return true if it's known this can never be an infinity. 297 /// Return true if it's known this can never be +infinity. 302 /// Return true if it's known this can never be -infinity. 307 /// Return true if it's known this can never be a subnormal 312 /// Return true if it's known this can never be a positive subnormal 317 /// Return true if it's known this can never be a negative subnormal 322 /// Return true if it's known this can never be a zero. This means a literal 323 /// [+-]0, and does not include denormal inputs implicitly treated as [+-]0. 328 /// Return true if it's known this can never be a literal positive zero. 333 /// Return true if it's known this can never be a negative zero. This means a 334 /// literal -0 and does not include denormal inputs implicitly treated as -0. 339 /// Return true if it's know this can never be interpreted as a zero. This 340 /// extends isKnownNeverZero to cover the case where the assumed 341 /// floating-point mode for the function interprets denormals as zero. 344 /// Return true if it's know this can never be interpreted as a negative zero. 347 /// Return true if it's know this can never be interpreted as a positive zero. 355 /// Return true if we can prove that the analyzed floating-point value is 356 /// either NaN or never less than -0.0. 367 /// Return true if we can prove that the analyzed floating-point value is 368 /// either NaN or never greater than -0.0. 418 /// Return true if the sign bit must be 0, ignoring the sign of nans. 423 /// Assume the sign bit is zero. 429 /// Assume the sign bit is one. 436// Don't know anything about the sign of the source. Expand the possible set 437// to its opposite sign pair. 447// Sign bit is exactly preserved even for nans. 450// Clear sign bits based on the input sign mask. 457// Propagate knowledge that a non-NaN source implies the result can also not 458// be a NaN. For unconstrained operations, signaling nans are not guaranteed 459// to be quieted but cannot be introduced. 461if (Src.isKnownNever(
fcNan)) {
465 }
elseif (Src.isKnownNever(
fcSNan))
469 /// Propagate knowledge from a source value that could be a denormal or 470 /// zero. We have to be conservative since output flushing is not guaranteed, 471 /// so known-never-zero may not hold. 473 /// This assumes a copy-like operation and will replace any currently known 477 /// Report known classes if \p Src is evaluated through a potentially 478 /// canonicalizing operation. We can assume signaling nans will not be 479 /// introduced, but cannot assume a denormal will be flushed under FTZ/DAZ. 481 /// This assumes a copy-like operation and will replace any currently known 496return std::move(
RHS);
499/// Determine which floating-point classes are valid for \p V, and return them 500/// in KnownFPClass bit sets. 502/// This function is defined on values with floating-point type, values vectors 503/// of floating-point type, and arrays of floating-point type. 505/// \p InterestedClasses is a compile time optimization hint for which floating 506/// point classes should be queried. Queries not specified in \p 507/// InterestedClasses should be reliable if they are determined during the 511const SimplifyQuery &SQ);
514unsignedDepth,
const SimplifyQuery &SQ);
521bool UseInstrInfo =
true) {
523 V, InterestedClasses,
Depth,
527/// Wrapper to account for known fast math flags at the use instruction. 533 InterestedClasses &= ~fcNan;
535 InterestedClasses &= ~fcInf;
541 Result.KnownFPClasses &= ~fcNan;
543 Result.KnownFPClasses &= ~fcInf;
551auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
558/// Return true if we can prove that the specified FP value is never equal to 559/// -0.0. Users should use caution when considering PreserveSign 567/// Return true if we can prove that the specified FP value is either NaN or 568/// never less than -0.0. 582/// Return true if the floating-point scalar value is not an infinity or if 583/// the floating-point vector value has no infinities. Return false if a value 584/// could ever be infinity. 591/// Return true if the floating-point value can never contain a NaN or infinity. 598/// Return true if the floating-point scalar value is not a NaN or if the 599/// floating-point vector value has no NaN elements. Return false if a value 600/// could ever be NaN. 607/// Return false if we can prove that the specified FP value's sign bit is 0. 608/// Return true if we can prove that the specified FP value's sign bit is 1. 609/// Otherwise return std::nullopt. 616/// If the specified value can be set by repeating the same byte in memory, 617/// return the i8 value that it is represented with. This is true for all i8 618/// values obviously, but is also true for i32 0, i32 -1, i16 0xF0F0, double 619/// 0.0 etc. If the value can't be handled with a repeated byte store (e.g. 620/// i16 0x1234), return null. If the value is entirely undef and padding, 624/// Given an aggregate and an sequence of indices, see if the scalar value 625/// indexed is already around as a register, for example if it were inserted 626/// directly into the aggregate. 628/// If InsertBefore is not empty, this function will duplicate (modified) 629/// insertvalues when a part of a nested struct is extracted. 631 Value *V, ArrayRef<unsigned> idx_range,
632 std::optional<BasicBlock::iterator> InsertBefore = std::nullopt);
634/// Analyze the specified pointer to see if it can be expressed as a base 635/// pointer plus a constant offset. Return the base and offset to the caller. 637/// This is a wrapper around Value::stripAndAccumulateConstantOffsets that 638/// creates and later unpacks the required APInt. 641bool AllowNonInbounds =
true) {
642APInt OffsetAPInt(
DL.getIndexTypeSizeInBits(
Ptr->getType()), 0);
644Ptr->stripAndAccumulateConstantOffsets(
DL, OffsetAPInt, AllowNonInbounds);
652bool AllowNonInbounds =
true) {
657/// Returns true if the GEP is based on a pointer to a string (array of 658// \p CharSize integers) and is indexing into this string. 661/// Represents offset+length into a ConstantDataArray. 663 /// ConstantDataArray pointer. nullptr indicates a zeroinitializer (a valid 664 /// initializer, it just doesn't fit the ConstantDataArray interface). 667 /// Slice starts at this Offset. 670 /// Length of the slice. 673 /// Moves the Offset and adjusts Length accordingly. 680 /// Convenience accessor for elements in the slice. 686/// Returns true if the value \p V is a pointer into a ConstantDataArray. 687/// If successful \p Slice will point to a ConstantDataArray info object 688/// with an appropriate offset. 692/// This function computes the length of a null-terminated C string pointed to 693/// by V. If successful, it returns true and returns the string in Str. If 694/// unsuccessful, it returns false. This does not include the trailing null 695/// character by default. If TrimAtNul is set to false, then this returns any 696/// trailing null characters as well as any other characters that come after 699bool TrimAtNul =
true);
701/// If we can compute the length of the string pointed to by the specified 702/// pointer, return 'len+1'. If we can't, return 0. 705/// This function returns call pointer argument that is considered the same by 706/// aliasing rules. You CAN'T use it to replace one value with another. If 707/// \p MustPreserveNullness is true, the call must preserve the nullness of 710bool MustPreserveNullness);
712bool MustPreserveNullness) {
714const_cast<constCallBase *
>(Call), MustPreserveNullness));
717/// {launder,strip}.invariant.group returns pointer that aliases its argument, 718/// and it only captures pointer by returning it. 719/// These intrinsics are not marked as nocapture, because returning is 720/// considered as capture. The arguments are not marked as returned neither, 721/// because it would make it useless. If \p MustPreserveNullness is true, 722/// the intrinsic must preserve the nullness of the pointer. 724const CallBase *Call,
bool MustPreserveNullness);
726/// This method strips off any GEP address adjustments, pointer casts 727/// or `llvm.threadlocal.address` from the specified value \p V, returning the 728/// original object being addressed. Note that the returned value has pointer 729/// type if the specified value does. If the \p MaxLookup value is non-zero, it 730/// limits the number of instructions to be stripped off. 733// Force const to avoid infinite recursion. 734constValue *VConst = V;
738/// Like getUnderlyingObject(), but will try harder to find a single underlying 739/// object. In particular, this function also looks through selects and phis. 742/// This method is similar to getUnderlyingObject except that it can 743/// look through phi and select instructions and return multiple objects. 745/// If LoopInfo is passed, loop phis are further analyzed. If a pointer 746/// accesses different objects in each iteration, we don't look through the 747/// phi node. E.g. consider this loop nest: 752/// A[i][j] = A[i-1][j] * B[j] 755/// This is transformed by Load-PRE to stash away A[i] for the next iteration 756/// of the outer loop: 758/// Curr = A[0]; // Prev_0 760/// Prev = Curr; // Prev = PHI (Prev_0, Curr) 763/// Curr[j] = Prev[j] * B[j] 767/// Since A[i] and A[i-1] are independent pointers, getUnderlyingObjects 768/// should not assume that Curr and Prev share the same underlying object thus 769/// it shouldn't look through the phi above. 771 SmallVectorImpl<const Value *> &Objects,
772const LoopInfo *LI =
nullptr,
unsigned MaxLookup = 6);
774/// This is a wrapper around getUnderlyingObjects and adds support for basic 775/// ptrtoint+arithmetic+inttoptr sequences. 777 SmallVectorImpl<Value *> &Objects);
779/// Returns unique alloca where the value comes from, or nullptr. 780/// If OffsetZero is true check that V points to the begining of the alloca. 783bool OffsetZero =
false) {
787/// Return true if the only users of this pointer are lifetime markers. 790/// Return true if the only users of this pointer are lifetime markers or 791/// droppable instructions. 794/// Return true if the instruction doesn't potentially cross vector lanes. This 795/// condition is weaker than checking that the instruction is lanewise: lanewise 796/// means that the same operation is splatted across all lanes, but we also 797/// include the case where there is a different operation on each lane, as long 798/// as the operation only uses data from that lane. An example of an operation 799/// that is not lanewise, but doesn't cross vector lanes is insertelement. 802/// Return true if the instruction does not have any effects besides 803/// calculating the result and does not have undefined behavior. 805/// This method never returns true for an instruction that returns true for 806/// mayHaveSideEffects; however, this method also does some other checks in 807/// addition. It checks for undefined behavior, like dividing by zero or 808/// loading from an invalid pointer (but not for undefined results, like a 809/// shift with a shift amount larger than the width of the result). It checks 810/// for malloc and alloca because speculatively executing them might cause a 811/// memory leak. It also returns false for instructions related to control 812/// flow, specifically terminators and PHI nodes. 814/// If the CtxI is specified this method performs context-sensitive analysis 815/// and returns true if it is safe to execute the instruction immediately 816/// before the CtxI. If the instruction has (transitive) operands that don't 817/// dominate CtxI, the analysis is performed under the assumption that these 818/// operands will also be speculated to a point before CxtI. 820/// If the CtxI is NOT specified this method only looks at the instruction 821/// itself and its operands, so if this method returns true, it is safe to 822/// move the instruction as long as the correct dominance relationships for 823/// the operands and users hold. 825/// This method can return true for instructions that read memory; 826/// for such instructions, moving them may change the resulting value. 828const Instruction *CtxI =
nullptr,
829 AssumptionCache *AC =
nullptr,
830const DominatorTree *DT =
nullptr,
831const TargetLibraryInfo *TLI =
nullptr,
832bool UseVariableInfo =
true);
839bool UseVariableInfo =
true) {
840// Take an iterator, and unwrap it into an Instruction *. 844/// Don't use information from its non-constant operands. This helper is used 845/// when its operands are going to be replaced. 849/*UseVariableInfo=*/false);
852/// This returns the same result as isSafeToSpeculativelyExecute if Opcode is 853/// the actual opcode of Inst. If the provided and actual opcode differ, the 854/// function (virtually) overrides the opcode of Inst with the provided 855/// Opcode. There are come constraints in this case: 856/// * If Opcode has a fixed number of operands (eg, as binary operators do), 857/// then Inst has to have at least as many leading operands. The function 858/// will ignore all trailing operands beyond that number. 859/// * If Opcode allows for an arbitrary number of operands (eg, as CallInsts 860/// do), then all operands are considered. 861/// * The virtual instruction has to satisfy all typing rules of the provided 863/// * This function is pessimistic in the following sense: If one actually 864/// materialized the virtual instruction, then isSafeToSpeculativelyExecute 865/// may say that the materialized instruction is speculatable whereas this 866/// function may have said that the instruction wouldn't be speculatable. 867/// This behavior is a shortcoming in the current implementation and not 870unsigned Opcode,
const Instruction *Inst,
const Instruction *CtxI =
nullptr,
871 AssumptionCache *AC =
nullptr,
const DominatorTree *DT =
nullptr,
872const TargetLibraryInfo *TLI =
nullptr,
bool UseVariableInfo =
true);
874/// Returns true if the result or effects of the given instructions \p I 875/// depend values not reachable through the def use graph. 876/// * Memory dependence arises for example if the instruction reads from 877/// memory or may produce effects or undefined behaviour. Memory dependent 878/// instructions generally cannot be reorderd with respect to other memory 879/// dependent instructions. 880/// * Control dependence arises for example if the instruction may fault 881/// if lifted above a throwing call or infinite loop. 884/// Return true if it is an intrinsic that cannot be speculated but also 888/// Return true if it is valid to use the assumptions provided by an 889/// assume intrinsic, I, at the point in the control-flow identified by the 890/// context instruction, CxtI. By default, ephemeral values of the assumption 891/// are treated as an invalid context, to prevent the assumption from being used 892/// to optimize away its argument. If the caller can ensure that this won't 893/// happen, it can call with AllowEphemerals set to true to get more valid 896const DominatorTree *DT =
nullptr,
897bool AllowEphemerals =
false);
900 /// Always overflows in the direction of signed/unsigned min value. 902 /// Always overflows in the direction of signed/unsigned max value. 904 /// May or may not overflow. 911const SimplifyQuery &SQ,
914const SimplifyQuery &SQ);
917const WithCache<const Value *> &
RHS,
918const SimplifyQuery &SQ);
920const WithCache<const Value *> &
RHS,
921const SimplifyQuery &SQ);
922/// This version also leverages the sign bit of Add if known. 924const SimplifyQuery &SQ);
926const SimplifyQuery &SQ);
928const SimplifyQuery &SQ);
930/// Returns true if the arithmetic part of the \p WO 's result is 931/// used only along the paths control dependent on the computation 932/// not overflowing, \p WO being an <op>.with.overflow intrinsic. 934const DominatorTree &DT);
936/// Determine the possible constant range of vscale with the given bit width, 937/// based on the vscale_range function attribute. 940/// Determine the possible constant range of an integer or vector of integer 941/// value. This is intended as a cheap, non-recursive check. 943bool UseInstrInfo =
true,
944 AssumptionCache *AC =
nullptr,
945const Instruction *CtxI =
nullptr,
946const DominatorTree *DT =
nullptr,
949/// Combine constant ranges from computeConstantRange() and computeKnownBits(). 952bool ForSigned,
const SimplifyQuery &SQ);
954/// Return true if this function can prove that the instruction I will 955/// always transfer execution to one of its successors (including the next 956/// instruction that follows within a basic block). E.g. this is not 957/// guaranteed for function calls that could loop infinitely. 959/// In other words, this function returns false for instructions that may 960/// transfer execution or fail to transfer execution in a way that is not 961/// captured in the CFG nor in the sequence of instructions within a basic 964/// Undefined behavior is assumed not to happen, so e.g. division is 965/// guaranteed to transfer execution to the following instruction even 966/// though division by zero might cause undefined behavior. 969/// Returns true if this block does not contain a potential implicit exit. 970/// This is equivelent to saying that all instructions within the basic block 971/// are guaranteed to transfer execution to their successor within the basic 972/// block. This has the same assumptions w.r.t. undefined behavior as the 973/// instruction variant of this function. 976/// Return true if every instruction in the range (Begin, End) is 977/// guaranteed to transfer execution to its static successor. \p ScanLimit 978/// bounds the search to avoid scanning huge blocks. 981unsigned ScanLimit = 32);
983/// Same as previous, but with range expressed via iterator_range. 985 iterator_range<BasicBlock::const_iterator>
Range,
unsigned ScanLimit = 32);
987/// Return true if this function can prove that the instruction I 988/// is executed for every iteration of the loop L. 990/// Note that this currently only considers the loop header. 994/// Return true if \p PoisonOp's user yields poison or raises UB if its 995/// operand \p PoisonOp is poison. 997/// If \p PoisonOp is a vector or an aggregate and the operation's result is a 998/// single value, any poison element in /p PoisonOp should make the result 999/// poison or raise UB. 1001/// To filter out operands that raise UB on poison, you can use 1002/// getGuaranteedNonPoisonOp. 1005/// Insert operands of I into Ops such that I will trigger undefined behavior 1006/// if I is executed and that operand has a poison value. 1008 SmallVectorImpl<const Value *> &Ops);
1010/// Insert operands of I into Ops such that I will trigger undefined behavior 1011/// if I is executed and that operand is not a well-defined value 1012/// (i.e. has undef bits or poison). 1014 SmallVectorImpl<const Value *> &Ops);
1016/// Return true if the given instruction must trigger undefined behavior 1017/// when I is executed with any operands which appear in KnownPoison holding 1018/// a poison value at the point of execution. 1020const SmallPtrSetImpl<const Value *> &KnownPoison);
1022/// Return true if this function can prove that if Inst is executed 1023/// and yields a poison value or undef bits, then that will trigger 1024/// undefined behavior. 1026/// Note that this currently only considers the basic block that is 1027/// the parent of Inst. 1031/// canCreateUndefOrPoison returns true if Op can create undef or poison from 1032/// non-undef & non-poison operands. 1033/// For vectors, canCreateUndefOrPoison returns true if there is potential 1034/// poison or undef in any element of the result when vectors without 1035/// undef/poison poison are given as operands. 1036/// For example, given `Op = shl <2 x i32> %x, <0, 32>`, this function returns 1037/// true. If Op raises immediate UB but never creates poison or undef 1038/// (e.g. sdiv I, 0), canCreatePoison returns false. 1040/// \p ConsiderFlagsAndMetadata controls whether poison producing flags and 1041/// metadata on the instruction are considered. This can be used to see if the 1042/// instruction could still introduce undef or poison even without poison 1043/// generating flags and metadata which might be on the instruction. 1044/// (i.e. could the result of Op->dropPoisonGeneratingFlags() still create 1047/// canCreatePoison returns true if Op can create poison from non-poison 1050bool ConsiderFlagsAndMetadata =
true);
1053/// Return true if V is poison given that ValAssumedPoison is already poison. 1054/// For example, if ValAssumedPoison is `icmp X, 10` and V is `icmp X, 5`, 1055/// impliesPoison returns true. 1056boolimpliesPoison(
const Value *ValAssumedPoison,
const Value *V);
1058/// Return true if this function can prove that V does not have undef bits 1059/// and is never poison. If V is an aggregate value or vector, check whether 1060/// all elements (except padding) are not undef or poison. 1061/// Note that this is different from canCreateUndefOrPoison because the 1062/// function assumes Op's operands are not poison/undef. 1064/// If CtxI and DT are specified this method performs flow-sensitive analysis 1065/// and returns true if it is guaranteed to be never undef or poison 1066/// immediately before the CtxI. 1068 AssumptionCache *AC =
nullptr,
1069const Instruction *CtxI =
nullptr,
1070const DominatorTree *DT =
nullptr,
1073/// Returns true if V cannot be poison, but may be undef. 1075const Instruction *CtxI =
nullptr,
1076const DominatorTree *DT =
nullptr,
1083// Takes an iterator as a position, passes down to Instruction * 1088/// Returns true if V cannot be undef, but may be poison. 1090const Instruction *CtxI =
nullptr,
1091const DominatorTree *DT =
nullptr,
1094/// Return true if undefined behavior would provable be executed on the path to 1095/// OnPathTo if Root produced a posion result. Note that this doesn't say 1096/// anything about whether OnPathTo is actually executed or whether Root is 1097/// actually poison. This can be used to assess whether a new use of Root can 1098/// be added at a location which is control equivalent with OnPathTo (such as 1099/// immediately before it) without introducing UB which didn't previously 1100/// exist. Note that a false result conveys no information. 1102 Instruction *OnPathTo,
1105/// Convert an integer comparison with a constant RHS into an equivalent 1106/// form with the strictness flipped predicate. Return the new predicate and 1107/// corresponding constant RHS if possible. Otherwise return std::nullopt. 1108/// E.g., (icmp sgt X, 0) -> (icmp sle X, 1). 1109std::optional<std::pair<CmpPredicate, Constant *>>
1112/// Specific patterns of select instructions we can match. 1125/// Behavior when a floating point min/max is given one NaN and one 1126/// non-NaN as input. 1132 /// it has been determined that no operands can 1139 /// SPF_FMINNUM or SPF_FMAXNUM. 1140boolOrdered;
/// When implementing this min/max pattern as 1141 /// fcmp; select, does the fcmp have to be 1144 /// Return true if \p SPF is a min or a max pattern. 1150/// Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind 1151/// and providing the out parameter results if we successfully match. 1153/// For ABS/NABS, LHS will be set to the input to the abs idiom. RHS will be 1154/// the negation instruction from the idiom. 1156/// If CastOp is not nullptr, also match MIN/MAX idioms where the type does 1157/// not match that of the original select. If this is the case, the cast 1158/// operation (one of Trunc,SExt,Zext) that must be done to transform the 1159/// type of LHS and RHS into the type of V is returned in CastOp. 1162/// %1 = icmp slt i32 %a, i32 4 1163/// %2 = sext i32 %a to i64 1164/// %3 = select i1 %1, i64 %2, i64 4 1166/// -> LHS = %a, RHS = i32 4, *CastOp = Instruction::SExt 1182/// Determine the pattern that a select with the given compare as its 1183/// predicate and given values as its true/false operands would match. 1185 CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&
LHS, Value *&
RHS,
1188/// Determine the pattern for predicate `X Pred Y ? X : Y`. 1192bool Ordered =
false);
1194/// Return the canonical comparison predicate for the specified 1195/// minimum/maximum flavor. 1198/// Convert given `SPF` to equivalent min/max intrinsic. 1199/// Caller must ensure `SPF` is an integer min or max pattern. 1202/// Return the inverse minimum/maximum flavor of the specified flavor. 1203/// For example, signed minimum is the inverse of signed maximum. 1208/// Return the minimum or maximum constant value for the specified integer 1209/// min/max flavor and type. 1212/// Check if the values in \p VL are select instructions that can be converted 1213/// to a min or max (vector) intrinsic. Returns the intrinsic ID, if such a 1214/// conversion is possible, together with a bool indicating whether all select 1215/// conditions are only used by the selects. Otherwise return 1216/// Intrinsic::not_intrinsic. 1217std::pair<Intrinsic::ID, bool>
1220/// Attempt to match a simple first order recurrence cycle of the form: 1221/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge] 1222/// %inc = binop %iv, %step 1224/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge] 1225/// %inc = binop %step, %iv 1227/// A first order recurrence is a formula with the form: X_n = f(X_(n-1)) 1229/// A couple of notes on subtleties in that definition: 1230/// * The Step does not have to be loop invariant. In math terms, it can 1231/// be a free variable. We allow recurrences with both constant and 1232/// variable coefficients. Callers may wish to filter cases where Step 1233/// does not dominate P. 1234/// * For non-commutative operators, we will match both forms. This 1235/// results in some odd recurrence structures. Callers may wish to filter 1236/// out recurrences where the phi is not the LHS of the returned operator. 1237/// * Because of the structure matched, the caller can assume as a post 1238/// condition of the match the presence of a Loop with P's parent as it's 1239/// header *except* in unreachable code. (Dominance decays in unreachable 1242/// NOTE: This is intentional simple. If you want the ability to analyze 1243/// non-trivial loop conditons, see ScalarEvolution instead. 1247/// Analogous to the above, but starting from the binary operator 1251/// Return true if RHS is known to be implied true by LHS. Return false if 1252/// RHS is known to be implied false by LHS. Otherwise, return std::nullopt if 1253/// no implication can be made. A & B must be i1 (boolean) values or a vector of 1254/// such values. Note that the truth table for implication is the same as <=u on 1255/// i1 values (but not 1256/// <=s!). The truth table for both is: 1262const DataLayout &
DL,
1263bool LHSIsTrue =
true,
1266const Value *RHSOp0,
const Value *RHSOp1,
1267const DataLayout &
DL,
1268bool LHSIsTrue =
true,
1271/// Return the boolean condition value in the context of the given instruction 1272/// if it is known based on dominating conditions. 1274const Instruction *ContextI,
1275const DataLayout &
DL);
1278const Instruction *ContextI,
1279const DataLayout &
DL);
1281/// Call \p InsertAffected on all Values whose known bits / value may be 1282/// affected by the condition \p Cond. Used by AssumptionCache and 1283/// DomConditionCache. 1285 function_ref<
void(Value *)> InsertAffected);
1287}
// end namespace llvm 1289#endif// LLVM_ANALYSIS_VALUETRACKING_H MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
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,...
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
This class represents an Operation in the Expression.
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.
This is a utility class that provides an abstraction for the common functionality between Instruction...
Provides information about what library functions are available for the current target.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
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.
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...
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
@ 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.
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,...
bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
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...
bool isSafeToSpeculativelyExecuteWithVariableReplaced(const Instruction *I)
Don't use information from its non-constant operands.
bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)
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.
const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
bool 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 val...
void 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 o...
bool isOnlyUsedInZeroComparison(const Instruction *CxtI)
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.
bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
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...
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.
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.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
bool 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.
bool isKnownNeverInfOrNaN(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point value can never contain a NaN or infinity.
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
void computeKnownBitsFromContext(const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Merge bits known from context-dependent facts into Known.
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.
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.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
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...
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,...
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)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
KnownBits 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).
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
bool isKnownNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
void 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 o...
FPClassTest fneg(FPClassTest Mask)
Return the test mask which returns true if the value's sign bit is flipped.
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
std::tuple< Value *, FPClassTest, FPClassTest > 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,...
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.
bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
void 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.
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
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.
bool programUndefinedIfPoison(const Instruction *Inst)
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...
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...
bool 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 ...
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'.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
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...
bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
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.
bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
const Value * getUnderlyingObjectAggressive(const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
bool 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.
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.
void 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/KnownOn...
DWARFExpression::Operation Op
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 >
constexpr unsigned BitWidth
SelectPatternResult 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 t...
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
std::pair< Value *, FPClassTest > 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...
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...
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...
void 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 instruct...
std::optional< bool > 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.
bool 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....
unsigned 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.
bool 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.
OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
bool 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...
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...
bool isGEPBasedOnPointerToString(const GEPOperator *GEP, unsigned CharSize=8)
Returns true if the GEP is based on a pointer to a string (array of.
APInt operator|(APInt a, const APInt &b)
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.
KnownFPClass 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.
void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
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...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
unsigned 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.
bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
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.
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.
bool isKnownAlwaysNaN() const
Return true if it's known this must always be a nan.
FPClassTest KnownFPClasses
Floating-point classes the value could be one of.
bool isKnownNeverInfinity() const
Return true if it's known this can never be an infinity.
bool cannotBeOrderedGreaterThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never greater tha...
static constexpr FPClassTest OrderedGreaterThanZeroMask
static constexpr FPClassTest OrderedLessThanZeroMask
void knownNot(FPClassTest RuleOut)
bool isKnownNeverZero() const
Return true if it's known this can never be a zero.
void copysign(const KnownFPClass &Sign)
bool isKnownNeverSubnormal() const
Return true if it's known this can never be a subnormal.
bool isKnownAlways(FPClassTest Mask) const
bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a negative zero.
bool isKnownNeverLogicalPosZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a positive zero.
KnownFPClass & operator|=(const KnownFPClass &RHS)
void propagateCanonicalizingSrc(const KnownFPClass &Src, const Function &F, Type *Ty)
Report known classes if Src is evaluated through a potentially canonicalizing operation.
void propagateDenormal(const KnownFPClass &Src, const Function &F, Type *Ty)
Propagate knowledge from a source value that could be a denormal or zero.
bool isKnownNeverNegInfinity() const
Return true if it's known this can never be -infinity.
bool isKnownNeverNegSubnormal() const
Return true if it's known this can never be a negative subnormal.
bool isKnownNeverPosZero() const
Return true if it's known this can never be a literal positive zero.
std::optional< bool > SignBit
std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
bool isKnownNever(FPClassTest Mask) const
Return true if it's known this can never be one of the mask entries.
bool isKnownNeverNegZero() const
Return true if it's known this can never be a negative zero.
bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a zero.
void propagateNaN(const KnownFPClass &Src, bool PreserveSign=false)
bool cannotBeOrderedLessThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never less than -...
void signBitMustBeOne()
Assume the sign bit is one.
void signBitMustBeZero()
Assume the sign bit is zero.
bool isKnownNeverPosInfinity() const
Return true if it's known this can never be +infinity.
bool operator==(KnownFPClass Other) const
bool signBitIsZeroOrNaN() const
Return true if the sign bit must be 0, ignoring the sign of nans.
bool isKnownNeverPosSubnormal() const
Return true if it's known this can never be a positive subnormal.
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
