[BOLT][NFC] Use range-based STL wrappers

[Amir]

Summary

Replace std:: algorithms taking begin/end iterators with llvm:: counterparts
accepting ranges.

[Amir]

Keep std::reverse

[rafauler]

It's a bit confusing to call a function named "stable_sort", which is a well-known C++ stdlib function, but we're actually calling stable_sort from LLVM and not from stdlib. I've tried looking up in LLVM repo and there are all sorts of usages of is_contained, for example: some of them use llvm:is_contained, others use is_contained directly. What is your take on this? Should we call llvm::stable_sort, or just stable_sort?

[Amir]

In D128154#3600489, @rafauler wrote:

It's a bit confusing to call a function named "stable_sort", which is a well-known C++ stdlib function, but we're actually calling stable_sort from LLVM and not from stdlib. I've tried looking up in LLVM repo and there are all sorts of usages of is_contained, for example: some of them use llvm:is_contained, others use is_contained directly. What is your take on this? Should we call llvm::stable_sort, or just stable_sort?

I’ll make it fully qualified to avoid ambiguity.

[Amir]

llvm::

[Amir]

Remaining llvm::

[rafauler]

LGTM

bolt/include/bolt/Core/BinaryBasicBlock.h

public:
   void removeDuplicateConditionalSuccessor(MCInst *CondBranch);
 
   /// Update successors of the basic block based on the jump table instruction.
   /// The block must end with a jump table instruction.
   void updateJumpTableSuccessors();
 
   /// Test if BB is a predecessor of this block.
   bool isPredecessor(const BinaryBasicBlock *BB) const {
-    auto Itr = std::find(Predecessors.begin(), Predecessors.end(), BB);
-    return Itr != Predecessors.end();
+    return llvm::is_contained(Predecessors, BB);
   }
 
   /// Test if BB is a successor of this block.
   bool isSuccessor(const BinaryBasicBlock *BB) const {
-    auto Itr = std::find(Successors.begin(), Successors.end(), BB);
-    return Itr != Successors.end();
+    return llvm::is_contained(Successors, BB);
   }
 
   /// Test if this BB has a valid execution count.
   bool hasProfile() const { return ExecutionCount != COUNT_NO_PROFILE; }
 
   /// Return the information about the number of times this basic block was
   /// executed.
   ///

bolt/include/bolt/Core/BinaryData.h

public:
   const std::vector<MCSymbol *> &getSymbols() const { return Symbols; }
   std::vector<MCSymbol *> &getSymbols() { return Symbols; }
 
   bool hasName(StringRef Name) const;
   bool hasNameRegex(StringRef Name) const;
   bool nameStartsWith(StringRef Prefix) const;
 
   bool hasSymbol(const MCSymbol *Symbol) const {
-    return std::find(Symbols.begin(), Symbols.end(), Symbol) != Symbols.end();
+    return llvm::is_contained(Symbols, Symbol);
   }
 
   bool isAbsolute() const;
   bool isMoveable() const;
 
   uint64_t getAddress() const { return Address; }
   uint64_t getEndAddress() const { return Address + Size; }
   uint64_t getOffset() const;

bolt/include/bolt/Core/BinaryFunction.h

BinaryBasicBlock *addBasicBlockAt(uint64_t Offset, MCSymbol *Label) {
 
     BasicBlocks.emplace_back(createBasicBlock(Label).release());
     BinaryBasicBlock *BB = BasicBlocks.back();
 
     BB->setIndex(BasicBlocks.size() - 1);
     BB->setOffset(Offset);
 
     BasicBlockOffsets.emplace_back(Offset, BB);
-    assert(std::is_sorted(BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
-                          CompareBasicBlockOffsets()) &&
-           std::is_sorted(begin(), end()));
+    assert(llvm::is_sorted(BasicBlockOffsets, CompareBasicBlockOffsets()) &&
+           llvm::is_sorted(blocks()));
 
     return BB;
   }
 
   /// Clear state of the function that could not be disassembled or if its
   /// disassembled state was later invalidated.
   void clearDisasmState();
 

bolt/lib/Core/BinaryBasicBlock.cpp

if (Function->hasValidProfile()) {
     for (const BinaryBranchInfo &BI : BranchInfo) {
       if (BI.Count != COUNT_NO_PROFILE) {
         TotalCount += BI.Count;
         TotalMispreds += BI.MispredictedCount;
       }
     }
 
     if (TotalCount > 0) {
-      auto Itr = std::find(Successors.begin(), Successors.end(), Succ);
+      auto Itr = llvm::find(Successors, Succ);
       assert(Itr != Successors.end());
       const BinaryBranchInfo &BI = BranchInfo[Itr - Successors.begin()];
       if (BI.Count && BI.Count != COUNT_NO_PROFILE) {
         if (TotalMispreds == 0)
           TotalMispreds = 1;
         return std::make_pair(double(BI.Count) / TotalCount,
                               double(BI.MispredictedCount) / TotalMispreds);
       }

bolt/lib/Core/BinaryContext.cpp

for (size_t I = 0; I != FragmentsToSkip.size(); I++) {
     BinaryFunction *BF = FragmentsToSkip[I];
     assert(UniqueFunctions.count(BF) &&
            "internal error in traversing function fragments");
     if (opts::Verbosity >= 1)
       errs() << "BOLT-WARNING: Ignoring " << BF->getPrintName() << '\n';
     BF->setSimple(false);
     BF->setHasSplitJumpTable(true);
 
-    std::for_each(BF->Fragments.begin(), BF->Fragments.end(), addToWorklist);
-    std::for_each(BF->ParentFragments.begin(), BF->ParentFragments.end(),
-                  addToWorklist);
+    llvm::for_each(BF->Fragments, addToWorklist);
+    llvm::for_each(BF->ParentFragments, addToWorklist);
   }
   if (!FragmentsToSkip.empty())
     errs() << "BOLT-WARNING: skipped " << FragmentsToSkip.size() << " function"
            << (FragmentsToSkip.size() == 1 ? "" : "s")
            << " due to cold fragments\n";
   FragmentsToSkip.clear();
 }
 
for (auto &Entry : BinaryDataMap) {
     BinaryData &BD = *Entry.second;
     StringRef Name = BD.getName();
 
     if (!isInternalSymbolName(Name))
       continue;
 
     // First check if a non-anonymous alias exists and move it to the front.
     if (BD.getSymbols().size() > 1) {
-      auto Itr = std::find_if(BD.getSymbols().begin(), BD.getSymbols().end(),
-                              [&](const MCSymbol *Symbol) {
-                                return !isInternalSymbolName(Symbol->getName());
-                              });
+      auto Itr = llvm::find_if(BD.getSymbols(), [&](const MCSymbol *Symbol) {
       if (Itr != BD.getSymbols().end()) {
         size_t Idx = std::distance(BD.getSymbols().begin(), Itr);
         std::swap(BD.getSymbols()[0], BD.getSymbols()[Idx]);
         continue;
       }
     }
 
     // We have to skip 0 size symbols since they will all collide.
for (MCSymbol *Symbol : ChildBF.getSymbols()) {
     WriteSymbolMapLock.lock();
     SymbolToFunctionMap[Symbol] = &ParentBF;
     WriteSymbolMapLock.unlock();
     // NB: there's no need to update BinaryDataMap and GlobalSymbols.
   }
   ChildBF.getSymbols().clear();
 
   // Move other names the child function is known under.
-  std::move(ChildBF.Aliases.begin(), ChildBF.Aliases.end(),
-            std::back_inserter(ParentBF.Aliases));
+  llvm::move(ChildBF.Aliases, std::back_inserter(ParentBF.Aliases));
   ChildBF.Aliases.clear();
 
   if (HasRelocations) {
     // Merge execution counts of ChildBF into those of ParentBF.
     // Without relocations, we cannot reliably merge profiles as both functions
     // continue to exist and either one can be executed.
     ChildBF.mergeProfileDataInto(ParentBF);
 
unsigned BinaryContext::addDebugFilenameToUnit(const uint32_t DestCUID,
   assert(FileName != "");
   DWARFCompileUnit *DstUnit = DwCtx->getCompileUnitForOffset(DestCUID);
   return cantFail(getDwarfFile(Dir, FileName, 0, None, None, DestCUID,
                                DstUnit->getVersion()));
 }
 
 std::vector<BinaryFunction *> BinaryContext::getSortedFunctions() {
   std::vector<BinaryFunction *> SortedFunctions(BinaryFunctions.size());
-  std::transform(BinaryFunctions.begin(), BinaryFunctions.end(),
-                 SortedFunctions.begin(),
+  llvm::transform(BinaryFunctions, SortedFunctions.begin(),
                   [](std::pair<const uint64_t, BinaryFunction> &BFI) {
                     return &BFI.second;
                   });
 
-  std::stable_sort(SortedFunctions.begin(), SortedFunctions.end(),
+  llvm::stable_sort(SortedFunctions,
                     [](const BinaryFunction *A, const BinaryFunction *B) {
                       if (A->hasValidIndex() && B->hasValidIndex()) {
                         return A->getIndex() < B->getIndex();
                       }
                       return A->hasValidIndex();
                     });
   return SortedFunctions;
 }
 
 std::vector<BinaryFunction *> BinaryContext::getAllBinaryFunctions() {
   std::vector<BinaryFunction *> AllFunctions;
   AllFunctions.reserve(BinaryFunctions.size() + InjectedBinaryFunctions.size());
-  std::transform(BinaryFunctions.begin(), BinaryFunctions.end(),
-                 std::back_inserter(AllFunctions),
+  llvm::transform(BinaryFunctions, std::back_inserter(AllFunctions),
                   [](std::pair<const uint64_t, BinaryFunction> &BFI) {
                     return &BFI.second;
                   });
-  std::copy(InjectedBinaryFunctions.begin(), InjectedBinaryFunctions.end(),
-            std::back_inserter(AllFunctions));
+  llvm::copy(InjectedBinaryFunctions, std::back_inserter(AllFunctions));
 
   return AllFunctions;
 }
 
 Optional<DWARFUnit *> BinaryContext::getDWOCU(uint64_t DWOId) {
   auto Iter = DWOCUs.find(DWOId);
   if (Iter == DWOCUs.end())
     return None;
for (const std::unique_ptr<DWARFUnit> &CU : DwCtx->compile_units()) {
     ContainsDwarf5 |= CU->getVersion() >= 5;
     ContainsDwarfLegacy |= CU->getVersion() < 5;
   }
 
   if (ContainsDwarf5 && ContainsDwarfLegacy)
     llvm::errs() << "BOLT-WARNING: BOLT does not support mix mode binary with "
                     "DWARF5 and DWARF{2,3,4}.\n";
 
-  std::sort(AllRanges.begin(), AllRanges.end());
+  llvm::sort(AllRanges);
   for (auto &KV : BinaryFunctions) {
     const uint64_t FunctionAddress = KV.first;
     BinaryFunction &Function = KV.second;
 
-    auto It = std::partition_point(
-        AllRanges.begin(), AllRanges.end(),
-        [=](CURange R) { return R.HighPC <= FunctionAddress; });
-    if (It != AllRanges.end() && It->LowPC <= FunctionAddress) {
+    auto It = llvm::partition_point(
+        AllRanges, [=](CURange R) { return R.HighPC <= FunctionAddress; });
+    if (It != AllRanges.end() && It->LowPC <= FunctionAddress)
       Function.setDWARFUnit(It->Unit);
-    }
-  }
 
   // Discover units with debug info that needs to be updated.
   for (const auto &KV : BinaryFunctions) {
     const BinaryFunction &BF = KV.second;
     if (shouldEmit(BF) && BF.getDWARFUnit())
       ProcessedCUs.insert(BF.getDWARFUnit());
   }
 
DebugAddressRangesVector BinaryContext::translateModuleAddressRanges(
   for (const DWARFAddressRange Range : InputRanges) {
     auto BFI = BinaryFunctions.lower_bound(Range.LowPC);
     while (BFI != BinaryFunctions.end()) {
       const BinaryFunction &Function = BFI->second;
       if (Function.getAddress() >= Range.HighPC)
         break;
       const DebugAddressRangesVector FunctionRanges =
           Function.getOutputAddressRanges();
-      std::move(std::begin(FunctionRanges), std::end(FunctionRanges),
-                std::back_inserter(OutputRanges));
+      llvm::move(FunctionRanges, std::back_inserter(OutputRanges));
       std::advance(BFI, 1);
     }
   }
 
   return OutputRanges;
 }
 
 } // namespace bolt
 } // namespace llvm

bolt/lib/Core/BinaryEmitter.cpp

if (LSDASymbol)
       Streamer.emitCFILsda(LSDASymbol, BC.LSDAEncoding);
     else
       Streamer.emitCFILsda(0, dwarf::DW_EH_PE_omit);
     // Emit CFI instructions relative to the CIE
     for (const MCCFIInstruction &CFIInstr : Function.cie()) {
       // Only write CIE CFI insns that LLVM will not already emit
       const std::vector<MCCFIInstruction> &FrameInstrs =
           MAI->getInitialFrameState();
-      if (std::find(FrameInstrs.begin(), FrameInstrs.end(), CFIInstr) ==
-          FrameInstrs.end())
+      if (!llvm::is_contained(FrameInstrs, CFIInstr))
         emitCFIInstruction(CFIInstr);
     }
   }
 
   assert((Function.empty() || !(*Function.begin()).isCold()) &&
          "first basic block should never be cold");
 
   // Emit UD2 at the beginning if requested by user.
void BinaryEmitter::emitDebugLineInfoForUnprocessedCUs() {
   for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
     DWARFDie CUDie = CU->getUnitDIE();
     auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
     if (!StmtList)
       continue;
 
     StmtListOffsets.push_back(*StmtList);
   }
-  std::sort(StmtListOffsets.begin(), StmtListOffsets.end());
+  llvm::sort(StmtListOffsets);
 
   // For each CU that was not processed, emit its line info as a binary blob.
   for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
     if (BC.ProcessedCUs.count(CU.get()))
       continue;
 
     DWARFDie CUDie = CU->getUnitDIE();
     auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
     if (!StmtList)
       continue;
 
     StringRef DebugLineContents = CU->getLineSection().Data;
 
     const uint64_t Begin = *StmtList;
 
     // Statement list ends where the next unit contribution begins, or at the
     // end of the section.
-    auto It =
-        std::upper_bound(StmtListOffsets.begin(), StmtListOffsets.end(), Begin);
+    auto It = llvm::upper_bound(StmtListOffsets, Begin);
     const uint64_t End =
         It == StmtListOffsets.end() ? DebugLineContents.size() : *It;
 
     BC.getDwarfLineTable(CU->getOffset())
         .addRawContents(DebugLineContents.slice(Begin, End));
   }
 }
 

bolt/lib/Core/BinaryFunction.cpp

if (BasicBlockOffsets.empty())
     return nullptr;
 
   /*
    * This is commented out because it makes BOLT too slow.
    * assert(std::is_sorted(BasicBlockOffsets.begin(),
    *                       BasicBlockOffsets.end(),
    *                       CompareBasicBlockOffsets())));
    */
-  auto I = std::upper_bound(BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
-                            BasicBlockOffset(Offset, nullptr),
-                            CompareBasicBlockOffsets());
+  auto I =
+      llvm::upper_bound(BasicBlockOffsets, BasicBlockOffset(Offset, nullptr),
   assert(I != BasicBlockOffsets.begin() && "first basic block not at offset 0");
   --I;
   BinaryBasicBlock *BB = I->second;
   return (Offset < BB->getOffset() + BB->getOriginalSize()) ? BB : nullptr;
 }
 
 void BinaryFunction::markUnreachableBlocks() {
   std::stack<BinaryBasicBlock *> Stack;
for (uint32_t I = 0, E = BasicBlocksLayout.size(); I != E; ++I) {
     Offset = BC.printInstructions(OS, BB->begin(), BB->end(), Offset, this);
 
     if (!BB->succ_empty()) {
       OS << "  Successors: ";
       // For more than 2 successors, sort them based on frequency.
       std::vector<uint64_t> Indices(BB->succ_size());
       std::iota(Indices.begin(), Indices.end(), 0);
       if (BB->succ_size() > 2 && BB->getKnownExecutionCount()) {
-        std::stable_sort(Indices.begin(), Indices.end(),
-                         [&](const uint64_t A, const uint64_t B) {
-                           return BB->BranchInfo[B] < BB->BranchInfo[A];
-                         });
+        llvm::stable_sort(Indices, [&](const uint64_t A, const uint64_t B) {
       }
       ListSeparator LS;
       for (unsigned I = 0; I < Indices.size(); ++I) {
         BinaryBasicBlock *Succ = BB->Successors[Indices[I]];
         BinaryBasicBlock::BinaryBranchInfo &BI = BB->BranchInfo[Indices[I]];
         OS << LS << Succ->getName();
         if (ExecutionCount != COUNT_NO_PROFILE &&
             BI.MispredictedCount != BinaryBasicBlock::COUNT_INFERRED) {
for (uint64_t Offset : UnknownIndirectBranchOffsets) {
         TakenBranches.emplace_back(Offset, PossibleDestination);
       }
     }
   }
 
   // Remove duplicates branches. We can get a bunch of them from jump tables.
   // Without doing jump table value profiling we don't have use for extra
   // (duplicate) branches.
-  std::sort(TakenBranches.begin(), TakenBranches.end());
+  llvm::sort(TakenBranches);
   auto NewEnd = std::unique(TakenBranches.begin(), TakenBranches.end());
   TakenBranches.erase(NewEnd, TakenBranches.end());
 }
 
 bool BinaryFunction::postProcessIndirectBranches(
     MCPlusBuilder::AllocatorIdTy AllocId) {
   auto addUnknownControlFlow = [&](BinaryBasicBlock &BB) {
     HasUnknownControlFlow = true;

 
 } // namespace
 
 void BinaryFunction::dumpGraph(raw_ostream &OS) const {
   OS << "digraph \"" << getPrintName() << "\" {\n"
      << "node [fontname=courier, shape=box, style=filled, colorscheme=brbg9]\n";
   uint64_t Offset = Address;
   for (BinaryBasicBlock *BB : BasicBlocks) {
-    auto LayoutPos =
-        std::find(BasicBlocksLayout.begin(), BasicBlocksLayout.end(), BB);
+    auto LayoutPos = llvm::find(BasicBlocksLayout, BB);
     unsigned Layout = LayoutPos - BasicBlocksLayout.begin();
     const char *ColdStr = BB->isCold() ? " (cold)" : "";
     std::vector<std::string> Attrs;
     // Bold box for entry points
     if (isEntryPoint(*BB))
       Attrs.push_back("penwidth=2");
     if (BLI && BLI->getLoopFor(BB)) {
       // Distinguish innermost loops
for (const BinaryBasicBlock *Thrower : BB->throwers()) {
         errs() << "BOLT-ERROR: duplicate thrower detected in" << BB->getName()
                << " in function " << *this << '\n';
         return false;
       }
       BBThrowers.insert(Thrower);
     }
 
     for (const BinaryBasicBlock *LPBlock : BB->landing_pads()) {
-      if (std::find(LPBlock->throw_begin(), LPBlock->throw_end(), BB) ==
-          LPBlock->throw_end()) {
+      if (!llvm::is_contained(LPBlock->throwers(), BB)) {
         errs() << "BOLT-ERROR: inconsistent landing pad detected in " << *this
                << ": " << BB->getName() << " is in LandingPads but not in "
                << LPBlock->getName() << " Throwers\n";
         return false;
       }
     }
     for (const BinaryBasicBlock *Thrower : BB->throwers()) {
-      if (std::find(Thrower->lp_begin(), Thrower->lp_end(), BB) ==
-          Thrower->lp_end()) {
+      if (!llvm::is_contained(Thrower->landing_pads(), BB)) {
         errs() << "BOLT-ERROR: inconsistent thrower detected in " << *this
                << ": " << BB->getName() << " is in Throwers list but not in "
                << Thrower->getName() << " LandingPads\n";
         return false;
       }
     }
   }
 
void BinaryFunction::updateLayout(BinaryBasicBlock *Start,
   if (!Start) {
     BasicBlocksLayout.insert(layout_begin(), BasicBlocks.begin(),
                              BasicBlocks.begin() + NumNewBlocks);
     updateLayoutIndices();
     return;
   }
 
   // Insert new blocks in the layout immediately after Start.
-  auto Pos = std::find(layout_begin(), layout_end(), Start);
+  auto Pos = llvm::find(layout(), Start);
   assert(Pos != layout_end());
   BasicBlockListType::iterator Begin =
       std::next(BasicBlocks.begin(), getIndex(Start) + 1);
   BasicBlockListType::iterator End =
       std::next(BasicBlocks.begin(), getIndex(Start) + NumNewBlocks + 1);
   BasicBlocksLayout.insert(Pos + 1, Begin, End);
   updateLayoutIndices();
 }
DebugAddressRangesVector BinaryFunction::translateInputToOutputRanges(
   DebugAddressRangesVector OutputRanges;
 
   if (isFolded())
     return OutputRanges;
 
   // If the function hasn't changed return the same ranges.
   if (!isEmitted()) {
     OutputRanges.resize(InputRanges.size());
-    std::transform(InputRanges.begin(), InputRanges.end(), OutputRanges.begin(),
+    llvm::transform(InputRanges, OutputRanges.begin(),
                     [](const DWARFAddressRange &Range) {
                       return DebugAddressRange(Range.LowPC, Range.HighPC);
                     });
     return OutputRanges;
   }
 
   // Even though we will merge ranges in a post-processing pass, we attempt to
   // merge them in a main processing loop as it improves the processing time.
   uint64_t PrevEndAddress = 0;
   for (const DWARFAddressRange &Range : InputRanges) {
     if (!containsAddress(Range.LowPC)) {
       LLVM_DEBUG(
           dbgs() << "BOLT-DEBUG: invalid debug address range detected for "
                  << *this << " : [0x" << Twine::utohexstr(Range.LowPC) << ", 0x"
                  << Twine::utohexstr(Range.HighPC) << "]\n");
       PrevEndAddress = 0;
       continue;
     }
     uint64_t InputOffset = Range.LowPC - getAddress();
     const uint64_t InputEndOffset =
         std::min(Range.HighPC - getAddress(), getSize());
 
-    auto BBI = std::upper_bound(
-        BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
-        BasicBlockOffset(InputOffset, nullptr), CompareBasicBlockOffsets());
+    auto BBI = llvm::upper_bound(BasicBlockOffsets,
+                                 BasicBlockOffset(InputOffset, nullptr),
+                                 CompareBasicBlockOffsets());
     --BBI;
     do {
       const BinaryBasicBlock *BB = BBI->second;
       if (InputOffset < BB->getOffset() || InputOffset >= BB->getEndOffset()) {
         LLVM_DEBUG(
             dbgs() << "BOLT-DEBUG: invalid debug address range detected for "
                    << *this << " : [0x" << Twine::utohexstr(Range.LowPC)
                    << ", 0x" << Twine::utohexstr(Range.HighPC) << "]\n");
do {
       }
 
       InputOffset = BB->getEndOffset();
       ++BBI;
     } while (InputOffset < InputEndOffset);
   }
 
   // Post-processing pass to sort and merge ranges.
-  std::sort(OutputRanges.begin(), OutputRanges.end());
+  llvm::sort(OutputRanges);
   DebugAddressRangesVector MergedRanges;
   PrevEndAddress = 0;
   for (const DebugAddressRange &Range : OutputRanges) {
     if (Range.LowPC <= PrevEndAddress) {
       MergedRanges.back().HighPC =
           std::max(MergedRanges.back().HighPC, Range.HighPC);
     } else {
       MergedRanges.emplace_back(Range.LowPC, Range.HighPC);
if (!containsAddress(Start)) {
       LLVM_DEBUG(dbgs() << "BOLT-DEBUG: invalid debug address range detected "
                            "for "
                         << *this << " : [0x" << Twine::utohexstr(Start)
                         << ", 0x" << Twine::utohexstr(End) << "]\n");
       continue;
     }
     uint64_t InputOffset = Start - getAddress();
     const uint64_t InputEndOffset = std::min(End - getAddress(), getSize());
-    auto BBI = std::upper_bound(
-        BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
-        BasicBlockOffset(InputOffset, nullptr), CompareBasicBlockOffsets());
+    auto BBI = llvm::upper_bound(BasicBlockOffsets,
+                                 BasicBlockOffset(InputOffset, nullptr),
+                                 CompareBasicBlockOffsets());
     --BBI;
     do {
       const BinaryBasicBlock *BB = BBI->second;
       if (InputOffset < BB->getOffset() || InputOffset >= BB->getEndOffset()) {
         LLVM_DEBUG(dbgs() << "BOLT-DEBUG: invalid debug address range detected "
                              "for "
                           << *this << " : [0x" << Twine::utohexstr(Start)
                           << ", 0x" << Twine::utohexstr(End) << "]\n");
do {
       }
 
       ++BBI;
       InputOffset = BB->getEndOffset();
     } while (InputOffset < InputEndOffset);
   }
 
   // Sort and merge adjacent entries with identical location.
-  std::stable_sort(
-      OutputLL.begin(), OutputLL.end(),
-      [](const DebugLocationEntry &A, const DebugLocationEntry &B) {
+  llvm::stable_sort(
+      OutputLL, [](const DebugLocationEntry &A, const DebugLocationEntry &B) {
         return A.LowPC < B.LowPC;
       });
   DebugLocationsVector MergedLL;
   PrevEndAddress = 0;
   PrevExpr = nullptr;
   for (const DebugLocationEntry &Entry : OutputLL) {
     if (Entry.LowPC <= PrevEndAddress && *PrevExpr == Entry.Expr) {
       MergedLL.back().HighPC = std::max(Entry.HighPC, MergedLL.back().HighPC);

bolt/lib/Core/DebugData.cpp

 }
 
 DebugAddrWriter::DebugAddrWriter(BinaryContext *Bc) { BC = Bc; }
 
 void DebugAddrWriter::AddressForDWOCU::dump() {
   std::vector<IndexAddressPair> SortedMap(indexToAddressBegin(),
                                           indexToAdddessEnd());
   // Sorting address in increasing order of indices.
-  std::sort(SortedMap.begin(), SortedMap.end(),
+  llvm::sort(SortedMap,
              [](const IndexAddressPair &A, const IndexAddressPair &B) {
                return A.first < B.first;
              });
   for (auto &Pair : SortedMap)
     dbgs() << Twine::utohexstr(Pair.second) << "\t" << Pair.first << "\n";
 }
 uint32_t DebugAddrWriter::getIndexFromAddress(uint64_t Address, DWARFUnit &CU) {
   std::lock_guard<std::mutex> Lock(WriterMutex);
   const uint64_t CUID = getCUID(CU);
   if (!AddressMaps.count(CUID))
     AddressMaps[CUID] = AddressForDWOCU();
for (std::unique_ptr<DWARFUnit> &CU : BC->DwCtx->compile_units()) {
     // The Skeleton CU might still have DW_AT_GNU_addr_base.
     DWOIdToOffsetMap[CUID] = Buffer.size();
     // If does not exist this CUs DWO section didn't contribute to .debug_addr.
     if (AM == AddressMaps.end())
       continue;
     std::vector<IndexAddressPair> SortedMap(AM->second.indexToAddressBegin(),
                                             AM->second.indexToAdddessEnd());
     // Sorting address in increasing order of indices.
-    std::sort(SortedMap.begin(), SortedMap.end(),
+    llvm::sort(SortedMap,
                [](const IndexAddressPair &A, const IndexAddressPair &B) {
                  return A.first < B.first;
                });
 
     uint8_t AddrSize = CU->getAddressByteSize();
     uint32_t Counter = 0;
     auto WriteAddress = [&](uint64_t Address) -> void {
       ++Counter;
       switch (AddrSize) {
       default:
         assert(false && "Address Size is invalid.");
for (std::unique_ptr<DWARFUnit> &CU : BC->DwCtx->compile_units()) {
     }
 
     DWOIdToOffsetMap[CUID] = Buffer.size() + HeaderSize;
 
     std::vector<IndexAddressPair> SortedMap(
         AMIter->second.indexToAddressBegin(),
         AMIter->second.indexToAdddessEnd());
     // Sorting address in increasing order of indices.
-    std::sort(SortedMap.begin(), SortedMap.end(),
+    llvm::sort(SortedMap,
                [](const IndexAddressPair &A, const IndexAddressPair &B) {
                  return A.first < B.first;
                });
     // Writing out Header
     const uint32_t Length = SortedMap.size() * AddrSize + 4;
     support::endian::write(AddressStream, Length, Endian);
     support::endian::write(AddressStream, static_cast<uint16_t>(5), Endian);
     support::endian::write(AddressStream, static_cast<uint8_t>(AddrSize),
                            Endian);
     support::endian::write(AddressStream, static_cast<uint8_t>(0), Endian);
 
for (const auto &Patch : Patches) {
     }
   }
   return BinaryContentsStr;
 }
 
 CUOffsetMap DebugInfoBinaryPatcher::computeNewOffsets(DWARFContext &DWCtx,
                                                       bool IsDWOContext) {
   CUOffsetMap CUMap;
-  std::sort(DebugPatches.begin(), DebugPatches.end(),
-            [](const UniquePatchPtrType &V1, const UniquePatchPtrType &V2) {
-              if (V1.get()->Offset == V2.get()->Offset) {
-                if (V1->Kind == DebugPatchKind::NewDebugEntry &&
-                    V2->Kind == DebugPatchKind::NewDebugEntry)
-                  return reinterpret_cast<const NewDebugEntry *>(V1.get())
-                             ->CurrentOrder <
-                         reinterpret_cast<const NewDebugEntry *>(V2.get())
-                             ->CurrentOrder;
+  llvm::sort(DebugPatches, [](const UniquePatchPtrType &V1,
+                              const UniquePatchPtrType &V2) {
+        return reinterpret_cast<const NewDebugEntry *>(V1.get())->CurrentOrder <
+               reinterpret_cast<const NewDebugEntry *>(V2.get())->CurrentOrder;
 
-                // This is a case where we are modifying first entry of next
-                // DIE, and adding a new one.
-                return V1->Kind == DebugPatchKind::NewDebugEntry;
-              }
-              return V1.get()->Offset < V2.get()->Offset;
-            });
 
   DWARFUnitVector::compile_unit_range CompileUnits =
       IsDWOContext ? DWCtx.dwo_compile_units() : DWCtx.compile_units();
 
   for (const std::unique_ptr<DWARFUnit> &CU : CompileUnits)
     CUMap[CU->getOffset()] = {static_cast<uint32_t>(CU->getOffset()),
                               static_cast<uint32_t>(CU->getLength())};
 

bolt/lib/Core/DynoStats.cpp

if (opts::PrintDynoOpcodeStat && Printer) {
     outs() << "\nProgram-wide opcode histogram:\n";
     OS << "              Opcode,   Execution Count,     Max Exec Count, "
           "Function Name:Offset ...\n";
     std::vector<std::pair<uint64_t, unsigned>> SortedHistogram;
     for (const OpcodeStatTy &Stat : OpcodeHistogram)
       SortedHistogram.emplace_back(Stat.second.first, Stat.first);
 
     // Sort using lexicographic ordering
-    std::sort(SortedHistogram.begin(), SortedHistogram.end());
+    llvm::sort(SortedHistogram);
 
     // Dump in ascending order: Start with Opcode with Highest execution
     // count.
     for (auto Stat = SortedHistogram.rbegin(); Stat != SortedHistogram.rend();
          ++Stat) {
       OS << format("%20s,%'18lld", Printer->getOpcodeName(Stat->second).data(),
                    Stat->first * opts::DynoStatsScale);
 

bolt/lib/Core/Exceptions.cpp

 std::vector<char> CFIReaderWriter::generateEHFrameHeader(
     const DWARFDebugFrame &OldEHFrame, const DWARFDebugFrame &NewEHFrame,
     uint64_t EHFrameHeaderAddress,
     std::vector<uint64_t> &FailedAddresses) const {
   // Common PC -> FDE map to be written into .eh_frame_hdr.
   std::map<uint64_t, uint64_t> PCToFDE;
 
   // Presort array for binary search.
-  std::sort(FailedAddresses.begin(), FailedAddresses.end());
+  llvm::sort(FailedAddresses);
 
   // Initialize PCToFDE using NewEHFrame.
   for (dwarf::FrameEntry &Entry : NewEHFrame.entries()) {
     const dwarf::FDE *FDE = dyn_cast<dwarf::FDE>(&Entry);
     if (FDE == nullptr)
       continue;
     const uint64_t FuncAddress = FDE->getInitialLocation();
     const uint64_t FDEAddress =
if (!std::binary_search(FailedAddresses.begin(), FailedAddresses.end(),
       LLVM_DEBUG(dbgs() << "BOLT-DEBUG: FDE for function at 0x"
                         << Twine::utohexstr(FuncAddress) << " is at 0x"
                         << Twine::utohexstr(FDEAddress) << '\n');
       PCToFDE[FuncAddress] = FDEAddress;
     }
   };
 
   LLVM_DEBUG(dbgs() << "BOLT-DEBUG: new .eh_frame contains "
-                    << std::distance(NewEHFrame.entries().begin(),
-                                     NewEHFrame.entries().end())
-                    << " entries\n");
+                    << llvm::size(NewEHFrame.entries()) << " entries\n");
 
   // Add entries from the original .eh_frame corresponding to the functions
   // that we did not update.
   for (const dwarf::FrameEntry &Entry : OldEHFrame) {
     const dwarf::FDE *FDE = dyn_cast<dwarf::FDE>(&Entry);
     if (FDE == nullptr)
       continue;
     const uint64_t FuncAddress = FDE->getInitialLocation();
     const uint64_t FDEAddress =
         OldEHFrame.getEHFrameAddress() + FDE->getOffset();
 
     // Add the address if we failed to write it.
     if (PCToFDE.count(FuncAddress) == 0) {
       LLVM_DEBUG(dbgs() << "BOLT-DEBUG: old FDE for function at 0x"
                         << Twine::utohexstr(FuncAddress) << " is at 0x"
                         << Twine::utohexstr(FDEAddress) << '\n');
       PCToFDE[FuncAddress] = FDEAddress;
     }
   };
 
   LLVM_DEBUG(dbgs() << "BOLT-DEBUG: old .eh_frame contains "
-                    << std::distance(OldEHFrame.entries().begin(),
-                                     OldEHFrame.entries().end())
-                    << " entries\n");
+                    << llvm::size(OldEHFrame.entries()) << " entries\n");
 
   // Generate a new .eh_frame_hdr based on the new map.
 
   // Header plus table of entries of size 8 bytes.
   std::vector<char> EHFrameHeader(12 + PCToFDE.size() * 8);
 
   // Version is 1.
   EHFrameHeader[0] = 1;

bolt/lib/Passes/BinaryPasses.cpp

void PrintProgramStats::runOnFunctions(BinaryContext &BC) {
   if (const uint64_t NumUnusedObjects = BC.getNumUnusedProfiledObjects()) {
     outs() << "BOLT-INFO: profile for " << NumUnusedObjects
            << " objects was ignored\n";
   }
 
   if (ProfiledFunctions.size() > 10) {
     if (opts::Verbosity >= 1) {
       outs() << "BOLT-INFO: top called functions are:\n";
-      std::sort(ProfiledFunctions.begin(), ProfiledFunctions.end(),
+      llvm::sort(ProfiledFunctions,
                  [](const BinaryFunction *A, const BinaryFunction *B) {
                    return B->getExecutionCount() < A->getExecutionCount();
                  });
       auto SFI = ProfiledFunctions.begin();
       auto SFIend = ProfiledFunctions.end();
       for (unsigned I = 0u; I < opts::TopCalledLimit && SFI != SFIend;
            ++SFI, ++I)
         outs() << "  " << **SFI << " : " << (*SFI)->getExecutionCount() << '\n';
     }
   }
 
   if (!opts::PrintSortedBy.empty() &&
-      std::find(opts::PrintSortedBy.begin(), opts::PrintSortedBy.end(),
-                DynoStats::FIRST_DYNO_STAT) == opts::PrintSortedBy.end()) {
+      !llvm::is_contained(opts::PrintSortedBy, DynoStats::FIRST_DYNO_STAT)) {
 
     std::vector<const BinaryFunction *> Functions;
     std::map<const BinaryFunction *, DynoStats> Stats;
 
     for (const auto &BFI : BC.getBinaryFunctions()) {
       const BinaryFunction &BF = BFI.second;
       if (shouldOptimize(BF) && BF.hasValidProfile()) {
         Functions.push_back(&BF);
         Stats.emplace(&BF, getDynoStats(BF));
       }
     }
 
     const bool SortAll =
-        std::find(opts::PrintSortedBy.begin(), opts::PrintSortedBy.end(),
-                  DynoStats::LAST_DYNO_STAT) != opts::PrintSortedBy.end();
+        llvm::is_contained(opts::PrintSortedBy, DynoStats::LAST_DYNO_STAT);
 
     const bool Ascending =
         opts::DynoStatsSortOrderOpt == opts::DynoStatsSortOrder::Ascending;
 
     if (SortAll) {
-      std::stable_sort(Functions.begin(), Functions.end(),
+      llvm::stable_sort(Functions,
                         [Ascending, &Stats](const BinaryFunction *A,
                                             const BinaryFunction *B) {
                           return Ascending ? Stats.at(A) < Stats.at(B)
                                            : Stats.at(B) < Stats.at(A);
                         });
     } else {
-      std::stable_sort(
-          Functions.begin(), Functions.end(),
-          [Ascending, &Stats](const BinaryFunction *A,
+      llvm::stable_sort(
+          Functions, [Ascending, &Stats](const BinaryFunction *A,
                                          const BinaryFunction *B) {
             const DynoStats &StatsA = Stats.at(A);
             const DynoStats &StatsB = Stats.at(B);
             return Ascending ? StatsA.lessThan(StatsB, opts::PrintSortedBy)
                              : StatsB.lessThan(StatsA, opts::PrintSortedBy);
           });
     }
 
     outs() << "BOLT-INFO: top functions sorted by ";
for (auto &BFI : BC.getBinaryFunctions()) {
         if (HotSeen && BB->getKnownExecutionCount() == 0) {
           SuboptimalFuncs.push_back(&BF);
           break;
         }
       }
     }
 
     if (!SuboptimalFuncs.empty()) {
-      std::sort(SuboptimalFuncs.begin(), SuboptimalFuncs.end(),
+      llvm::sort(SuboptimalFuncs,
                  [](const BinaryFunction *A, const BinaryFunction *B) {
                    return A->getKnownExecutionCount() / A->getSize() >
                           B->getKnownExecutionCount() / B->getSize();
                  });
 
       outs() << "BOLT-INFO: " << SuboptimalFuncs.size()
              << " functions have "
                 "cold code in the middle of hot code. Top functions are:\n";
       for (unsigned I = 0;
            I < std::min(static_cast<size_t>(opts::ReportBadLayout),
                         SuboptimalFuncs.size());
            ++I)

bolt/lib/Passes/ExtTSPReorderAlgorithm.cpp

void mergeChains(Chain *Into, Chain *From, size_t MergeOffset,
     // Update cached ext-tsp score for the new chain
     Edge *SelfEdge = Into->getEdge(Into);
     if (SelfEdge != nullptr) {
       MergedBlocks = MergedChain(Into->blocks().begin(), Into->blocks().end());
       Into->setScore(score(MergedBlocks, SelfEdge->jumps()));
     }
 
     // Remove chain From from the list of active chains
-    auto Iter = std::remove(HotChains.begin(), HotChains.end(), From);
-    HotChains.erase(Iter, HotChains.end());
+    llvm::erase_value(HotChains, From);
 
     // Invalidate caches
     for (std::pair<Chain *, Edge *> EdgeIter : Into->edges())
       EdgeIter.second->invalidateCache();
   }
 
   /// Concatenate all chains into a final order
   void concatChains(BinaryFunction::BasicBlockOrderType &Order) {
     // Collect chains
     std::vector<Chain *> SortedChains;
     for (Chain &Chain : AllChains)
       if (Chain.blocks().size() > 0)
         SortedChains.push_back(&Chain);
 
     // Sorting chains by density in decreasing order
-    std::stable_sort(
-      SortedChains.begin(), SortedChains.end(),
-      [](const Chain *C1, const Chain *C2) {
-        // Original entry point to the front
-        if (C1->isEntryPoint() != C2->isEntryPoint()) {
-          if (C1->isEntryPoint())
-            return true;
-          if (C2->isEntryPoint())
-            return false;
-        }
+    llvm::stable_sort(SortedChains, [](const Chain *C1, const Chain *C2) {
 
-        const double D1 = C1->density();
-        const double D2 = C2->density();
-        if (D1 != D2)
-          return D1 > D2;
 
-        // Making the order deterministic
-        return C1->id() < C2->id();
-      }
-    );
+    });
 
     // Collect the basic blocks in the order specified by their chains
     Order.reserve(BF.layout_size());
     for (Chain *Chain : SortedChains)
       for (Block *Block : Chain->blocks())
         Order.push_back(Block->BB);
   }
 

bolt/lib/Passes/HFSort.cpp

std::string Cluster::toString() const {
   CS << "]";
   return CS.str();
 }
 
 namespace {
 
 void freezeClusters(const CallGraph &Cg, std::vector<Cluster> &Clusters) {
   uint32_t TotalSize = 0;
-  std::sort(Clusters.begin(), Clusters.end(), compareClustersDensity);
+  llvm::sort(Clusters, compareClustersDensity);
   for (Cluster &C : Clusters) {
     uint32_t NewSize = TotalSize + C.size();
     if (NewSize > FrozenPages * HugePageSize)
       break;
     C.freeze();
     TotalSize = NewSize;
     LLVM_DEBUG(NodeId Fid = C.target(0);
                dbgs() << format(
std::vector<Cluster> clusterize(const CallGraph &Cg) {
 
   freezeClusters(Cg, Clusters);
 
   // The size and order of Clusters is fixed until we reshuffle it immediately
   // before returning.
   for (Cluster &Cluster : Clusters)
     FuncCluster[Cluster.targets().front()] = &Cluster;
 
-  std::sort(SortedFuncs.begin(), SortedFuncs.end(),
-            [&](const NodeId F1, const NodeId F2) {
-              const CallGraph::Node &Func1 = Cg.getNode(F1);
-              const CallGraph::Node &Func2 = Cg.getNode(F2);
-              return Func1.samples() * Func2.size() > // TODO: is this correct?
-                     Func2.samples() * Func1.size();
-            });
+  llvm::sort(SortedFuncs, [&](const NodeId F1, const NodeId F2) {
 
   // Process each function, and consider merging its cluster with the
   // one containing its most likely predecessor.
   for (const NodeId Fid : SortedFuncs) {
     Cluster *Cluster = FuncCluster[Fid];
     if (Cluster->frozen())
       continue;
 
for (const NodeId Func : SortedFuncs) {
     Cluster *Cluster = FuncCluster[Func];
     if (!Cluster || Visited.count(Cluster) == 1 || Cluster->target(0) != Func)
       continue;
 
     SortedClusters.emplace_back(std::move(*Cluster));
     Visited.insert(Cluster);
   }
 
-  std::sort(SortedClusters.begin(), SortedClusters.end(),
-            compareClustersDensity);
+  llvm::sort(SortedClusters, compareClustersDensity);
 
   return SortedClusters;
 }
 
 std::vector<Cluster> randomClusters(const CallGraph &Cg) {
   std::vector<NodeId> FuncIds(Cg.numNodes(), 0);
   std::vector<Cluster> Clusters;
   Clusters.reserve(Cg.numNodes());
 
   for (NodeId F = 0; F < Cg.numNodes(); F++) {
     if (Cg.samples(F) == 0)
       continue;
     Clusters.emplace_back(F, Cg.getNode(F));
   }
 
-  std::sort(
-      Clusters.begin(), Clusters.end(),
-      [](const Cluster &A, const Cluster &B) { return A.size() < B.size(); });
+  llvm::sort(Clusters, [](const Cluster &A, const Cluster &B) {
+    return A.size() < B.size();
+  });
 
   auto pickMergeCluster = [&Clusters](const size_t Idx) {
     size_t MaxIdx = Idx + 1;
 
     while (MaxIdx < Clusters.size() &&
            Clusters[Idx].size() + Clusters[MaxIdx].size() <= MaxClusterSize)
       ++MaxIdx;
 

bolt/lib/Passes/HFSortPlus.cpp

std::vector<Cluster> run() {
 
     // Sorting chains by density in decreasing order
     auto DensityComparator = [](const Chain *L, const Chain *R) {
       if (L->density() != R->density())
         return L->density() > R->density();
       // Making sure the comparison is deterministic
       return L->Id < R->Id;
     };
-    std::stable_sort(HotChains.begin(), HotChains.end(), DensityComparator);
+    llvm::stable_sort(HotChains, DensityComparator);
 
     // Return the set of clusters that are left, which are the ones that
     // didn't get merged (so their first func is its original func)
     std::vector<Cluster> Clusters;
     Clusters.reserve(HotChains.size());
     for (Chain *Chain : HotChains)
       Clusters.emplace_back(Cluster(Chain->Nodes, Cg));
     return Clusters;
for (Chain *ChainPred : HotChains) {
         assert(0.0 <= ProbIn && ProbIn <= 1.0 && "incorrect in-probability");
 
         if (std::min(ProbOut, ProbIn) >= opts::MergeProbability)
           ArcsToMerge.push_back(&Arc);
       }
     }
 
     // Sort the pairs by the weight in reverse order
-    std::sort(
-        ArcsToMerge.begin(), ArcsToMerge.end(),
-        [](const Arc *L, const Arc *R) { return L->weight() > R->weight(); });
+    llvm::sort(ArcsToMerge, [](const Arc *L, const Arc *R) {
+      return L->weight() > R->weight();
+    });
 
     // Merge the pairs of chains
     for (const Arc *Arc : ArcsToMerge) {
       Chain *ChainPred = NodeChain[Arc->src()];
       Chain *ChainSucc = NodeChain[Arc->dst()];
       if (ChainPred == ChainSucc)
         continue;
       if (ChainPred->Nodes.back() == Arc->src() &&
void mergeChains(Chain *Into, Chain *From) {
     Into->mergeEdges(From);
     From->clear();
 
     // Update cached scores for the new chain
     Into->ShortCalls = shortCalls(Into);
     Into->Score = score(Into);
 
     // Remove chain From From the list of active chains
-    auto it = std::remove(HotChains.begin(), HotChains.end(), From);
-    HotChains.erase(it, HotChains.end());
+    llvm::erase_value(HotChains, From);
   }
 
 private:
   // The call graph
   const CallGraph &Cg;
 
   // All chains of functions
   std::vector<Chain> AllChains;

bolt/lib/Passes/IdenticalCodeFolding.cpp

auto processSingleBucket = [&](std::set<BinaryFunction *> &Candidates) {
       for (auto &IBI : IdenticalBuckets) {
         // Functions identified as identical.
         std::vector<BinaryFunction *> &Twins = IBI.second;
         if (Twins.size() < 2)
           continue;
 
         // Fold functions. Keep the order consistent across invocations with
         // different options.
-        std::stable_sort(Twins.begin(), Twins.end(),
-                         [](const BinaryFunction *A, const BinaryFunction *B) {
-                           return A->getFunctionNumber() <
-                                  B->getFunctionNumber();
-                         });
+        llvm::stable_sort(
+            Twins, [](const BinaryFunction *A, const BinaryFunction *B) {
+              return A->getFunctionNumber() < B->getFunctionNumber();
 
         BinaryFunction *ParentBF = Twins[0];
         for (unsigned I = 1; I < Twins.size(); ++I) {
           BinaryFunction *ChildBF = Twins[I];
           LLVM_DEBUG(dbgs() << "BOLT-DEBUG: folding " << *ChildBF << " into "
                             << *ParentBF << '\n');
 
           // Remove child function from the list of candidates.

bolt/lib/Passes/IndirectCallPromotion.cpp

for (size_t I = Range.first; I < Range.second; ++I, JI += JIAdj) {
         continue;
       const Location To(Entry);
       const BinaryBasicBlock::BinaryBranchInfo &BI = BB.getBranchInfo(Entry);
       Targets.emplace_back(From, To, BI.MispredictedCount, BI.Count,
                            I - Range.first);
     }
 
     // Sort by symbol then addr.
-    std::sort(Targets.begin(), Targets.end(),
-              [](const Callsite &A, const Callsite &B) {
-                if (A.To.Sym && B.To.Sym)
-                  return A.To.Sym < B.To.Sym;
-                else if (A.To.Sym && !B.To.Sym)
-                  return true;
-                else if (!A.To.Sym && B.To.Sym)
-                  return false;
-                else
-                  return A.To.Addr < B.To.Addr;
-              });
+    llvm::sort(Targets, [](const Callsite &A, const Callsite &B) {
 
     // Targets may contain multiple entries to the same target, but using
     // different indices. Their profile will report the same number of branches
     // for different indices if the target is the same. That's because we don't
     // profile the index value, but only the target via LBR.
     auto First = Targets.begin();
     auto Last = Targets.end();
     auto Result = First;
if (ICSP) {
           Targets.emplace_back(std::move(Site));
       }
     }
   }
 
   // Sort by target count, number of indices in case of jump table, and
   // mispredicts. We prioritize targets with high count, small number of indices
   // and high mispredicts. Break ties by selecting targets with lower addresses.
-  std::stable_sort(Targets.begin(), Targets.end(),
-                   [](const Callsite &A, const Callsite &B) {
-                     if (A.Branches != B.Branches)
-                       return A.Branches > B.Branches;
-                     if (A.JTIndices.size() != B.JTIndices.size())
-                       return A.JTIndices.size() < B.JTIndices.size();
-                     if (A.Mispreds != B.Mispreds)
-                       return A.Mispreds > B.Mispreds;
-                     return A.To.Addr < B.To.Addr;
-                   });
+  llvm::stable_sort(Targets, [](const Callsite &A, const Callsite &B) {
 
   // Remove non-symbol targets
-  auto Last = std::remove_if(Targets.begin(), Targets.end(),
-                             [](const Callsite &CS) { return !CS.To.Sym; });
-  Targets.erase(Last, Targets.end());
+  llvm::erase_if(Targets, [](const Callsite &CS) { return !CS.To.Sym; });
 
   LLVM_DEBUG(if (BF.getJumpTable(Inst)) {
     uint64_t TotalCount = 0;
     uint64_t TotalMispreds = 0;
     for (const Callsite &S : Targets) {
       TotalCount += S.Branches;
       TotalMispreds += S.Mispreds;
     }
for (const AddressAccess &AccessInfo : MemAccessProfile.AddressAccessInfo) {
     }
 
     std::pair<uint64_t, uint64_t> &HotTarget =
         HotTargetMap[JT->Entries[Index + Range.first]];
     HotTarget.first += AccessInfo.Count;
     HotTarget.second = Index;
   }
 
-  std::transform(
-      HotTargetMap.begin(), HotTargetMap.end(), std::back_inserter(HotTargets),
+  llvm::transform(
+      HotTargetMap, std::back_inserter(HotTargets),
       [](const std::pair<MCSymbol *, std::pair<uint64_t, uint64_t>> &A) {
         return A.second;
       });
 
   // Sort with highest counts first.
-  std::sort(HotTargets.rbegin(), HotTargets.rend());
+  llvm::sort(reverse(HotTargets));
 
   LLVM_DEBUG({
     dbgs() << "BOLT-INFO: ICP jump table hot targets:\n";
     for (const std::pair<uint64_t, uint64_t> &Target : HotTargets)
       dbgs() << "BOLT-INFO:  Idx = " << Target.second << ", "
              << "Count = " << Target.first << "\n";
   });
 
for (; I < HotTargets.size(); ++I) {
         break;
       RemainingMemAccesses -= MemAccesses;
 
       const uint64_t JTIndex = HotTargets[I].second;
       Callsite &Target = Targets[findTargetsIndex(JTIndex)];
 
       NewTargets.push_back(Target);
       std::vector<uint64_t>({JTIndex}).swap(NewTargets.back().JTIndices);
-      Target.JTIndices.erase(std::remove(Target.JTIndices.begin(),
-                                         Target.JTIndices.end(), JTIndex),
-                             Target.JTIndices.end());
+      llvm::erase_value(Target.JTIndices, JTIndex);
 
       // Keep fixCFG counts sane if more indices use this same target later
       assert(IndicesPerTarget[Target.To.Sym] > 0 && "wrong map");
       NewTargets.back().Branches =
           Target.Branches / IndicesPerTarget[Target.To.Sym];
       NewTargets.back().Mispreds =
           Target.Mispreds / IndicesPerTarget[Target.To.Sym];
       assert(Target.Branches >= NewTargets.back().Branches);
       assert(Target.Mispreds >= NewTargets.back().Mispreds);
       Target.Branches -= NewTargets.back().Branches;
       Target.Mispreds -= NewTargets.back().Mispreds;
     }
-    std::copy(Targets.begin(), Targets.end(), std::back_inserter(NewTargets));
+    llvm::copy(Targets, std::back_inserter(NewTargets));
     std::swap(NewTargets, Targets);
     N = I;
 
     if (N == 0 && opts::Verbosity >= 1) {
       outs() << "BOLT-INFO: ICP failed in " << *BB.getFunction() << " in "
              << BB.getName() << ": failed to meet thresholds after memory "
              << "profile data was loaded.\n";
       return SymTargets;
for (auto &BFIt : BFs) {
                 std::make_tuple(NumCalls, &Inst, &Function));
             TotalIndirectCalls += NumCalls;
           }
         }
       }
     }
 
     // Sort callsites by execution count.
-    std::sort(IndirectCalls.rbegin(), IndirectCalls.rend());
+    llvm::sort(reverse(IndirectCalls));
 
     // Find callsites that contribute to the top "opts::ICPTopCallsites"%
     // number of calls.
     const float TopPerc = opts::ICPTopCallsites / 100.0f;
     int64_t MaxCalls = TotalIndirectCalls * TopPerc;
     uint64_t LastFreq = std::numeric_limits<uint64_t>::max();
     size_t Num = 0;
     for (const IndirectCallsite &IC : IndirectCalls) {

bolt/lib/Passes/Inliner.cpp

for (MCInst Inst : BB) {
       }
 
       InsertII =
           std::next(InlinedBB->insertInstruction(InsertII, std::move(Inst)));
     }
 
     // Add CFG edges to the basic blocks of the inlined instance.
     std::vector<BinaryBasicBlock *> Successors(BB.succ_size());
-    std::transform(BB.succ_begin(), BB.succ_end(), Successors.begin(),
+    llvm::transform(BB.successors(), Successors.begin(),
                     [&InlinedBBMap](const BinaryBasicBlock *BB) {
                       return InlinedBBMap.at(BB);
                     });
 
     if (CallerFunction.hasValidProfile() && Callee.hasValidProfile())
       InlinedBB->addSuccessors(Successors.begin(), Successors.end(),
                                BB.branch_info_begin(), BB.branch_info_end());
     else
       InlinedBB->addSuccessors(Successors.begin(), Successors.end());
 
     if (!CSIsTailCall && BB.succ_size() == 0 && NextBB) {
Inliner::inlineCall(BinaryBasicBlock &CallerBB,
 
   return std::make_pair(FirstInlinedBB, FirstInlinedBB->end());
 }
 
 bool Inliner::inlineCallsInFunction(BinaryFunction &Function) {
   BinaryContext &BC = Function.getBinaryContext();
   std::vector<BinaryBasicBlock *> Blocks(Function.layout().begin(),
                                          Function.layout().end());
-  std::sort(Blocks.begin(), Blocks.end(),
-            [](const BinaryBasicBlock *BB1, const BinaryBasicBlock *BB2) {
-              return BB1->getKnownExecutionCount() >
-                     BB2->getKnownExecutionCount();
-            });
+  llvm::sort(
+      Blocks, [](const BinaryBasicBlock *BB1, const BinaryBasicBlock *BB2) {
+        return BB1->getKnownExecutionCount() > BB2->getKnownExecutionCount();
 
   bool DidInlining = false;
   for (BinaryBasicBlock *BB : Blocks) {
     for (auto InstIt = BB->begin(); InstIt != BB->end();) {
       MCInst &Inst = *InstIt;
       if (!BC.MIB->isCall(Inst) || MCPlus::getNumPrimeOperands(Inst) != 1 ||
           !Inst.getOperand(0).isExpr()) {
         ++InstIt;
do {
 
     std::vector<BinaryFunction *> ConsideredFunctions;
     for (auto &BFI : BC.getBinaryFunctions()) {
       BinaryFunction &Function = BFI.second;
       if (!shouldOptimize(Function))
         continue;
       ConsideredFunctions.push_back(&Function);
     }
-    std::sort(ConsideredFunctions.begin(), ConsideredFunctions.end(),
-              [](const BinaryFunction *A, const BinaryFunction *B) {
-                return B->getKnownExecutionCount() <
-                       A->getKnownExecutionCount();
-              });
+    llvm::sort(ConsideredFunctions, [](const BinaryFunction *A,
+                                       const BinaryFunction *B) {
+      return B->getKnownExecutionCount() < A->getKnownExecutionCount();
     for (BinaryFunction *Function : ConsideredFunctions) {
       if (opts::InlineLimit && NumInlinedCallSites >= opts::InlineLimit)
         break;
 
       const bool DidInline = inlineCallsInFunction(*Function);
 
       if (DidInline)
         Modified.insert(Function);

bolt/lib/Passes/Instrumentation.cpp

if (BinaryData *BD = BC.getBinaryDataByName("___GLOBAL_init_65535/1")) {
           BC.getUniqueSectionByName("I__fini");
       if (!FiniSection) {
         llvm::errs() << "Cannot find I__fini section\n";
         exit(1);
       }
       MCSymbol *Target = BC.registerNameAtAddress(
           "__bolt_instr_fini", FiniSection->getAddress(), 0, 0);
       auto IsLEA = [&BC](const MCInst &Inst) { return BC.MIB->isLEA64r(Inst); };
-      const auto LEA =
-          std::find_if(std::next(std::find_if(BB.rbegin(), BB.rend(), IsLEA)),
-                       BB.rend(), IsLEA);
+      const auto LEA = std::find_if(
+          std::next(llvm::find_if(reverse(BB), IsLEA)), BB.rend(), IsLEA);
       LEA->getOperand(4).setExpr(
           MCSymbolRefExpr::create(Target, MCSymbolRefExpr::VK_None, *BC.Ctx));
     } else {
       llvm::errs() << "BOLT-WARNING: ___GLOBAL_init_65535 not found\n";
     }
   }
 
   setupRuntimeLibrary(BC);

bolt/lib/Passes/LongJmp.cpp

if (TgtIsFunc)
     BC.MIB->convertJmpToTailCall(Inst);
   StubBB->addInstruction(Inst);
   StubBB->setExecutionCount(0);
 
   // Register this in stubs maps
   auto registerInMap = [&](StubGroupsTy &Map) {
     StubGroupTy &StubGroup = Map[TgtSym];
     StubGroup.insert(
-        std::lower_bound(
-            StubGroup.begin(), StubGroup.end(),
-            std::make_pair(AtAddress, nullptr),
+        llvm::lower_bound(
+            StubGroup, std::make_pair(AtAddress, nullptr),
             [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
                 const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
               return LHS.first < RHS.first;
             }),
         std::make_pair(AtAddress, StubBB.get()));
   };
 
   Stubs[&Func].insert(StubBB.get());
BinaryBasicBlock *LongJmpPass::lookupStubFromGroup(
     const MCInst &Inst, const MCSymbol *TgtSym, uint64_t DotAddress) const {
   const BinaryContext &BC = Func.getBinaryContext();
   auto CandidatesIter = StubGroups.find(TgtSym);
   if (CandidatesIter == StubGroups.end())
     return nullptr;
   const StubGroupTy &Candidates = CandidatesIter->second;
   if (Candidates.empty())
     return nullptr;
-  auto Cand = std::lower_bound(
-      Candidates.begin(), Candidates.end(), std::make_pair(DotAddress, nullptr),
+  auto Cand = llvm::lower_bound(
+      Candidates, std::make_pair(DotAddress, nullptr),
       [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
           const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
         return LHS.first < RHS.first;
       });
   if (Cand == Candidates.end())
     return nullptr;
   if (Cand != Candidates.begin()) {
     const StubTy *LeftCand = std::prev(Cand);
LongJmpPass::replaceTargetWithStub(BinaryBasicBlock &BB, MCInst &Inst,
   return NewBB;
 }
 
 void LongJmpPass::updateStubGroups() {
   auto update = [&](StubGroupsTy &StubGroups) {
     for (auto &KeyVal : StubGroups) {
       for (StubTy &Elem : KeyVal.second)
         Elem.first = BBAddresses[Elem.second];
-      std::sort(KeyVal.second.begin(), KeyVal.second.end(),
+      llvm::sort(KeyVal.second,
                  [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
                      const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
                    return LHS.first < RHS.first;
                  });
     }
   };
 
   for (auto &KeyVal : HotLocalStubs)
     update(KeyVal.second);
   for (auto &KeyVal : ColdLocalStubs)
     update(KeyVal.second);
   update(HotStubGroups);

bolt/lib/Passes/LoopInversionPass.cpp

if (SuccBB == PredBB && BB != SuccBB && BBIndex != 0 && SuccBBIndex != 0 &&
       IsChanged = true;
       BB->setLayoutIndex(SuccBBIndex);
       SuccBB->setLayoutIndex(BBIndex);
     }
   }
 
   if (IsChanged) {
     BinaryFunction::BasicBlockOrderType NewOrder = BF.getLayout();
-    std::sort(NewOrder.begin(), NewOrder.end(),
-              [&](BinaryBasicBlock *BB1, BinaryBasicBlock *BB2) {
-                return BB1->getLayoutIndex() < BB2->getLayoutIndex();
-              });
+    llvm::sort(NewOrder, [&](BinaryBasicBlock *BB1, BinaryBasicBlock *BB2) {
     BF.updateBasicBlockLayout(NewOrder);
   }
 
   return IsChanged;
 }
 
 void LoopInversionPass::runOnFunctions(BinaryContext &BC) {
   std::atomic<uint64_t> ModifiedFuncCount{0};

bolt/lib/Passes/PettisAndHansen.cpp

std::vector<Cluster> pettisAndHansen(const CallGraph &Cg) {
   std::set<Cluster *> LiveClusters;
   std::vector<Cluster> OutClusters;
 
   for (NodeId Fid : Funcs)
     LiveClusters.insert(FuncCluster[Fid]);
   for (Cluster *C : LiveClusters)
     OutClusters.push_back(std::move(*C));
 
-  std::sort(OutClusters.begin(), OutClusters.end(), compareClustersDensity);
+  llvm::sort(OutClusters, compareClustersDensity);
 
   return OutClusters;
 }
 
 } // namespace bolt
 } // namespace llvm

bolt/lib/Passes/RegReAssign.cpp

for (MCInst &Inst : BB) {
           continue;
         }
 
         RegScore[RegEC] += BB.getKnownExecutionCount();
       }
     }
   }
   std::iota(RankedRegs.begin(), RankedRegs.end(), 0); // 0, 1, 2, 3...
-  std::sort(RankedRegs.begin(), RankedRegs.end(),
+  llvm::sort(RankedRegs,
              [&](size_t A, size_t B) { return RegScore[A] > RegScore[B]; });
 
   LLVM_DEBUG({
     for (size_t Reg : RankedRegs) {
       if (RegScore[Reg] == 0)
         continue;
       dbgs() << Reg << " ";
       if (RegScore[Reg] > 0)
         dbgs() << BC.MRI->getName(Reg) << ": " << RegScore[Reg] << "\n";

bolt/lib/Passes/ReorderAlgorithm.cpp

if (A.Count == B.Count) {
       return (SrcOrder != 0)
                  ? SrcOrder > 0
                  : BF.getOriginalLayoutRelativeOrder(A.Dst, B.Dst) > 0;
     }
     return A.Count < B.Count;
   };
 
   // Sort edges in increasing profile count order.
-  std::sort(Queue.begin(), Queue.end(), Comp);
+  llvm::sort(Queue, Comp);
 }
 
 void PHGreedyClusterAlgorithm::adjustQueue(std::vector<EdgeTy> &Queue,
                                            const BinaryFunction &BF) {
   // Nothing to do.
   return;
 }
 
for (const EdgeTy &E : Queue) {
 
     // Case 3: None of the previous cases is true, so just keep this edge in
     // the queue.
     NewQueue.emplace_back(E);
   }
 
   // Sort remaining edges in increasing weight order.
   Queue.swap(NewQueue);
-  std::sort(Queue.begin(), Queue.end(), Comp);
+  llvm::sort(Queue, Comp);
 }
 
 bool MinBranchGreedyClusterAlgorithm::areClustersCompatible(
     const ClusterTy &Front, const ClusterTy &Back, const EdgeTy &E) const {
   return Front.back() == E.Src && Back.front() == E.Dst;
 }
 
 void MinBranchGreedyClusterAlgorithm::reset() {

bolt/lib/Passes/ReorderData.cpp

if (BF.hasValidProfile()) {
         }
       }
     }
   }
 
   DataOrder Order = baseOrder(BC, Section);
   unsigned SplitPoint = Order.size();
 
-  std::sort(
-      Order.begin(), Order.end(),
+  llvm::sort(
+      Order,
       [&](const DataOrder::value_type &A, const DataOrder::value_type &B) {
         // Total execution counts of functions referencing BD.
         const uint64_t ACount = BDtoFuncCount[A.first];
         const uint64_t BCount = BDtoFuncCount[B.first];
         // Weight by number of loads/data size.
         const double AWeight = double(A.second) / A.first->getSize();
         const double BWeight = double(B.second) / B.first->getSize();
         return (ACount > BCount ||

 }
 
 std::pair<DataOrder, unsigned>
 ReorderData::sortedByCount(BinaryContext &BC,
                            const BinarySection &Section) const {
   DataOrder Order = baseOrder(BC, Section);
   unsigned SplitPoint = Order.size();
 
-  std::sort(Order.begin(), Order.end(),
-            [](const DataOrder::value_type &A, const DataOrder::value_type &B) {
-              // Weight by number of loads/data size.
-              const double AWeight = double(A.second) / A.first->getSize();
-              const double BWeight = double(B.second) / B.first->getSize();
-              return (AWeight > BWeight ||
-                      (AWeight == BWeight &&
-                       (A.first->getSize() < B.first->getSize() ||
-                        (A.first->getSize() == B.first->getSize() &&
-                         A.first->getAddress() < B.first->getAddress()))));
-            });
+  llvm::sort(Order, [](const DataOrder::value_type &A,
+                       const DataOrder::value_type &B) {
 
   for (unsigned Idx = 0; Idx < Order.size(); ++Idx) {
     if (!Order[Idx].second) {
       SplitPoint = Idx;
       break;
     }
   }
 

bolt/lib/Passes/ReorderFunctions.cpp

void ReorderFunctions::runOnFunctions(BinaryContext &BC) {
 
   switch (opts::ReorderFunctions) {
   case RT_NONE:
     break;
   case RT_EXEC_COUNT:
     {
       std::vector<BinaryFunction *> SortedFunctions(BFs.size());
       uint32_t Index = 0;
-      std::transform(BFs.begin(),
-                     BFs.end(),
-                     SortedFunctions.begin(),
+      llvm::transform(BFs, SortedFunctions.begin(),
                       [](std::pair<const uint64_t, BinaryFunction> &BFI) {
                         return &BFI.second;
                       });
-      std::stable_sort(SortedFunctions.begin(), SortedFunctions.end(),
-                       [&](const BinaryFunction *A, const BinaryFunction *B) {
-                         if (A->isIgnored())
-                           return false;
-                         const size_t PadA = opts::padFunction(*A);
-                         const size_t PadB = opts::padFunction(*B);
-                         if (!PadA || !PadB) {
-                           if (PadA)
-                             return true;
-                           if (PadB)
-                             return false;
-                         }
-                         return !A->hasProfile() &&
-                           (B->hasProfile() ||
-                            (A->getExecutionCount() > B->getExecutionCount()));
-                       });
+      llvm::stable_sort(SortedFunctions, [&](const BinaryFunction *A,
+                                             const BinaryFunction *B) {
       for (BinaryFunction *BF : SortedFunctions)
         if (BF->hasProfile())
           BF->setIndex(Index++);
     }
     break;
   case RT_HFSORT:
     Clusters = clusterize(Cg);
     break;
if (!LinkSectionsFile) {
       errs() << "BOLT-ERROR: link sections file " << opts::LinkSectionsFile
              << " cannot be opened\n";
       exit(1);
     }
   }
 
   if (FuncsFile || LinkSectionsFile) {
     std::vector<BinaryFunction *> SortedFunctions(BFs.size());
-    std::transform(BFs.begin(), BFs.end(), SortedFunctions.begin(),
+    llvm::transform(BFs, SortedFunctions.begin(),
                     [](std::pair<const uint64_t, BinaryFunction> &BFI) {
                       return &BFI.second;
                     });
 
     // Sort functions by index.
-    std::stable_sort(
-      SortedFunctions.begin(),
-      SortedFunctions.end(),
+    llvm::stable_sort(SortedFunctions,
                       [](const BinaryFunction *A, const BinaryFunction *B) {
                         if (A->hasValidIndex() && B->hasValidIndex())
                           return A->getIndex() < B->getIndex();
                         if (A->hasValidIndex() && !B->hasValidIndex())
                           return true;
                         if (!A->hasValidIndex() && B->hasValidIndex())
                           return false;
                         return A->getAddress() < B->getAddress();
                       });
 
     for (const BinaryFunction *Func : SortedFunctions) {
       if (!Func->hasValidIndex())
         break;
       if (Func->isPLTFunction())
         continue;
 
       if (FuncsFile)
         *FuncsFile << Func->getOneName().str() << '\n';
 
       if (LinkSectionsFile) {
         const char *Indent = "";
         std::vector<StringRef> AllNames = Func->getNames();
-        std::sort(AllNames.begin(), AllNames.end());
+        llvm::sort(AllNames);
         for (StringRef Name : AllNames) {
           const size_t SlashPos = Name.find('/');
           if (SlashPos != std::string::npos) {
             // Avoid duplicates for local functions.
             if (Name.find('/', SlashPos + 1) != std::string::npos)
               continue;
             Name = Name.substr(0, SlashPos);
           }

bolt/lib/Passes/ShrinkWrapping.cpp

 void ShrinkWrapping::computeDomOrder() {
   std::vector<MCPhysReg> Order;
   for (MCPhysReg I = 0, E = BC.MRI->getNumRegs(); I != E; ++I) {
     Order.push_back(I);
   }
 
   DominatorAnalysis<false> &DA = Info.getDominatorAnalysis();
   auto &InsnToBB = Info.getInsnToBBMap();
-  std::sort(Order.begin(), Order.end(),
-            [&](const MCPhysReg &A, const MCPhysReg &B) {
-              BinaryBasicBlock *BBA =
-                  BestSavePos[A] ? InsnToBB[BestSavePos[A]] : nullptr;
-              BinaryBasicBlock *BBB =
-                  BestSavePos[B] ? InsnToBB[BestSavePos[B]] : nullptr;
-              if (BBA == BBB)
-                return A < B;
-              if (!BBA && BBB)
-                return false;
-              if (BBA && !BBB)
-                return true;
-              if (DA.doesADominateB(*BestSavePos[A], *BestSavePos[B]))
-                return true;
-              if (DA.doesADominateB(*BestSavePos[B], *BestSavePos[A]))
-                return false;
-              return A < B;
-            });
+  llvm::sort(Order, [&](const MCPhysReg &A, const MCPhysReg &B) {
+    BinaryBasicBlock *BBA = BestSavePos[A] ? InsnToBB[BestSavePos[A]] : nullptr;
+    BinaryBasicBlock *BBB = BestSavePos[B] ? InsnToBB[BestSavePos[B]] : nullptr;
 
   for (MCPhysReg I = 0, E = BC.MRI->getNumRegs(); I != E; ++I)
     DomOrder[Order[I]] = I;
 }
 
 bool ShrinkWrapping::isBestSavePosCold(unsigned CSR, MCInst *&BestPosSave,
                                        uint64_t &TotalEstimatedWin) {
   const uint64_t CurSavingCost = CSA.SavingCost[CSR];
for (WorklistItem &Item : TodoList) {
       if (Item.FIEToInsert.IsStore)
         SPVal += Item.FIEToInsert.Size;
       if (Item.FIEToInsert.IsLoad)
         SPVal -= Item.FIEToInsert.Size;
     }
   }
 
   // Reorder POPs to obey the correct dominance relation between them
-  std::stable_sort(TodoList.begin(), TodoList.end(),
-                   [&](const WorklistItem &A, const WorklistItem &B) {
-                     if ((A.Action != WorklistItem::InsertPushOrPop ||
-                          !A.FIEToInsert.IsLoad) &&
-                         (B.Action != WorklistItem::InsertPushOrPop ||
-                          !B.FIEToInsert.IsLoad))
-                       return false;
-                     if ((A.Action != WorklistItem::InsertPushOrPop ||
-                          !A.FIEToInsert.IsLoad))
-                       return true;
-                     if ((B.Action != WorklistItem::InsertPushOrPop ||
-                          !B.FIEToInsert.IsLoad))
-                       return false;
-                     return DomOrder[B.AffectedReg] < DomOrder[A.AffectedReg];
-                   });
+  llvm::stable_sort(TodoList, [&](const WorklistItem &A,
+                                  const WorklistItem &B) {
+    if ((A.Action != WorklistItem::InsertPushOrPop || !A.FIEToInsert.IsLoad) &&
+        (B.Action != WorklistItem::InsertPushOrPop || !B.FIEToInsert.IsLoad))
+    if ((A.Action != WorklistItem::InsertPushOrPop || !A.FIEToInsert.IsLoad))
+    if ((B.Action != WorklistItem::InsertPushOrPop || !B.FIEToInsert.IsLoad))
 
   // Process insertions
   for (WorklistItem &Item : TodoList) {
     if (Item.Action == WorklistItem::Erase ||
         Item.Action == WorklistItem::ChangeToAdjustment)
       continue;
 
     InsertionPoint =

bolt/lib/Passes/SplitFunctions.cpp

if (BF.hasEHRanges() && !opts::SplitEH) {
       }
     }
   }
 
   if (opts::AggressiveSplitting) {
     // All blocks with 0 count that we can move go to the end of the function.
     // Even if they were natural to cluster formation and were seen in-between
     // hot basic blocks.
-    std::stable_sort(BF.layout_begin(), BF.layout_end(),
+    llvm::stable_sort(BF.layout(),
                       [&](BinaryBasicBlock *A, BinaryBasicBlock *B) {
                         return A->canOutline() < B->canOutline();
                       });
   } else if (BF.hasEHRanges() && !opts::SplitEH) {
     // Typically functions with exception handling have landing pads at the end.
     // We cannot move beginning of landing pads, but we can move 0-count blocks
     // comprising landing pads to the end and thus facilitate splitting.
     auto FirstLP = BF.layout_begin();
     while ((*FirstLP)->isLandingPad())
       ++FirstLP;
 

bolt/lib/Passes/ThreeWayBranch.cpp

if (!BC.MIB->isValidCondCode(FirstCC) ||
         !BC.MIB->isValidCondCode(ThirdCC) || !BC.MIB->isValidCondCode(SecondCC))
       continue;
 
     std::vector<std::pair<BinaryBasicBlock *, unsigned>> Blocks;
     Blocks.push_back(std::make_pair(FirstEndpoint, FirstCC));
     Blocks.push_back(std::make_pair(SecondEndpoint, SecondCC));
     Blocks.push_back(std::make_pair(ThirdEndpoint, ThirdCC));
 
-    std::sort(Blocks.begin(), Blocks.end(),
-              [&](const std::pair<BinaryBasicBlock *, unsigned> A,
+    llvm::sort(Blocks, [&](const std::pair<BinaryBasicBlock *, unsigned> A,
                            const std::pair<BinaryBasicBlock *, unsigned> B) {
-                return A.first->getExecutionCount() <
-                       B.first->getExecutionCount();
-              });
+      return A.first->getExecutionCount() < B.first->getExecutionCount();
 
     uint64_t NewSecondBranchCount = Blocks[1].first->getExecutionCount() +
                                     Blocks[0].first->getExecutionCount();
     bool SecondBranchBigger =
         NewSecondBranchCount > Blocks[2].first->getExecutionCount();
 
     BB->removeAllSuccessors();
     if (SecondBranchBigger) {

bolt/lib/Profile/DataAggregator.cpp

std::vector<SectionNameAndRange> getTextSections(const BinaryContext *BC) {
   for (BinarySection &Section : BC->sections()) {
     if (!Section.isText())
       continue;
     if (Section.getSize() == 0)
       continue;
     sections.push_back(
         {Section.getName(), Section.getAddress(), Section.getEndAddress()});
   }
-  std::sort(sections.begin(), sections.end(),
+  llvm::sort(sections,
              [](const SectionNameAndRange &A, const SectionNameAndRange &B) {
                return A.BeginAddress < B.BeginAddress;
              });
   return sections;
 }
 }
 
 constexpr uint64_t DataAggregator::KernelBaseAddr;
 
 DataAggregator::~DataAggregator() { deleteTempFiles(); }
 

bolt/lib/Profile/DataReader.cpp

if (I->From.Name == FBD.Name) {
       I->From.Name = this->Name;
       I->From.Offset += Offset;
     }
     if (I->To.Name == FBD.Name) {
       I->To.Name = this->Name;
       I->To.Offset += Offset;
     }
   }
-  std::stable_sort(Data.begin(), Data.end());
+  llvm::stable_sort(Data);
   ExecutionCount += FBD.ExecutionCount;
   for (auto I = FBD.EntryData.begin(), E = FBD.EntryData.end(); I != E; ++I) {
     assert(I->To.Name == FBD.Name);
     auto NewElmt = EntryData.insert(EntryData.end(), *I);
     NewElmt->To.Name = this->Name;
     NewElmt->To.Offset += Offset;
   }
 }

 void SampleInfo::mergeWith(const SampleInfo &SI) { Hits += SI.Hits; }
 
 void SampleInfo::print(raw_ostream &OS) const {
   OS << Loc.IsSymbol << " " << Loc.Name << " " << Twine::utohexstr(Loc.Offset)
      << " " << Hits << "\n";
 }
 
 uint64_t FuncSampleData::getSamples(uint64_t Start, uint64_t End) const {
-  assert(std::is_sorted(Data.begin(), Data.end()));
+  assert(llvm::is_sorted(Data));
   struct Compare {
     bool operator()(const SampleInfo &SI, const uint64_t Val) const {
       return SI.Loc.Offset < Val;
     }
     bool operator()(const uint64_t Val, const SampleInfo &SI) const {
       return Val < SI.Loc.Offset;
     }
   };
   uint64_t Result = 0;
-  for (auto I = std::lower_bound(Data.begin(), Data.end(), Start, Compare()),
-            E = std::lower_bound(Data.begin(), Data.end(), End, Compare());
+  for (auto I = llvm::lower_bound(Data, Start, Compare()),
+            E = llvm::lower_bound(Data, End, Compare());
        I != E; ++I)
     Result += I->Hits;
   return Result;
 }
 
 void FuncSampleData::bumpCount(uint64_t Offset, uint64_t Count) {
   auto Iter = Index.find(Offset);
   if (Iter == Index.end()) {
while (hasMemData()) {
     if (!MI.Offset.IsSymbol)
       continue;
 
     StringMapIterator<FuncMemData> I = GetOrCreateFuncMemEntry(MI.Offset.Name);
     I->getValue().Data.emplace_back(std::move(MI));
   }
 
   for (StringMapEntry<FuncSampleData> &FuncSamples : NamesToSamples)
-    std::stable_sort(FuncSamples.second.Data.begin(),
-                     FuncSamples.second.Data.end());
+    llvm::stable_sort(FuncSamples.second.Data);
 
   for (StringMapEntry<FuncMemData> &MemEvents : NamesToMemEvents)
-    std::stable_sort(MemEvents.second.Data.begin(),
-                     MemEvents.second.Data.end());
+    llvm::stable_sort(MemEvents.second.Data);
 
   return std::error_code();
 }
 
 std::error_code DataReader::parse() {
   auto GetOrCreateFuncEntry = [&](StringRef Name) {
     auto I = NamesToBranches.find(Name);
     if (I == NamesToBranches.end()) {
while (hasMemData()) {
     if (!MI.Offset.IsSymbol)
       continue;
 
     StringMapIterator<FuncMemData> I = GetOrCreateFuncMemEntry(MI.Offset.Name);
     I->getValue().Data.emplace_back(std::move(MI));
   }
 
   for (StringMapEntry<FuncBranchData> &FuncBranches : NamesToBranches)
-    std::stable_sort(FuncBranches.second.Data.begin(),
-                     FuncBranches.second.Data.end());
+    llvm::stable_sort(FuncBranches.second.Data);
 
   for (StringMapEntry<FuncMemData> &MemEvents : NamesToMemEvents)
-    std::stable_sort(MemEvents.second.Data.begin(),
-                     MemEvents.second.Data.end());
+    llvm::stable_sort(MemEvents.second.Data);
 
   return std::error_code();
 }
 
 void DataReader::buildLTONameMaps() {
   for (StringMapEntry<FuncBranchData> &FuncData : NamesToBranches) {
     const StringRef FuncName = FuncData.getKey();
     const Optional<StringRef> CommonName = getLTOCommonName(FuncName);

bolt/lib/Profile/Heatmap.cpp

void Heatmap::printCDF(raw_ostream &OS) const {
   uint64_t NumTotalCounts = 0;
   std::vector<uint64_t> Counts;
 
   for (const std::pair<const uint64_t, uint64_t> &KV : Map) {
     Counts.push_back(KV.second);
     NumTotalCounts += KV.second;
   }
 
-  std::sort(Counts.begin(), Counts.end(), std::greater<uint64_t>());
+  llvm::sort(Counts, std::greater<uint64_t>());
 
   double RatioLeftInKB = (1.0 * BucketSize) / 1024;
   assert(NumTotalCounts > 0 &&
          "total number of heatmap buckets should be greater than 0");
   double RatioRightInPercent = 100.0 / NumTotalCounts;
   uint64_t RunningCount = 0;
 
   OS << "Bucket counts, Size (KB), CDF (%)\n";

bolt/lib/Profile/YAMLProfileWriter.cpp

for (const MCInst &Instr : *BB) {
             CSI.Count = *Count;
         }
 
         if (CSI.Count)
           YamlBB.CallSites.emplace_back(CSI);
       }
     }
 
-    std::sort(YamlBB.CallSites.begin(), YamlBB.CallSites.end());
+    llvm::sort(YamlBB.CallSites);
 
     // Skip printing if there's no profile data for non-entry basic block.
     // Include landing pads with non-zero execution count.
     if (YamlBB.CallSites.empty() && !BB->isEntryPoint() &&
         !(BB->isLandingPad() && BB->getKnownExecutionCount() != 0)) {
       uint64_t SuccessorExecCount = 0;
       for (const BinaryBasicBlock::BinaryBranchInfo &BranchInfo :
            BB->branch_info())

bolt/lib/Rewrite/BoltDiff.cpp

if (opts::PrintProfiledUnmapped) {
       outs() << "\nFunctions in profile 1 that are missing in the profile 2:\n";
       std::vector<const BinaryFunction *> Unmapped;
       for (const auto &BFI : RI1.BC->getBinaryFunctions()) {
         const BinaryFunction &Function = BFI.second;
         if (!Function.hasValidProfile() || Bin1ProfiledMapped.count(&Function))
           continue;
         Unmapped.emplace_back(&Function);
       }
-      std::sort(Unmapped.begin(), Unmapped.end(),
+      llvm::sort(Unmapped,
                  [&](const BinaryFunction *A, const BinaryFunction *B) {
                    return A->getFunctionScore() > B->getFunctionScore();
                  });
       for (const BinaryFunction *Function : Unmapped) {
         outs() << Function->getPrintName() << " : ";
         outs() << Function->getFunctionScore() << "\n";
       }
       outs() << "=====\n";
     }
   }
 

bolt/lib/Rewrite/DWARFRewriter.cpp

for (const uint64_t TUSignature : TypeSignaturesPerCU.at(DWOId)) {
     const DWARFUnitIndex::Entry *TUDWOEntry = TUIndex.getFromHash(TUSignature);
     const DWARFUnitIndex::Entry::SectionContribution *C =
         TUDWOEntry->getContribution(DW_SECT_EXT_TYPES);
     TUContributions.emplace_back(TUSignature, C);
   }
 
   // Sorting so it's easy to compare output.
   // They should be sharing the same Abbrev.
-  std::sort(TUContributions.begin(), TUContributions.end(),
-            [](const TUEntry &V1, const TUEntry &V2) -> bool {
-              return V1.second->Offset < V2.second->Offset;
-            });
+  llvm::sort(TUContributions, [](const TUEntry &V1, const TUEntry &V2) -> bool {
 
   for (auto &PairEntry : TUContributions) {
     const DWARFUnitIndex::Entry::SectionContribution *C = PairEntry.second;
     const uint64_t TUSignature = PairEntry.first;
     DWOTUSection.append(Contents.slice(C->Offset, C->Offset + C->Length).str());
     TUContributionsToCU.push_back({TUSignature, C->Length});
   }
   return DWOTUSection;
static void extractTypesFromDWPDWARF5(
   for (const uint64_t Val : TypeSignaturesPerCU.at(DWOId)) {
     const DWARFUnitIndex::Entry *TUE = TUIndex.getFromHash(Val);
     const DWARFUnitIndex::Entry::SectionContribution *C =
         TUE->getContribution(DWARFSectionKind::DW_SECT_INFO);
     TUContributions.push_back(C);
   }
   // Sorting so it's easy to compare output.
   // They should be sharing the same Abbrev.
-  std::sort(TUContributions.begin(), TUContributions.end(),
+  llvm::sort(TUContributions,
              [](const DWARFUnitIndex::Entry::SectionContribution *V1,
                 const DWARFUnitIndex::Entry::SectionContribution *V2) -> bool {
                return V1->Offset < V2->Offset;
              });
   Streamer.switchSection(MCOFI.getDwarfInfoDWOSection());
   for (const auto *C : TUContributions)
     Streamer.emitBytes(Contents.slice(C->Offset, C->Offset + C->Length));
 }
 
 void DWARFRewriter::writeDWP(
     std::unordered_map<uint64_t, std::string> &DWOIdToName) {
   SmallString<0> OutputNameStr;

bolt/lib/Rewrite/MachORewriteInstance.cpp

std::vector<DataInCodeRegion> readDataInCode(const MachOObjectFile &O) {
   const MachO::linkedit_data_command DataInCodeLC =
       O.getDataInCodeLoadCommand();
   const uint32_t NumberOfEntries =
       DataInCodeLC.datasize / sizeof(MachO::data_in_code_entry);
   std::vector<DataInCodeRegion> DataInCode;
   DataInCode.reserve(NumberOfEntries);
   for (auto I = O.begin_dices(), E = O.end_dices(); I != E; ++I)
     DataInCode.emplace_back(*I);
-  std::stable_sort(DataInCode.begin(), DataInCode.end(),
-                   [](DataInCodeRegion LHS, DataInCodeRegion RHS) {
-                     return LHS.Offset < RHS.Offset;
-                   });
+  llvm::stable_sort(DataInCode, [](DataInCodeRegion LHS, DataInCodeRegion RHS) {
   return DataInCode;
 }
 
 Optional<uint64_t> readStartAddress(const MachOObjectFile &O) {
   Optional<uint64_t> StartOffset;
   Optional<uint64_t> TextVMAddr;
   for (const object::MachOObjectFile::LoadCommandInfo &LC : O.load_commands()) {
     switch (LC.C.cmd) {
void MachORewriteInstance::discoverFileObjects() {
   std::vector<SymbolRef> FunctionSymbols;
   for (const SymbolRef &S : InputFile->symbols()) {
     SymbolRef::Type Type = cantFail(S.getType(), "cannot get symbol type");
     if (Type == SymbolRef::ST_Function)
       FunctionSymbols.push_back(S);
   }
   if (FunctionSymbols.empty())
     return;
-  std::stable_sort(FunctionSymbols.begin(), FunctionSymbols.end(),
-                   [](const SymbolRef &LHS, const SymbolRef &RHS) {
-                     return cantFail(LHS.getValue()) < cantFail(RHS.getValue());
-                   });
+  llvm::stable_sort(
+      FunctionSymbols, [](const SymbolRef &LHS, const SymbolRef &RHS) {
   for (size_t Index = 0; Index < FunctionSymbols.size(); ++Index) {
     const uint64_t Address = cantFail(FunctionSymbols[Index].getValue());
     ErrorOr<BinarySection &> Section = BC->getSectionForAddress(Address);
     // TODO: It happens for some symbols (e.g. __mh_execute_header).
     // Add proper logic to handle them correctly.
     if (!Section) {
       errs() << "BOLT-WARNING: no section found for address " << Address
              << "\n";

bolt/lib/Rewrite/RewriteInstance.cpp

 
 } // namespace bolt
 } // namespace llvm
 
 namespace {
 
 bool refersToReorderedSection(ErrorOr<BinarySection &> Section) {
   auto Itr =
-      std::find_if(opts::ReorderData.begin(), opts::ReorderData.end(),
-                   [&](const std::string &SectionName) {
-                     return (Section && Section->getName() == SectionName);
-                   });
+      llvm::find_if(opts::ReorderData, [&](const std::string &SectionName) {
   return Itr != opts::ReorderData.end();
 }
 
 } // anonymous namespace
 
 Expected<std::unique_ptr<RewriteInstance>>
 RewriteInstance::createRewriteInstance(ELFObjectFileBase *File, const int Argc,
                                        const char *const *Argv,
auto isSymbolInMemory = [this](const SymbolRef &Sym) {
     if (cantFail(Sym.getFlags()) & SymbolRef::SF_Absolute)
       return true;
     if (cantFail(Sym.getFlags()) & SymbolRef::SF_Undefined)
       return false;
     BinarySection Section(*BC, *cantFail(Sym.getSection()));
     return Section.isAllocatable();
   };
   std::vector<SymbolRef> SortedFileSymbols;
-  std::copy_if(InputFile->symbol_begin(), InputFile->symbol_end(),
-               std::back_inserter(SortedFileSymbols), isSymbolInMemory);
+  llvm::copy_if(InputFile->symbols(), std::back_inserter(SortedFileSymbols),
+                isSymbolInMemory);
   auto CompareSymbols = [this](const SymbolRef &A, const SymbolRef &B) {
     // Marker symbols have the highest precedence, while
     // SECTIONs have the lowest.
     auto AddressA = cantFail(A.getAddress());
     auto AddressB = cantFail(B.getAddress());
     if (AddressA != AddressB)
       return AddressA < AddressB;
 
     bool AMarker = BC->isMarker(A);
     bool BMarker = BC->isMarker(B);
     if (AMarker || BMarker) {
       return AMarker && !BMarker;
     }
 
     auto AType = cantFail(A.getType());
     auto BType = cantFail(B.getType());
     if (AType == SymbolRef::ST_Function && BType != SymbolRef::ST_Function)
       return true;
     if (BType == SymbolRef::ST_Debug && AType != SymbolRef::ST_Debug)
       return true;
 
     return false;
   };
 
-  std::stable_sort(SortedFileSymbols.begin(), SortedFileSymbols.end(),
-                   CompareSymbols);
+  llvm::stable_sort(SortedFileSymbols, CompareSymbols);
 
   auto LastSymbol = SortedFileSymbols.end() - 1;
 
   // For aarch64, the ABI defines mapping symbols so we identify data in the
   // code section (see IHI0056B). $d identifies data contents.
   // Compilers usually merge multiple data objects in a single $d-$x interval,
   // but we need every data object to be marked with $d. Because of that we
   // create a vector of MarkerSyms with all locations of data objects.
if (opts::LiteThresholdPct > 100)
       opts::LiteThresholdPct = 100;
 
     std::vector<const BinaryFunction *> TopFunctions;
     for (auto &BFI : BC->getBinaryFunctions()) {
       const BinaryFunction &Function = BFI.second;
       if (ProfileReader->mayHaveProfileData(Function))
         TopFunctions.push_back(&Function);
     }
-    std::sort(TopFunctions.begin(), TopFunctions.end(),
-              [](const BinaryFunction *A, const BinaryFunction *B) {
-                return
-                    A->getKnownExecutionCount() < B->getKnownExecutionCount();
-              });
+    llvm::sort(
+        TopFunctions, [](const BinaryFunction *A, const BinaryFunction *B) {
+          return A->getKnownExecutionCount() < B->getKnownExecutionCount();
 
     size_t Index = TopFunctions.size() * opts::LiteThresholdPct / 100;
     if (Index)
       --Index;
     LiteThresholdExecCount = TopFunctions[Index]->getKnownExecutionCount();
     outs() << "BOLT-INFO: limiting processing to functions with at least "
            << LiteThresholdExecCount << " invocations\n";
   }
for (auto &F : BC->getBinaryFunctions())
       for (BinaryBasicBlock &BinaryBlock : F.second)
         Addr2BlockNames[BinaryBlock.getOutputAddressRange().first] =
             BinaryBlock.getName();
 
     // scan all addresses -> correlate probe to block when print out
     std::vector<uint64_t> Addresses;
     for (auto &Entry : Address2ProbesMap)
       Addresses.push_back(Entry.first);
-    std::sort(Addresses.begin(), Addresses.end());
+    llvm::sort(Addresses);
     for (uint64_t Key : Addresses) {
       for (MCDecodedPseudoProbe &Probe : Address2ProbesMap[Key]) {
         if (Probe.getAddress() == INT64_MAX)
           outs() << "Deleted Probe: ";
         else
           outs() << "Address: " << format_hex(Probe.getAddress(), 8) << " ";
         Probe.print(outs(), GUID2Func, true);
         // print block name only if the probe is block type and undeleted.
auto compareSections = [&](const BinarySection *A, const BinarySection *B) {
     // Depending on the option, put main text at the beginning or at the end.
     if (opts::HotFunctionsAtEnd)
       return B->getName() == BC->getMainCodeSectionName();
     else
       return A->getName() == BC->getMainCodeSectionName();
   };
 
   // Determine the order of sections.
-  std::stable_sort(CodeSections.begin(), CodeSections.end(), compareSections);
+  llvm::stable_sort(CodeSections, compareSections);
 
   return CodeSections;
 }
 
 void RewriteInstance::mapCodeSections(RuntimeDyld &RTDyld) {
   if (BC->HasRelocations) {
     ErrorOr<BinarySection &> TextSection =
         BC->getUniqueSectionByName(BC->getMainCodeSectionName());
for (BinaryFunction *InjectedFunction : BC->getInjectedBinaryFunctions()) {
       InjectedFunction->setImageAddress(FunctionSection->getAllocAddress());
       InjectedFunction->setImageSize(FunctionSection->getOutputSize());
     }
 
     // Populate the list of sections to be allocated.
     std::vector<BinarySection *> CodeSections = getCodeSections();
 
     // Remove sections that were pre-allocated (patch sections).
-    CodeSections.erase(
-        std::remove_if(CodeSections.begin(), CodeSections.end(),
-                       [](BinarySection *Section) {
-                         return Section->getOutputAddress();
-                       }),
-        CodeSections.end());
+    llvm::erase_if(CodeSections, [](BinarySection *Section) {
+    });
     LLVM_DEBUG(dbgs() << "Code sections in the order of output:\n";
       for (const BinarySection *Section : CodeSections)
         dbgs() << Section->getName() << '\n';
     );
 
     uint64_t PaddingSize = 0; // size of padding required at the end
 
     // Allocate sections starting at a given Address.
for (const BinarySection &Section : BC->allocatableSections()) {
     NewSection.sh_flags = Section.getELFFlags();
     NewSection.sh_link = 0;
     NewSection.sh_info = 0;
     NewSection.sh_addralign = Section.getAlignment();
     addSection(std::string(Section.getName()), NewSection);
   }
 
   // Sort all allocatable sections by their offset.
-  std::stable_sort(OutputSections.begin(), OutputSections.end(),
-      [] (const std::pair<std::string, ELFShdrTy> &A,
+  llvm::stable_sort(OutputSections,
+                    [](const std::pair<std::string, ELFShdrTy> &A,
                        const std::pair<std::string, ELFShdrTy> &B) {
                       return A.second.sh_offset < B.second.sh_offset;
                     });
 
   // Fix section sizes to prevent overlapping.
   ELFShdrTy *PrevSection = nullptr;
   StringRef PrevSectionName;
   for (auto &SectionKV : OutputSections) {
     ELFShdrTy &Section = SectionKV.second;
 
     // TBSS section does not take file or memory space. Ignore it for layout
for (const ELFShdrTy &Section : Sections) {
     // Some sections are stripped
     if (!NameToIndex.count(SectionName))
       continue;
 
     NewSectionIndex[OrgIndex] = NameToIndex[SectionName];
   }
 
   std::vector<ELFShdrTy> SectionsOnly(OutputSections.size());
-  std::transform(OutputSections.begin(), OutputSections.end(),
-                 SectionsOnly.begin(),
+  llvm::transform(OutputSections, SectionsOnly.begin(),
                   [](std::pair<std::string, ELFShdrTy> &SectionInfo) {
                     return SectionInfo.second;
                   });
 
   return SectionsOnly;
 }
 
 // Rewrite section header table inserting new entries as needed. The sections
 // header table size itself may affect the offsets of other sections,
 // so we are placing it at the end of the binary.
 //
void RewriteInstance::updateELFSymbolTable(
   }
 
   if (opts::HotData && !NumHotDataSymsUpdated) {
     addSymbol("__hot_data_start");
     addSymbol("__hot_data_end");
   }
 
   // Put local symbols at the beginning.
-  std::stable_sort(Symbols.begin(), Symbols.end(),
-                   [](const ELFSymTy &A, const ELFSymTy &B) {
-                     if (A.getBinding() == ELF::STB_LOCAL &&
-                         B.getBinding() != ELF::STB_LOCAL)
-                       return true;
-                     return false;
-                   });
+  llvm::stable_sort(Symbols, [](const ELFSymTy &A, const ELFSymTy &B) {
+    if (A.getBinding() == ELF::STB_LOCAL && B.getBinding() != ELF::STB_LOCAL)
 
   for (const ELFSymTy &Symbol : Symbols)
     Write(0, Symbol);
 }
 
 template <typename ELFT>
 void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
   const ELFFile<ELFT> &Obj = File->getELFFile();

bolt/lib/RuntimeLibs/InstrumentationRuntimeLibrary.cpp

std::string InstrumentationRuntimeLibrary::buildTables(BinaryContext &BC) {
   auto getOutputAddress = [](const BinaryFunction &Func,
                              uint64_t Offset) -> uint64_t {
     return Offset == 0
                ? Func.getOutputAddress()
                : Func.translateInputToOutputAddress(Func.getAddress() + Offset);
   };
 
   // Indirect targets need to be sorted for fast lookup during runtime
-  std::sort(Summary->IndCallTargetDescriptions.begin(),
-            Summary->IndCallTargetDescriptions.end(),
+  llvm::sort(Summary->IndCallTargetDescriptions,
              [&](const IndCallTargetDescription &A,
                  const IndCallTargetDescription &B) {
                return getOutputAddress(*A.Target, A.ToLoc.Offset) <
                       getOutputAddress(*B.Target, B.ToLoc.Offset);
              });
 
   // Start of the vector with descriptions (one CounterDescription for each
   // counter), vector size is Counters.size() CounterDescription-sized elmts
   const size_t IDSize =
       Summary->IndCallDescriptions.size() * sizeof(IndCallDescription);
   OS.write(reinterpret_cast<const char *>(&IDSize), 4);
   for (const IndCallDescription &Desc : Summary->IndCallDescriptions) {
     OS.write(reinterpret_cast<const char *>(&Desc.FromLoc.FuncString), 4);

bolt/tools/merge-fdata/merge-fdata.cpp

int main(int argc, char **argv) {
   }
 
   if (!opts::SuppressMergedDataOutput) {
     yaml::Output YamlOut(output());
 
     BinaryProfile MergedProfile;
     MergedProfile.Header = MergedHeader;
     MergedProfile.Functions.resize(MergedBFs.size());
-    std::transform(
-        MergedBFs.begin(), MergedBFs.end(), MergedProfile.Functions.begin(),
+    llvm::transform(
+        MergedBFs, MergedProfile.Functions.begin(),
         [](StringMapEntry<BinaryFunctionProfile> &V) { return V.second; });
 
     // For consistency, sort functions by their IDs.
-    std::sort(MergedProfile.Functions.begin(), MergedProfile.Functions.end(),
+    llvm::sort(MergedProfile.Functions,
                [](const BinaryFunctionProfile &A,
                   const BinaryFunctionProfile &B) { return A.Id < B.Id; });
 
     YamlOut << MergedProfile;
   }
 
   errs() << "Data for " << MergedBFs.size()
          << " unique objects successfully merged.\n";
 
   if (opts::PrintFunctionList != opts::ST_NONE) {
CountFuncType BranchCountFunc =
             for (const SuccessorInfo &SI : BI.Successors)
               BranchCount += SI.Count;
           return std::make_pair(BranchCount, StringRef(V.second.Name));
         };
 
     CountFuncType CountFunc = (opts::PrintFunctionList == opts::ST_EXEC_COUNT)
                                   ? ExecCountFunc
                                   : BranchCountFunc;
-    std::transform(MergedBFs.begin(), MergedBFs.end(), FunctionList.begin(),
-                   CountFunc);
-    std::stable_sort(FunctionList.rbegin(), FunctionList.rend());
+    llvm::transform(MergedBFs, FunctionList.begin(), CountFunc);
+    llvm::stable_sort(reverse(FunctionList));
     errs() << "Functions sorted by "
            << (opts::PrintFunctionList == opts::ST_EXEC_COUNT ? "execution"
                                                               : "total branch")
            << " count:\n";
     for (std::pair<uint64_t, StringRef> &FI : FunctionList)
       errs() << FI.second << " : " << FI.first << '\n';
   }
 
   return 0;
 }