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

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[craig.topper]

lib/IR/Instructions.cpp

1375

Push the negate through

2603

Push the negate through

lib/IR/Verifier.cpp

1515

Operators should go on end of previous lines.

[LegalizeAdulthood]

lib/IR/Instructions.cpp

1375

Fixed.

2603

Fixed.

lib/IR/Verifier.cpp

1515

Fixed.

[LegalizeAdulthood]

Update from comments, run clang-format

[LegalizeAdulthood]

Update from latest
I do not have commit access.

lib/IR/ConstantFold.cpp

static bool isIndexInRangeOfSequentialType(const SequentialType *STy,
 
   // We cannot bounds check the index if it doesn't fit in an int64_t.
   if (CI->getValue().getActiveBits() > 64)
     return false;
 
   // A negative index or an index past the end of our sequential type is
   // considered out-of-range.
   int64_t IndexVal = CI->getSExtValue();
-  if (IndexVal < 0 || (NumElements > 0 && (uint64_t)IndexVal >= NumElements))
-    return false;
-
-  // Otherwise, it is in-range.
-  return true;
+  return !(IndexVal < 0 || (NumElements > 0 && (uint64_t)IndexVal >= NumElements));
 }
 
 template<typename IndexTy>
 static Constant *ConstantFoldGetElementPtrImpl(Type *PointeeTy, Constant *C,
                                                bool inBounds,
                                                ArrayRef<IndexTy> Idxs) {
   if (Idxs.empty()) return C;
   Constant *Idx0 = cast<Constant>(Idxs[0]);

lib/IR/InlineAsm.cpp

case 1:
     break;
   default:
     StructType *STy = dyn_cast<StructType>(Ty->getReturnType());
     if (!STy || STy->getNumElements() != NumOutputs)
       return false;
     break;
   }      
   
-  if (Ty->getNumParams() != NumInputs) return false;
-  return true;
+  return Ty->getNumParams() == NumInputs;
 }
 

lib/IR/Instructions.cpp

ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
 
   Op<0>() = Val;
   Op<1>() = Index;
   setName(Name);
 }
 
 
 bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
-  if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy())
-    return false;
-  return true;
+  return !(!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy());
 }
 
 
 //===----------------------------------------------------------------------===//
 //                           InsertElementInst Implementation
 //===----------------------------------------------------------------------===//
 
 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
   // Could still have vectors of pointers if the number of elements doesn't
   // match
   if (SrcBits == 0 || DestBits == 0)
     return false;
 
   if (SrcBits != DestBits)
     return false;
 
-  if (DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy())
-    return false;
-
-  return true;
+  return !(DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy());
 }
 
 bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
                                           const DataLayout &DL) {
   if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
     if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
       return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
   if (auto *PtrTy = dyn_cast<PointerType>(DestTy))

lib/IR/Verifier.cpp

 }
 
 bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {
   if (Attrs.getNumSlots() == 0)
     return true;
 
   unsigned LastSlot = Attrs.getNumSlots() - 1;
   unsigned LastIndex = Attrs.getSlotIndex(LastSlot);
-  if (LastIndex <= Params
+  return LastIndex <= Params
       || (LastIndex == AttributeSet::FunctionIndex
-          && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params)))
-    return true;
-
-  return false;
+          && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params));
 }
 
 /// \brief Verify that statepoint intrinsic is well formed.
 void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
   assert(CS.getCalledFunction() &&
          CS.getCalledFunction()->getIntrinsicID() ==
            Intrinsic::experimental_gc_statepoint);