[SCEV] Simplify some flags expressions.

[jlebar]

Summary

Sending for presubmit review out of an abundance of caution; it would be
bad to mess this up.

[sanjoy]

lgtm, thanks!

llvm/trunk/lib/Analysis/ScalarEvolution.cpp

const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
   if (LHS == RHS)
     return getZero(LHS->getType());
 
   // We represent LHS - RHS as LHS + (-1)*RHS. This transformation
   // makes it so that we cannot make much use of NUW.
   auto AddFlags = SCEV::FlagAnyWrap;
   const bool RHSIsNotMinSigned =
       !getSignedRangeMin(RHS).isMinSignedValue();
-  if ((Flags & SCEV::FlagNSW) == SCEV::FlagNSW) {
+  if (Flags & SCEV::FlagNSW) {
     // Let M be the minimum representable signed value. Then (-1)*RHS
     // signed-wraps if and only if RHS is M. That can happen even for
     // a NSW subtraction because e.g. (-1)*M signed-wraps even though
     // -1 - M does not. So to transfer NSW from LHS - RHS to LHS +
     // (-1)*RHS, we need to prove that RHS != M.
     //
     // If LHS is non-negative and we know that LHS - RHS does not
     // signed-wrap, then RHS cannot be M. So we can rule out signed-wrap
bool SCEVWrapPredicate::implies(const SCEVPredicate *N) const {
 
   return Op && Op->AR == AR && (Flags | Op->Flags) == Flags;
 }
 
 bool SCEVWrapPredicate::isAlwaysTrue() const {
   SCEV::NoWrapFlags ScevFlags = AR->getNoWrapFlags();
   IncrementWrapFlags IFlags = Flags;
 
-  if ((ScevFlags | SCEV::FlagNSW) == ScevFlags)
+  if (ScevFlags & SCEV::FlagNSW)
     IFlags &= ~IncrementNSSW;
 
   return IFlags == IncrementAnyWrap;
 }
 
 void SCEVWrapPredicate::print(raw_ostream &OS, unsigned Depth) const {
   OS.indent(Depth) << *getExpr() << " Added Flags: ";
   if (SCEVWrapPredicate::IncrementNUSW & getFlags())
     OS << "<nusw>";
   if (SCEVWrapPredicate::IncrementNSSW & getFlags())
     OS << "<nssw>";
   OS << "\n";
 }
 
 SCEVWrapPredicate::IncrementWrapFlags
 SCEVWrapPredicate::getImpliedFlags(const SCEVAddRecExpr *AR,
                                    ScalarEvolution &SE) {
   IncrementWrapFlags ImpliedFlags = IncrementAnyWrap;
   SCEV::NoWrapFlags StaticFlags = AR->getNoWrapFlags();
 
   // We can safely transfer the NSW flag as NSSW.
-  if ((StaticFlags | SCEV::FlagNSW) == StaticFlags)
+  if (StaticFlags & SCEV::FlagNSW)
     ImpliedFlags = IncrementNSSW;
 
-  if ((StaticFlags | SCEV::FlagNUW) == StaticFlags) {
+  if (StaticFlags & SCEV::FlagNUW) {
     // If the increment is positive, the SCEV NUW flag will also imply the
     // WrapPredicate NUSW flag.
     if (const auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(SE)))
       if (Step->getValue()->getValue().isNonNegative())
         ImpliedFlags |= IncrementNUSW;
   }
 
   return ImpliedFlags;