Use llvm::erase_if (NFC)

Author: kazutakahirata

Diff for: lld/COFF/Writer.cpp

@@ -1090,18 +1090,14 @@ void Writer::removeUnusedSections() {
     // later. Only remove sections that have no Chunks at all.
     return s->chunks.empty();
   };
-  ctx.outputSections.erase(std::remove_if(ctx.outputSections.begin(),
-                                          ctx.outputSections.end(), isUnused),
-                           ctx.outputSections.end());
+  llvm::erase_if(ctx.outputSections, isUnused);
 }
 
 // The Windows loader doesn't seem to like empty sections,
 // so we remove them if any.
 void Writer::removeEmptySections() {
   auto isEmpty = [](OutputSection *s) { return s->getVirtualSize() == 0; };
-  ctx.outputSections.erase(std::remove_if(ctx.outputSections.begin(),
-                                          ctx.outputSections.end(), isEmpty),
-                           ctx.outputSections.end());
+  llvm::erase_if(ctx.outputSections, isEmpty);
 }
 
 void Writer::assignOutputSectionIndices() {

Diff for: lld/lib/Core/Resolver.cpp

@@ -380,11 +380,9 @@ void Resolver::deadStripOptimize() {
     markLive(dsrAtom);
 
   // now remove all non-live atoms from _atoms
-  _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(),
-                              [&](OwningAtomPtr<Atom> &a) {
-                 return _liveAtoms.count(a.get()) == 0;
-               }),
-               _atoms.end());
+  llvm::erase_if(_atoms, [&](OwningAtomPtr<Atom> &a) {
+    return _liveAtoms.count(a.get()) == 0;
+  });
 }
 
 // error out if some undefines remain
@@ -396,10 +394,8 @@ bool Resolver::checkUndefines() {
   std::vector<const UndefinedAtom *> undefinedAtoms = _symbolTable.undefines();
   if (_ctx.deadStrip()) {
     // When dead code stripping, we don't care if dead atoms are undefined.
-    undefinedAtoms.erase(
-        std::remove_if(undefinedAtoms.begin(), undefinedAtoms.end(),
-                       [&](const Atom *a) { return _liveAtoms.count(a) == 0; }),
-        undefinedAtoms.end());
+    llvm::erase_if(undefinedAtoms,
+                   [&](const Atom *a) { return _liveAtoms.count(a) == 0; });
   }
 
   if (undefinedAtoms.empty())
@@ -440,12 +436,9 @@ void Resolver::removeCoalescedAwayAtoms() {
   DEBUG_WITH_TYPE("resolver",
                   llvm::dbgs() << "******** Removing coalesced away atoms:\n");
   ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms");
-  _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(),
-                              [&](OwningAtomPtr<Atom> &a) {
-                 return _symbolTable.isCoalescedAway(a.get()) ||
-                        _deadAtoms.count(a.get());
-               }),
-               _atoms.end());
+  llvm::erase_if(_atoms, [&](OwningAtomPtr<Atom> &a) {
+    return _symbolTable.isCoalescedAway(a.get()) || _deadAtoms.count(a.get());
+  });
 }
 
 bool Resolver::resolve() {

Diff for: lldb/source/Breakpoint/BreakpointList.cpp

@@ -101,10 +101,8 @@ void BreakpointList::RemoveAllowed(bool notify) {
       NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
   }
 
-  m_breakpoints.erase(
-      std::remove_if(m_breakpoints.begin(), m_breakpoints.end(),
-                     [&](const BreakpointSP &bp) { return bp->AllowDelete(); }),
-      m_breakpoints.end());
+  llvm::erase_if(m_breakpoints,
+                 [&](const BreakpointSP &bp) { return bp->AllowDelete(); });
 }
 
 BreakpointList::bp_collection::iterator

Diff for: llvm/include/llvm/Analysis/InlineOrder.h

@@ -160,8 +160,7 @@ class PriorityInlineOrder : public InlineOrder<std::pair<CallBase *, int>> {
     auto PredWrapper = [=](HeapT P) -> bool {
       return Pred(std::make_pair(P.first, 0));
     };
-    Heap.erase(std::remove_if(Heap.begin(), Heap.end(), PredWrapper),
-               Heap.end());
+    llvm::erase_if(Heap, PredWrapper);
     std::make_heap(Heap.begin(), Heap.end(), cmp);
   }
 

Diff for: llvm/lib/CodeGen/LiveInterval.cpp

@@ -631,9 +631,8 @@ void LiveRange::removeSegment(SlotIndex Start, SlotIndex End,
 /// Also remove the value# from value# list.
 void LiveRange::removeValNo(VNInfo *ValNo) {
   if (empty()) return;
-  segments.erase(remove_if(*this, [ValNo](const Segment &S) {
-    return S.valno == ValNo;
-  }), end());
+  llvm::erase_if(segments,
+                 [ValNo](const Segment &S) { return S.valno == ValNo; });
   // Now that ValNo is dead, remove it.
   markValNoForDeletion(ValNo);
 }

Diff for: llvm/lib/Target/AMDGPU/AMDGPUReplaceLDSUseWithPointer.cpp

@@ -130,11 +130,9 @@ class ReplaceLDSUseImpl {
     std::vector<GlobalVariable *> LDSGlobals = AMDGPU::findVariablesToLower(M);
 
     // Remove LDS which don't qualify for replacement.
-    LDSGlobals.erase(std::remove_if(LDSGlobals.begin(), LDSGlobals.end(),
-                                    [&](GlobalVariable *GV) {
-                                      return shouldIgnorePointerReplacement(GV);
-                                    }),
-                     LDSGlobals.end());
+    llvm::erase_if(LDSGlobals, [&](GlobalVariable *GV) {
+      return shouldIgnorePointerReplacement(GV);
+    });
 
     return LDSGlobals;
   }

Diff for: llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

@@ -2027,12 +2027,8 @@ SDValue WebAssemblyTargetLowering::LowerBUILD_VECTOR(SDValue Op,
   size_t NumShuffleLanes = 0;
   if (ShuffleCounts.size()) {
     std::tie(ShuffleSrc1, NumShuffleLanes) = GetMostCommon(ShuffleCounts);
-    ShuffleCounts.erase(std::remove_if(ShuffleCounts.begin(),
-                                       ShuffleCounts.end(),
-                                       [&](const auto &Pair) {
-                                         return Pair.first == ShuffleSrc1;
-                                       }),
-                        ShuffleCounts.end());
+    llvm::erase_if(ShuffleCounts,
+                   [&](const auto &Pair) { return Pair.first == ShuffleSrc1; });
   }
   if (ShuffleCounts.size()) {
     size_t AdditionalShuffleLanes;

Diff for: polly/lib/Analysis/ScopInfo.cpp

@@ -1303,8 +1303,7 @@ void ScopStmt::removeMemoryAccess(MemoryAccess *MA) {
       Parent.removeAccessData(MA);
     }
   }
-  MemAccs.erase(std::remove_if(MemAccs.begin(), MemAccs.end(), Predicate),
-                MemAccs.end());
+  llvm::erase_if(MemAccs, Predicate);
   InstructionToAccess.erase(MA->getAccessInstruction());
 }