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 ↗

(On Diff #26416)

Push the negate through

lib/Transforms/InstCombine/InstCombineCompares.cpp

2673

Push the negate through.

lib/Transforms/InstCombine/InstructionCombining.cpp

102

Push the negate through

994

Push the negate through

[LegalizeAdulthood]

lib/Transforms/InstCombine/InstCombineCasts.cpp

281 ↗

(On Diff #26416)

Fixed.

lib/Transforms/InstCombine/InstCombineCompares.cpp

2673

Fixed.

lib/Transforms/InstCombine/InstructionCombining.cpp

102

FIxed.

994

Fixed.

[LegalizeAdulthood]

Update from comments

[LegalizeAdulthood]

Update to latest

lib/Transforms/InstCombine/InstCombineAddSub.cpp

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/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(unsigned FromWidth,
   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 true if it is desirable to convert a computation from 'From' to 'To'.
 /// We don't want to convert from a legal to an illegal type for example or from
 /// a smaller to a larger illegal type.
 bool InstCombiner::ShouldChangeType(Type *From, Type *To) const {
   assert(From->isIntegerTy() && To->isIntegerTy());
 
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();
 }
 
 /// 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!");