[clang] Change std::sort to llvm::sort in response to r327219

[mgrang]

Summary

r327219 added wrappers to std::sort which randomly shuffle the container before sorting.
This will help in uncovering non-determinism caused due to undefined sorting
order of objects having the same key.

To make use of that infrastructure we need to invoke llvm::sort instead of std::sort.

[rsmith]

include/clang-c/Index.h

2133 ↗

(On Diff #137938)

This shouldn't be changed.

lib/AST/VTableBuilder.cpp

2109

Reindent this (and other calls) please.

[mgrang]

Fixed indentation.

[mgrang]

Ping for reviews please.

[rnk]

lgtm

include/clang/Basic/Attr.td

                Architecture == Other.Architecture && Features == Other.Features;
       }
     };
     ParsedTargetAttr parse() const {
       return parse(getFeaturesStr());
     }
 
     template<class Compare>
     ParsedTargetAttr parse(Compare cmp) const {
       ParsedTargetAttr Attrs = parse();
-      std::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
+      llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
       return Attrs;
     }
 
     bool isDefaultVersion() const { return getFeaturesStr() == "default"; }
 
     static ParsedTargetAttr parse(StringRef Features) {
       ParsedTargetAttr Ret;
       if (Features == "default") return Ret;
       SmallVector<StringRef, 1> AttrFeatures;
       Features.split(AttrFeatures, ",");

include/clang/Serialization/ContinuousRangeMap.h

   /// from a set of values.
   class Builder {
     ContinuousRangeMap &Self;
 
   public:
     explicit Builder(ContinuousRangeMap &Self) : Self(Self) {}
     Builder(const Builder&) = delete;
     Builder &operator=(const Builder&) = delete;
     
     ~Builder() {
-      std::sort(Self.Rep.begin(), Self.Rep.end(), Compare());
+      llvm::sort(Self.Rep.begin(), Self.Rep.end(), Compare());
       std::unique(Self.Rep.begin(), Self.Rep.end(),
                   [](const_reference A, const_reference B) {
         // FIXME: we should not allow any duplicate keys, but there are a lot of
         // duplicate 0 -> 0 mappings to remove first.
         assert((A == B || A.first != B.first) &&
                "ContinuousRangeMap::Builder given non-unique keys");
         return A == B;
       });
     }
     

lib/AST/ASTContext.cpp

       // have tail padding, so just make sure there isn't an error.
       if (!isStructEmpty(Base.getType())) {
         llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
             Context, Base.getType()->getAs<RecordType>()->getDecl());
         if (!Size)
           return llvm::None;
         Bases.emplace_back(Base.getType(), Size.getValue());
       }
     }
 
-    std::sort(
+    llvm::sort(
         Bases.begin(), Bases.end(), [&](const std::pair<QualType, int64_t> &L,
                                         const std::pair<QualType, int64_t> &R) {
           return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
                  Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
         });
 
     for (const auto Base : Bases) {
       int64_t BaseOffset = Context.toBits(
           Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
       int64_t BaseSize = Base.second;

lib/AST/ItaniumMangle.cpp

                        AbiTag->tags().end());
       }
 
       if (AdditionalAbiTags) {
         UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(),
                            AdditionalAbiTags->end());
         TagList.insert(TagList.end(), AdditionalAbiTags->begin(),
                        AdditionalAbiTags->end());
       }
 
-      std::sort(TagList.begin(), TagList.end());
+      llvm::sort(TagList.begin(), TagList.end());
       TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end());
 
       writeSortedUniqueAbiTags(Out, TagList);
     }
 
     const AbiTagList &getUsedAbiTags() const { return UsedAbiTags; }
     void setUsedAbiTags(const AbiTagList &AbiTags) {
       UsedAbiTags = AbiTags;
     }
 
     const AbiTagList &getEmittedAbiTags() const {
       return EmittedAbiTags;
     }
 
     const AbiTagList &getSortedUniqueUsedAbiTags() {
-      std::sort(UsedAbiTags.begin(), UsedAbiTags.end());
+      llvm::sort(UsedAbiTags.begin(), UsedAbiTags.end());
       UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
                         UsedAbiTags.end());
       return UsedAbiTags;
     }
 
   private:
     //! All abi tags used implicitly or explicitly.
     AbiTagList UsedAbiTags;
     //! All explicit abi tags (i.e. not from namespace).
     AbiTagList EmittedAbiTags;

lib/AST/VTableBuilder.cpp

                                     MD);
       
       MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
     }
 
     for (const auto &I : MethodNamesAndDecls) {
       const std::string &MethodName = I.first;
       const CXXMethodDecl *MD = I.second;
 
       ThunkInfoVectorTy ThunksVector = Thunks[MD];
-      std::sort(ThunksVector.begin(), ThunksVector.end(),
+      llvm::sort(ThunksVector.begin(), ThunksVector.end(),
                  [](const ThunkInfo &LHS, const ThunkInfo &RHS) {
         assert(LHS.Method == nullptr && RHS.Method == nullptr);
         return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
       });
 
       Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
       Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
       
       for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
         const ThunkInfo &Thunk = ThunksVector[I];
 

                            ArrayRef<VTableComponent> VTableComponents,
                            ArrayRef<VTableThunkTy> VTableThunks,
                            const AddressPointsMapTy &AddressPoints)
     : VTableComponents(VTableComponents), VTableThunks(VTableThunks),
       AddressPoints(AddressPoints) {
   if (VTableIndices.size() <= 1)
     assert(VTableIndices.size() == 1 && VTableIndices[0] == 0);
   else
     this->VTableIndices = OwningArrayRef<size_t>(VTableIndices);
 
-  std::sort(this->VTableThunks.begin(), this->VTableThunks.end(),
+  llvm::sort(this->VTableThunks.begin(), this->VTableThunks.end(),
              [](const VTableLayout::VTableThunkTy &LHS,
                 const VTableLayout::VTableThunkTy &RHS) {
               assert((LHS.first != RHS.first || LHS.second == RHS.second) &&
                      "Different thunks should have unique indices!");
               return LHS.first < RHS.first;
             });
 }
 
 VTableLayout::~VTableLayout() { }
 
 ItaniumVTableContext::ItaniumVTableContext(ASTContext &Context)
     : VTableContextBase(/*MS=*/false) {}

   // What we're essentially doing here is bucketing together ambiguous paths.
   // Any bucket with more than one path in it gets extended by NextBase, which
   // is usually the direct base of the inherited the vbptr.  This code uses a
   // sorted vector to implement a multiset to form the buckets.  Note that the
   // ordering is based on pointers, but it doesn't change our output order.  The
   // current algorithm is designed to match MSVC 2012's names.
   llvm::SmallVector<std::reference_wrapper<VPtrInfo>, 2> PathsSorted;
   PathsSorted.reserve(Paths.size());
   for (auto& P : Paths)
     PathsSorted.push_back(*P);
-  std::sort(PathsSorted.begin(), PathsSorted.end(),
+  llvm::sort(PathsSorted.begin(), PathsSorted.end(),
              [](const VPtrInfo &LHS, const VPtrInfo &RHS) {
     return LHS.MangledPath < RHS.MangledPath;
   });
   bool Changed = false;
   for (size_t I = 0, E = PathsSorted.size(); I != E;) {
     // Scan forward to find the end of the bucket.
     size_t BucketStart = I;
     do {
       ++I;
     } while (I != E &&
              PathsSorted[BucketStart].get().MangledPath ==

lib/ASTMatchers/Dynamic/Parser.cpp

 std::vector<MatcherCompletion>
 Parser::completeExpression(StringRef Code, unsigned CompletionOffset, Sema *S,
                            const NamedValueMap *NamedValues) {
   Diagnostics Error;
   CodeTokenizer Tokenizer(Code, &Error, CompletionOffset);
   Parser P(&Tokenizer, S, NamedValues, &Error);
   VariantValue Dummy;
   P.parseExpressionImpl(&Dummy);
 
   // Sort by specificity, then by name.
-  std::sort(P.Completions.begin(), P.Completions.end(),
+  llvm::sort(P.Completions.begin(), P.Completions.end(),
              [](const MatcherCompletion &A, const MatcherCompletion &B) {
     if (A.Specificity != B.Specificity)
       return A.Specificity > B.Specificity;
     return A.TypedText < B.TypedText;
   });
 
   return P.Completions;
 }
 
 llvm::Optional<DynTypedMatcher>
 Parser::parseMatcherExpression(StringRef Code, Sema *S,

lib/Analysis/LiveVariables.cpp

   getImpl(impl).dumpBlockLiveness(M);
 }
 
 void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
   std::vector<const CFGBlock *> vec;
   for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator
        it = blocksEndToLiveness.begin(), ei = blocksEndToLiveness.end();
        it != ei; ++it) {
     vec.push_back(it->first);    
   }
-  std::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) {
+  llvm::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) {
     return A->getBlockID() < B->getBlockID();
   });
 
   std::vector<const VarDecl*> declVec;
 
   for (std::vector<const CFGBlock *>::iterator
         it = vec.begin(), ei = vec.end(); it != ei; ++it) {
     llvm::errs() << "\n[ B" << (*it)->getBlockID()
                  << " (live variables at block exit) ]\n";
     
     LiveVariables::LivenessValues vals = blocksEndToLiveness[*it];
     declVec.clear();
     
     for (llvm::ImmutableSet<const VarDecl *>::iterator si =
           vals.liveDecls.begin(),
           se = vals.liveDecls.end(); si != se; ++si) {
       declVec.push_back(*si);      
     }
 
-    std::sort(declVec.begin(), declVec.end(), [](const Decl *A, const Decl *B) {
+    llvm::sort(declVec.begin(), declVec.end(),
+               [](const Decl *A, const Decl *B) {
       return A->getLocStart() < B->getLocStart();
     });
 
     for (std::vector<const VarDecl*>::iterator di = declVec.begin(),
          de = declVec.end(); di != de; ++di) {
       llvm::errs() << " " << (*di)->getDeclName().getAsString()
                    << " <";
       (*di)->getLocation().dump(M);
       llvm::errs() << ">\n";
     }

lib/Basic/VirtualFileSystem.cpp

       endDirectory();
     }
     OS << "\n";
   }
 
   OS << "  ]\n"
      << "}\n";
 }
 
 void YAMLVFSWriter::write(llvm::raw_ostream &OS) {
-  std::sort(Mappings.begin(), Mappings.end(),
+  llvm::sort(Mappings.begin(), Mappings.end(),
              [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) {
     return LHS.VPath < RHS.VPath;
   });
 
   JSONWriter(OS).write(Mappings, UseExternalNames, IsCaseSensitive,
                        IsOverlayRelative, IgnoreNonExistentContents,
                        OverlayDir);
 }
 
 VFSFromYamlDirIterImpl::VFSFromYamlDirIterImpl(
     const Twine &_Path, RedirectingFileSystem &FS,

lib/CodeGen/CGVTables.cpp

   typedef std::pair<const CXXRecordDecl *, unsigned> BSEntry;
   std::vector<BSEntry> BitsetEntries;
   // Create a bit set entry for each address point.
   for (auto &&AP : VTLayout.getAddressPoints())
     BitsetEntries.push_back(
         std::make_pair(AP.first.getBase(),
                        VTLayout.getVTableOffset(AP.second.VTableIndex) +
                            AP.second.AddressPointIndex));
 
   // Sort the bit set entries for determinism.
-  std::sort(BitsetEntries.begin(), BitsetEntries.end(),
+  llvm::sort(BitsetEntries.begin(), BitsetEntries.end(),
              [this](const BSEntry &E1, const BSEntry &E2) {
     if (&E1 == &E2)
       return false;
 
     std::string S1;
     llvm::raw_string_ostream O1(S1);
     getCXXABI().getMangleContext().mangleTypeName(
         QualType(E1.first->getTypeForDecl(), 0), O1);
     O1.flush();
 
     std::string S2;

lib/CodeGen/CodeGenModule.cpp

     // Otherwise just add the existing target cpu and target features to the
     // function.
     Features = getTarget().getTargetOpts().Features;
   }
 
   if (TargetCPU != "") {
     Attrs.addAttribute("target-cpu", TargetCPU);
     AddedAttr = true;
   }
   if (!Features.empty()) {
-    std::sort(Features.begin(), Features.end());
+    llvm::sort(Features.begin(), Features.end());
     Attrs.addAttribute("target-features", llvm::join(Features, ","));
     AddedAttr = true;
   }
 
   return AddedAttr;
 }
 
 void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
                                           llvm::GlobalObject *GO) {
   const Decl *D = GD.getDecl();

lib/CodeGen/TargetInfo.cpp

     StubEnc += '}';  // StubEnc now holds a valid incomplete TypeString.
     TSC.addIncomplete(ID, std::move(StubEnc));
     if (!extractFieldType(FE, RD, CGM, TSC)) {
       (void) TSC.removeIncomplete(ID);
       return false;
     }
     IsRecursive = TSC.removeIncomplete(ID);
     // The ABI requires unions to be sorted but not structures.
     // See FieldEncoding::operator< for sort algorithm.
     if (RT->isUnionType())
-      std::sort(FE.begin(), FE.end());
+      llvm::sort(FE.begin(), FE.end());
     // We can now complete the TypeString.
     unsigned E = FE.size();
     for (unsigned I = 0; I != E; ++I) {
       if (I)
         Enc += ',';
       Enc += FE[I].str();
     }
   }
   Enc += '}';
   TSC.addIfComplete(ID, Enc.substr(Start), IsRecursive);

     for (auto I = ED->enumerator_begin(), E = ED->enumerator_end(); I != E;
          ++I) {
       SmallStringEnc EnumEnc;
       EnumEnc += "m(";
       EnumEnc += I->getName();
       EnumEnc += "){";
       I->getInitVal().toString(EnumEnc);
       EnumEnc += '}';
       FE.push_back(FieldEncoding(!I->getName().empty(), EnumEnc));
     }
-    std::sort(FE.begin(), FE.end());
+    llvm::sort(FE.begin(), FE.end());
     unsigned E = FE.size();
     for (unsigned I = 0; I != E; ++I) {
       if (I)
         Enc += ',';
       Enc += FE[I].str();
     }
   }
   Enc += '}';
   TSC.addIfComplete(ID, Enc.substr(Start), false);
   return true;

lib/Driver/Driver.cpp

     // this code.
     for (StringRef S : DiagnosticIDs::getDiagnosticFlags())
       if (S.startswith(Cur))
         SuggestedCompletions.push_back(S);
   }
 
   // Sort the autocomplete candidates so that shells print them out in a
   // deterministic order. We could sort in any way, but we chose
   // case-insensitive sorting for consistency with the -help option
   // which prints out options in the case-insensitive alphabetical order.
-  std::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
+  llvm::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
              [](StringRef A, StringRef B) {
                if (int X = A.compare_lower(B))
                  return X < 0;
                return A.compare(B) > 0;
             });
 
   llvm::outs() << llvm::join(SuggestedCompletions, "\n") << '\n';
 }
 
 bool Driver::HandleImmediateArgs(const Compilation &C) {
   // The order these options are handled in gcc is all over the place, but we
   // don't expect inconsistencies w.r.t. that to matter in practice.
 
   if (C.getArgs().hasArg(options::OPT_dumpmachine)) {

lib/Format/FormatTokenLexer.cpp

       Style(Style), IdentTable(getFormattingLangOpts(Style)),
       Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
   Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
   for (const std::string &ForEachMacro : Style.ForEachMacros)
     ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
-  std::sort(ForEachMacros.begin(), ForEachMacros.end());
+  llvm::sort(ForEachMacros.begin(), ForEachMacros.end());
 }
 
 ArrayRef<FormatToken *> FormatTokenLexer::lex() {
   assert(Tokens.empty());
   assert(FirstInLineIndex == 0);
   do {
     Tokens.push_back(getNextToken());
     if (Style.Language == FormatStyle::LK_JavaScript) {
       tryParseJSRegexLiteral();
       handleTemplateStrings();

lib/Format/WhitespaceManager.cpp

       Change(Tok, /*CreateReplacement=*/true,
              SourceRange(Start, Start.getLocWithOffset(ReplaceChars)), Spaces,
              std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,
              InPPDirective && !Tok.IsFirst, /*IsInsideToken=*/true));
 }
 
 const tooling::Replacements &WhitespaceManager::generateReplacements() {
   if (Changes.empty())
     return Replaces;
 
-  std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
+  llvm::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
   calculateLineBreakInformation();
   alignConsecutiveDeclarations();
   alignConsecutiveAssignments();
   alignTrailingComments();
   alignEscapedNewlines();
   generateChanges();
 
   return Replaces;
 }
 

lib/Frontend/CompilerInvocation.cpp

   Opts.VerifyPrefixes = Args.getAllArgValues(OPT_verify_EQ);
   if (Args.hasArg(OPT_verify))
     Opts.VerifyPrefixes.push_back("expected");
   // Keep VerifyPrefixes in its original order for the sake of diagnostics, and
   // then sort it to prepare for fast lookup using std::binary_search.
   if (!checkVerifyPrefixes(Opts.VerifyPrefixes, Diags)) {
     Opts.VerifyDiagnostics = false;
     Success = false;
   }
   else
-    std::sort(Opts.VerifyPrefixes.begin(), Opts.VerifyPrefixes.end());
+    llvm::sort(Opts.VerifyPrefixes.begin(), Opts.VerifyPrefixes.end());
   DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
   Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
     Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
     Diags, DiagMask);
   if (Args.hasArg(OPT_verify_ignore_unexpected))
     DiagMask = DiagnosticLevelMask::All;
   Opts.setVerifyIgnoreUnexpected(DiagMask);
   Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
   Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
   Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);

   Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
   Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
   Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
   Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
   Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
   Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
   Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
   Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ);
   Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
   Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
-  std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
+  llvm::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
   Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
   Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
   // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
   // is enabled.
   Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
                             | Opts.NativeHalfArgsAndReturns;
   Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
 
   // __declspec is enabled by default for the PS4 by the driver, and also
   // enabled for Microsoft Extensions or Borland Extensions, here.

lib/Frontend/DiagnosticRenderer.cpp

 
 /// Collect the expansions of the begin and end locations and compute the set
 /// intersection. Produces a sorted vector of FileIDs in CommonArgExpansions.
 static void computeCommonMacroArgExpansionFileIDs(
     SourceLocation Begin, SourceLocation End, const SourceManager *SM,
     SmallVectorImpl<FileID> &CommonArgExpansions) {
   SmallVector<FileID, 4> BeginArgExpansions;
   SmallVector<FileID, 4> EndArgExpansions;
   getMacroArgExpansionFileIDs(Begin, BeginArgExpansions, /*IsBegin=*/true, SM);
   getMacroArgExpansionFileIDs(End, EndArgExpansions, /*IsBegin=*/false, SM);
-  std::sort(BeginArgExpansions.begin(), BeginArgExpansions.end());
-  std::sort(EndArgExpansions.begin(), EndArgExpansions.end());
+  llvm::sort(BeginArgExpansions.begin(), BeginArgExpansions.end());
+  llvm::sort(EndArgExpansions.begin(), EndArgExpansions.end());
   std::set_intersection(BeginArgExpansions.begin(), BeginArgExpansions.end(),
                         EndArgExpansions.begin(), EndArgExpansions.end(),
                         std::back_inserter(CommonArgExpansions));
 }
 
 // Helper function to fix up source ranges.  It takes in an array of ranges,
 // and outputs an array of ranges where we want to draw the range highlighting
 // around the location specified by CaretLoc.
 //
 // To find locations which correspond to the caret, we crawl the macro caller

lib/Sema/AnalysisBasedWarnings.cpp

     }
 
     UsesByStmt.push_back(StmtUsesPair(UI->getUseExpr(), I));
   }
 
   if (UsesByStmt.empty())
     return;
 
   // Sort by first use so that we emit the warnings in a deterministic order.
   SourceManager &SM = S.getSourceManager();
-  std::sort(UsesByStmt.begin(), UsesByStmt.end(),
+  llvm::sort(UsesByStmt.begin(), UsesByStmt.end(),
              [&SM](const StmtUsesPair &LHS, const StmtUsesPair &RHS) {
     return SM.isBeforeInTranslationUnit(LHS.first->getLocStart(),
                                         RHS.first->getLocStart());
   });
 
   // Classify the current code body for better warning text.
   // This enum should stay in sync with the cases in
   // warn_arc_repeated_use_of_weak and warn_arc_possible_repeated_use_of_weak.
   // FIXME: Should we use a common classification enum and the same set of
   // possibilities all throughout Sema?
   enum {

       // to report the diagnostic at the self-init since that is the root cause.
       if (!vec->empty() && hasSelfInit && hasAlwaysUninitializedUse(vec))
         DiagnoseUninitializedUse(S, vd,
                                  UninitUse(vd->getInit()->IgnoreParenCasts(),
                                            /* isAlwaysUninit */ true),
                                  /* alwaysReportSelfInit */ true);
       else {
         // Sort the uses by their SourceLocations.  While not strictly
         // guaranteed to produce them in line/column order, this will provide
         // a stable ordering.
-        std::sort(vec->begin(), vec->end(),
+        llvm::sort(vec->begin(), vec->end(),
                    [](const UninitUse &a, const UninitUse &b) {
           // Prefer a more confident report over a less confident one.
           if (a.getKind() != b.getKind())
             return a.getKind() > b.getKind();
           return a.getUser()->getLocStart() < b.getUser()->getLocStart();
         });
 
         for (const auto &U : *vec) {
           // If we have self-init, downgrade all uses to 'may be uninitialized'.
           UninitUse Use = hasSelfInit ? UninitUse(U.getUser(), false) : U;
 

lib/Sema/SemaDecl.cpp

     return false;
 
   if (OldFD->isMultiVersion() && !NewTA) {
     S.Diag(NewFD->getLocation(), diag::err_target_required_in_redecl);
     NewFD->setInvalidDecl();
     return true;
   }
 
   TargetAttr::ParsedTargetAttr NewParsed = NewTA->parse();
   // Sort order doesn't matter, it just needs to be consistent.
-  std::sort(NewParsed.Features.begin(), NewParsed.Features.end());
+  llvm::sort(NewParsed.Features.begin(), NewParsed.Features.end());
 
   const auto *OldTA = OldFD->getAttr<TargetAttr>();
   if (!OldFD->isMultiVersion()) {
     // If the old decl is NOT MultiVersioned yet, and we don't cause that
     // to change, this is a simple redeclaration.
     if (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())
       return false;
 
     // Otherwise, this decl causes MultiVersioning.
     if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) {

lib/Sema/SemaDeclAttr.cpp

     if (NS->isAnonymousNamespace()) {
       S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
       return;
     }
     if (AL.getNumArgs() == 0)
       Tags.push_back(NS->getName());
   } else if (!checkAttributeAtLeastNumArgs(S, AL, 1))
     return;
 
   // Store tags sorted and without duplicates.
-  std::sort(Tags.begin(), Tags.end());
+  llvm::sort(Tags.begin(), Tags.end());
   Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
 
   D->addAttr(::new (S.Context)
              AbiTagAttr(AL.getRange(), S.Context, Tags.data(), Tags.size(),
                         AL.getAttributeSpellingListIndex()));
 }
 
 static void handleARMInterruptAttr(Sema &S, Decl *D,
                                    const AttributeList &AL) {
   // Check the attribute arguments.

lib/Sema/SemaLookup.cpp

       // the nominated namespace.
       DeclContext *Common = UD->getNominatedNamespace();
       while (!Common->Encloses(EffectiveDC))
         Common = Common->getParent();
       Common = Common->getPrimaryContext();
 
       list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
     }
 
     void done() {
-      std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
+      llvm::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
     }
 
     typedef ListTy::const_iterator const_iterator;
 
     const_iterator begin() const { return list.begin(); }
     const_iterator end() const { return list.end(); }
 
     llvm::iterator_range<const_iterator>
     getNamespacesFor(DeclContext *DC) const {
       return llvm::make_range(std::equal_range(begin(), end(),

lib/Sema/SemaOverload.cpp

   // and sort those.
   SmallVector<TemplateSpecCandidate *, 32> Cands;
   Cands.reserve(size());
   for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
     if (Cand->Specialization)
       Cands.push_back(Cand);
     // Otherwise, this is a non-matching builtin candidate.  We do not,
     // in general, want to list every possible builtin candidate.
   }
 
-  std::sort(Cands.begin(), Cands.end(),
+  llvm::sort(Cands.begin(), Cands.end(),
              CompareTemplateSpecCandidatesForDisplay(S));
 
   // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
   // for generalization purposes (?).
   const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
 
   SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E;
   unsigned CandsShown = 0;
   for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
     TemplateSpecCandidate *Cand = *I;
 

lib/Sema/SemaType.cpp

         assert(Chunk.Kind == DeclaratorChunk::Function);
         if (Chunk.Fun.hasRefQualifier())
           RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc());
         if (Chunk.Fun.TypeQuals & Qualifiers::Const)
           RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc());
         if (Chunk.Fun.TypeQuals & Qualifiers::Volatile)
           RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc());
         if (Chunk.Fun.TypeQuals & Qualifiers::Restrict)
           RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc());
         if (!RemovalLocs.empty()) {
-          std::sort(RemovalLocs.begin(), RemovalLocs.end(),
+          llvm::sort(RemovalLocs.begin(), RemovalLocs.end(),
                      BeforeThanCompare<SourceLocation>(S.getSourceManager()));
           RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back());
           Loc = RemovalLocs.front();
         }
       }
 
       S.Diag(Loc, diag::err_invalid_qualified_function_type)
         << Kind << D.isFunctionDeclarator() << T
         << getFunctionQualifiersAsString(FnTy)
         << FixItHint::CreateRemoval(RemovalRange);
 

lib/Serialization/ASTReader.cpp

     CHECK_TARGET_OPT(CPU, "target CPU");
 
 #undef CHECK_TARGET_OPT
 
   // Compare feature sets.
   SmallVector<StringRef, 4> ExistingFeatures(
                                              ExistingTargetOpts.FeaturesAsWritten.begin(),
                                              ExistingTargetOpts.FeaturesAsWritten.end());
   SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
                                          TargetOpts.FeaturesAsWritten.end());
-  std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
-  std::sort(ReadFeatures.begin(), ReadFeatures.end());
+  llvm::sort(ExistingFeatures.begin(), ExistingFeatures.end());
+  llvm::sort(ReadFeatures.begin(), ReadFeatures.end());
 
   // We compute the set difference in both directions explicitly so that we can
   // diagnose the differences differently.
   SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
   std::set_difference(
       ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
       ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
   std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
                       ExistingFeatures.begin(), ExistingFeatures.end(),
                       std::back_inserter(UnmatchedReadFeatures));

         bool IsAlmostTrailingComment = Record[Idx++];
         Comments.push_back(new (Context) RawComment(
             SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
         break;
       }
       }
     }
   NextCursor:
     // De-serialized SourceLocations get negative FileIDs for other modules,
     // potentially invalidating the original order. Sort it again.
-    std::sort(Comments.begin(), Comments.end(),
+    llvm::sort(Comments.begin(), Comments.end(),
                BeforeThanCompare<RawComment>(SourceMgr));
     Context.Comments.addDeserializedComments(Comments);
   }
 }
 
 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
                                 bool IncludeSystem, bool Complain,
                     llvm::function_ref<void(const serialization::InputFile &IF,
                                             bool isSystem)> Visitor) {
   unsigned NumUserInputs = MF.NumUserInputFiles;
   unsigned NumInputs = MF.InputFilesLoaded.size();

lib/Serialization/ASTReaderDecl.cpp

       if (IDs.empty())
         return;
 
       // FIXME: We should avoid this pattern of getting the ASTContext.
       ASTContext &C = D->getASTContext();
 
       auto *&LazySpecializations = D->getCommonPtr()->LazySpecializations;
 
       if (auto &Old = LazySpecializations) {
         IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]);
-        std::sort(IDs.begin(), IDs.end());
+        llvm::sort(IDs.begin(), IDs.end());
         IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end());
       }
 
       auto *Result = new (C) serialization::DeclID[1 + IDs.size()];
       *Result = IDs.size();
       std::copy(IDs.begin(), IDs.end(), Result + 1);
 
       LazySpecializations = Result;
     }
 

lib/Serialization/ASTWriter.cpp

   // Construct the list of identifiers with macro directives that need to be
   // serialized.
   SmallVector<const IdentifierInfo *, 128> MacroIdentifiers;
   for (auto &Id : PP.getIdentifierTable())
     if (Id.second->hadMacroDefinition() &&
         (!Id.second->isFromAST() ||
          Id.second->hasChangedSinceDeserialization()))
       MacroIdentifiers.push_back(Id.second);
   // Sort the set of macro definitions that need to be serialized by the
   // name of the macro, to provide a stable ordering.
-  std::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(),
+  llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(),
              llvm::less_ptr<IdentifierInfo>());
 
   // Emit the macro directives as a list and associate the offset with the
   // identifier they belong to.
   for (const IdentifierInfo *Name : MacroIdentifiers) {
     MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name);
     auto StartOffset = Stream.GetCurrentBitNo();
 
     // Emit the macro directives in reverse source order.
     for (; MD; MD = MD->getPrevious()) {
       // Once we hit an ignored macro, we're done: the rest of the chain

                                        FirstDeclID - NUM_PREDEF_DECL_IDS};
     Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets));
   }
 }
 
 void ASTWriter::WriteFileDeclIDsMap() {
   using namespace llvm;
 
   SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> SortedFileDeclIDs(
       FileDeclIDs.begin(), FileDeclIDs.end());
-  std::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(),
+  llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(),
              llvm::less_first());
 
   // Join the vectors of DeclIDs from all files.
   SmallVector<DeclID, 256> FileGroupedDeclIDs;
   for (auto &FileDeclEntry : SortedFileDeclIDs) {
     DeclIDInFileInfo &Info = *FileDeclEntry.second;
     Info.FirstDeclIndex = FileGroupedDeclIDs.size();
     for (auto &LocDeclEntry : Info.DeclIDs)
       FileGroupedDeclIDs.push_back(LocDeclEntry.second);
   }
 

     // Look for any identifiers that were named while processing the
     // headers, but are otherwise not needed. We add these to the hash
     // table to enable checking of the predefines buffer in the case
     // where the user adds new macro definitions when building the AST
     // file.
     SmallVector<const IdentifierInfo *, 128> IIs;
     for (const auto &ID : PP.getIdentifierTable())
       IIs.push_back(ID.second);
     // Sort the identifiers lexicographically before getting them references so
     // that their order is stable.
-    std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
+    llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
     for (const IdentifierInfo *II : IIs)
       if (Trait.isInterestingNonMacroIdentifier(II))
         getIdentifierRef(II);
 
     // Create the on-disk hash table representation. We only store offsets
     // for identifiers that appear here for the first time.
     IdentifierOffsets.resize(NextIdentID - FirstIdentID);
     for (auto IdentIDPair : IdentifierIDs) {
       auto *II = const_cast<IdentifierInfo *>(IdentIDPair.first);
       IdentID ID = IdentIDPair.second;

 
     case DeclarationName::CXXConversionFunctionName:
       assert(isa<CXXRecordDecl>(DC) &&
              "Cannot have a conversion function name outside of a class!");
       ConversionNameSet.insert(Name);
       break;
     }
   }
 
   // Sort the names into a stable order.
-  std::sort(Names.begin(), Names.end());
+  llvm::sort(Names.begin(), Names.end());
 
   if (auto *D = dyn_cast<CXXRecordDecl>(DC)) {
     // We need to establish an ordering of constructor and conversion function
     // names, and they don't have an intrinsic ordering.
 
     // First we try the easy case by forming the current context's constructor
     // name and adding that name first. This is a very useful optimization to
     // avoid walking the lexical declarations in many cases, and it also
     // handles the only case where a constructor name can come from some other
     // lexical context -- when that name is an implicit constructor merged from

     StoredDeclsMap *Map = DC->getPrimaryContext()->buildLookup();
     SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16>
         LookupResults;
     if (Map) {
       LookupResults.reserve(Map->size());
       for (auto &Entry : *Map)
         LookupResults.push_back(
             std::make_pair(Entry.first, Entry.second.getLookupResult()));
     }
 
-    std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first());
+    llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first());
     for (auto &NameAndResult : LookupResults) {
       DeclarationName Name = NameAndResult.first;
       DeclContext::lookup_result Result = NameAndResult.second;
       if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
           Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
         // We have to work around a name lookup bug here where negative lookup
         // results for these names get cached in namespace lookup tables (these
         // names should never be looked up in a namespace).
         assert(Result.empty() && "Cannot have a constructor or conversion "
                                  "function name in a namespace!");

   // Make sure all decls associated with an identifier are registered for
   // serialization, if we're storing decls with identifiers.
   if (!WritingModule || !getLangOpts().CPlusPlus) {
     llvm::SmallVector<const IdentifierInfo*, 256> IIs;
     for (const auto &ID : PP.getIdentifierTable()) {
       const IdentifierInfo *II = ID.second;
       if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization())
         IIs.push_back(II);
     }
     // Sort the identifiers to visit based on their name.
-    std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
+    llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
     for (const IdentifierInfo *II : IIs) {
       for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II),
                                      DEnd = SemaRef.IdResolver.end();
            D != DEnd; ++D) {
         GetDeclRef(*D);
       }
     }
   }
 
   // For method pool in the module, if it contains an entry for a selector,

 
     if (!Imports.empty()) {
       auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
         return A.ID < B.ID;
       };
       auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) {
         return A.ID == B.ID;
       };
 
       // Sort and deduplicate module IDs.
-      std::sort(Imports.begin(), Imports.end(), Cmp);
+      llvm::sort(Imports.begin(), Imports.end(), Cmp);
       Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq),
                     Imports.end());
 
       RecordData ImportedModules;
       for (const auto &Import : Imports) {
         ImportedModules.push_back(Import.ID);
         // FIXME: If the module has macros imported then later has declarations
         // imported, this location won't be the right one as a location for the
         // declaration imports.
         AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules);

lib/StaticAnalyzer/Checkers/PaddingChecker.cpp

       auto &Ctx = FD->getASTContext();
       std::tie(RetVal.Size, RetVal.Align) =
           Ctx.getTypeInfoInChars(FD->getType());
       assert(llvm::isPowerOf2_64(RetVal.Align.getQuantity()));
       if (auto Max = FD->getMaxAlignment())
         RetVal.Align = std::max(Ctx.toCharUnitsFromBits(Max), RetVal.Align);
       return RetVal;
     };
     std::transform(RD->field_begin(), RD->field_end(),
                    std::back_inserter(Fields), GatherSizesAndAlignments);
-    std::sort(Fields.begin(), Fields.end());
+    llvm::sort(Fields.begin(), Fields.end());
     // This lets us skip over vptrs and non-virtual bases,
     // so that we can just worry about the fields in our object.
     // Note that this does cause us to miss some cases where we
     // could pack more bytes in to a base class's tail padding.
     CharUnits NewOffset = ASTContext.toCharUnitsFromBits(RL.getFieldOffset(0));
     CharUnits NewPad;
     SmallVector<const FieldDecl *, 20> OptimalFieldsOrder;
     while (!Fields.empty()) {
       unsigned TrailingZeros =
           llvm::countTrailingZeros((unsigned long long)NewOffset.getQuantity());

lib/StaticAnalyzer/Core/BugReporter.cpp

       if (RemainingNodes.empty())
         break;
 
     for (ExplodedNode::const_pred_iterator I = Node->succ_begin(),
                                            E = Node->succ_end();
          I != E; ++I)
       WS.push(*I);
   }
 
   // Sort the error paths from longest to shortest.
-  std::sort(ReportNodes.begin(), ReportNodes.end(),
+  llvm::sort(ReportNodes.begin(), ReportNodes.end(),
              PriorityCompare<true>(PriorityMap));
 }
 
 bool TrimmedGraph::popNextReportGraph(ReportGraph &GraphWrapper) {
   if (ReportNodes.empty())
     return false;
 
   const ExplodedNode *OrigN;
   std::tie(OrigN, GraphWrapper.Index) = ReportNodes.pop_back_val();
   assert(PriorityMap.find(OrigN) != PriorityMap.end() &&
          "error node not accessible from root");

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

   std::tie(packageName, leafName) = name.rsplit(PackageSeparator);
   while (!leafName.empty()) {
     Packages[packageName] += 1;
     std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
   }
 }
 
 void CheckerRegistry::initializeManager(CheckerManager &checkerMgr,
                                   SmallVectorImpl<CheckerOptInfo> &opts) const {
   // Sort checkers for efficient collection.
-  std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
+  llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 
   // Collect checkers enabled by the options.
   CheckerInfoSet enabledCheckers;
   for (SmallVectorImpl<CheckerOptInfo>::iterator
          i = opts.begin(), e = opts.end(); i != e; ++i) {
     collectCheckers(Checkers, Packages, *i, enabledCheckers);
   }
 
   // Initialize the CheckerManager with all enabled checkers.
   for (CheckerInfoSet::iterator

       diags.Report(diag::err_unknown_analyzer_checker) << checkerName;
     }
   }
 }
 
 void CheckerRegistry::printHelp(raw_ostream &out,
                                 size_t maxNameChars) const {
   // FIXME: Alphabetical sort puts 'experimental' in the middle.
   // Would it be better to name it '~experimental' or something else
   // that's ASCIIbetically last?
-  std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
+  llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 
   // FIXME: Print available packages.
 
   out << "CHECKERS:\n";
 
   // Find the maximum option length.
   size_t optionFieldWidth = 0;
   for (CheckerInfoList::const_iterator i = Checkers.begin(), e = Checkers.end();
        i != e; ++i) {
     // Limit the amount of padding we are willing to give up for alignment.

       pad = optionFieldWidth + initialPad;
     }
     out.indent(pad + 2) << i->Desc;
 
     out << '\n';
   }
 }
 
 void CheckerRegistry::printList(
     raw_ostream &out, SmallVectorImpl<CheckerOptInfo> &opts) const {
-  std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
+  llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 
   // Collect checkers enabled by the options.
   CheckerInfoSet enabledCheckers;
   for (SmallVectorImpl<CheckerOptInfo>::iterator i = opts.begin(),
                                                        e = opts.end();
        i != e; ++i) {
     collectCheckers(Checkers, Packages, *i, enabledCheckers);
   }
 
   for (CheckerInfoSet::const_iterator i = enabledCheckers.begin(),

lib/Tooling/ASTDiff/ASTDiff.cpp

   std::vector<NodeId> pop() {
     int Max = peekMax();
     std::vector<NodeId> Result;
     if (Max == 0)
       return Result;
     while (peekMax() == Max) {
       Result.push_back(List.top());
       List.pop();
     }
     // TODO this is here to get a stable output, not a good heuristic
-    std::sort(Result.begin(), Result.end());
+    llvm::sort(Result.begin(), Result.end());
     return Result;
   }
   int peekMax() const {
     if (List.empty())
       return 0;
     return Tree.getNode(List.top()).Height;
   }
   void open(NodeId Id) {
     for (NodeId Child : Tree.getNode(Id).Children)
       push(Child);

lib/Tooling/Core/Replacement.cpp

     Delta -= Merged.deltaFirst();
     Result.insert(Merged.asReplacement());
   }
   return Replacements(Result.begin(), Result.end());
 }
 
 // Combines overlapping ranges in \p Ranges and sorts the combined ranges.
 // Returns a set of non-overlapping and sorted ranges that is equivalent to
 // \p Ranges.
 static std::vector<Range> combineAndSortRanges(std::vector<Range> Ranges) {
-  std::sort(Ranges.begin(), Ranges.end(),
+  llvm::sort(Ranges.begin(), Ranges.end(),
              [](const Range &LHS, const Range &RHS) {
                if (LHS.getOffset() != RHS.getOffset())
                  return LHS.getOffset() < RHS.getOffset();
                return LHS.getLength() < RHS.getLength();
             });
   std::vector<Range> Result;
   for (const auto &R : Ranges) {
     if (Result.empty() ||
         Result.back().getOffset() + Result.back().getLength() < R.getOffset()) {
       Result.push_back(R);
     } else {
       unsigned NewEnd =
           std::max(Result.back().getOffset() + Result.back().getLength(),
                    R.getOffset() + R.getLength());

tools/diagtool/DiagTool.cpp

 void DiagTools::printCommands(llvm::raw_ostream &out) {
   std::vector<llvm::StringRef> toolNames;
   unsigned maxName = 0;
   for (ToolMap::iterator it = getTools(tools)->begin(),
        ei = getTools(tools)->end(); it != ei; ++it) {
     toolNames.push_back(it->getKey());
     unsigned len = it->getKey().size();
     if (len > maxName)
       maxName = len;    
   }
-  std::sort(toolNames.begin(), toolNames.end());
+  llvm::sort(toolNames.begin(), toolNames.end());
 
   for (std::vector<llvm::StringRef>::iterator it = toolNames.begin(),
        ei = toolNames.end(); it != ei; ++it) {
 
     out << "  " << (*it);
     unsigned spaces = (maxName + 3) - (it->size());
     for (unsigned i = 0; i < spaces; ++i)
       out << ' ';
     
     out << getTool(*it)->getDescription() << '\n';    

tools/libclang/CIndex.cpp

   // Get all the Decls in the DeclContext, and sort them with the
   // additional ones we've collected.  Then visit them.
   for (auto *SubDecl : D->decls()) {
     if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
         SubDecl->getLocStart().isInvalid())
       continue;
     DeclsInContainer.push_back(SubDecl);
   }
 
   // Now sort the Decls so that they appear in lexical order.
-  std::sort(DeclsInContainer.begin(), DeclsInContainer.end(),
+  llvm::sort(DeclsInContainer.begin(), DeclsInContainer.end(),
              [&SM](Decl *A, Decl *B) {
     SourceLocation L_A = A->getLocStart();
     SourceLocation L_B = B->getLocStart();
     return L_A != L_B ?
            SM.isBeforeInTranslationUnit(L_A, L_B) :
            SM.isBeforeInTranslationUnit(A->getLocEnd(), B->getLocEnd());
   });
 
   // Now visit the decls.
   for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(),
          E = DeclsInContainer.end(); I != E; ++I) {

   if (!HadAvailAttr)
     if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
       return getCursorPlatformAvailabilityForDecl(
           cast<Decl>(EnumConst->getDeclContext()), always_deprecated,
           deprecated_message, always_unavailable, unavailable_message,
           AvailabilityAttrs);
 
   if (AvailabilityAttrs.empty())
     return;
 
-  std::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
+  llvm::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
              [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
                return LHS->getPlatform()->getName() <
                       RHS->getPlatform()->getName();
             });
   ASTContext &Ctx = D->getASTContext();
   auto It = std::unique(
       AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
       [&Ctx](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
         if (LHS->getPlatform() != RHS->getPlatform())
           return false;
 
         if (LHS->getIntroduced() == RHS->getIntroduced() &&
             LHS->getDeprecated() == RHS->getDeprecated() &&

unittests/Basic/VirtualFileSystemTest.cpp

       outs() << "Error code tested for:\n"
              << "EC value: " << EC2.value() << "\n"
              << "EC category: " << EC2.category().name()
              << "EC message: " << EC2.message() << "\n";
     }
     ASSERT_FALSE(EC);
     Contents.push_back(I->getName());
   }
 
   // Check sorted contents.
-  std::sort(Contents.begin(), Contents.end());
+  llvm::sort(Contents.begin(), Contents.end());
   EXPECT_EQ(Expected.size(), Contents.size());
   EXPECT_TRUE(std::equal(Contents.begin(), Contents.end(), Expected.begin()));
 }
 #endif
 
 template <typename DirIter>
 static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) {
   std::error_code EC;
   SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end());
   SmallVector<std::string, 4> InputToCheck;
 
   // Do not rely on iteration order to check for contents, sort both
   // content vectors before comparison.
   for (DirIter E; !EC && I != E; I.increment(EC))
     InputToCheck.push_back(I->getName());
 
-  std::sort(InputToCheck.begin(), InputToCheck.end());
-  std::sort(Expected.begin(), Expected.end());
+  llvm::sort(InputToCheck.begin(), InputToCheck.end());
+  llvm::sort(Expected.begin(), Expected.end());
   EXPECT_EQ(InputToCheck.size(), Expected.size());
 
   unsigned LastElt = std::min(InputToCheck.size(), Expected.size());
   for (unsigned Idx = 0; Idx != LastElt; ++Idx)
     EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]);
 }
 
 TEST(VirtualFileSystemTest, OverlayIteration) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());

utils/TableGen/ClangAttrEmitter.cpp

         SplitDocs[Category].push_back(DocumentationData(
             Doc, Attr, GetAttributeHeadingAndSpellingKinds(Doc, Attr)));
     }
   }
 
   // Having split the attributes out based on what documentation goes where,
   // we can begin to generate sections of documentation.
   for (auto &I : SplitDocs) {
     WriteCategoryHeader(I.first, OS);
 
-    std::sort(I.second.begin(), I.second.end(),
+    llvm::sort(I.second.begin(), I.second.end(),
                [](const DocumentationData &D1, const DocumentationData &D2) {
                  return D1.Heading < D2.Heading;
               });
 
     // Walk over each of the attributes in the category and write out their
     // documentation.
     for (const auto &Doc : I.second)
       WriteDocumentation(Records, Doc, OS);
   }
 }
 
 void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,

utils/TableGen/ClangDiagnosticsEmitter.cpp

        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
     I->second.IDNo = IDNo;
 
   // Sort the implicit groups, so we can warn about them deterministically.
   SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
                                             ImplicitGroups.end());
   for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
                                               E = SortedGroups.end();
        I != E; ++I) {
     MutableArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
-    std::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare);
+    llvm::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare);
   }
-  std::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups);
+  llvm::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups);
 
   // Warn about the same group being used anonymously in multiple places.
   for (SmallVectorImpl<GroupInfo *>::const_iterator I = SortedGroups.begin(),
                                                     E = SortedGroups.end();
        I != E; ++I) {
     ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
 
     if ((*I)->ExplicitDef) {
       std::string Name = (*I)->ExplicitDef->getValueAsString("GroupName");
       for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),

   const std::vector<Record*> &Diags =
     Records.getAllDerivedDefinitions("Diagnostic");
 
   std::vector<RecordIndexElement> Index;
   Index.reserve(Diags.size());
   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     const Record &R = *(Diags[i]);
     Index.push_back(RecordIndexElement(R));
   }
 
-  std::sort(Index.begin(), Index.end(),
-            [](const RecordIndexElement &Lhs,
-               const RecordIndexElement &Rhs) { return Lhs.Name < Rhs.Name; });
+  llvm::sort(Index.begin(), Index.end(),
+             [](const RecordIndexElement &Lhs, const RecordIndexElement &Rhs) {
+               return Lhs.Name < Rhs.Name;
+            });
 
   for (unsigned i = 0, e = Index.size(); i != e; ++i) {
     const RecordIndexElement &R = Index[i];
 
     OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Diagnostic documentation generation

                     "no documentation will be generated.");
     return;
   }
 
   OS << Documentation->getValueAsString("Intro") << "\n";
 
   std::vector<Record*> Diags =
       Records.getAllDerivedDefinitions("Diagnostic");
   std::vector<Record*> DiagGroups =
       Records.getAllDerivedDefinitions("DiagGroup");
-  std::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName);
+  llvm::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName);
 
   DiagGroupParentMap DGParentMap(Records);
 
   std::map<std::string, GroupInfo> DiagsInGroup;
   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
 
   // Compute the set of diagnostics that are in -Wpedantic.
   {
     RecordSet DiagsInPedanticSet;
     RecordSet GroupsInPedanticSet;
     InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
     inferPedantic.compute(&DiagsInPedanticSet, &GroupsInPedanticSet);
     auto &PedDiags = DiagsInGroup["pedantic"];
     // Put the diagnostics into a deterministic order.
     RecordVec DiagsInPedantic(DiagsInPedanticSet.begin(),
                               DiagsInPedanticSet.end());
     RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(),
                                GroupsInPedanticSet.end());
-    std::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(),
+    llvm::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(),
                beforeThanCompare);
-    std::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(),
+    llvm::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(),
                beforeThanCompare);
     PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(),
                                  DiagsInPedantic.begin(),
                                  DiagsInPedantic.end());
     for (auto *Group : GroupsInPedantic)
       PedDiags.SubGroups.push_back(Group->getValueAsString("GroupName"));
   }
 
   // FIXME: Write diagnostic categories and link to diagnostic groups in each.
 
   // Write out the diagnostic groups.

 
     if (!GroupInfo.SubGroups.empty()) {
       if (IsSynonym)
         OS << "Synonym for ";
       else if (GroupInfo.DiagsInGroup.empty())
         OS << "Controls ";
       else
         OS << "Also controls ";
 
       bool First = true;
-      std::sort(GroupInfo.SubGroups.begin(), GroupInfo.SubGroups.end());
+      llvm::sort(GroupInfo.SubGroups.begin(), GroupInfo.SubGroups.end());
       for (const auto &Name : GroupInfo.SubGroups) {
         if (!First) OS << ", ";
         OS << "`" << (IsRemarkGroup ? "-R" : "-W") << Name << "`_";
         First = false;
       }
       OS << ".\n\n";
     }
 
     if (!GroupInfo.DiagsInGroup.empty()) {
       OS << "**Diagnostic text:**\n\n";

utils/TableGen/ClangOptionDocEmitter.cpp

   auto CompareByName = [](Record *A, Record *B) {
     return A->getValueAsString("Name") < B->getValueAsString("Name");
   };
 
   auto CompareByLocation = [](Record *A, Record *B) {
     return A->getLoc()[0].getPointer() < B->getLoc()[0].getPointer();
   };
 
   auto DocumentationForOption = [&](Record *R) -> DocumentedOption {
     auto &A = Aliases[R];
-    std::sort(A.begin(), A.end(), CompareByName);
+    llvm::sort(A.begin(), A.end(), CompareByName);
     return {R, std::move(A)};
   };
 
   std::function<Documentation(Record *)> DocumentationForGroup =
       [&](Record *R) -> Documentation {
     Documentation D;
 
     auto &Groups = GroupsInGroup[R];
-    std::sort(Groups.begin(), Groups.end(), CompareByLocation);
+    llvm::sort(Groups.begin(), Groups.end(), CompareByLocation);
     for (Record *G : Groups) {
       D.Groups.emplace_back();
       D.Groups.back().Group = G;
       Documentation &Base = D.Groups.back();
       Base = DocumentationForGroup(G);
     }
 
     auto &Options = OptionsInGroup[R];
-    std::sort(Options.begin(), Options.end(), CompareByName);
+    llvm::sort(Options.begin(), Options.end(), CompareByName);
     for (Record *O : Options)
       D.Options.push_back(DocumentationForOption(O));
 
     return D;
   };
 
   return DocumentationForGroup(nullptr);
 }
 
 // Get the first and successive separators to use for an OptionKind.

utils/TableGen/NeonEmitter.cpp

         if (TS == SrcTS ||
             DefaultSrcT.getSizeInBits() != DefaultT.getSizeInBits())
           continue;
         NewTypeSpecs.push_back(std::make_pair(TS, SrcTS));
       }
     } else {
       NewTypeSpecs.push_back(std::make_pair(TS, TS));
     }
   }
 
-  std::sort(NewTypeSpecs.begin(), NewTypeSpecs.end());
+  llvm::sort(NewTypeSpecs.begin(), NewTypeSpecs.end());
   NewTypeSpecs.erase(std::unique(NewTypeSpecs.begin(), NewTypeSpecs.end()),
          NewTypeSpecs.end());
   auto &Entry = IntrinsicMap[Name];
 
   for (auto &I : NewTypeSpecs) {
     Entry.emplace_back(R, Name, Proto, I.first, I.second, CK, Body, *this,
                        Guard, IsUnavailable, BigEndianSafe);
     Out.push_back(&Entry.back());
   }