Use llvm::is_contained where appropriate (NFC)

[kazu]

Summary

This patch replaces std::find with llvm::is_contained where
appropriate.

[nhaehnle]

This is a nice cleanup, thanks. LGTM.

llvm/lib/Analysis/AssumptionCache.cpp

 
 void AssumptionCache::transferAffectedValuesInCache(Value *OV, Value *NV) {
   auto &NAVV = getOrInsertAffectedValues(NV);
   auto AVI = AffectedValues.find(OV);
   if (AVI == AffectedValues.end())
     return;
 
   for (auto &A : AVI->second)
-    if (std::find(NAVV.begin(), NAVV.end(), A) == NAVV.end())
+    if (!llvm::is_contained(NAVV, A))
       NAVV.push_back(A);
   AffectedValues.erase(OV);
 }
 
 void AssumptionCache::AffectedValueCallbackVH::allUsesReplacedWith(Value *NV) {
   if (!isa<Instruction>(NV) && !isa<Argument>(NV))
     return;
 

llvm/lib/CodeGen/GlobalISel/LegalityPredicates.cpp

return
       [=](const LegalityQuery &Query) { return Query.Types[TypeIdx] == Type; };
 }
 
 LegalityPredicate
 LegalityPredicates::typeInSet(unsigned TypeIdx,
                               std::initializer_list<LLT> TypesInit) {
   SmallVector<LLT, 4> Types = TypesInit;
   return [=](const LegalityQuery &Query) {
-    return std::find(Types.begin(), Types.end(), Query.Types[TypeIdx]) != Types.end();
+    return llvm::is_contained(Types, Query.Types[TypeIdx]);
   };
 }
 
 LegalityPredicate LegalityPredicates::typePairInSet(
     unsigned TypeIdx0, unsigned TypeIdx1,
     std::initializer_list<std::pair<LLT, LLT>> TypesInit) {
   SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
   return [=](const LegalityQuery &Query) {
     std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]};
-    return std::find(Types.begin(), Types.end(), Match) != Types.end();
+    return llvm::is_contained(Types, Match);
   };
 }
 
 LegalityPredicate LegalityPredicates::typePairAndMemDescInSet(
     unsigned TypeIdx0, unsigned TypeIdx1, unsigned MMOIdx,
     std::initializer_list<TypePairAndMemDesc> TypesAndMemDescInit) {
   SmallVector<TypePairAndMemDesc, 4> TypesAndMemDesc = TypesAndMemDescInit;
   return [=](const LegalityQuery &Query) {

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

if (auto Op = dyn_cast<FPMathOperator>(CI))
     if (Op->isFast())
       return true;
   const Function *F = CI->getParent()->getParent();
   Attribute Attr = F->getFnAttribute("unsafe-fp-math");
   return Attr.getValueAsString() == "true";
 }
 
 bool AMDGPULibCalls::useNativeFunc(const StringRef F) const {
-  return AllNative ||
-         std::find(UseNative.begin(), UseNative.end(), F) != UseNative.end();
+  return AllNative || llvm::is_contained(UseNative, F);
 }
 
 void AMDGPULibCalls::initNativeFuncs() {
   AllNative = useNativeFunc("all") ||
               (UseNative.getNumOccurrences() && UseNative.size() == 1 &&
                UseNative.begin()->empty());
 }
 

llvm/lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp

namespace {
   bool unifyExtensionMD(Module &M, StringRef Name) {
     auto NamedMD = M.getNamedMetadata(Name);
     if (!NamedMD || NamedMD->getNumOperands() == 1)
       return false;
 
     SmallVector<Metadata *, 4> All;
     for (auto MD : NamedMD->operands())
       for (const auto &Op : MD->operands())
-        if (std::find(All.begin(), All.end(), Op.get()) == All.end())
+        if (!llvm::is_contained(All, Op.get()))
           All.push_back(Op.get());
 
     NamedMD->eraseFromParent();
     NamedMD = M.getOrInsertNamedMetadata(Name);
     for (const auto &MD : All)
       NamedMD->addOperand(MDNode::get(M.getContext(), MD));
 
     return true;

llvm/lib/Target/BPF/BPFMIChecking.cpp

if (GPR32LiveDefs.empty())
     return false;
 
   // No GPR64 dead Def, so all those GPR32 live Def can't have alias, therefore
   // must be truely live, safe to return true.
   if (GPR64DeadDefs.empty())
     return true;
 
   // Otherwise, return true if any aliased SuperReg of GPR32 is not dead.
-  std::vector<unsigned>::iterator search_begin = GPR64DeadDefs.begin();
-  std::vector<unsigned>::iterator search_end = GPR64DeadDefs.end();
   for (auto I : GPR32LiveDefs)
     for (MCSuperRegIterator SR(I, TRI); SR.isValid(); ++SR)
-       if (std::find(search_begin, search_end, *SR) == search_end)
-         return true;
+      if (!llvm::is_contained(GPR64DeadDefs, *SR))
 
   return false;
 }
 
 void BPFMIPreEmitChecking::checkingIllegalXADD(void) {
   for (MachineBasicBlock &MBB : *MF) {
     for (MachineInstr &MI : MBB) {
       if (MI.getOpcode() != BPF::XADDW &&

llvm/lib/Transforms/IPO/GlobalOpt.cpp

for (User *U : F.users()) {
     if (isa<BlockAddress>(U))
       continue;
 
     CallBase &CB = cast<CallBase>(*U);
     Function *CallerFunc = CB.getParent()->getParent();
     BlockFrequencyInfo &CallerBFI = GetBFI(*CallerFunc);
     if (!isColdCallSite(CB, CallerBFI))
       return false;
-    auto It = std::find(AllCallsCold.begin(), AllCallsCold.end(), CallerFunc);
-    if (It == AllCallsCold.end())
+    if (!llvm::is_contained(AllCallsCold, CallerFunc))
       return false;
   }
   return true;
 }
 
 static void changeCallSitesToColdCC(Function *F) {
   for (User *U : F->users()) {
     if (isa<BlockAddress>(U))

llvm/lib/Transforms/IPO/PartialInlining.cpp

 }
 
 Function *
 PartialInlinerImpl::FunctionCloner::doSingleRegionFunctionOutlining() {
   // Returns true if the block is to be partial inlined into the caller
   // (i.e. not to be extracted to the out of line function)
   auto ToBeInlined = [&, this](BasicBlock *BB) {
     return BB == ClonedOI->ReturnBlock ||
-           (std::find(ClonedOI->Entries.begin(), ClonedOI->Entries.end(), BB) !=
-            ClonedOI->Entries.end());
+           llvm::is_contained(ClonedOI->Entries, BB);
   };
 
   assert(ClonedOI && "Expecting OutlineInfo for single region outline");
   // The CodeExtractor needs a dominator tree.
   DominatorTree DT;
   DT.recalculate(*ClonedFunc);
 
   // Manually calculate a BlockFrequencyInfo and BranchProbabilityInfo.

llvm/lib/Transforms/Scalar/GVNSink.cpp

public:
   // resultant order of elements in Blocks needs to be deterministic.
   // Using SmallPtrSet instead causes non-deterministic order while
   // copying. And we cannot simply sort Blocks as they need to match the
   // corresponding Values.
   SmallSetVector<BasicBlock *, 4> &getActiveBlocks() { return ActiveBlocks; }
 
   void restrictToBlocks(SmallSetVector<BasicBlock *, 4> &Blocks) {
     for (auto II = Insts.begin(); II != Insts.end();) {
-      if (std::find(Blocks.begin(), Blocks.end(), (*II)->getParent()) ==
-          Blocks.end()) {
+      if (!llvm::is_contained(Blocks, (*II)->getParent())) {
         ActiveBlocks.remove((*II)->getParent());
         II = Insts.erase(II);
       } else {
         ++II;
       }
     }
   }
 
public:
 
   /// Restrict the PHI's contents down to only \c NewBlocks.
   /// \c NewBlocks must be a subset of \c this->Blocks.
   void restrictToBlocks(const SmallSetVector<BasicBlock *, 4> &NewBlocks) {
     auto BI = Blocks.begin();
     auto VI = Values.begin();
     while (BI != Blocks.end()) {
       assert(VI != Values.end());
-      if (std::find(NewBlocks.begin(), NewBlocks.end(), *BI) ==
-          NewBlocks.end()) {
+      if (!llvm::is_contained(NewBlocks, *BI)) {
         BI = Blocks.erase(BI);
         VI = Values.erase(VI);
       } else {
         ++BI;
         ++VI;
       }
     }
     assert(Blocks.size() == NewBlocks.size());

llvm/lib/Transforms/Vectorize/VPlanSLP.cpp

bool VPlanSlp::areVectorizable(ArrayRef<VPValue *> Operands) const {
   // TODO: we only have to forbid instructions writing to memory that could
   //       interfere with any of the loads in the bundle
   if (Opcode == Instruction::Load) {
     unsigned LoadsSeen = 0;
     VPBasicBlock *Parent = cast<VPInstruction>(Operands[0])->getParent();
     for (auto &I : *Parent) {
       auto *VPI = cast<VPInstruction>(&I);
       if (VPI->getOpcode() == Instruction::Load &&
-          std::find(Operands.begin(), Operands.end(), VPI) != Operands.end())
+          llvm::is_contained(Operands, VPI))
         LoadsSeen++;
 
       if (LoadsSeen == Operands.size())
         break;
       if (LoadsSeen > 0 && VPI->mayWriteToMemory()) {
         LLVM_DEBUG(
             dbgs() << "VPSLP: instruction modifying memory between loads\n");
         return false;

llvm/lib/Transforms/Vectorize/VPlanVerifier.cpp

for (const VPBlockBase *VPB :
     // There must be only one instance of a successor in block's successor list.
     // TODO: This won't work for switch statements.
     assert(!hasDuplicates(Successors) &&
            "Multiple instances of the same successor.");
 
     for (const VPBlockBase *Succ : Successors) {
       // There must be a bi-directional link between block and successor.
       const auto &SuccPreds = Succ->getPredecessors();
-      assert(std::find(SuccPreds.begin(), SuccPreds.end(), VPB) !=
-                 SuccPreds.end() &&
-             "Missing predecessor link.");
+      assert(llvm::is_contained(SuccPreds, VPB) && "Missing predecessor link.");
       (void)SuccPreds;
     }
 
     // Check block's predecessors.
     const auto &Predecessors = VPB->getPredecessors();
     // There must be only one instance of a predecessor in block's predecessor
     // list.
     // TODO: This won't work for switch statements.
     assert(!hasDuplicates(Predecessors) &&
            "Multiple instances of the same predecessor.");
 
     for (const VPBlockBase *Pred : Predecessors) {
       // Block and predecessor must be inside the same region.
       assert(Pred->getParent() == VPB->getParent() &&
              "Predecessor is not in the same region.");
 
       // There must be a bi-directional link between block and predecessor.
       const auto &PredSuccs = Pred->getSuccessors();
-      assert(std::find(PredSuccs.begin(), PredSuccs.end(), VPB) !=
-                 PredSuccs.end() &&
-             "Missing successor link.");
+      assert(llvm::is_contained(PredSuccs, VPB) && "Missing successor link.");
       (void)PredSuccs;
     }
   }
 }
 
 /// Verify the CFG invariants of VPRegionBlock \p Region and its nested
 /// VPBlockBases. Do not recurse inside nested VPRegionBlocks.
 static void verifyRegion(const VPRegionBlock *Region) {

llvm/tools/bugpoint/ExtractFunction.cpp

BugDriver::extractMappedBlocksFromModule(const std::vector<BasicBlock *> &BBs,
   }
   DiscardTemp Discard{*Temp};
 
   // Extract all of the blocks except the ones in BBs.
   SmallVector<BasicBlock *, 32> BlocksToExtract;
   for (Function &F : *M)
     for (BasicBlock &BB : F)
       // Check if this block is going to be extracted.
-      if (std::find(BBs.begin(), BBs.end(), &BB) == BBs.end())
+      if (!llvm::is_contained(BBs, &BB))
         BlocksToExtract.push_back(&BB);
 
   raw_fd_ostream OS(Temp->FD, /*shouldClose*/ false);
   for (BasicBlock *BB : BBs) {
     // If the BB doesn't have a name, give it one so we have something to key
     // off of.
     if (!BB->hasName())
       BB->setName("tmpbb");

llvm/tools/llvm-exegesis/lib/Analysis.cpp

 
 namespace {
 
 enum EscapeTag { kEscapeCsv, kEscapeHtml, kEscapeHtmlString };
 
 template <EscapeTag Tag> void writeEscaped(raw_ostream &OS, const StringRef S);
 
 template <> void writeEscaped<kEscapeCsv>(raw_ostream &OS, const StringRef S) {
-  if (std::find(S.begin(), S.end(), kCsvSep) == S.end()) {
+  if (!llvm::is_contained(S, kCsvSep)) {
     OS << S;
   } else {
     // Needs escaping.
     OS << '"';
     for (const char C : S) {
       if (C == '"')
         OS << "\"\"";
       else