LLVM: llvm::SCEVWrapPredicate Class Reference (original) (raw)

This class represents an assumption made on an AddRec expression. More...

#include "[llvm/Analysis/ScalarEvolution.h](ScalarEvolution%5F8h%5Fsource.html)"

Public Member Functions
SCEVWrapPredicate (const FoldingSetNodeIDRef ID, const SCEVAddRecExpr *AR, IncrementWrapFlags Flags)
IncrementWrapFlags getFlags () const
Returns the set assumed no overflow flags.
const SCEVAddRecExpr * getExpr () const
Implementation of the SCEVPredicate interface.
bool implies (const SCEVPredicate *N, ScalarEvolution &SE) const override
Returns true if this predicate implies N.
void print (raw_ostream &OS, unsigned Depth=0) const override
Prints a textual representation of this predicate with an indentation of Depth.
bool isAlwaysTrue () const override
Returns true if the predicate is always true.
Public Member Functions inherited from llvm::SCEVPredicate
LLVM_ABI SCEVPredicate (const FoldingSetNodeIDRef ID, SCEVPredicateKind Kind)
SCEV predicates.
SCEVPredicateKind getKind () const
virtual unsigned getComplexity () const
Returns the estimated complexity of this predicate.
Public Member Functions inherited from llvm::FoldingSetBase::Node
Node ()=default
void * getNextInBucket () const
void SetNextInBucket (void *N)
Static Public Member Functions
static SCEVWrapPredicate::IncrementWrapFlags clearFlags (SCEVWrapPredicate::IncrementWrapFlags Flags, SCEVWrapPredicate::IncrementWrapFlags OffFlags)
Convenient IncrementWrapFlags manipulation methods.
static SCEVWrapPredicate::IncrementWrapFlags maskFlags (SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask)
static SCEVWrapPredicate::IncrementWrapFlags setFlags (SCEVWrapPredicate::IncrementWrapFlags Flags, SCEVWrapPredicate::IncrementWrapFlags OnFlags)
static SCEVWrapPredicate::IncrementWrapFlags getImpliedFlags (const SCEVAddRecExpr *AR, ScalarEvolution &SE)
Returns the set of SCEVWrapPredicate no wrap flags implied by a SCEVAddRecExpr.
static bool classof (const SCEVPredicate *P)
Methods for support type inquiry through isa, cast, and dyn_cast:
Additional Inherited Members
Protected Member Functions inherited from llvm::SCEVPredicate
~SCEVPredicate ()=default
SCEVPredicate (const SCEVPredicate &)=default
SCEVPredicate & operator= (const SCEVPredicate &)=default
Protected Attributes inherited from llvm::SCEVPredicate
SCEVPredicateKind Kind

This class represents an assumption made on an AddRec expression.

Given an affine AddRec expression {a,+,b}, we assume that it has the nssw or nusw flags (defined below) in the first X iterations of the loop, where X is a SCEV expression returned by getPredicatedBackedgeTakenCount).

Note that this does not imply that X is equal to the backedge taken count. This means that if we have a nusw predicate for i32 {0,+,1} with a predicated backedge taken count of X, we only guarantee that {0,+,1} has nusw in the first X iterations. {0,+,1} may still wrap in the loop if we have more than X iterations.

Definition at line 318 of file ScalarEvolution.h.

◆ IncrementWrapFlags

Similar to SCEV::NoWrapFlags, but with slightly different semantics for FlagNUSW.

The increment is considered to be signed, and a + b (where b is the increment) is considered to wrap if: zext(a + b) != zext(a) + sext(b)

If Signed is a function that takes an n-bit tuple and maps to the integer domain as the tuples value interpreted as twos complement, and Unsigned a function that takes an n-bit tuple and maps to the integer domain as the base two value of input tuple, then a + b has IncrementNUSW iff:

0 <= Unsigned(a) + Signed(b) < 2^n

The IncrementNSSW flag has identical semantics with SCEV::FlagNSW.

Note that the IncrementNUSW flag is not commutative: if base + inc has IncrementNUSW, then inc + base doesn't neccessarily have this property. The reason for this is that this is used for sign/zero extending affine AddRec SCEV expressions when a SCEVWrapPredicate is assumed. A {base,+,inc} expression is already non-commutative with regards to base and inc, since it is interpreted as: (((base + inc) + inc) + inc) ...

Enumerator
IncrementAnyWrap
IncrementNUSW
IncrementNSSW
IncrementNoWrapMask

Definition at line 342 of file ScalarEvolution.h.

◆ classof()

◆ clearFlags()

SCEVWrapPredicate::IncrementWrapFlags llvm::SCEVWrapPredicate::clearFlags ( SCEVWrapPredicate::IncrementWrapFlags Flags, SCEVWrapPredicate::IncrementWrapFlags OffFlags ) inlinestaticnodiscard

◆ getExpr()

◆ getFlags()

IncrementWrapFlags llvm::SCEVWrapPredicate::getFlags ( ) const inline

◆ getImpliedFlags()

◆ implies()

Returns true if this predicate implies N.

Implements llvm::SCEVPredicate.

Definition at line 15110 of file ScalarEvolution.cpp.

References llvm::dyn_cast(), llvm::ScalarEvolution::getNoopOrSignExtend(), llvm::ScalarEvolution::getNoopOrZeroExtend(), llvm::SCEV::getType(), llvm::ScalarEvolution::getWiderType(), llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_ULE, IncrementNSSW, IncrementNUSW, llvm::ScalarEvolution::isKnownPositive(), llvm::ScalarEvolution::isKnownPredicate(), llvm::Type::isPointerTy(), N, llvm::SCEVPredicate::SCEVPredicate(), and setFlags().

◆ isAlwaysTrue()

bool SCEVWrapPredicate::isAlwaysTrue ( ) const overridevirtual

◆ maskFlags()

SCEVWrapPredicate::IncrementWrapFlags llvm::SCEVWrapPredicate::maskFlags ( SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask ) inlinestaticnodiscard

◆ print()

◆ setFlags()

The documentation for this class was generated from the following files: