Use llvm::sort instead of std::sort where possible

[gribozavr]

Summary

llvm::sort is beneficial even when we use the iterator-based overload,
since it can optionally shuffle the elements (to detect
non-determinism). However llvm::sort is not usable everywhere, for
example, in compiler-rt.

[nhaehnle]

LGTM

clang-tools-extra/clang-include-fixer/IncludeFixerContext.cpp

 //===-- IncludeFixerContext.cpp - Include fixer context ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeFixerContext.h"
-#include <algorithm>
+#include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 namespace include_fixer {
 
 namespace {
 
 // Splits a multiply qualified names (e.g. a::b::c).
 llvm::SmallVector<llvm::StringRef, 8>
IncludeFixerContext::IncludeFixerContext(
     std::vector<find_all_symbols::SymbolInfo> Symbols)
     : FilePath(FilePath), QuerySymbolInfos(std::move(QuerySymbols)),
       MatchedSymbols(std::move(Symbols)) {
   // Remove replicated QuerySymbolInfos with the same range.
   //
   // QuerySymbolInfos may contain replicated elements. Because CorrectTypo
   // callback doesn't always work as we expected. In somecases, it will be
   // triggered at the same position or unidentified symbol multiple times.
-  std::sort(QuerySymbolInfos.begin(), QuerySymbolInfos.end(),
+  llvm::sort(QuerySymbolInfos,
              [&](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {
                return std::make_pair(A.Range.getOffset(), A.Range.getLength()) <
                       std::make_pair(B.Range.getOffset(), B.Range.getLength());
              });
   QuerySymbolInfos.erase(
       std::unique(QuerySymbolInfos.begin(), QuerySymbolInfos.end(),
                   [](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {
                     return A.Range == B.Range;
                   }),
       QuerySymbolInfos.end());
   for (const auto &Symbol : MatchedSymbols) {
     HeaderInfos.push_back(

clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp

 #include "clang/AST/AST.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Refactoring.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
-#include <algorithm>
 #include <string>
 
 namespace clang {
 namespace reorder_fields {
 using namespace clang::ast_matchers;
 using llvm::SmallSetVector;
 
 /// Finds the definition of a record by name.
for (const auto *Initializer : CtorDecl->inits()) {
     NewWrittenInitializersOrder.push_back(Initializer);
   }
   auto ByFieldNewPosition = [&](const CXXCtorInitializer *LHS,
                                 const CXXCtorInitializer *RHS) {
     assert(LHS && RHS);
     return NewFieldsPositions[LHS->getMember()->getFieldIndex()] <
            NewFieldsPositions[RHS->getMember()->getFieldIndex()];
   };
-  std::sort(std::begin(NewWrittenInitializersOrder),
-            std::end(NewWrittenInitializersOrder), ByFieldNewPosition);
+  llvm::sort(NewWrittenInitializersOrder, ByFieldNewPosition);
   assert(OldWrittenInitializersOrder.size() ==
          NewWrittenInitializersOrder.size());
   for (unsigned i = 0, e = NewWrittenInitializersOrder.size(); i < e; ++i)
     if (OldWrittenInitializersOrder[i] != NewWrittenInitializersOrder[i])
       addReplacement(OldWrittenInitializersOrder[i]->getSourceRange(),
                      NewWrittenInitializersOrder[i]->getSourceRange(), Context,
                      Replacements);
 }

clang-tools-extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp

 //===--- UseAfterMoveCheck.cpp - clang-tidy -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "UseAfterMoveCheck.h"
 
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Lex/Lexer.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include "../utils/ExprSequence.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::tidy::utils;
 
 
 namespace clang {
void UseAfterMoveFinder::getUsesAndReinits(
   // All references to the variable that aren't reinitializations are uses.
   Uses->clear();
   for (const DeclRefExpr *DeclRef : DeclRefs) {
     if (!ReinitDeclRefs.count(DeclRef))
       Uses->push_back(DeclRef);
   }
 
   // Sort the uses by their occurrence in the source code.
-  std::sort(Uses->begin(), Uses->end(),
-            [](const DeclRefExpr *D1, const DeclRefExpr *D2) {
-              return D1->getExprLoc() < D2->getExprLoc();
-            });
+  llvm::sort(*Uses, [](const DeclRefExpr *D1, const DeclRefExpr *D2) {
 }
 
 bool isStandardSmartPointer(const ValueDecl *VD) {
   const Type *TheType = VD->getType().getNonReferenceType().getTypePtrOrNull();
   if (!TheType)
     return false;
 
   const CXXRecordDecl *RecordDecl = TheType->getAsCXXRecordDecl();

clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp

 //===--- IncludeOrderCheck.cpp - clang-tidy -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeOrderCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include <map>
 
 namespace clang {
 namespace tidy {
 namespace llvm_check {
 
 namespace {
for (auto &Bucket : IncludeDirectives) {
 
     // Get a vector of indices.
     std::vector<unsigned> IncludeIndices;
     for (unsigned I = 0, E = FileDirectives.size(); I != E; ++I)
       IncludeIndices.push_back(I);
 
     // Sort the includes. We first sort by priority, then lexicographically.
     for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI)
-      std::sort(IncludeIndices.begin() + Blocks[BI],
+      llvm::sort(IncludeIndices.begin() + Blocks[BI],
                  IncludeIndices.begin() + Blocks[BI + 1],
                  [&FileDirectives](unsigned LHSI, unsigned RHSI) {
                    IncludeDirective &LHS = FileDirectives[LHSI];
                    IncludeDirective &RHS = FileDirectives[RHSI];
 
-                  int PriorityLHS =
-                      getPriority(LHS.Filename, LHS.IsAngled, LHS.IsMainModule);
-                  int PriorityRHS =
-                      getPriority(RHS.Filename, RHS.IsAngled, RHS.IsMainModule);
+                   int PriorityLHS = getPriority(LHS.Filename, LHS.IsAngled,
+                                                 LHS.IsMainModule);
+                   int PriorityRHS = getPriority(RHS.Filename, RHS.IsAngled,
+                                                 RHS.IsMainModule);
 
                    return std::tie(PriorityLHS, LHS.Filename) <
                           std::tie(PriorityRHS, RHS.Filename);
                  });
 
     // Emit a warning for each block and fixits for all changes within that
     // block.
     for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI) {
       // Find the first include that's not in the right position.
       unsigned I, E;
       for (I = Blocks[BI], E = Blocks[BI + 1]; I != E; ++I)
         if (IncludeIndices[I] != I)

clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp

 //===--- BuildConfusableTable.cpp - clang-tidy---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include <algorithm>
-
 using namespace llvm;
 
 int main(int argc, char *argv[]) {
   auto ErrorOrBuffer = MemoryBuffer::getFile(argv[1], true);
   if (!ErrorOrBuffer)
     return 1;
   std::unique_ptr<MemoryBuffer> Buffer = std::move(ErrorOrBuffer.get());
   StringRef Content = Buffer->getBuffer();
for (StringRef To_ : ToN) {
       To_.trim().getAsInteger(16, ToCodePoint);
       To.push_back(ToCodePoint);
     }
     // Sentinel
     To.push_back(0);
 
     Entries.emplace_back(CodePoint, To);
   }
-  std::sort(Entries.begin(), Entries.end());
+  llvm::sort(Entries);
 
   unsigned LargestValue =
       std::max_element(Entries.begin(), Entries.end(),
                        [](const auto &Entry0, const auto &Entry1) {
                          return Entry0.second.size() < Entry1.second.size();
                        })
           ->second.size();
 

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

 //===--- InconsistentDeclarationParameterNameCheck.cpp - clang-tidy-------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "llvm/ADT/STLExtras.h"
 
-#include <algorithm>
 #include <functional>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
if (OtherLocation != ParameterSourceLocation) { // Skip self.
         InconsistentDeclarations.emplace_back(OtherDeclaration->getLocation(),
                                               std::move(DifferingParams));
       }
     }
   }
 
   // Sort in order of appearance in translation unit to generate clear
   // diagnostics.
-  std::sort(InconsistentDeclarations.begin(), InconsistentDeclarations.end(),
+  llvm::sort(InconsistentDeclarations,
              [&SM](const InconsistentDeclarationInfo &Info1,
                    const InconsistentDeclarationInfo &Info2) {
                return SM.isBeforeInTranslationUnit(Info1.DeclarationLocation,
                                                    Info2.DeclarationLocation);
              });
   return InconsistentDeclarations;
 }
 
 const FunctionDecl *
 getParameterSourceDeclaration(const FunctionDecl *OriginalDeclaration) {
   const FunctionTemplateDecl *PrimaryTemplate =
       OriginalDeclaration->getPrimaryTemplate();
   if (PrimaryTemplate != nullptr) {

clang-tools-extra/clangd/IncludeFixer.cpp

 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <algorithm>
 #include <set>
 #include <string>
collectAccessibleScopes(Sema &Sem, const DeclarationNameInfo &Typo, Scope *S,
   };
 
   std::vector<std::string> Scopes;
   Scopes.push_back("");
   VisitedContextCollector Collector(Scopes);
   Sem.LookupVisibleDecls(S, LookupKind, Collector,
                          /*IncludeGlobalScope=*/false,
                          /*LoadExternal=*/false);
-  std::sort(Scopes.begin(), Scopes.end());
+  llvm::sort(Scopes);
   Scopes.erase(std::unique(Scopes.begin(), Scopes.end()), Scopes.end());
   return Scopes;
 }
 
 class IncludeFixer::UnresolvedNameRecorder : public ExternalSemaSource {
 public:
   UnresolvedNameRecorder(llvm::Optional<UnresolvedName> &LastUnresolvedName)
       : LastUnresolvedName(LastUnresolvedName) {}

clang-tools-extra/pseudo/lib/grammar/LRTableBuild.cpp

 //===--- LRTableBuild.cpp - Build a LRTable from LRGraph ---------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-pseudo/grammar/Grammar.h"
 #include "clang-pseudo/grammar/LRGraph.h"
 #include "clang-pseudo/grammar/LRTable.h"
 #include "clang/Basic/TokenKinds.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include <cstdint>
 
 namespace clang {
 namespace pseudo {
 
 LRTable LRTable::Builder::build() && {
   assert(NumNonterminals != 0 && "Set NumNonterminals or init with grammar");
LRTable LRTable::Builder::build() && {
   std::vector<RuleID> StateRules;
   for (StateID S = 0; S < NumStates; ++S) {
     Table.ReduceOffset.push_back(Table.Reduces.size());
     auto It = Reduce.find(S);
     if (It == Reduce.end())
       continue;
     Table.Reduces.insert(Table.Reduces.end(), It->second.begin(),
                          It->second.end());
-    std::sort(Table.Reduces.begin() + Table.ReduceOffset.back(),
+    llvm::sort(Table.Reduces.begin() + Table.ReduceOffset.back(),
                Table.Reduces.end());
   }
   Table.ReduceOffset.push_back(Table.Reduces.size());
 
   // Error recovery entries: sort (no dups already), and build offset lookup.
   llvm::sort(Recoveries, [&](const auto &L, const auto &R) {
     return std::tie(L.first, L.second.Result, L.second.Strategy) <
            std::tie(R.first, R.second.Result, R.second.Strategy);
   });

clang/lib/CodeGen/TargetInfo.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IntrinsicsNVPTX.h"
 #include "llvm/IR/IntrinsicsS390.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
-#include <algorithm> // std::sort
+#include <algorithm>
 
 using namespace clang;
 using namespace CodeGen;
 
 // Helper for coercing an aggregate argument or return value into an integer
 // array of the same size (including padding) and alignment.  This alternate
 // coercion happens only for the RenderScript ABI and can be removed after
 // runtimes that rely on it are no longer supported.

clang/unittests/Tooling/TransformerTest.cpp

 //===- unittest/Tooling/TransformerTest.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Transformer/Transformer.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
 #include "clang/Tooling/Transformer/RangeSelector.h"
 #include "clang/Tooling/Transformer/RewriteRule.h"
 #include "clang/Tooling/Transformer/Stencil.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace ast_matchers;
Transformer T(
       consumer());
   T.registerMatchers(&MatchFinder);
   auto Factory = newFrontendActionFactory(&MatchFinder);
   EXPECT_TRUE(runToolOnCodeWithArgs(
       Factory->create(), Source, std::vector<std::string>(), "input.cc",
       "clang-tool", std::make_shared<PCHContainerOperations>(),
       {{"input.h", Header}}));
 
-  std::sort(Changes.begin(), Changes.end(),
-            [](const AtomicChange &L, const AtomicChange &R) {
-              return L.getFilePath() < R.getFilePath();
-            });
+  llvm::sort(Changes, [](const AtomicChange &L, const AtomicChange &R) {
 
   ASSERT_EQ(Changes[0].getFilePath(), "./input.h");
   EXPECT_THAT(Changes[0].getInsertedHeaders(), IsEmpty());
   EXPECT_THAT(Changes[0].getRemovedHeaders(), IsEmpty());
   llvm::Expected<std::string> UpdatedCode =
       clang::tooling::applyAllReplacements(Header,
                                            Changes[0].getReplacements());
   ASSERT_TRUE(static_cast<bool>(UpdatedCode))

lld/COFF/Chunks.cpp

 //===- Chunks.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "COFFLinkerContext.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
void LocalImportChunk::writeTo(uint8_t *buf) const {
   }
 }
 
 void RVATableChunk::writeTo(uint8_t *buf) const {
   ulittle32_t *begin = reinterpret_cast<ulittle32_t *>(buf);
   size_t cnt = 0;
   for (const ChunkAndOffset &co : syms)
     begin[cnt++] = co.inputChunk->getRVA() + co.offset;
-  std::sort(begin, begin + cnt);
+  llvm::sort(begin, begin + cnt);
   assert(std::unique(begin, begin + cnt) == begin + cnt &&
          "RVA tables should be de-duplicated");
 }
 
 void RVAFlagTableChunk::writeTo(uint8_t *buf) const {
   struct RVAFlag {
     ulittle32_t rva;
     uint8_t flag;

lld/COFF/DLL.cpp

 // understand the rest of the linker.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DLL.h"
 #include "COFFLinkerContext.h"
 #include "Chunks.h"
 #include "SymbolTable.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::COFF;
std::map<std::string, std::vector<DefinedImportData *>,
            bool(*)(const std::string &, const std::string &)> m(less);
   for (DefinedImportData *sym : imports)
     m[sym->getDLLName().lower()].push_back(sym);
 
   std::vector<std::vector<DefinedImportData *>> v;
   for (auto &kv : m) {
     // Sort symbols by name for each group.
     std::vector<DefinedImportData *> &syms = kv.second;
-    std::sort(syms.begin(), syms.end(),
-              [](DefinedImportData *a, DefinedImportData *b) {
-                return a->getName() < b->getName();
-              });
+    llvm::sort(syms, [](DefinedImportData *a, DefinedImportData *b) {
     v.push_back(std::move(syms));
   }
   return v;
 }
 
 // See Microsoft PE/COFF spec 4.3 for details.
 
 // A chunk for the delay import descriptor table etnry.

lld/COFF/DriverUtils.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "Driver.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
for (Export &e : config->exports) {
     Export *existing = pair.first->second;
     if (e == *existing || e.name != existing->name)
       continue;
     warn("duplicate /export option: " + e.name);
   }
   config->exports = std::move(v);
 
   // Sort by name.
-  std::sort(config->exports.begin(), config->exports.end(),
-            [](const Export &a, const Export &b) {
-              return a.exportName < b.exportName;
-            });
+  llvm::sort(config->exports, [](const Export &a, const Export &b) {
 }
 
 void assignExportOrdinals() {
   // Assign unique ordinals if default (= 0).
   uint32_t max = 0;
   for (Export &e : config->exports)
     max = std::max(max, (uint32_t)e.ordinal);
   for (Export &e : config->exports)

lld/ELF/SyntheticSections.cpp

 #include "Symbols.h"
 #include "Target.h"
 #include "Thunks.h"
 #include "Writer.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/DWARF.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Version.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
void RelocationBaseSection::computeRels() {
   // Sort by (!IsRelative,SymIndex,r_offset). DT_REL[A]COUNT requires us to
   // place R_*_RELATIVE first. SymIndex is to improve locality, while r_offset
   // is to make results easier to read.
   if (combreloc) {
     auto nonRelative = relocs.begin() + numRelativeRelocs;
     parallelSort(relocs.begin(), nonRelative,
                  [&](auto &a, auto &b) { return a.r_offset < b.r_offset; });
     // Non-relative relocations are few, so don't bother with parallelSort.
-    std::sort(nonRelative, relocs.end(), [&](auto &a, auto &b) {
+    llvm::sort(nonRelative, relocs.end(), [&](auto &a, auto &b) {
       return std::tie(a.r_sym, a.r_offset) < std::tie(b.r_sym, b.r_offset);
     });
   }
 }
 
 template <class ELFT>
 RelocationSection<ELFT>::RelocationSection(StringRef name, bool combreloc)
     : RelocationBaseSection(name, config->isRela ? SHT_RELA : SHT_REL,
template <class ELFT> bool RelrSection<ELFT>::updateAllocSize() {
   // Number of bits to use for the relocation offsets bitmap.
   // Must be either 63 or 31.
   const size_t nBits = wordsize * 8 - 1;
 
   // Get offsets for all relative relocations and sort them.
   std::unique_ptr<uint64_t[]> offsets(new uint64_t[relocs.size()]);
   for (auto it : llvm::enumerate(relocs))
     offsets[it.index()] = it.value().getOffset();
-  std::sort(offsets.get(), offsets.get() + relocs.size());
+  llvm::sort(offsets.get(), offsets.get() + relocs.size());
 
   // For each leading relocation, find following ones that can be folded
   // as a bitmap and fold them.
   for (size_t i = 0, e = relocs.size(); i != e;) {
     // Add a leading relocation.
     relrRelocs.push_back(Elf_Relr(offsets[i]));
     uint64_t base = offsets[i] + wordsize;
     ++i;

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

void ValueEnumerator::organizeMetadata() {
   Order.reserve(MetadataMap.size());
   for (const Metadata *MD : MDs)
     Order.push_back(MetadataMap.lookup(MD));
 
   // Partition:
   //   - by function, then
   //   - by isa<MDString>
   // and then sort by the original/current ID.  Since the IDs are guaranteed to
-  // be unique, the result of std::sort will be deterministic.  There's no need
+  // be unique, the result of llvm::sort will be deterministic.  There's no need
   // for std::stable_sort.
   llvm::sort(Order, [this](MDIndex LHS, MDIndex RHS) {
     return std::make_tuple(LHS.F, getMetadataTypeOrder(LHS.get(MDs)), LHS.ID) <
            std::make_tuple(RHS.F, getMetadataTypeOrder(RHS.get(MDs)), RHS.ID);
   });
 
   // Rebuild MDs, index the metadata ranges for each function in FunctionMDs,
   // and fix up MetadataMap.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

for (const auto &DBG_PHI : DBGPHIRange) {
     ValidatedValues.insert(std::make_pair(Block, Num));
   }
 
   // Sort PHIs to validate into RPO-order.
   SmallVector<LDVSSAPhi *, 8> SortedPHIs;
   for (auto &PHI : CreatedPHIs)
     SortedPHIs.push_back(PHI);
 
-  std::sort(
-      SortedPHIs.begin(), SortedPHIs.end(), [&](LDVSSAPhi *A, LDVSSAPhi *B) {
-        return BBToOrder[&A->getParent()->BB] < BBToOrder[&B->getParent()->BB];
-      });
+  llvm::sort(SortedPHIs, [&](LDVSSAPhi *A, LDVSSAPhi *B) {
 
   for (auto &PHI : SortedPHIs) {
     ValueIDNum ThisBlockValueNum =
         MLiveIns[PHI->ParentBlock->BB.getNumber()][Loc.asU64()];
 
     // Are all these things actually defined?
     for (auto &PHIIt : PHI->IncomingValues) {
       // Any undef input means DBG_PHIs didn't dominate the use point.

llvm/lib/MC/MCPseudoProbe.cpp

 //===- lib/MC/MCPseudoProbe.cpp - Pseudo probe encoding support ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCPseudoProbe.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
if (It != Address2ProbesMap.end()) {
     }
   }
 }
 
 void MCPseudoProbeDecoder::printProbesForAllAddresses(raw_ostream &OS) {
   std::vector<uint64_t> Addresses;
   for (auto Entry : Address2ProbesMap)
     Addresses.push_back(Entry.first);
-  std::sort(Addresses.begin(), Addresses.end());
+  llvm::sort(Addresses);
   for (auto K : Addresses) {
     OS << "Address:\t";
     OS << K;
     OS << "\n";
     printProbeForAddress(OS, K);
   }
 }
 

llvm/lib/Target/DirectX/DXILWriter/DXILBitcodeWriter.cpp

 //===- Bitcode/Writer/DXILBitcodeWriter.cpp - DXIL Bitcode Writer ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DXILBitcodeWriter.h"
 #include "DXILValueEnumerator.h"
 #include "PointerTypeAnalysis.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Bitcode/BitcodeCommon.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/LLVMBitCodes.h"
 #include "llvm/Bitstream/BitCodes.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
   // Read the named values from a sorted list instead of the original list
   // to ensure the binary is the same no matter what values ever existed.
   SmallVector<const ValueName *, 16> SortedTable;
 
   for (auto &VI : VST) {
     SortedTable.push_back(VI.second->getValueName());
   }
   // The keys are unique, so there shouldn't be stability issues.
-  std::sort(SortedTable.begin(), SortedTable.end(),
-            [](const ValueName *A, const ValueName *B) {
-              return A->first() < B->first();
-            });
+  llvm::sort(SortedTable, [](const ValueName *A, const ValueName *B) {
 
   for (const ValueName *SI : SortedTable) {
     auto &Name = *SI;
 
     // Figure out the encoding to use for the name.
     bool is7Bit = true;
     bool isChar6 = true;
     for (const char *C = Name.getKeyData(), *E = C + Name.getKeyLength();

llvm/lib/Target/DirectX/DXILWriter/DXILValueEnumerator.cpp

void ValueEnumerator::organizeMetadata() {
   Order.reserve(MetadataMap.size());
   for (const Metadata *MD : MDs)
     Order.push_back(MetadataMap.lookup(MD));
 
   // Partition:
   //   - by function, then
   //   - by isa<MDString>
   // and then sort by the original/current ID.  Since the IDs are guaranteed to
-  // be unique, the result of std::sort will be deterministic.  There's no need
+  // be unique, the result of llvm::sort will be deterministic.  There's no need
   // for std::stable_sort.
   llvm::sort(Order, [this](MDIndex LHS, MDIndex RHS) {
     return std::make_tuple(LHS.F, getMetadataTypeOrder(LHS.get(MDs)), LHS.ID) <
            std::make_tuple(RHS.F, getMetadataTypeOrder(RHS.get(MDs)), RHS.ID);
   });
 
   // Rebuild MDs, index the metadata ranges for each function in FunctionMDs,
   // and fix up MetadataMap.

llvm/lib/Target/XCore/XCoreFrameLowering.cpp

 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetOptions.h"
-#include <algorithm> // std::sort
+#include <algorithm>
 
 using namespace llvm;
 
 static const unsigned FramePtr = XCore::R10;
 static const int MaxImmU16 = (1<<16) - 1;
 
 // helper functions. FIXME: Eliminate.
 static inline bool isImmU6(unsigned val) {

llvm/unittests/ADT/SmallSetTest.cpp

 //===- llvm/unittest/ADT/SmallSetTest.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // SmallSet unit tests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 
 TEST(SmallSetTest, Insert) {
 
   SmallSet<int, 4> s1;
TEST(SmallSetTest, IteratorInt) {
   SmallSet<int, 4> s1;
 
   // Test the 'small' case.
   for (int i = 0; i < 3; i++)
     s1.insert(i);
 
   std::vector<int> V(s1.begin(), s1.end());
   // Make sure the elements are in the expected order.
-  std::sort(V.begin(), V.end());
+  llvm::sort(V);
   for (int i = 0; i < 3; i++)
     EXPECT_EQ(i, V[i]);
 
   // Test the 'big' case by adding a few more elements to switch to std::set
   // internally.
   for (int i = 3; i < 6; i++)
     s1.insert(i);
 
   V.assign(s1.begin(), s1.end());
   // Make sure the elements are in the expected order.
-  std::sort(V.begin(), V.end());
+  llvm::sort(V);
   for (int i = 0; i < 6; i++)
     EXPECT_EQ(i, V[i]);
 }
 
 TEST(SmallSetTest, IteratorString) {
   // Test SmallSetIterator for SmallSet with a type with non-trivial
   // ctors/dtors.
   SmallSet<std::string, 2> s1;
 
   s1.insert("str 1");
   s1.insert("str 2");
   s1.insert("str 1");
 
   std::vector<std::string> V(s1.begin(), s1.end());
-  std::sort(V.begin(), V.end());
+  llvm::sort(V);
   EXPECT_EQ(2u, s1.size());
   EXPECT_EQ("str 1", V[0]);
   EXPECT_EQ("str 2", V[1]);
 
   s1.insert("str 4");
   s1.insert("str 0");
   s1.insert("str 4");
 
   V.assign(s1.begin(), s1.end());
   // Make sure the elements are in the expected order.
-  std::sort(V.begin(), V.end());
+  llvm::sort(V);
   EXPECT_EQ(4u, s1.size());
   EXPECT_EQ("str 0", V[0]);
   EXPECT_EQ("str 1", V[1]);
   EXPECT_EQ("str 2", V[2]);
   EXPECT_EQ("str 4", V[3]);
 }
 
 TEST(SmallSetTest, IteratorIncMoveCopy) {

llvm/unittests/MIR/MachineMetadata.cpp

 //===- MachineInstrBundleIteratorTest.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MIRPrinter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineModuleSlotTracker.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
)MIR";
   // Examine machine metadata collected. They should match ones
   // afore-generated.
   std::vector<const MDNode *> Collected;
   MachineModuleSlotTracker::MachineMDNodeListType MDList;
   MST.collectMachineMDNodes(MDList);
   for (auto &MD : MDList)
     Collected.push_back(MD.second);
 
-  std::sort(Generated.begin(), Generated.end());
-  std::sort(Collected.begin(), Collected.end());
+  llvm::sort(Generated);
+  llvm::sort(Collected);
   EXPECT_EQ(Collected, Generated);
 
   // FileCheck the output from MIR printer.
   std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); });
   std::string CheckString = R"(
 CHECK: machineMetadataNodes:
 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"}
 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"}
)MIR";
   // Examine machine metadata collected. They should match ones
   // afore-generated.
   std::vector<const MDNode *> Collected;
   MachineModuleSlotTracker::MachineMDNodeListType MDList;
   MST.collectMachineMDNodes(MDList);
   for (auto &MD : MDList)
     Collected.push_back(MD.second);
 
-  std::sort(Generated.begin(), Generated.end());
-  std::sort(Collected.begin(), Collected.end());
+  llvm::sort(Generated);
+  llvm::sort(Collected);
   EXPECT_EQ(Collected, Generated);
 
   // FileCheck the output from MIR printer.
   std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); });
   std::string CheckString = R"(
 CHECK: machineMetadataNodes:
 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"}
 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"}
)MIR";
   // Examine machine metadata collected. They should match ones
   // afore-generated.
   std::vector<const MDNode *> Collected;
   MachineModuleSlotTracker::MachineMDNodeListType MDList;
   MST.collectMachineMDNodes(MDList);
   for (auto &MD : MDList)
     Collected.push_back(MD.second);
 
-  std::sort(Generated.begin(), Generated.end());
-  std::sort(Collected.begin(), Collected.end());
+  llvm::sort(Generated);
+  llvm::sort(Collected);
   EXPECT_EQ(Collected, Generated);
 
   // FileCheck the output from MIR printer.
   std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); });
   std::string CheckString = R"(
 CHECK: machineMetadataNodes:
 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"}
 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"}

llvm/unittests/Support/AlignmentTest.cpp

 //=== - llvm/unittest/Support/Alignment.cpp - Alignment utility tests -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Alignment.h"
+#include "llvm/ADT/STLExtras.h"
 #include "gtest/gtest.h"
 
 #include <vector>
 
 #ifdef _MSC_VER
 // Disable warnings about potential divide by 0.
 #pragma warning(push)
 #pragma warning(disable : 4723)
for (const auto &T : kTests) {
     const Align A(T.alignment);
     EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
     EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
   }
 }
 
 TEST(AlignmentTest, AlignComparisons) {
   std::vector<uint64_t> ValidAlignments = getValidAlignments();
-  std::sort(ValidAlignments.begin(), ValidAlignments.end());
+  llvm::sort(ValidAlignments);
   for (size_t I = 1; I < ValidAlignments.size(); ++I) {
     assert(I >= 1);
     const Align A(ValidAlignments[I - 1]);
     const Align B(ValidAlignments[I]);
     EXPECT_EQ(A, A);
     EXPECT_NE(A, B);
     EXPECT_LT(A, B);
     EXPECT_GT(B, A);

llvm/utils/TableGen/DXILEmitter.cpp

static std::string buildCategoryStr(StringSet<> &Cetegorys) {
   }
   return OS.str();
 }
 
 // Emit enum declaration for DXIL.
 static void emitDXILEnums(std::vector<DXILOperationData> &DXILOps,
                           raw_ostream &OS) {
   // Sort by Category + OpName.
-  std::sort(DXILOps.begin(), DXILOps.end(),
-            [](DXILOperationData &A, DXILOperationData &B) {
-              // Group by Category first.
-              if (A.Category == B.Category)
-                // Inside same Category, order by OpName.
-                return A.DXILOp < B.DXILOp;
-              else
-                return A.Category < B.Category;
-            });
+  llvm::sort(DXILOps, [](DXILOperationData &A, DXILOperationData &B) {
 
   OS << "// Enumeration for operations specified by DXIL\n";
   OS << "enum class OpCode : unsigned {\n";
 
   StringMap<StringSet<>> ClassMap;
   StringRef PrevCategory = "";
   for (auto &DXILOp : DXILOps) {
     StringRef Category = DXILOp.Category;
static void emitDXILEnums(std::vector<DXILOperationData> &DXILOps,
   OS << "\n};\n\n";
 
   std::vector<std::pair<std::string, std::string>> ClassVec;
   for (auto &It : ClassMap) {
     ClassVec.emplace_back(
         std::make_pair(It.getKey().str(), buildCategoryStr(It.second)));
   }
   // Sort by Category + ClassName.
-  std::sort(ClassVec.begin(), ClassVec.end(),
-            [](std::pair<std::string, std::string> &A,
+  llvm::sort(ClassVec, [](std::pair<std::string, std::string> &A,
                           std::pair<std::string, std::string> &B) {
-              StringRef ClassA = A.first;
-              StringRef CategoryA = A.second;
-              StringRef ClassB = B.first;
-              StringRef CategoryB = B.second;
-              // Group by Category first.
-              if (CategoryA == CategoryB)
-                // Inside same Category, order by ClassName.
-                return ClassA < ClassB;
-              else
-                return CategoryA < CategoryB;
-            });
 
   OS << "// Groups for DXIL operations with equivalent function templates\n";
   OS << "enum class OpCodeClass : unsigned {\n";
   PrevCategory = "";
   for (auto &It : ClassVec) {
 
     StringRef Category = It.second;
     if (Category != PrevCategory) {
return StringSwitch<std::string>(DXILOpClass)
       .Case("CBufferLoadLegacy", "cbufferLoadLegacy")
       .Case("GSInstanceID", "gsInstanceID")
       .Default(lowerFirstLetter(DXILOpClass));
 }
 
 static void emitDXILOperationTable(std::vector<DXILOperationData> &DXILOps,
                                    raw_ostream &OS) {
   // Sort by DXILOpID.
-  std::sort(DXILOps.begin(), DXILOps.end(),
-            [](DXILOperationData &A, DXILOperationData &B) {
-              return A.DXILOpID < B.DXILOpID;
-            });
+  llvm::sort(DXILOps, [](DXILOperationData &A, DXILOperationData &B) {
 
   // Collect Names.
   SequenceToOffsetTable<std::string> OpClassStrings;
   SequenceToOffsetTable<std::string> OpStrings;
 
   StringSet<> ClassSet;
   for (auto &DXILOp : DXILOps) {
     OpStrings.add(DXILOp.DXILOp.str());

llvm/utils/TableGen/DirectiveEmitter.cpp

 }
 
 // Generate the parser for the clauses.
 void GenerateFlangClausesParser(const DirectiveLanguage &DirLang,
                                 raw_ostream &OS) {
   std::vector<Record *> Clauses = DirLang.getClauses();
   // Sort clauses in reverse alphabetical order so with clauses with same
   // beginning, the longer option is tried before.
-  std::sort(Clauses.begin(), Clauses.end(), compareClauseName);
+  llvm::sort(Clauses, compareClauseName);
   IfDefScope Scope("GEN_FLANG_CLAUSES_PARSER", OS);
   OS << "\n";
   unsigned index = 0;
   unsigned lastClauseIndex = DirLang.getClauses().size() - 1;
   OS << "TYPE_PARSER(\n";
   for (const auto &C : Clauses) {
     Clause Clause{C};
     if (Clause.getAliases().empty()) {

llvm/utils/TableGen/SearchableTableEmitter.cpp

 // together with companion index tables and lookup functions (binary search,
 // currently).
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenIntrinsics.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
if (auto RecordTy = dyn_cast<RecordRecTy>(Field.RecType)) {
       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
         Field.IsInstruction = true;
     }
   }
 
   SearchIndex Idx;
   std::copy(Table.Fields.begin(), Table.Fields.end(),
             std::back_inserter(Idx.Fields));
-  std::sort(Table.Entries.begin(), Table.Entries.end(),
-            [&](Record *LHS, Record *RHS) { return compareBy(LHS, RHS, Idx); });
+  llvm::sort(Table.Entries, [&](Record *LHS, Record *RHS) {
+    return compareBy(LHS, RHS, Idx);
+  });
 }
 
 void SearchableTableEmitter::run(raw_ostream &OS) {
   // Emit tables in a deterministic order to avoid needless rebuilds.
   SmallVector<std::unique_ptr<GenericTable>, 4> Tables;
   DenseMap<Record *, GenericTable *> TableMap;
 
   // Collect all definitions first.

llvm/utils/UnicodeData/UnicodeNameMappingGenerator.cpp

public:
   // The longest names are inserted first into the dictionary,
   // in the hope it will contain shorter labels as substring,
   // thereby reducing duplication.
   // We could theorically be more clever by trying to minimizing the size
   // of the dictionary.
   std::pair<std::string, std::vector<uint8_t>> serialize() {
     std::set<std::string> Names = this->getNameFragments();
     std::vector<std::string> Sorted(Names.begin(), Names.end());
-    std::sort(Sorted.begin(), Sorted.end(),
-              [](const auto &a, const auto &b) { return a.size() > b.size(); });
+    llvm::sort(Sorted, [](const auto &a, const auto &b) {
+      return a.size() > b.size();
+    });
     std::string Dict(Letters.begin(), Letters.end());
     Dict.reserve(50000);
     for (const std::string &Name : Sorted) {
       if (Name.size() <= 1)
         continue;
       if (Dict.find(Name) != std::string::npos)
         continue;
       Dict += Name;

mlir/lib/Analysis/Liveness.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Liveness.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Region.h"
 #include "mlir/IR/Value.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 namespace {
 /// Builds and holds block information during the construction phase.
else {
       os << "arg" << blockArg.getArgNumber() << "@"
          << blockIds[blockArg.getOwner()];
     }
     os << " ";
   };
 
   auto printValueRefs = [&](const ValueSetT &values) {
     std::vector<Value> orderedValues(values.begin(), values.end());
-    std::sort(orderedValues.begin(), orderedValues.end(),
-              [&](Value left, Value right) {
-                return valueIds[left] < valueIds[right];
-              });
+    llvm::sort(orderedValues, [&](Value left, Value right) {
     for (Value value : orderedValues)
       printValueRef(value);
   };
 
   // Dump information about in and out values.
   operation->walk<WalkOrder::PreOrder>([&](Block *block) {
     os << "// - Block: " << blockIds[block] << "\n";
     const auto *liveness = getLiveness(block);
for (Operation &op : *block) {
       if (op.getNumResults() < 1)
         continue;
       os << "\n";
       for (Value result : op.getResults()) {
         os << "// ";
         printValueRef(result);
         os << ":";
         auto liveOperations = resolveLiveness(result);
-        std::sort(liveOperations.begin(), liveOperations.end(),
-                  [&](Operation *left, Operation *right) {
-                    return operationIds[left] < operationIds[right];
-                  });
+        llvm::sort(liveOperations, [&](Operation *left, Operation *right) {
         for (Operation *operation : liveOperations) {
           os << "\n//     ";
           operation->print(os);
         }
       }
     }
     os << "\n// --- EndLivenessIntervals\n";
 

mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp

 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iomanip>
 #include <sstream>
 #define DEBUG_TYPE "affine-loop-fusion"
 
for (auto &srcEdge : mdg->inEdges[dstId]) {
 
     if (any_of(srcNode->stores, [&](Operation *op) {
           auto storeOp = cast<AffineWriteOpInterface>(op);
           return consumedMemrefs.count(storeOp.getMemRef()) > 0;
         }))
       srcIdCandidates.push_back(srcNode->id);
   }
 
-  std::sort(srcIdCandidates.begin(), srcIdCandidates.end());
+  llvm::sort(srcIdCandidates);
   srcIdCandidates.erase(
       std::unique(srcIdCandidates.begin(), srcIdCandidates.end()),
       srcIdCandidates.end());
 }
 
 /// Returns in 'producerConsumerMemrefs' the memrefs involved in a
 /// producer-consumer dependence between 'srcId' and 'dstId'.
 static void

mlir/lib/Dialect/SCF/Utils/Utils.cpp

 void mlir::collapseParallelLoops(
     scf::ParallelOp loops, ArrayRef<std::vector<unsigned>> combinedDimensions) {
   OpBuilder outsideBuilder(loops);
   Location loc = loops.getLoc();
 
   // Presort combined dimensions.
   auto sortedDimensions = llvm::to_vector<3>(combinedDimensions);
   for (auto &dims : sortedDimensions)
-    std::sort(dims.begin(), dims.end());
+    llvm::sort(dims);
 
   // Normalize ParallelOp's iteration pattern.
   SmallVector<Value, 3> normalizedLowerBounds, normalizedSteps,
       normalizedUpperBounds;
   for (unsigned i = 0, e = loops.getNumLoops(); i < e; ++i) {
     OpBuilder insideLoopBuilder = OpBuilder::atBlockBegin(loops.getBody());
     auto resultBounds =
         normalizeLoop(outsideBuilder, insideLoopBuilder, loc,

mlir/lib/IR/AffineExpr.cpp

if (rhs.isa<AffineConstantExpr>()) {
       addEntry(indexEntry, flatExprs[numDims + numSymbols + it.index()], expr);
     }
     addedToMap[it.index()] = true;
   }
 
   // Constructing the simplified semi-affine sum of product/division/mod
   // expression from the flattened form in the desired sorted order of indices
   // of the various individual product/division/mod expressions.
-  std::sort(indices.begin(), indices.end());
+  llvm::sort(indices);
   for (const std::pair<unsigned, unsigned> index : indices) {
     assert(indexToExprMap.lookup(index) &&
            "cannot find key in `indexToExprMap` map");
     expr = expr + indexToExprMap.lookup(index) * coefficients.lookup(index);
   }
 
   // Local identifiers.
   for (unsigned j = numDims + numSymbols, e = flatExprs.size() - 1; j < e;