[BOLT][NFC] Use llvm::less_first

[Amir]

Summary

Follow the case of https://reviews.llvm.org/D126068 and simplify call sites
with llvm::less_first.

[rafauler]

LGTM

[Amir]

Rebase + llvm::less_first

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.
-  llvm::sort(SortedMap,
-             [](const IndexAddressPair &A, const IndexAddressPair &B) {
-               return A.first < B.first;
-             });
+  llvm::sort(SortedMap, llvm::less_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.
-    llvm::sort(SortedMap,
-               [](const IndexAddressPair &A, const IndexAddressPair &B) {
-                 return A.first < B.first;
-               });
+    llvm::sort(SortedMap, llvm::less_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.
-    llvm::sort(SortedMap,
-               [](const IndexAddressPair &A, const IndexAddressPair &B) {
-                 return A.first < B.first;
-               });
+    llvm::sort(SortedMap, llvm::less_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);
 

bolt/lib/Passes/LongJmp.cpp

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];
-      llvm::sort(KeyVal.second,
-                 [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
-                     const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
-                   return LHS.first < RHS.first;
-                 });
+      llvm::sort(KeyVal.second, llvm::less_first());
     }
   };
 
   for (auto &KeyVal : HotLocalStubs)
     update(KeyVal.second);
   for (auto &KeyVal : ColdLocalStubs)
     update(KeyVal.second);
   update(HotStubGroups);