Refactor: Simplify boolean conditional return statements in lib/Transforms/InstCombine

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[craig.topper]

lib/Transforms/InstCombine/InstCombineCasts.cpp

281

Push the negate through

lib/Transforms/InstCombine/InstCombineCompares.cpp

2559

Push the negate through.

lib/Transforms/InstCombine/InstructionCombining.cpp

100

Push the negate through

959

Push the negate through

[LegalizeAdulthood]

lib/Transforms/InstCombine/InstCombineCasts.cpp

281

Fixed.

lib/Transforms/InstCombine/InstCombineCompares.cpp

2559

Fixed.

lib/Transforms/InstCombine/InstructionCombining.cpp

100

FIxed.

959

Fixed.

[LegalizeAdulthood]

Update from comments

[LegalizeAdulthood]

Update to latest

lib/Transforms/InstCombine/InstCombineAddSub.cpp

bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS,
   // overflow.
   if ((LHSKnownOne[BitWidth - 1] && RHSKnownZero[BitWidth - 1]) ||
       (LHSKnownZero[BitWidth - 1] && RHSKnownOne[BitWidth - 1]))
     return true;
 
   // Check if carry bit of addition will not cause overflow.
   if (checkRippleForAdd(LHSKnownZero, RHSKnownZero))
     return true;
-  if (checkRippleForAdd(RHSKnownZero, LHSKnownZero))
-    return true;
-
-  return false;
+  return checkRippleForAdd(RHSKnownZero, LHSKnownZero);
 }
 
 /// \brief Return true if we can prove that:
 ///    (sub LHS, RHS)  === (sub nsw LHS, RHS)
 /// This basically requires proving that the add in the original type would not
 /// overflow to change the sign bit or have a carry out.
 /// TODO: Handle this for Vectors.
 bool InstCombiner::WillNotOverflowSignedSub(Value *LHS, Value *RHS,
bool InstCombiner::WillNotOverflowUnsignedSub(Value *LHS, Value *RHS,
                                               Instruction &CxtI) {
   // If the LHS is negative and the RHS is non-negative, no unsigned wrap.
   bool LHSKnownNonNegative, LHSKnownNegative;
   bool RHSKnownNonNegative, RHSKnownNegative;
   ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, /*Depth=*/0,
                  &CxtI);
   ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, /*Depth=*/0,
                  &CxtI);
-  if (LHSKnownNegative && RHSKnownNonNegative)
-    return true;
-
-  return false;
+  return LHSKnownNegative && RHSKnownNonNegative;
 }
 
 // Checks if any operand is negative and we can convert add to sub.
 // This function checks for following negative patterns
 //   ADD(XOR(OR(Z, NOT(C)), C)), 1) == NEG(AND(Z, C))
 //   ADD(XOR(AND(Z, C), C), 1) == NEG(OR(Z, ~C))
 //   XOR(AND(Z, C), (C + 1)) == NEG(OR(Z, ~C)) if C is even
 static Value *checkForNegativeOperand(BinaryOperator &I,

lib/Transforms/InstCombine/InstCombineCalls.cpp

static bool isSafeToEliminateVarargsCast(const CallSite CS,
   if (!CS.isByValOrInAllocaArgument(ix))
     return true;
 
   Type* SrcTy =
             cast<PointerType>(CI->getOperand(0)->getType())->getElementType();
   Type* DstTy = cast<PointerType>(CI->getType())->getElementType();
   if (!SrcTy->isSized() || !DstTy->isSized())
     return false;
-  if (DL.getTypeAllocSize(SrcTy) != DL.getTypeAllocSize(DstTy))
-    return false;
-  return true;
+  return DL.getTypeAllocSize(SrcTy) == DL.getTypeAllocSize(DstTy);
 }
 
 // Try to fold some different type of calls here.
 // Currently we're only working with the checking functions, memcpy_chk,
 // mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk,
 // strcat_chk and strncat_chk.
 Instruction *InstCombiner::tryOptimizeCall(CallInst *CI) {
   if (!CI->getCalledFunction()) return nullptr;

lib/Transforms/InstCombine/InstCombineCasts.cpp

bool InstCombiner::ShouldOptimizeCast(Instruction::CastOps opc, const Value *V,
   // If this is another cast that can be eliminated, we prefer to have it
   // eliminated.
   if (const CastInst *CI = dyn_cast<CastInst>(V))
     if (isEliminableCastPair(CI, opc, Ty, DL))
       return false;
 
   // If this is a vector sext from a compare, then we don't want to break the
   // idiom where each element of the extended vector is either zero or all ones.
-  if (opc == Instruction::SExt && isa<CmpInst>(V) && Ty->isVectorTy())
-    return false;
-
-  return true;
+  return !(opc == Instruction::SExt && isa<CmpInst>(V) && Ty->isVectorTy());
 }
 
 
 /// @brief Implement the transforms common to all CastInst visitors.
 Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
   Value *Src = CI.getOperand(0);
 
   // Many cases of "cast of a cast" are eliminable. If it's eliminable we just

lib/Transforms/InstCombine/InstCombineCompares.cpp

 static bool isChainSelectCmpBranch(const SelectInst *SI) {
   const BasicBlock *BB = SI->getParent();
   if (!BB)
     return false;
   auto *BI = dyn_cast_or_null<BranchInst>(BB->getTerminator());
   if (!BI || BI->getNumSuccessors() != 2)
     return false;
   auto *IC = dyn_cast<ICmpInst>(BI->getCondition());
-  if (!IC || (IC->getOperand(0) != SI && IC->getOperand(1) != SI))
-    return false;
-  return true;
+  return !(!IC || (IC->getOperand(0) != SI && IC->getOperand(1) != SI));
 }
 
 ///
 /// \brief True when a select result is replaced by one of its operands
 /// in select-icmp sequence. This will eventually result in the elimination
 /// of the select.
 ///
 /// \param SI    Select instruction

lib/Transforms/InstCombine/InstructionCombining.cpp

bool InstCombiner::ShouldChangeType(Type *From, Type *To) const {
 
   // If this is a legal integer from type, and the result would be an illegal
   // type, don't do the transformation.
   if (FromLegal && !ToLegal)
     return false;
 
   // Otherwise, if both are illegal, do not increase the size of the result. We
   // do allow things like i160 -> i64, but not i64 -> i160.
-  if (!FromLegal && !ToLegal && ToWidth > FromWidth)
-    return false;
-
-  return true;
+  return !(!FromLegal && !ToLegal && ToWidth > FromWidth);
 }
 
 // Return true, if No Signed Wrap should be maintained for I.
 // The No Signed Wrap flag can be kept if the operation "B (I.getOpcode) C",
 // where both B and C should be ConstantInts, results in a constant that does
 // not overflow. This function only handles the Add and Sub opcodes. For
 // all other opcodes, the function conservatively returns false.
 static bool MaintainNoSignedWrap(BinaryOperator &I, Value *B, Value *C) {
Type *InstCombiner::FindElementAtOffset(PointerType *PtrTy, int64_t Offset,
 
   return Ty;
 }
 
 static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
   // If this GEP has only 0 indices, it is the same pointer as
   // Src. If Src is not a trivial GEP too, don't combine
   // the indices.
-  if (GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
-      !Src.hasOneUse())
-    return false;
-  return true;
+  return !(GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
+      !Src.hasOneUse());
 }
 
 /// Descale - Return a value X such that Val = X * Scale, or null if none.  If
 /// the multiplication is known not to overflow then NoSignedWrap is set.
 Value *InstCombiner::Descale(Value *Val, APInt Scale, bool &NoSignedWrap) {
   assert(isa<IntegerType>(Val->getType()) && "Can only descale integers!");
   assert(cast<IntegerType>(Val->getType())->getBitWidth() ==
          Scale.getBitWidth() && "Scale not compatible with value!");