[llvm][clang][bolt][NFC] Use llvm::less_first() when applicable

[steakhal]

Summary

One could reuse this functor instead of rolling out your own version.
There were a couple other cases where the code was similar, but not
quite the same, such as it might have an assertion in the lambda or other
constructs. Thus, I've not touched any of those, as it might change the
behavior in some way.

As per https://discourse.llvm.org/t/submitting-simple-nfc-patches/62640/3?u=steakhal
Chris Lattner

LLVM intentionally has a “yes, you can apply common sense judgement to
things” policy when it comes to code review. If you are doing mechanical
patches (e.g. adopting less_first) that apply to the entire monorepo,
then you don’t need everyone in the monorepo to sign off on it. Having
some +1 validation from someone is useful, but you don’t need everyone
whose code you touch to weigh in.

[lattner]

This patch LGTM other than the apparent build breakage

bolt/lib/Passes/LongJmp.cpp

LongJmpPass::createNewStub(BinaryBasicBlock &SourceBB, const MCSymbol *TgtSym,
   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(),
+    StubGroup.insert(std::lower_bound(StubGroup.begin(), StubGroup.end(),
                                       std::make_pair(AtAddress, nullptr),
-            [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
-                const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
-              return LHS.first < RHS.first;
-            }),
+                                      llvm::less_first()),
                      std::make_pair(AtAddress, StubBB.get()));
   };
 
   Stubs[&Func].insert(StubBB.get());
   StubBits[StubBB.get()] = BC.MIB->getUncondBranchEncodingSize();
   if (IsCold) {
     registerInMap(ColdLocalStubs[&Func]);
     if (opts::GroupStubs && TgtIsFunc)
       registerInMap(ColdStubGroups);
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),
-      [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
-          const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
-        return LHS.first < RHS.first;
-      });
+  auto Cand =
+      std::lower_bound(Candidates.begin(), Candidates.end(),
+                       std::make_pair(DotAddress, nullptr), llvm::less_first());
   if (Cand == Candidates.end())
     return nullptr;
   if (Cand != Candidates.begin()) {
     const StubTy *LeftCand = std::prev(Cand);
     if (Cand->first - DotAddress > DotAddress - LeftCand->first)
       Cand = LeftCand;
   }
   int BitsAvail = BC.MIB->getPCRelEncodingSize(Inst) - 1;
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(),
-                [&](const std::pair<uint64_t, BinaryBasicBlock *> &LHS,
-                    const std::pair<uint64_t, BinaryBasicBlock *> &RHS) {
-                  return LHS.first < RHS.first;
-                });
+      std::sort(KeyVal.second.begin(), KeyVal.second.end(), llvm::less_first());
     }
   };
 
   for (auto &KeyVal : HotLocalStubs)
     update(KeyVal.second);
   for (auto &KeyVal : ColdLocalStubs)
     update(KeyVal.second);
   update(HotStubGroups);

clang/lib/Frontend/FrontendAction.cpp

for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
       Headers.push_back(std::make_pair(RelName, *Header));
     }
 
     if (EC)
       return EC;
 
     // Sort header paths and make the header inclusion order deterministic
     // across different OSs and filesystems.
-    llvm::sort(Headers.begin(), Headers.end(), [](
-      const std::pair<std::string, const FileEntry *> &LHS,
-      const std::pair<std::string, const FileEntry *> &RHS) {
-        return LHS.first < RHS.first;
-    });
+    llvm::sort(Headers.begin(), Headers.end(), llvm::less_first());
     for (auto &H : Headers) {
       // Include this header as part of the umbrella directory.
       Module->addTopHeader(H.second);
       addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
     }
   }
 
   // Recurse into submodules.

clang/lib/Sema/SemaDeclCXX.cpp

for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
     }
     CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
   }
 
   if (WarnIndexes.empty())
     return;
 
   // Sort based on the ideal order, first in the pair.
-  llvm::sort(CorrelatedInitOrder,
-             [](auto &LHS, auto &RHS) { return LHS.first < RHS.first; });
+  llvm::sort(CorrelatedInitOrder, llvm::less_first());
 
   // Introduce a new scope as SemaDiagnosticBuilder needs to be destroyed to
   // emit the diagnostic before we can try adding notes.
   {
     Sema::SemaDiagnosticBuilder D = SemaRef.Diag(
         Inits[WarnIndexes.front() - 1]->getSourceLocation(),
         WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
                                 : diag::warn_some_initializers_out_of_order);

clang/lib/Sema/SemaStmtAsm.cpp

StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
   typedef std::pair<StringRef , Expr *> NamedOperand;
   SmallVector<NamedOperand, 4> NamedOperandList;
   for (unsigned i = 0, e = NumOutputs + NumInputs + NumLabels; i != e; ++i)
     if (Names[i])
       NamedOperandList.emplace_back(
           std::make_pair(Names[i]->getName(), Exprs[i]));
   // Sort NamedOperandList.
   std::stable_sort(NamedOperandList.begin(), NamedOperandList.end(),
-              [](const NamedOperand &LHS, const NamedOperand &RHS) {
-                return LHS.first < RHS.first;
-              });
+                   llvm::less_first());
   // Find adjacent duplicate operand.
   SmallVector<NamedOperand, 4>::iterator Found =
       std::adjacent_find(begin(NamedOperandList), end(NamedOperandList),
                          [](const NamedOperand &LHS, const NamedOperand &RHS) {
                            return LHS.first == RHS.first;
                          });
   if (Found != NamedOperandList.end()) {
     Diag((Found + 1)->second->getBeginLoc(),

clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp

#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
                   " (default: " #SHALLOW_VAL " in shallow mode, " #DEEP_VAL    \
                   " in deep mode)").str()                                      \
     },
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
 #undef ANALYZER_OPTION
 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
   };
 
-  llvm::sort(PrintableOptions, [](const OptionAndDescriptionTy &LHS,
-                                  const OptionAndDescriptionTy &RHS) {
-    return LHS.first < RHS.first;
-  });
+  llvm::sort(PrintableOptions, llvm::less_first());
 
   for (const auto &Pair : PrintableOptions) {
     AnalyzerOptions::printFormattedEntry(out, Pair, /*InitialPad*/ 2,
                                          /*EntryWidth*/ 30,
                                          /*MinLineWidth*/ 70);
     out << "\n\n";
   }
 }

clang/unittests/Introspection/IntrospectionTest.cpp

 STRING_LOCATION_STDPAIR(MethodDecl, getTypeSpecStartLoc())
   };
   // clang-format on
 
   EXPECT_EQ(ExpectedLocations, ActualLocations);
 
   auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
 
-  llvm::sort(ExpectedRanges, [](const auto &LHS, const auto &RHS) {
-    return LHS.first < RHS.first;
-  });
+  llvm::sort(ExpectedRanges, llvm::less_first());
 
   // clang-format off
   EXPECT_EQ(
             llvm::makeArrayRef(ExpectedRanges),
       (ArrayRef<std::pair<std::string, SourceRange>>{
 STRING_LOCATION_STDPAIR(MethodDecl, getExceptionSpecSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getParametersSourceRange()),

llvm/include/llvm/ExecutionEngine/Orc/Core.h

SymbolNameVector getSymbolNames() const {
     for (auto &KV : Symbols)
       Names.push_back(KV.first);
     return Names;
   }
 
   /// Sort the lookup set by pointer value. This sort is fast but sensitive to
   /// allocation order and so should not be used where a consistent order is
   /// required.
-  void sortByAddress() {
-    llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
-      return LHS.first < RHS.first;
-    });
-  }
+  void sortByAddress() { llvm::sort(Symbols, llvm::less_first()); }
 
   /// Sort the lookup set lexicographically. This sort is slow but the order
   /// is unaffected by allocation order.
   void sortByName() {
     llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
       return *LHS.first < *RHS.first;
     });
   }

llvm/lib/IR/Attributes.cpp

 
 AttributeList
 AttributeList::get(LLVMContext &C,
                    ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
   // If there are no attributes then return a null AttributesList pointer.
   if (Attrs.empty())
     return {};
 
-  assert(llvm::is_sorted(Attrs,
-                         [](const std::pair<unsigned, Attribute> &LHS,
-                            const std::pair<unsigned, Attribute> &RHS) {
-                           return LHS.first < RHS.first;
-                         }) &&
+  assert(llvm::is_sorted(Attrs, llvm::less_first()) &&
          "Misordered Attributes list!");
   assert(llvm::all_of(Attrs,
                       [](const std::pair<unsigned, Attribute> &Pair) {
                         return Pair.second.isValid();
                       }) &&
          "Pointless attribute!");
 
   // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes

 
 AttributeList
 AttributeList::get(LLVMContext &C,
                    ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
   // If there are no attributes then return a null AttributesList pointer.
   if (Attrs.empty())
     return {};
 
-  assert(llvm::is_sorted(Attrs,
-                         [](const std::pair<unsigned, AttributeSet> &LHS,
-                            const std::pair<unsigned, AttributeSet> &RHS) {
-                           return LHS.first < RHS.first;
-                         }) &&
+  assert(llvm::is_sorted(Attrs, llvm::less_first()) &&
          "Misordered Attributes list!");
   assert(llvm::none_of(Attrs,
                        [](const std::pair<unsigned, AttributeSet> &Pair) {
                          return !Pair.second.hasAttributes();
                        }) &&
          "Pointless attribute!");
 
   unsigned MaxIndex = Attrs.back().first;

llvm/lib/ObjCopy/MachO/MachOWriter.cpp

if (LinkEditDataCommandIndex) {
       const MachO::linkedit_data_command &LinkEditDataCommand =
           O.LoadCommands[*LinkEditDataCommandIndex]
               .MachOLoadCommand.linkedit_data_command_data;
       if (LinkEditDataCommand.dataoff)
         Queue.emplace_back(LinkEditDataCommand.dataoff, WriteHandler);
     }
   }
 
-  llvm::sort(Queue, [](const WriteOperation &LHS, const WriteOperation &RHS) {
-    return LHS.first < RHS.first;
-  });
+  llvm::sort(Queue, llvm::less_first());
 
   for (auto WriteOp : Queue)
     (this->*WriteOp.second)();
 }
 
 Error MachOWriter::finalize() { return LayoutBuilder.layout(); }
 
 Error MachOWriter::write() {

llvm/tools/dsymutil/DebugMap.cpp

void DebugMapObject::print(raw_ostream &OS) const {
   OS << getObjectFilename() << ":\n";
   // Sort the symbols in alphabetical order, like llvm-nm (and to get
   // deterministic output for testing).
   using Entry = std::pair<StringRef, SymbolMapping>;
   std::vector<Entry> Entries;
   Entries.reserve(Symbols.getNumItems());
   for (const auto &Sym : Symbols)
     Entries.push_back(std::make_pair(Sym.getKey(), Sym.getValue()));
-  llvm::sort(Entries, [](const Entry &LHS, const Entry &RHS) {
-    return LHS.first < RHS.first;
-  });
+  llvm::sort(Entries, llvm::less_first());
   for (const auto &Sym : Entries) {
     if (Sym.second.ObjectAddress)
       OS << format("\t%016" PRIx64, uint64_t(*Sym.second.ObjectAddress));
     else
       OS << "\t????????????????";
     OS << format(" => %016" PRIx64 "+0x%x\t%s\n",
                  uint64_t(Sym.second.BinaryAddress), uint32_t(Sym.second.Size),
                  Sym.first.data());

llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp

AttributeList convertAttributeRefVecToAttributeList(
   SetVec.reserve(AttributeSets.size());
 
   transform(AttributeSets, std::back_inserter(SetVec),
             [&C](const AttrPtrIdxVecVecTy &V) {
               return std::make_pair(
                   V.first, convertAttributeRefToAttributeSet(C, V.second));
             });
 
-  sort(SetVec, [](const std::pair<unsigned, AttributeSet> &LHS,
-                  const std::pair<unsigned, AttributeSet> &RHS) {
-    return LHS.first < RHS.first; // All values are unique.
-  });
+  // All values are unique.
+  sort(SetVec, llvm::less_first());
 
   return AttributeList::get(C, SetVec);
 }
 
 /// Removes out-of-chunk attributes from module.
 static void extractAttributesFromModule(Oracle &O, Module &Program) {
   AttributeRemapper R(O);
   R.visit(Program);