reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Analysis/ScalarEvolution.h
  335   LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
  336   clearFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
  337              SCEVWrapPredicate::IncrementWrapFlags OffFlags) {
  344   LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
  345   maskFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask) {
  352   LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
  353   setFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
  354            SCEVWrapPredicate::IncrementWrapFlags OnFlags) {
  364   LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
 1079                    SCEVWrapPredicate::IncrementWrapFlags AddedFlags);
 1992   void setNoOverflow(Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags);
 1996   bool hasNoOverflow(Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags);
 2030   ValueMap<Value *, SCEVWrapPredicate::IncrementWrapFlags> FlagsMap;
include/llvm/Analysis/ScalarEvolutionExpander.h
  232     Value *expandWrapPredicate(const SCEVWrapPredicate *P, Instruction *Loc);
include/llvm/Support/Casting.h
   58     return To::classof(&Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
lib/Analysis/LoopAccessAnalysis.cpp
  647   if (Stride == 1 || PSE.hasNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW))
  671     PSE.setNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW);
 1032     PSE.hasNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW) ||
 1038       PSE.setNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW);
 1092       PSE.setNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW);
lib/Analysis/ScalarEvolution.cpp
 4817     SCEVWrapPredicate::IncrementWrapFlags AddedFlags =
 4818         Signed ? SCEVWrapPredicate::IncrementNSSW
 4819                : SCEVWrapPredicate::IncrementNUSW;
12084     SCEVWrapPredicate::IncrementWrapFlags AddedFlags) {
12093   auto *OF = new (SCEVAllocator)
12094       SCEVWrapPredicate(ID.Intern(SCEVAllocator), AR, AddedFlags);
12138       if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNUSW))
12154       if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNSSW))
12178                              SCEVWrapPredicate::IncrementWrapFlags AddedFlags) {
12198       if (auto *WP = dyn_cast<const SCEVWrapPredicate>(P)) {
12276   const auto *Op = dyn_cast<SCEVWrapPredicate>(N);
12276   const auto *Op = dyn_cast<SCEVWrapPredicate>(N);
12293   if (SCEVWrapPredicate::IncrementNUSW & getFlags())
12295   if (SCEVWrapPredicate::IncrementNSSW & getFlags())
12300 SCEVWrapPredicate::IncrementWrapFlags
12431     Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags) {
12435   auto ImpliedFlags = SCEVWrapPredicate::getImpliedFlags(AR, SE);
12438   Flags = SCEVWrapPredicate::clearFlags(Flags, ImpliedFlags);
12443     II.first->second = SCEVWrapPredicate::setFlags(Flags, II.first->second);
12447     Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags) {
12451   Flags = SCEVWrapPredicate::clearFlags(
12452       Flags, SCEVWrapPredicate::getImpliedFlags(AR, SE));
12457     Flags = SCEVWrapPredicate::clearFlags(Flags, II->second);
12459   return Flags == SCEVWrapPredicate::IncrementAnyWrap;
lib/Analysis/ScalarEvolutionExpander.cpp
 2221     auto *AddRecPred = cast<SCEVWrapPredicate>(Pred);
 2335 Value *SCEVExpander::expandWrapPredicate(const SCEVWrapPredicate *Pred,
 2341   if (Pred->getFlags() & SCEVWrapPredicate::IncrementNUSW)
 2345   if (Pred->getFlags() & SCEVWrapPredicate::IncrementNSSW)