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

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[LegalizeAdulthood]

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

[alexfh]

lib/Transforms/Utils/Local.cpp

298

Please remove the braces here and in the next if as well.

lib/Transforms/Utils/SimplifyCFG.cpp

3663

Push the negation through (should the check be taught to do this?).

lib/Transforms/Utils/Local.cpp

bool llvm::isInstructionTriviallyDead(Instruction *I,
 
   // We don't want the landingpad-like instructions removed by anything this
   // general.
   if (I->isEHPad())
     return false;
 
   // We don't want debug info removed by anything this general, unless
   // debug info is empty.
   if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I)) {
-    if (DDI->getAddress())
-      return false;
-    return true;
+    return DDI->getAddress() == nullptr;
   }
   if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(I)) {
-    if (DVI->getValue())
-      return false;
-    return true;
+    return DVI->getValue() == nullptr;
   }
 
   if (!I->mayHaveSideEffects()) return true;
 
   // Special case intrinsics that "may have side effects" but can be deleted
   // when dead.
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     // Safe to delete llvm.stacksave if dead.

lib/Transforms/Utils/SimplifyCFG.cpp

static bool InitializeUniqueCases(SwitchInst *SI, PHINode *&PHI,
   SmallVector<std::pair<PHINode *, Constant *>, 1> DefaultResults;
   BasicBlock *DefaultDest = SI->getDefaultDest();
   GetCaseResults(SI, nullptr, SI->getDefaultDest(), &CommonDest, DefaultResults,
                  DL);
   // If the default value is not found abort unless the default destination
   // is unreachable.
   DefaultResult =
       DefaultResults.size() == 1 ? DefaultResults.begin()->second : nullptr;
-  if ((!DefaultResult &&
-        !isa<UnreachableInst>(DefaultDest->getFirstNonPHIOrDbg())))
-    return false;
-
-  return true;
+  return !(!DefaultResult &&
+        !isa<UnreachableInst>(DefaultDest->getFirstNonPHIOrDbg()));
 }
 
 // Helper function that checks if it is possible to transform a switch with only
 // two cases (or two cases + default) that produces a result into a select.
 // Example:
 // switch (a) {
 //   case 10:                %0 = icmp eq i32 %a, 10
 //     return 10;            %1 = select i1 %0, i32 10, i32 4

lib/Transforms/Utils/SimplifyIndVar.cpp

bool SimplifyIndvar::eliminateIVUser(Instruction *UseInst,
   if (BinaryOperator *Rem = dyn_cast<BinaryOperator>(UseInst)) {
     bool IsSigned = Rem->getOpcode() == Instruction::SRem;
     if (IsSigned || Rem->getOpcode() == Instruction::URem) {
       eliminateIVRemainder(Rem, IVOperand, IsSigned);
       return true;
     }
   }
 
-  if (eliminateIdentitySCEV(UseInst, IVOperand))
-    return true;
-
-  return false;
+  return eliminateIdentitySCEV(UseInst, IVOperand);
 }
 
 /// Eliminate any operation that SCEV can prove is an identity function.
 bool SimplifyIndvar::eliminateIdentitySCEV(Instruction *UseInst,
                                            Instruction *IVOperand) {
   if (!SE->isSCEVable(UseInst->getType()) ||
       (UseInst->getType() != IVOperand->getType()) ||
       (SE->getSCEV(UseInst) != SE->getSCEV(IVOperand)))
static bool isSimpleIVUser(Instruction *I, const Loop *L, ScalarEvolution *SE) {
   if (!SE->isSCEVable(I->getType()))
     return false;
 
   // Get the symbolic expression for this instruction.
   const SCEV *S = SE->getSCEV(I);
 
   // Only consider affine recurrences.
   const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S);
-  if (AR && AR->getLoop() == L)
-    return true;
-
-  return false;
+  return AR && AR->getLoop() == L;
 }
 
 /// Iteratively perform simplification on a worklist of users
 /// of the specified induction variable. Each successive simplification may push
 /// more users which may themselves be candidates for simplification.
 ///
 /// This algorithm does not require IVUsers analysis. Instead, it simplifies
 /// instructions in-place during analysis. Rather than rewriting induction