LLVM 20.0.0git
ValueTracking.h
Go to the documentation of this file.
1//===- llvm/Analysis/ValueTracking.h - Walk computations --------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains routines that help analyze properties that chains of
10// computations have.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ANALYSIS_VALUETRACKING_H
15#define LLVM_ANALYSIS_VALUETRACKING_H
16
17#include "llvm/ADT/ArrayRef.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/DataLayout.h"
22#include "llvm/IR/FMF.h"
24#include "llvm/IR/InstrTypes.h"
25#include "llvm/IR/Intrinsics.h"
26#include <cassert>
27#include <cstdint>
28
29namespace llvm {
30
31class Operator;
32class AddOperator;
33class AllocaInst;
34class APInt;
35class AssumptionCache;
36class DominatorTree;
37class GEPOperator;
38class LoadInst;
39class WithOverflowInst;
40struct KnownBits;
41class Loop;
42class LoopInfo;
43class MDNode;
44class StringRef;
45class TargetLibraryInfo;
46class Value;
47
48constexpr unsigned MaxAnalysisRecursionDepth = 6;
49
50/// Determine which bits of V are known to be either zero or one and return
51/// them in the KnownZero/KnownOne bit sets.
52///
53/// This function is defined on values with integer type, values with pointer
54/// type, and vectors of integers. In the case
55/// where V is a vector, the known zero and known one values are the
56/// same width as the vector element, and the bit is set only if it is true
57/// for all of the elements in the vector.
58void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL,
59 unsigned Depth = 0, AssumptionCache *AC = nullptr,
60 const Instruction *CxtI = nullptr,
61 const DominatorTree *DT = nullptr,
62 bool UseInstrInfo = true);
63
64/// Returns the known bits rather than passing by reference.
66 unsigned Depth = 0, AssumptionCache *AC = nullptr,
67 const Instruction *CxtI = nullptr,
68 const DominatorTree *DT = nullptr,
69 bool UseInstrInfo = true);
70
71/// Returns the known bits rather than passing by reference.
72KnownBits computeKnownBits(const Value *V, const APInt &DemandedElts,
73 const DataLayout &DL, unsigned Depth = 0,
74 AssumptionCache *AC = nullptr,
75 const Instruction *CxtI = nullptr,
76 const DominatorTree *DT = nullptr,
77 bool UseInstrInfo = true);
78
79KnownBits computeKnownBits(const Value *V, const APInt &DemandedElts,
80 unsigned Depth, const SimplifyQuery &Q);
81
82KnownBits computeKnownBits(const Value *V, unsigned Depth,
83 const SimplifyQuery &Q);
84
85void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
86 const SimplifyQuery &Q);
87
88/// Compute known bits from the range metadata.
89/// \p KnownZero the set of bits that are known to be zero
90/// \p KnownOne the set of bits that are known to be one
91void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known);
92
93/// Merge bits known from context-dependent facts into Known.
94void computeKnownBitsFromContext(const Value *V, KnownBits &Known,
95 unsigned Depth, const SimplifyQuery &Q);
96
97/// Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
99 const KnownBits &KnownLHS,
100 const KnownBits &KnownRHS,
101 unsigned Depth, const SimplifyQuery &SQ);
102
103/// Adjust \p Known for the given select \p Arm to include information from the
104/// select \p Cond.
106 bool Invert, unsigned Depth,
107 const SimplifyQuery &Q);
108
109/// Return true if LHS and RHS have no common bits set.
111 const WithCache<const Value *> &RHSCache,
112 const SimplifyQuery &SQ);
113
114/// Return true if the given value is known to have exactly one bit set when
115/// defined. For vectors return true if every element is known to be a power
116/// of two when defined. Supports values with integer or pointer type and
117/// vectors of integers. If 'OrZero' is set, then return true if the given
118/// value is either a power of two or zero.
119bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL,
120 bool OrZero = false, unsigned Depth = 0,
121 AssumptionCache *AC = nullptr,
122 const Instruction *CxtI = nullptr,
123 const DominatorTree *DT = nullptr,
124 bool UseInstrInfo = true);
125
127
129
130/// Return true if the given value is known to be non-zero when defined. For
131/// vectors, return true if every element is known to be non-zero when
132/// defined. For pointers, if the context instruction and dominator tree are
133/// specified, perform context-sensitive analysis and return true if the
134/// pointer couldn't possibly be null at the specified instruction.
135/// Supports values with integer or pointer type and vectors of integers.
136bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth = 0);
137
138/// Return true if the two given values are negation.
139/// Currently can recoginze Value pair:
140/// 1: <X, Y> if X = sub (0, Y) or Y = sub (0, X)
141/// 2: <X, Y> if X = sub (A, B) and Y = sub (B, A)
142bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW = false,
143 bool AllowPoison = true);
144
145/// Return true iff:
146/// 1. X is poison implies Y is poison.
147/// 2. X is true implies Y is false.
148/// 3. X is false implies Y is true.
149/// Otherwise, return false.
150bool isKnownInversion(const Value *X, const Value *Y);
151
152/// Returns true if the give value is known to be non-negative.
153bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ,
154 unsigned Depth = 0);
155
156/// Returns true if the given value is known be positive (i.e. non-negative
157/// and non-zero).
158bool isKnownPositive(const Value *V, const SimplifyQuery &SQ,
159 unsigned Depth = 0);
160
161/// Returns true if the given value is known be negative (i.e. non-positive
162/// and non-zero).
163bool isKnownNegative(const Value *V, const SimplifyQuery &DL,
164 unsigned Depth = 0);
165
166/// Return true if the given values are known to be non-equal when defined.
167/// Supports scalar integer types only.
168bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL,
169 AssumptionCache *AC = nullptr,
170 const Instruction *CxtI = nullptr,
171 const DominatorTree *DT = nullptr,
172 bool UseInstrInfo = true);
173
174/// Return true if 'V & Mask' is known to be zero. We use this predicate to
175/// simplify operations downstream. Mask is known to be zero for bits that V
176/// cannot have.
177///
178/// This function is defined on values with integer type, values with pointer
179/// type, and vectors of integers. In the case
180/// where V is a vector, the mask, known zero, and known one values are the
181/// same width as the vector element, and the bit is set only if it is true
182/// for all of the elements in the vector.
183bool MaskedValueIsZero(const Value *V, const APInt &Mask,
184 const SimplifyQuery &DL, unsigned Depth = 0);
185
186/// Return the number of times the sign bit of the register is replicated into
187/// the other bits. We know that at least 1 bit is always equal to the sign
188/// bit (itself), but other cases can give us information. For example,
189/// immediately after an "ashr X, 2", we know that the top 3 bits are all
190/// equal to each other, so we return 3. For vectors, return the number of
191/// sign bits for the vector element with the mininum number of known sign
192/// bits.
193unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL,
194 unsigned Depth = 0, AssumptionCache *AC = nullptr,
195 const Instruction *CxtI = nullptr,
196 const DominatorTree *DT = nullptr,
197 bool UseInstrInfo = true);
198
199/// Get the upper bound on bit size for this Value \p Op as a signed integer.
200/// i.e. x == sext(trunc(x to MaxSignificantBits) to bitwidth(x)).
201/// Similar to the APInt::getSignificantBits function.
202unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL,
203 unsigned Depth = 0,
204 AssumptionCache *AC = nullptr,
205 const Instruction *CxtI = nullptr,
206 const DominatorTree *DT = nullptr);
207
208/// Map a call instruction to an intrinsic ID. Libcalls which have equivalent
209/// intrinsics are treated as-if they were intrinsics.
211 const TargetLibraryInfo *TLI);
212
213/// Given an exploded icmp instruction, return true if the comparison only
214/// checks the sign bit. If it only checks the sign bit, set TrueIfSigned if
215/// the result of the comparison is true when the input value is signed.
217 bool &TrueIfSigned);
218
219/// Returns a pair of values, which if passed to llvm.is.fpclass, returns the
220/// same result as an fcmp with the given operands.
221///
222/// If \p LookThroughSrc is true, consider the input value when computing the
223/// mask.
224///
225/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair
226/// element will always be LHS.
227std::pair<Value *, FPClassTest> fcmpToClassTest(CmpInst::Predicate Pred,
228 const Function &F, Value *LHS,
229 Value *RHS,
230 bool LookThroughSrc = true);
231std::pair<Value *, FPClassTest> fcmpToClassTest(CmpInst::Predicate Pred,
232 const Function &F, Value *LHS,
233 const APFloat *ConstRHS,
234 bool LookThroughSrc = true);
235
236/// Compute the possible floating-point classes that \p LHS could be based on
237/// fcmp \Pred \p LHS, \p RHS.
238///
239/// \returns { TestedValue, ClassesIfTrue, ClassesIfFalse }
240///
241/// If the compare returns an exact class test, ClassesIfTrue == ~ClassesIfFalse
242///
243/// This is a less exact version of fcmpToClassTest (e.g. fcmpToClassTest will
244/// only succeed for a test of x > 0 implies positive, but not x > 1).
245///
246/// If \p LookThroughSrc is true, consider the input value when computing the
247/// mask. This may look through sign bit operations.
248///
249/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair
250/// element will always be LHS.
251///
252std::tuple<Value *, FPClassTest, FPClassTest>
254 Value *RHS, bool LookThroughSrc = true);
255std::tuple<Value *, FPClassTest, FPClassTest>
257 FPClassTest RHS, bool LookThroughSrc = true);
258std::tuple<Value *, FPClassTest, FPClassTest>
260 const APFloat &RHS, bool LookThroughSrc = true);
261
263 /// Floating-point classes the value could be one of.
265
266 /// std::nullopt if the sign bit is unknown, true if the sign bit is
267 /// definitely set or false if the sign bit is definitely unset.
268 std::optional<bool> SignBit;
269
271 return KnownFPClasses == Other.KnownFPClasses && SignBit == Other.SignBit;
272 }
273
274 /// Return true if it's known this can never be one of the mask entries.
275 bool isKnownNever(FPClassTest Mask) const {
276 return (KnownFPClasses & Mask) == fcNone;
277 }
278
279 bool isKnownAlways(FPClassTest Mask) const { return isKnownNever(~Mask); }
280
281 bool isUnknown() const {
282 return KnownFPClasses == fcAllFlags && !SignBit;
283 }
284
285 /// Return true if it's known this can never be a nan.
286 bool isKnownNeverNaN() const {
287 return isKnownNever(fcNan);
288 }
289
290 /// Return true if it's known this must always be a nan.
291 bool isKnownAlwaysNaN() const { return isKnownAlways(fcNan); }
292
293 /// Return true if it's known this can never be an infinity.
294 bool isKnownNeverInfinity() const {
295 return isKnownNever(fcInf);
296 }
297
298 /// Return true if it's known this can never be +infinity.
300 return isKnownNever(fcPosInf);
301 }
302
303 /// Return true if it's known this can never be -infinity.
305 return isKnownNever(fcNegInf);
306 }
307
308 /// Return true if it's known this can never be a subnormal
311 }
312
313 /// Return true if it's known this can never be a positive subnormal
316 }
317
318 /// Return true if it's known this can never be a negative subnormal
321 }
322
323 /// Return true if it's known this can never be a zero. This means a literal
324 /// [+-]0, and does not include denormal inputs implicitly treated as [+-]0.
325 bool isKnownNeverZero() const {
326 return isKnownNever(fcZero);
327 }
328
329 /// Return true if it's known this can never be a literal positive zero.
330 bool isKnownNeverPosZero() const {
331 return isKnownNever(fcPosZero);
332 }
333
334 /// Return true if it's known this can never be a negative zero. This means a
335 /// literal -0 and does not include denormal inputs implicitly treated as -0.
336 bool isKnownNeverNegZero() const {
337 return isKnownNever(fcNegZero);
338 }
339
340 /// Return true if it's know this can never be interpreted as a zero. This
341 /// extends isKnownNeverZero to cover the case where the assumed
342 /// floating-point mode for the function interprets denormals as zero.
343 bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const;
344
345 /// Return true if it's know this can never be interpreted as a negative zero.
346 bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const;
347
348 /// Return true if it's know this can never be interpreted as a positive zero.
349 bool isKnownNeverLogicalPosZero(const Function &F, Type *Ty) const;
350
355
356 /// Return true if we can prove that the analyzed floating-point value is
357 /// either NaN or never less than -0.0.
358 ///
359 /// NaN --> true
360 /// +0 --> true
361 /// -0 --> true
362 /// x > +0 --> true
363 /// x < -0 --> false
366 }
367
368 /// Return true if we can prove that the analyzed floating-point value is
369 /// either NaN or never greater than -0.0.
370 /// NaN --> true
371 /// +0 --> true
372 /// -0 --> true
373 /// x > +0 --> false
374 /// x < -0 --> true
377 }
378
380 KnownFPClasses = KnownFPClasses | RHS.KnownFPClasses;
381
382 if (SignBit != RHS.SignBit)
383 SignBit = std::nullopt;
384 return *this;
385 }
386
387 void knownNot(FPClassTest RuleOut) {
388 KnownFPClasses = KnownFPClasses & ~RuleOut;
389 if (isKnownNever(fcNan) && !SignBit) {
391 SignBit = false;
392 else if (isKnownNever(fcPositive))
393 SignBit = true;
394 }
395 }
396
397 void fneg() {
399 if (SignBit)
400 SignBit = !*SignBit;
401 }
402
403 void fabs() {
406
409
412
415
417 }
418
419 /// Return true if the sign bit must be 0, ignoring the sign of nans.
420 bool signBitIsZeroOrNaN() const {
421 return isKnownNever(fcNegative);
422 }
423
424 /// Assume the sign bit is zero.
427 SignBit = false;
428 }
429
430 /// Assume the sign bit is one.
433 SignBit = true;
434 }
435
436 void copysign(const KnownFPClass &Sign) {
437 // Don't know anything about the sign of the source. Expand the possible set
438 // to its opposite sign pair.
445 if (KnownFPClasses & fcInf)
447
448 // Sign bit is exactly preserved even for nans.
449 SignBit = Sign.SignBit;
450
451 // Clear sign bits based on the input sign mask.
452 if (Sign.isKnownNever(fcPositive | fcNan) || (SignBit && *SignBit))
454 if (Sign.isKnownNever(fcNegative | fcNan) || (SignBit && !*SignBit))
456 }
457
458 // Propagate knowledge that a non-NaN source implies the result can also not
459 // be a NaN. For unconstrained operations, signaling nans are not guaranteed
460 // to be quieted but cannot be introduced.
461 void propagateNaN(const KnownFPClass &Src, bool PreserveSign = false) {
462 if (Src.isKnownNever(fcNan)) {
464 if (PreserveSign)
465 SignBit = Src.SignBit;
466 } else if (Src.isKnownNever(fcSNan))
468 }
469
470 /// Propagate knowledge from a source value that could be a denormal or
471 /// zero. We have to be conservative since output flushing is not guaranteed,
472 /// so known-never-zero may not hold.
473 ///
474 /// This assumes a copy-like operation and will replace any currently known
475 /// information.
476 void propagateDenormal(const KnownFPClass &Src, const Function &F, Type *Ty);
477
478 /// Report known classes if \p Src is evaluated through a potentially
479 /// canonicalizing operation. We can assume signaling nans will not be
480 /// introduced, but cannot assume a denormal will be flushed under FTZ/DAZ.
481 ///
482 /// This assumes a copy-like operation and will replace any currently known
483 /// information.
484 void propagateCanonicalizingSrc(const KnownFPClass &Src, const Function &F,
485 Type *Ty);
486
487 void resetAll() { *this = KnownFPClass(); }
488};
489
491 LHS |= RHS;
492 return LHS;
493}
494
496 RHS |= LHS;
497 return std::move(RHS);
498}
499
500/// Determine which floating-point classes are valid for \p V, and return them
501/// in KnownFPClass bit sets.
502///
503/// This function is defined on values with floating-point type, values vectors
504/// of floating-point type, and arrays of floating-point type.
505
506/// \p InterestedClasses is a compile time optimization hint for which floating
507/// point classes should be queried. Queries not specified in \p
508/// InterestedClasses should be reliable if they are determined during the
509/// query.
510KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts,
511 FPClassTest InterestedClasses, unsigned Depth,
512 const SimplifyQuery &SQ);
513
514KnownFPClass computeKnownFPClass(const Value *V, FPClassTest InterestedClasses,
515 unsigned Depth, const SimplifyQuery &SQ);
516
518 const Value *V, const DataLayout &DL,
519 FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
520 const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
521 const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
522 bool UseInstrInfo = true) {
523 return computeKnownFPClass(
524 V, InterestedClasses, Depth,
525 SimplifyQuery(DL, TLI, DT, AC, CxtI, UseInstrInfo));
526}
527
528/// Wrapper to account for known fast math flags at the use instruction.
529inline KnownFPClass
530computeKnownFPClass(const Value *V, const APInt &DemandedElts,
531 FastMathFlags FMF, FPClassTest InterestedClasses,
532 unsigned Depth, const SimplifyQuery &SQ) {
533 if (FMF.noNaNs())
534 InterestedClasses &= ~fcNan;
535 if (FMF.noInfs())
536 InterestedClasses &= ~fcInf;
537
538 KnownFPClass Result =
539 computeKnownFPClass(V, DemandedElts, InterestedClasses, Depth, SQ);
540
541 if (FMF.noNaNs())
542 Result.KnownFPClasses &= ~fcNan;
543 if (FMF.noInfs())
544 Result.KnownFPClasses &= ~fcInf;
545 return Result;
546}
547
549 FPClassTest InterestedClasses,
550 unsigned Depth,
551 const SimplifyQuery &SQ) {
552 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
553 APInt DemandedElts =
554 FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
555 return computeKnownFPClass(V, DemandedElts, FMF, InterestedClasses, Depth,
556 SQ);
557}
558
559/// Return true if we can prove that the specified FP value is never equal to
560/// -0.0. Users should use caution when considering PreserveSign
561/// denormal-fp-math.
562inline bool cannotBeNegativeZero(const Value *V, unsigned Depth,
563 const SimplifyQuery &SQ) {
565 return Known.isKnownNeverNegZero();
566}
567
568/// Return true if we can prove that the specified FP value is either NaN or
569/// never less than -0.0.
570///
571/// NaN --> true
572/// +0 --> true
573/// -0 --> true
574/// x > +0 --> true
575/// x < -0 --> false
576inline bool cannotBeOrderedLessThanZero(const Value *V, unsigned Depth,
577 const SimplifyQuery &SQ) {
578 KnownFPClass Known =
580 return Known.cannotBeOrderedLessThanZero();
581}
582
583/// Return true if the floating-point scalar value is not an infinity or if
584/// the floating-point vector value has no infinities. Return false if a value
585/// could ever be infinity.
586inline bool isKnownNeverInfinity(const Value *V, unsigned Depth,
587 const SimplifyQuery &SQ) {
589 return Known.isKnownNeverInfinity();
590}
591
592/// Return true if the floating-point value can never contain a NaN or infinity.
593inline bool isKnownNeverInfOrNaN(const Value *V, unsigned Depth,
594 const SimplifyQuery &SQ) {
596 return Known.isKnownNeverNaN() && Known.isKnownNeverInfinity();
597}
598
599/// Return true if the floating-point scalar value is not a NaN or if the
600/// floating-point vector value has no NaN elements. Return false if a value
601/// could ever be NaN.
602inline bool isKnownNeverNaN(const Value *V, unsigned Depth,
603 const SimplifyQuery &SQ) {
605 return Known.isKnownNeverNaN();
606}
607
608/// Return false if we can prove that the specified FP value's sign bit is 0.
609/// Return true if we can prove that the specified FP value's sign bit is 1.
610/// Otherwise return std::nullopt.
611inline std::optional<bool> computeKnownFPSignBit(const Value *V, unsigned Depth,
612 const SimplifyQuery &SQ) {
614 return Known.SignBit;
615}
616
617/// If the specified value can be set by repeating the same byte in memory,
618/// return the i8 value that it is represented with. This is true for all i8
619/// values obviously, but is also true for i32 0, i32 -1, i16 0xF0F0, double
620/// 0.0 etc. If the value can't be handled with a repeated byte store (e.g.
621/// i16 0x1234), return null. If the value is entirely undef and padding,
622/// return undef.
623Value *isBytewiseValue(Value *V, const DataLayout &DL);
624
625/// Given an aggregate and an sequence of indices, see if the scalar value
626/// indexed is already around as a register, for example if it were inserted
627/// directly into the aggregate.
628///
629/// If InsertBefore is not empty, this function will duplicate (modified)
630/// insertvalues when a part of a nested struct is extracted.
631Value *FindInsertedValue(
632 Value *V, ArrayRef<unsigned> idx_range,
633 std::optional<BasicBlock::iterator> InsertBefore = std::nullopt);
634
635/// Analyze the specified pointer to see if it can be expressed as a base
636/// pointer plus a constant offset. Return the base and offset to the caller.
637///
638/// This is a wrapper around Value::stripAndAccumulateConstantOffsets that
639/// creates and later unpacks the required APInt.
641 const DataLayout &DL,
642 bool AllowNonInbounds = true) {
643 APInt OffsetAPInt(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
644 Value *Base =
645 Ptr->stripAndAccumulateConstantOffsets(DL, OffsetAPInt, AllowNonInbounds);
646
647 Offset = OffsetAPInt.getSExtValue();
648 return Base;
649}
650inline const Value *
652 const DataLayout &DL,
653 bool AllowNonInbounds = true) {
654 return GetPointerBaseWithConstantOffset(const_cast<Value *>(Ptr), Offset, DL,
655 AllowNonInbounds);
656}
657
658/// Returns true if the GEP is based on a pointer to a string (array of
659// \p CharSize integers) and is indexing into this string.
660bool isGEPBasedOnPointerToString(const GEPOperator *GEP, unsigned CharSize = 8);
661
662/// Represents offset+length into a ConstantDataArray.
664 /// ConstantDataArray pointer. nullptr indicates a zeroinitializer (a valid
665 /// initializer, it just doesn't fit the ConstantDataArray interface).
667
668 /// Slice starts at this Offset.
670
671 /// Length of the slice.
673
674 /// Moves the Offset and adjusts Length accordingly.
675 void move(uint64_t Delta) {
676 assert(Delta < Length);
677 Offset += Delta;
678 Length -= Delta;
679 }
680
681 /// Convenience accessor for elements in the slice.
682 uint64_t operator[](unsigned I) const {
683 return Array == nullptr ? 0 : Array->getElementAsInteger(I + Offset);
684 }
685};
686
687/// Returns true if the value \p V is a pointer into a ConstantDataArray.
688/// If successful \p Slice will point to a ConstantDataArray info object
689/// with an appropriate offset.
690bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice,
691 unsigned ElementSize, uint64_t Offset = 0);
692
693/// This function computes the length of a null-terminated C string pointed to
694/// by V. If successful, it returns true and returns the string in Str. If
695/// unsuccessful, it returns false. This does not include the trailing null
696/// character by default. If TrimAtNul is set to false, then this returns any
697/// trailing null characters as well as any other characters that come after
698/// it.
699bool getConstantStringInfo(const Value *V, StringRef &Str,
700 bool TrimAtNul = true);
701
702/// If we can compute the length of the string pointed to by the specified
703/// pointer, return 'len+1'. If we can't, return 0.
704uint64_t GetStringLength(const Value *V, unsigned CharSize = 8);
705
706/// This function returns call pointer argument that is considered the same by
707/// aliasing rules. You CAN'T use it to replace one value with another. If
708/// \p MustPreserveNullness is true, the call must preserve the nullness of
709/// the pointer.
710const Value *getArgumentAliasingToReturnedPointer(const CallBase *Call,
711 bool MustPreserveNullness);
713 bool MustPreserveNullness) {
714 return const_cast<Value *>(getArgumentAliasingToReturnedPointer(
715 const_cast<const CallBase *>(Call), MustPreserveNullness));
716}
717
718/// {launder,strip}.invariant.group returns pointer that aliases its argument,
719/// and it only captures pointer by returning it.
720/// These intrinsics are not marked as nocapture, because returning is
721/// considered as capture. The arguments are not marked as returned neither,
722/// because it would make it useless. If \p MustPreserveNullness is true,
723/// the intrinsic must preserve the nullness of the pointer.
725 const CallBase *Call, bool MustPreserveNullness);
726
727/// This method strips off any GEP address adjustments, pointer casts
728/// or `llvm.threadlocal.address` from the specified value \p V, returning the
729/// original object being addressed. Note that the returned value has pointer
730/// type if the specified value does. If the \p MaxLookup value is non-zero, it
731/// limits the number of instructions to be stripped off.
732const Value *getUnderlyingObject(const Value *V, unsigned MaxLookup = 6);
733inline Value *getUnderlyingObject(Value *V, unsigned MaxLookup = 6) {
734 // Force const to avoid infinite recursion.
735 const Value *VConst = V;
736 return const_cast<Value *>(getUnderlyingObject(VConst, MaxLookup));
737}
738
739/// Like getUnderlyingObject(), but will try harder to find a single underlying
740/// object. In particular, this function also looks through selects and phis.
741const Value *getUnderlyingObjectAggressive(const Value *V);
742
743/// This method is similar to getUnderlyingObject except that it can
744/// look through phi and select instructions and return multiple objects.
745///
746/// If LoopInfo is passed, loop phis are further analyzed. If a pointer
747/// accesses different objects in each iteration, we don't look through the
748/// phi node. E.g. consider this loop nest:
749///
750/// int **A;
751/// for (i)
752/// for (j) {
753/// A[i][j] = A[i-1][j] * B[j]
754/// }
755///
756/// This is transformed by Load-PRE to stash away A[i] for the next iteration
757/// of the outer loop:
758///
759/// Curr = A[0]; // Prev_0
760/// for (i: 1..N) {
761/// Prev = Curr; // Prev = PHI (Prev_0, Curr)
762/// Curr = A[i];
763/// for (j: 0..N) {
764/// Curr[j] = Prev[j] * B[j]
765/// }
766/// }
767///
768/// Since A[i] and A[i-1] are independent pointers, getUnderlyingObjects
769/// should not assume that Curr and Prev share the same underlying object thus
770/// it shouldn't look through the phi above.
771void getUnderlyingObjects(const Value *V,
772 SmallVectorImpl<const Value *> &Objects,
773 const LoopInfo *LI = nullptr, unsigned MaxLookup = 6);
774
775/// This is a wrapper around getUnderlyingObjects and adds support for basic
776/// ptrtoint+arithmetic+inttoptr sequences.
777bool getUnderlyingObjectsForCodeGen(const Value *V,
778 SmallVectorImpl<Value *> &Objects);
779
780/// Returns unique alloca where the value comes from, or nullptr.
781/// If OffsetZero is true check that V points to the begining of the alloca.
782AllocaInst *findAllocaForValue(Value *V, bool OffsetZero = false);
783inline const AllocaInst *findAllocaForValue(const Value *V,
784 bool OffsetZero = false) {
785 return findAllocaForValue(const_cast<Value *>(V), OffsetZero);
786}
787
788/// Return true if the only users of this pointer are lifetime markers.
789bool onlyUsedByLifetimeMarkers(const Value *V);
790
791/// Return true if the only users of this pointer are lifetime markers or
792/// droppable instructions.
794
795/// Return true if the instruction does not have any effects besides
796/// calculating the result and does not have undefined behavior.
797///
798/// This method never returns true for an instruction that returns true for
799/// mayHaveSideEffects; however, this method also does some other checks in
800/// addition. It checks for undefined behavior, like dividing by zero or
801/// loading from an invalid pointer (but not for undefined results, like a
802/// shift with a shift amount larger than the width of the result). It checks
803/// for malloc and alloca because speculatively executing them might cause a
804/// memory leak. It also returns false for instructions related to control
805/// flow, specifically terminators and PHI nodes.
806///
807/// If the CtxI is specified this method performs context-sensitive analysis
808/// and returns true if it is safe to execute the instruction immediately
809/// before the CtxI.
810///
811/// If the CtxI is NOT specified this method only looks at the instruction
812/// itself and its operands, so if this method returns true, it is safe to
813/// move the instruction as long as the correct dominance relationships for
814/// the operands and users hold.
815///
816/// This method can return true for instructions that read memory;
817/// for such instructions, moving them may change the resulting value.
818bool isSafeToSpeculativelyExecute(const Instruction *I,
819 const Instruction *CtxI = nullptr,
820 AssumptionCache *AC = nullptr,
821 const DominatorTree *DT = nullptr,
822 const TargetLibraryInfo *TLI = nullptr,
823 bool UseVariableInfo = true);
824
827 AssumptionCache *AC = nullptr,
828 const DominatorTree *DT = nullptr,
829 const TargetLibraryInfo *TLI = nullptr,
830 bool UseVariableInfo = true) {
831 // Take an iterator, and unwrap it into an Instruction *.
832 return isSafeToSpeculativelyExecute(I, &*CtxI, AC, DT, TLI, UseVariableInfo);
833}
834
835/// Don't use information from its non-constant operands. This helper is used
836/// when its operands are going to be replaced.
837inline bool
839 return isSafeToSpeculativelyExecute(I, nullptr, nullptr, nullptr, nullptr,
840 /*UseVariableInfo=*/false);
841}
842
843/// This returns the same result as isSafeToSpeculativelyExecute if Opcode is
844/// the actual opcode of Inst. If the provided and actual opcode differ, the
845/// function (virtually) overrides the opcode of Inst with the provided
846/// Opcode. There are come constraints in this case:
847/// * If Opcode has a fixed number of operands (eg, as binary operators do),
848/// then Inst has to have at least as many leading operands. The function
849/// will ignore all trailing operands beyond that number.
850/// * If Opcode allows for an arbitrary number of operands (eg, as CallInsts
851/// do), then all operands are considered.
852/// * The virtual instruction has to satisfy all typing rules of the provided
853/// Opcode.
854/// * This function is pessimistic in the following sense: If one actually
855/// materialized the virtual instruction, then isSafeToSpeculativelyExecute
856/// may say that the materialized instruction is speculatable whereas this
857/// function may have said that the instruction wouldn't be speculatable.
858/// This behavior is a shortcoming in the current implementation and not
859/// intentional.
861 unsigned Opcode, const Instruction *Inst, const Instruction *CtxI = nullptr,
862 AssumptionCache *AC = nullptr, const DominatorTree *DT = nullptr,
863 const TargetLibraryInfo *TLI = nullptr, bool UseVariableInfo = true);
864
865/// Returns true if the result or effects of the given instructions \p I
866/// depend values not reachable through the def use graph.
867/// * Memory dependence arises for example if the instruction reads from
868/// memory or may produce effects or undefined behaviour. Memory dependent
869/// instructions generally cannot be reorderd with respect to other memory
870/// dependent instructions.
871/// * Control dependence arises for example if the instruction may fault
872/// if lifted above a throwing call or infinite loop.
873bool mayHaveNonDefUseDependency(const Instruction &I);
874
875/// Return true if it is an intrinsic that cannot be speculated but also
876/// cannot trap.
877bool isAssumeLikeIntrinsic(const Instruction *I);
878
879/// Return true if it is valid to use the assumptions provided by an
880/// assume intrinsic, I, at the point in the control-flow identified by the
881/// context instruction, CxtI. By default, ephemeral values of the assumption
882/// are treated as an invalid context, to prevent the assumption from being used
883/// to optimize away its argument. If the caller can ensure that this won't
884/// happen, it can call with AllowEphemerals set to true to get more valid
885/// assumptions.
886bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI,
887 const DominatorTree *DT = nullptr,
888 bool AllowEphemerals = false);
889
890enum class OverflowResult {
891 /// Always overflows in the direction of signed/unsigned min value.
893 /// Always overflows in the direction of signed/unsigned max value.
895 /// May or may not overflow.
897 /// Never overflows.
899};
900
901OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS,
902 const SimplifyQuery &SQ,
903 bool IsNSW = false);
904OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS,
905 const SimplifyQuery &SQ);
907computeOverflowForUnsignedAdd(const WithCache<const Value *> &LHS,
908 const WithCache<const Value *> &RHS,
909 const SimplifyQuery &SQ);
910OverflowResult computeOverflowForSignedAdd(const WithCache<const Value *> &LHS,
911 const WithCache<const Value *> &RHS,
912 const SimplifyQuery &SQ);
913/// This version also leverages the sign bit of Add if known.
915 const SimplifyQuery &SQ);
916OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS,
917 const SimplifyQuery &SQ);
918OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS,
919 const SimplifyQuery &SQ);
920
921/// Returns true if the arithmetic part of the \p WO 's result is
922/// used only along the paths control dependent on the computation
923/// not overflowing, \p WO being an <op>.with.overflow intrinsic.
924bool isOverflowIntrinsicNoWrap(const WithOverflowInst *WO,
925 const DominatorTree &DT);
926
927/// Determine the possible constant range of vscale with the given bit width,
928/// based on the vscale_range function attribute.
929ConstantRange getVScaleRange(const Function *F, unsigned BitWidth);
930
931/// Determine the possible constant range of an integer or vector of integer
932/// value. This is intended as a cheap, non-recursive check.
933ConstantRange computeConstantRange(const Value *V, bool ForSigned,
934 bool UseInstrInfo = true,
935 AssumptionCache *AC = nullptr,
936 const Instruction *CtxI = nullptr,
937 const DominatorTree *DT = nullptr,
938 unsigned Depth = 0);
939
940/// Combine constant ranges from computeConstantRange() and computeKnownBits().
941ConstantRange
942computeConstantRangeIncludingKnownBits(const WithCache<const Value *> &V,
943 bool ForSigned, const SimplifyQuery &SQ);
944
945/// Return true if this function can prove that the instruction I will
946/// always transfer execution to one of its successors (including the next
947/// instruction that follows within a basic block). E.g. this is not
948/// guaranteed for function calls that could loop infinitely.
949///
950/// In other words, this function returns false for instructions that may
951/// transfer execution or fail to transfer execution in a way that is not
952/// captured in the CFG nor in the sequence of instructions within a basic
953/// block.
954///
955/// Undefined behavior is assumed not to happen, so e.g. division is
956/// guaranteed to transfer execution to the following instruction even
957/// though division by zero might cause undefined behavior.
958bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I);
959
960/// Returns true if this block does not contain a potential implicit exit.
961/// This is equivelent to saying that all instructions within the basic block
962/// are guaranteed to transfer execution to their successor within the basic
963/// block. This has the same assumptions w.r.t. undefined behavior as the
964/// instruction variant of this function.
965bool isGuaranteedToTransferExecutionToSuccessor(const BasicBlock *BB);
966
967/// Return true if every instruction in the range (Begin, End) is
968/// guaranteed to transfer execution to its static successor. \p ScanLimit
969/// bounds the search to avoid scanning huge blocks.
972 unsigned ScanLimit = 32);
973
974/// Same as previous, but with range expressed via iterator_range.
976 iterator_range<BasicBlock::const_iterator> Range, unsigned ScanLimit = 32);
977
978/// Return true if this function can prove that the instruction I
979/// is executed for every iteration of the loop L.
980///
981/// Note that this currently only considers the loop header.
982bool isGuaranteedToExecuteForEveryIteration(const Instruction *I,
983 const Loop *L);
984
985/// Return true if \p PoisonOp's user yields poison or raises UB if its
986/// operand \p PoisonOp is poison.
987///
988/// If \p PoisonOp is a vector or an aggregate and the operation's result is a
989/// single value, any poison element in /p PoisonOp should make the result
990/// poison or raise UB.
991///
992/// To filter out operands that raise UB on poison, you can use
993/// getGuaranteedNonPoisonOp.
994bool propagatesPoison(const Use &PoisonOp);
995
996/// Insert operands of I into Ops such that I will trigger undefined behavior
997/// if I is executed and that operand has a poison value.
998void getGuaranteedNonPoisonOps(const Instruction *I,
999 SmallVectorImpl<const Value *> &Ops);
1000
1001/// Insert operands of I into Ops such that I will trigger undefined behavior
1002/// if I is executed and that operand is not a well-defined value
1003/// (i.e. has undef bits or poison).
1004void getGuaranteedWellDefinedOps(const Instruction *I,
1005 SmallVectorImpl<const Value *> &Ops);
1006
1007/// Return true if the given instruction must trigger undefined behavior
1008/// when I is executed with any operands which appear in KnownPoison holding
1009/// a poison value at the point of execution.
1010bool mustTriggerUB(const Instruction *I,
1011 const SmallPtrSetImpl<const Value *> &KnownPoison);
1012
1013/// Return true if this function can prove that if Inst is executed
1014/// and yields a poison value or undef bits, then that will trigger
1015/// undefined behavior.
1016///
1017/// Note that this currently only considers the basic block that is
1018/// the parent of Inst.
1019bool programUndefinedIfUndefOrPoison(const Instruction *Inst);
1020bool programUndefinedIfPoison(const Instruction *Inst);
1021
1022/// canCreateUndefOrPoison returns true if Op can create undef or poison from
1023/// non-undef & non-poison operands.
1024/// For vectors, canCreateUndefOrPoison returns true if there is potential
1025/// poison or undef in any element of the result when vectors without
1026/// undef/poison poison are given as operands.
1027/// For example, given `Op = shl <2 x i32> %x, <0, 32>`, this function returns
1028/// true. If Op raises immediate UB but never creates poison or undef
1029/// (e.g. sdiv I, 0), canCreatePoison returns false.
1030///
1031/// \p ConsiderFlagsAndMetadata controls whether poison producing flags and
1032/// metadata on the instruction are considered. This can be used to see if the
1033/// instruction could still introduce undef or poison even without poison
1034/// generating flags and metadata which might be on the instruction.
1035/// (i.e. could the result of Op->dropPoisonGeneratingFlags() still create
1036/// poison or undef)
1037///
1038/// canCreatePoison returns true if Op can create poison from non-poison
1039/// operands.
1040bool canCreateUndefOrPoison(const Operator *Op,
1041 bool ConsiderFlagsAndMetadata = true);
1042bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata = true);
1043
1044/// Return true if V is poison given that ValAssumedPoison is already poison.
1045/// For example, if ValAssumedPoison is `icmp X, 10` and V is `icmp X, 5`,
1046/// impliesPoison returns true.
1047bool impliesPoison(const Value *ValAssumedPoison, const Value *V);
1048
1049/// Return true if this function can prove that V does not have undef bits
1050/// and is never poison. If V is an aggregate value or vector, check whether
1051/// all elements (except padding) are not undef or poison.
1052/// Note that this is different from canCreateUndefOrPoison because the
1053/// function assumes Op's operands are not poison/undef.
1054///
1055/// If CtxI and DT are specified this method performs flow-sensitive analysis
1056/// and returns true if it is guaranteed to be never undef or poison
1057/// immediately before the CtxI.
1058bool isGuaranteedNotToBeUndefOrPoison(const Value *V,
1059 AssumptionCache *AC = nullptr,
1060 const Instruction *CtxI = nullptr,
1061 const DominatorTree *DT = nullptr,
1062 unsigned Depth = 0);
1063
1064/// Returns true if V cannot be poison, but may be undef.
1065bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC = nullptr,
1066 const Instruction *CtxI = nullptr,
1067 const DominatorTree *DT = nullptr,
1068 unsigned Depth = 0);
1069
1072 const DominatorTree *DT = nullptr,
1073 unsigned Depth = 0) {
1074 // Takes an iterator as a position, passes down to Instruction *
1075 // implementation.
1076 return isGuaranteedNotToBePoison(V, AC, &*CtxI, DT, Depth);
1077}
1078
1079/// Returns true if V cannot be undef, but may be poison.
1080bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC = nullptr,
1081 const Instruction *CtxI = nullptr,
1082 const DominatorTree *DT = nullptr,
1083 unsigned Depth = 0);
1084
1085/// Return true if undefined behavior would provable be executed on the path to
1086/// OnPathTo if Root produced a posion result. Note that this doesn't say
1087/// anything about whether OnPathTo is actually executed or whether Root is
1088/// actually poison. This can be used to assess whether a new use of Root can
1089/// be added at a location which is control equivalent with OnPathTo (such as
1090/// immediately before it) without introducing UB which didn't previously
1091/// exist. Note that a false result conveys no information.
1092bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root,
1093 Instruction *OnPathTo,
1094 DominatorTree *DT);
1095
1096/// Specific patterns of select instructions we can match.
1099 SPF_SMIN, /// Signed minimum
1100 SPF_UMIN, /// Unsigned minimum
1101 SPF_SMAX, /// Signed maximum
1102 SPF_UMAX, /// Unsigned maximum
1103 SPF_FMINNUM, /// Floating point minnum
1104 SPF_FMAXNUM, /// Floating point maxnum
1105 SPF_ABS, /// Absolute value
1106 SPF_NABS /// Negated absolute value
1108
1109/// Behavior when a floating point min/max is given one NaN and one
1110/// non-NaN as input.
1112 SPNB_NA = 0, /// NaN behavior not applicable.
1113 SPNB_RETURNS_NAN, /// Given one NaN input, returns the NaN.
1114 SPNB_RETURNS_OTHER, /// Given one NaN input, returns the non-NaN.
1115 SPNB_RETURNS_ANY /// Given one NaN input, can return either (or
1116 /// it has been determined that no operands can
1117 /// be NaN).
1119
1122 SelectPatternNaNBehavior NaNBehavior; /// Only applicable if Flavor is
1123 /// SPF_FMINNUM or SPF_FMAXNUM.
1124 bool Ordered; /// When implementing this min/max pattern as
1125 /// fcmp; select, does the fcmp have to be
1126 /// ordered?
1127
1128 /// Return true if \p SPF is a min or a max pattern.
1130 return SPF != SPF_UNKNOWN && SPF != SPF_ABS && SPF != SPF_NABS;
1131 }
1132};
1133
1134/// Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind
1135/// and providing the out parameter results if we successfully match.
1136///
1137/// For ABS/NABS, LHS will be set to the input to the abs idiom. RHS will be
1138/// the negation instruction from the idiom.
1139///
1140/// If CastOp is not nullptr, also match MIN/MAX idioms where the type does
1141/// not match that of the original select. If this is the case, the cast
1142/// operation (one of Trunc,SExt,Zext) that must be done to transform the
1143/// type of LHS and RHS into the type of V is returned in CastOp.
1144///
1145/// For example:
1146/// %1 = icmp slt i32 %a, i32 4
1147/// %2 = sext i32 %a to i64
1148/// %3 = select i1 %1, i64 %2, i64 4
1149///
1150/// -> LHS = %a, RHS = i32 4, *CastOp = Instruction::SExt
1151///
1152SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,
1153 Instruction::CastOps *CastOp = nullptr,
1154 unsigned Depth = 0);
1155
1157 const Value *&RHS) {
1158 Value *L = const_cast<Value *>(LHS);
1159 Value *R = const_cast<Value *>(RHS);
1160 auto Result = matchSelectPattern(const_cast<Value *>(V), L, R);
1161 LHS = L;
1162 RHS = R;
1163 return Result;
1164}
1165
1166/// Determine the pattern that a select with the given compare as its
1167/// predicate and given values as its true/false operands would match.
1168SelectPatternResult matchDecomposedSelectPattern(
1169 CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS,
1170 Instruction::CastOps *CastOp = nullptr, unsigned Depth = 0);
1171
1172/// Return the canonical comparison predicate for the specified
1173/// minimum/maximum flavor.
1174CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered = false);
1175
1176/// Return the inverse minimum/maximum flavor of the specified flavor.
1177/// For example, signed minimum is the inverse of signed maximum.
1179
1181
1182/// Return the minimum or maximum constant value for the specified integer
1183/// min/max flavor and type.
1184APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth);
1185
1186/// Check if the values in \p VL are select instructions that can be converted
1187/// to a min or max (vector) intrinsic. Returns the intrinsic ID, if such a
1188/// conversion is possible, together with a bool indicating whether all select
1189/// conditions are only used by the selects. Otherwise return
1190/// Intrinsic::not_intrinsic.
1191std::pair<Intrinsic::ID, bool>
1192canConvertToMinOrMaxIntrinsic(ArrayRef<Value *> VL);
1193
1194/// Attempt to match a simple first order recurrence cycle of the form:
1195/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge]
1196/// %inc = binop %iv, %step
1197/// OR
1198/// %iv = phi Ty [%Start, %Entry], [%Inc, %backedge]
1199/// %inc = binop %step, %iv
1200///
1201/// A first order recurrence is a formula with the form: X_n = f(X_(n-1))
1202///
1203/// A couple of notes on subtleties in that definition:
1204/// * The Step does not have to be loop invariant. In math terms, it can
1205/// be a free variable. We allow recurrences with both constant and
1206/// variable coefficients. Callers may wish to filter cases where Step
1207/// does not dominate P.
1208/// * For non-commutative operators, we will match both forms. This
1209/// results in some odd recurrence structures. Callers may wish to filter
1210/// out recurrences where the phi is not the LHS of the returned operator.
1211/// * Because of the structure matched, the caller can assume as a post
1212/// condition of the match the presence of a Loop with P's parent as it's
1213/// header *except* in unreachable code. (Dominance decays in unreachable
1214/// code.)
1215///
1216/// NOTE: This is intentional simple. If you want the ability to analyze
1217/// non-trivial loop conditons, see ScalarEvolution instead.
1218bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start,
1219 Value *&Step);
1220
1221/// Analogous to the above, but starting from the binary operator
1222bool matchSimpleRecurrence(const BinaryOperator *I, PHINode *&P, Value *&Start,
1223 Value *&Step);
1224
1225/// Return true if RHS is known to be implied true by LHS. Return false if
1226/// RHS is known to be implied false by LHS. Otherwise, return std::nullopt if
1227/// no implication can be made. A & B must be i1 (boolean) values or a vector of
1228/// such values. Note that the truth table for implication is the same as <=u on
1229/// i1 values (but not
1230/// <=s!). The truth table for both is:
1231/// | T | F (B)
1232/// T | T | F
1233/// F | T | T
1234/// (A)
1235std::optional<bool> isImpliedCondition(const Value *LHS, const Value *RHS,
1236 const DataLayout &DL,
1237 bool LHSIsTrue = true,
1238 unsigned Depth = 0);
1239std::optional<bool> isImpliedCondition(const Value *LHS,
1240 CmpInst::Predicate RHSPred,
1241 const Value *RHSOp0, const Value *RHSOp1,
1242 const DataLayout &DL,
1243 bool LHSIsTrue = true,
1244 unsigned Depth = 0);
1245
1246/// Return the boolean condition value in the context of the given instruction
1247/// if it is known based on dominating conditions.
1248std::optional<bool> isImpliedByDomCondition(const Value *Cond,
1249 const Instruction *ContextI,
1250 const DataLayout &DL);
1251std::optional<bool> isImpliedByDomCondition(CmpInst::Predicate Pred,
1252 const Value *LHS, const Value *RHS,
1253 const Instruction *ContextI,
1254 const DataLayout &DL);
1255
1256/// Call \p InsertAffected on all Values whose known bits / value may be
1257/// affected by the condition \p Cond. Used by AssumptionCache and
1258/// DomConditionCache.
1259void findValuesAffectedByCondition(Value *Cond, bool IsAssume,
1260 function_ref<void(Value *)> InsertAffected);
1261
1262} // end namespace llvm
1263
1264#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...
bool End
Definition: ELF_riscv.cpp:480
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Hexagon Common GEP
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
#define P(N)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:78
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
Definition: APInt.h:214
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1522
an instruction to allocate memory on the stack
Definition: Instructions.h:61
A cache of @llvm.assume calls within a function.
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:178
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:177
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1236
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:757
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:693
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
Definition: Constants.cpp:3074
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:162
Convenience struct for specifying and reasoning about fast-math flags.
Definition: FMF.h:20
bool noInfs() const
Definition: FMF.h:67
bool noNaNs() const
Definition: FMF.h:66
Metadata node.
Definition: Metadata.h:1069
This is a utility class that provides an abstraction for the common functionality between Instruction...
Definition: Operator.h:32
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.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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)
@ Offset
Definition: DWP.cpp:480
OverflowResult
@ 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 MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &DL, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
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 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
Definition: ValueTracking.h:48
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_UNKNOWN
@ 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.
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 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.
@ Other
Any other memory.
const Value * getUnderlyingObjectAggressive(const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
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 isKnownNegative(const Value *V, const SimplifyQuery &DL, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
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.
@ Add
Sum of integers.
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.
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:191
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...
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)
Definition: APInt.h:2092
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 isUnknown() const
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