Refactor: Simplify boolean conditional return statements in llvm/lib/Analysis

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements.

[craig.topper]

lib/Analysis/CostModel.cpp

155

Just use == here

lib/Analysis/LoopAccessAnalysis.cpp

149

Maybe push the negate through and use ORs

lib/Analysis/TargetLibraryInfo.cpp

45

Push the ! through and use an OR

[craig.topper]

lib/Analysis/CaptureTracking.cpp

80

Push negate through and indent second line to start after 'return' so it aligns better with the expression part of the first line.

lib/Analysis/InstructionSimplify.cpp

127

Fix indentation to align with where the expression starts on previous line.

[LegalizeAdulthood]

Update from latest.
Update from comments.
I do not have commit access.

[sanjoy]

LGTM, should I check this in for you?

How would you like to be credited? I was going to go with "Patch by Richard!", but please let me know if you'd prefer something else.

lib/Analysis/BasicAliasAnalysis.cpp

 /// been considered an escape by isNonEscapingLocalObject.
 static bool isEscapeSource(const Value *V) {
   if (isa<CallInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V))
     return true;
 
   // The load case works because isNonEscapingLocalObject considers all
   // stores to be escapes (it passes true for the StoreCaptures argument
   // to PointerMayBeCaptured).
-  if (isa<LoadInst>(V))
-    return true;
-
-  return false;
+  return isa<LoadInst>(V);
 }
 
 /// getObjectSize - Return the size of the object specified by V, or
 /// UnknownSize if unknown.
 static uint64_t getObjectSize(const Value *V, const DataLayout &DL,
                               const TargetLibraryInfo &TLI,
                               bool RoundToAlign = false) {
   uint64_t Size;
BasicAliasAnalysis::getArgLocation(ImmutableCallSite CS, unsigned ArgIdx,
   }
   // FIXME: Handle memset_pattern4 and memset_pattern8 also.
 
   return Loc;
 }
 
 static bool isAssumeIntrinsic(ImmutableCallSite CS) {
   const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction());
-  if (II && II->getIntrinsicID() == Intrinsic::assume)
-    return true;
-
-  return false;
+  return II && II->getIntrinsicID() == Intrinsic::assume;
 }
 
 bool BasicAliasAnalysis::doInitialization(Module &M) {
   InitializeAliasAnalysis(this, &M.getDataLayout());
   return true;
 }
 
 /// getModRefInfo - Check to see if the specified callsite can clobber the

lib/Analysis/CaptureTracking.cpp

bool shouldExplore(const Use *U) override {
       BasicBlock *BB = I->getParent();
       // We explore this usage only if the usage can reach "BeforeHere".
       // If use is not reachable from entry, there is no need to explore.
       if (BeforeHere != I && !DT->isReachableFromEntry(BB))
         return false;
       // If the value is defined in the same basic block as use and BeforeHere,
       // there is no need to explore the use if BeforeHere dominates use.
       // Check whether there is a path from I to BeforeHere.
-      if (BeforeHere != I && DT->dominates(BeforeHere, I) &&
-          !isPotentiallyReachable(I, BeforeHere, DT))
-        return false;
-      return true;
+      return !(BeforeHere != I && DT->dominates(BeforeHere, I) &&
+          !isPotentiallyReachable(I, BeforeHere, DT));
     }
 
     bool captured(const Use *U) override {
       if (isa<ReturnInst>(U->getUser()) && !ReturnCaptures)
         return false;
 
       Instruction *I = cast<Instruction>(U->getUser());
       if (BeforeHere == I && !IncludeI)

lib/Analysis/CostModel.cpp

static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
   SmallVector<int, 32> Mask(SI->getType()->getVectorNumElements(), -1);
 
   // Build a mask of 0, 2, ... (left) or 1, 3, ... (right) depending on whether
   // we look at the left or right side.
   for (unsigned i = 0, e = (1 << Level), val = !IsLeft; i != e; ++i, val += 2)
     Mask[i] = val;
 
   SmallVector<int, 16> ActualMask = SI->getShuffleMask();
-  if (Mask != ActualMask)
-    return false;
-
-  return true;
+  return !(Mask != ActualMask);
 }
 
 static bool matchPairwiseReductionAtLevel(const BinaryOperator *BinOp,
                                           unsigned Level, unsigned NumLevels) {
   // Match one level of pairwise operations.
   // %rdx.shuf.0.0 = shufflevector <4 x float> %rdx, <4 x float> undef,
   //       <4 x i32> <i32 0, i32 2 , i32 undef, i32 undef>
   // %rdx.shuf.0.1 = shufflevector <4 x float> %rdx, <4 x float> undef,

lib/Analysis/InstructionSimplify.cpp

if (!DT->isReachableFromEntry(P->getParent()))
       return true;
     if (!DT->isReachableFromEntry(I->getParent()))
       return false;
     return DT->dominates(I, P);
   }
 
   // Otherwise, if the instruction is in the entry block, and is not an invoke,
   // then it obviously dominates all phi nodes.
-  if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() &&
-      !isa<InvokeInst>(I))
-    return true;
-
-  return false;
+  return I->getParent() == &I->getParent()->getParent()->getEntryBlock() &&
+      !isa<InvokeInst>(I);
 }
 
 /// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning
 /// it into "(A op B) op' (A op C)".  Here "op" is given by Opcode and "op'" is
 /// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS.
 /// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)".
 /// Returns the simplified value, or null if no simplification was performed.
 static Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS,

lib/Analysis/LoopAccessAnalysis.cpp

bool LoopAccessInfo::RuntimePointerCheck::needsChecking(
 
   // Only need to check pointers in the same alias set.
   if (AliasSetId[I] != AliasSetId[J])
     return false;
 
   // If PtrPartition is set omit checks between pointers of the same partition.
   // Partition number -1 means that the pointer is used in multiple partitions.
   // In this case we can't omit the check.
-  if (PtrPartition && (*PtrPartition)[I] != -1 &&
-      (*PtrPartition)[I] == (*PtrPartition)[J])
-    return false;
-
-  return true;
+  return !(PtrPartition && (*PtrPartition)[I] != -1 &&
+      (*PtrPartition)[I] == (*PtrPartition)[J]);
 }
 
 void LoopAccessInfo::RuntimePointerCheck::print(
     raw_ostream &OS, unsigned Depth,
     const SmallVectorImpl<int> *PtrPartition) const {
   unsigned NumPointers = Pointers.size();
   if (NumPointers == 0)
     return;

lib/Analysis/TargetLibraryInfo.cpp

static bool hasSinCosPiStret(const Triple &T) {
 
   // The ABI is rather complicated on x86, so don't do anything special there.
   if (T.getArch() == Triple::x86)
     return false;
 
   if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9))
     return false;
 
-  if (T.isiOS() && T.isOSVersionLT(7, 0))
-    return false;
-
-  return true;
+  return !(T.isiOS() && T.isOSVersionLT(7, 0));
 }
 
 /// initialize - Initialize the set of available library functions based on the
 /// specified target triple.  This should be carefully written so that a missing
 /// target triple gets a sane set of defaults.
 static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
                        const char *const *StandardNames) {
 #ifndef NDEBUG

lib/Analysis/ValueTracking.cpp

return isKnownToBeAPowerOfTwo(SI->getTrueValue(), OrZero, Depth, Q, DL) &&
            isKnownToBeAPowerOfTwo(SI->getFalseValue(), OrZero, Depth, Q, DL);
 
   if (OrZero && match(V, m_And(m_Value(X), m_Value(Y)))) {
     // A power of two and'd with anything is a power of two or zero.
     if (isKnownToBeAPowerOfTwo(X, /*OrZero*/ true, Depth, Q, DL) ||
         isKnownToBeAPowerOfTwo(Y, /*OrZero*/ true, Depth, Q, DL))
       return true;
     // X & (-X) is always a power of two or zero.
-    if (match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X))))
-      return true;
-    return false;
+    return match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X)));
   }
 
   // Adding a power-of-two or zero to the same power-of-two or zero yields
   // either the original power-of-two, a larger power-of-two or zero.
   if (match(V, m_Add(m_Value(X), m_Value(Y)))) {
     OverflowingBinaryOperator *VOBO = cast<OverflowingBinaryOperator>(V);
     if (OrZero || VOBO->hasNoUnsignedWrap() || VOBO->hasNoSignedWrap()) {
       if (match(X, m_And(m_Specific(Y), m_Value())) ||
bool llvm::isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI) {
   if (const LoadInst *LI = dyn_cast<LoadInst>(V))
     return LI->getMetadata(LLVMContext::MD_nonnull);
 
   if (auto CS = ImmutableCallSite(V))
     if (CS.isReturnNonNull())
       return true;
 
   // operator new never returns null.
-  if (isOperatorNewLikeFn(V, TLI, /*LookThroughBitCast=*/true))
-    return true;
-
-  return false;
+  return isOperatorNewLikeFn(V, TLI, /*LookThroughBitCast=*/true);
 }
 
 static bool isKnownNonNullFromDominatingCondition(const Value *V,
                                                   const Instruction *CtxI,
                                                   const DominatorTree *DT) {
   unsigned NumUsesExplored = 0;
   for (auto U : V->users()) {
     // Avoid massive lists