From: Fangrui Song Date: Tue, 23 Apr 2019 14:51:27 +0000 (+0000) Subject: Use llvm::stable_sort X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=46622a5909033d613f22371fded1e8f60e0fd030;p=llvm Use llvm::stable_sort While touching the code, simplify if feasible. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@358996 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/ProfileData/GCOV.h b/include/llvm/ProfileData/GCOV.h index 9e2d27f083f..004ff3f4a2e 100644 --- a/include/llvm/ProfileData/GCOV.h +++ b/include/llvm/ProfileData/GCOV.h @@ -318,12 +318,6 @@ class GCOVBlock { uint64_t Count = 0; }; - struct SortDstEdgesFunctor { - bool operator()(const GCOVEdge *E1, const GCOVEdge *E2) { - return E1->Dst.Number < E2->Dst.Number; - } - }; - public: using EdgeIterator = SmallVectorImpl::const_iterator; using BlockVector = SmallVector; diff --git a/include/llvm/ProfileData/SampleProf.h b/include/llvm/ProfileData/SampleProf.h index 7e32f1d2edb..7fbc857b723 100644 --- a/include/llvm/ProfileData/SampleProf.h +++ b/include/llvm/ProfileData/SampleProf.h @@ -572,10 +572,9 @@ public: SampleSorter(const std::map &Samples) { for (const auto &I : Samples) V.push_back(&I); - std::stable_sort(V.begin(), V.end(), - [](const SamplesWithLoc *A, const SamplesWithLoc *B) { - return A->first < B->first; - }); + llvm::stable_sort(V, [](const SamplesWithLoc *A, const SamplesWithLoc *B) { + return A->first < B->first; + }); } const SamplesWithLocList &get() const { return V; } diff --git a/lib/Analysis/LoopAccessAnalysis.cpp b/lib/Analysis/LoopAccessAnalysis.cpp index 5130807cadd..6ec138c42a4 100644 --- a/lib/Analysis/LoopAccessAnalysis.cpp +++ b/lib/Analysis/LoopAccessAnalysis.cpp @@ -1144,10 +1144,9 @@ bool llvm::sortPtrAccesses(ArrayRef VL, const DataLayout &DL, std::iota(SortedIndices.begin(), SortedIndices.end(), 0); // Sort the memory accesses and keep the order of their uses in UseOrder. - std::stable_sort(SortedIndices.begin(), SortedIndices.end(), - [&OffValPairs](unsigned Left, unsigned Right) { - return OffValPairs[Left].first < OffValPairs[Right].first; - }); + llvm::stable_sort(SortedIndices, [&](unsigned Left, unsigned Right) { + return OffValPairs[Left].first < OffValPairs[Right].first; + }); // Check if the order is consecutive already. if (llvm::all_of(SortedIndices, [&SortedIndices](const unsigned I) { diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index 1f69bc8f22e..d7635a82cf2 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -799,11 +799,10 @@ static void GroupByComplexity(SmallVectorImpl &Ops, } // Do the rough sort by complexity. - std::stable_sort(Ops.begin(), Ops.end(), - [&](const SCEV *LHS, const SCEV *RHS) { - return CompareSCEVComplexity(EqCacheSCEV, EqCacheValue, LI, - LHS, RHS, DT) < 0; - }); + llvm::stable_sort(Ops, [&](const SCEV *LHS, const SCEV *RHS) { + return CompareSCEVComplexity(EqCacheSCEV, EqCacheValue, LI, LHS, RHS, DT) < + 0; + }); // Now that we are sorted by complexity, group elements of the same // complexity. Note that this is, at worst, N^2, but the vector is likely to diff --git a/lib/Analysis/ScalarEvolutionExpander.cpp b/lib/Analysis/ScalarEvolutionExpander.cpp index ccf031f7eae..a540cd622cf 100644 --- a/lib/Analysis/ScalarEvolutionExpander.cpp +++ b/lib/Analysis/ScalarEvolutionExpander.cpp @@ -694,7 +694,7 @@ Value *SCEVExpander::visitAddExpr(const SCEVAddExpr *S) { // Sort by loop. Use a stable sort so that constants follow non-constants and // pointer operands precede non-pointer operands. - std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(SE.DT)); + llvm::stable_sort(OpsAndLoops, LoopCompare(SE.DT)); // Emit instructions to add all the operands. Hoist as much as possible // out of loops, and form meaningful getelementptrs where possible. @@ -761,7 +761,7 @@ Value *SCEVExpander::visitMulExpr(const SCEVMulExpr *S) { OpsAndLoops.push_back(std::make_pair(getRelevantLoop(*I), *I)); // Sort by loop. Use a stable sort so that constants follow non-constants. - std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(SE.DT)); + llvm::stable_sort(OpsAndLoops, LoopCompare(SE.DT)); // Emit instructions to mul all the operands. Hoist as much as possible // out of loops. diff --git a/lib/CodeGen/AsmPrinter/AccelTable.cpp b/lib/CodeGen/AsmPrinter/AccelTable.cpp index 16286ea8bf3..b5617f46ddd 100644 --- a/lib/CodeGen/AsmPrinter/AccelTable.cpp +++ b/lib/CodeGen/AsmPrinter/AccelTable.cpp @@ -55,10 +55,10 @@ void AccelTableBase::finalize(AsmPrinter *Asm, StringRef Prefix) { // Create the individual hash data outputs. for (auto &E : Entries) { // Unique the entries. - std::stable_sort(E.second.Values.begin(), E.second.Values.end(), - [](const AccelTableData *A, const AccelTableData *B) { - return *A < *B; - }); + llvm::stable_sort(E.second.Values, + [](const AccelTableData *A, const AccelTableData *B) { + return *A < *B; + }); E.second.Values.erase( std::unique(E.second.Values.begin(), E.second.Values.end()), E.second.Values.end()); @@ -81,10 +81,9 @@ void AccelTableBase::finalize(AsmPrinter *Asm, StringRef Prefix) { // Sort the contents of the buckets by hash value so that hash collisions end // up together. Stable sort makes testing easier and doesn't cost much more. for (auto &Bucket : Buckets) - std::stable_sort(Bucket.begin(), Bucket.end(), - [](HashData *LHS, HashData *RHS) { - return LHS->HashValue < RHS->HashValue; - }); + llvm::stable_sort(Bucket, [](HashData *LHS, HashData *RHS) { + return LHS->HashValue < RHS->HashValue; + }); } namespace { diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index d34254699ed..987d324df2c 100644 --- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -1979,9 +1979,9 @@ void AsmPrinter::EmitXXStructorList(const DataLayout &DL, const Constant *List, // Emit the function pointers in the target-specific order unsigned Align = Log2_32(DL.getPointerPrefAlignment()); - std::stable_sort(Structors.begin(), Structors.end(), - [](const Structor &L, - const Structor &R) { return L.Priority < R.Priority; }); + llvm::stable_sort(Structors, [](const Structor &L, const Structor &R) { + return L.Priority < R.Priority; + }); for (Structor &S : Structors) { const TargetLoweringObjectFile &Obj = getObjFileLowering(); const MCSymbol *KeySym = nullptr; diff --git a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index f94215bb47d..5b0e77b8a06 100644 --- a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -2233,19 +2233,18 @@ void DwarfDebug::emitDebugARanges() { } // Sort the symbols by offset within the section. - std::stable_sort( - List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) { - unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0; - unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0; - - // Symbols with no order assigned should be placed at the end. - // (e.g. section end labels) - if (IA == 0) - return false; - if (IB == 0) - return true; - return IA < IB; - }); + llvm::stable_sort(List, [&](const SymbolCU &A, const SymbolCU &B) { + unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0; + unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0; + + // Symbols with no order assigned should be placed at the end. + // (e.g. section end labels) + if (IA == 0) + return false; + if (IB == 0) + return true; + return IA < IB; + }); // Insert a final terminator. List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section))); diff --git a/lib/CodeGen/GlobalMerge.cpp b/lib/CodeGen/GlobalMerge.cpp index d4cc1dadb2e..09201c2e7ba 100644 --- a/lib/CodeGen/GlobalMerge.cpp +++ b/lib/CodeGen/GlobalMerge.cpp @@ -219,11 +219,11 @@ bool GlobalMerge::doMerge(SmallVectorImpl &Globals, Module &M, bool isConst, unsigned AddrSpace) const { auto &DL = M.getDataLayout(); // FIXME: Find better heuristics - std::stable_sort(Globals.begin(), Globals.end(), - [&DL](const GlobalVariable *GV1, const GlobalVariable *GV2) { - return DL.getTypeAllocSize(GV1->getValueType()) < - DL.getTypeAllocSize(GV2->getValueType()); - }); + llvm::stable_sort( + Globals, [&DL](const GlobalVariable *GV1, const GlobalVariable *GV2) { + return DL.getTypeAllocSize(GV1->getValueType()) < + DL.getTypeAllocSize(GV2->getValueType()); + }); // If we want to just blindly group all globals together, do so. if (!GlobalMergeGroupByUse) { @@ -385,11 +385,11 @@ bool GlobalMerge::doMerge(SmallVectorImpl &Globals, // // Multiply that by the size of the set to give us a crude profitability // metric. - std::stable_sort(UsedGlobalSets.begin(), UsedGlobalSets.end(), - [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) { - return UGS1.Globals.count() * UGS1.UsageCount < - UGS2.Globals.count() * UGS2.UsageCount; - }); + llvm::stable_sort(UsedGlobalSets, + [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) { + return UGS1.Globals.count() * UGS1.UsageCount < + UGS2.Globals.count() * UGS2.UsageCount; + }); // We can choose to merge all globals together, but ignore globals never used // with another global. This catches the obviously non-profitable cases of diff --git a/lib/CodeGen/IfConversion.cpp b/lib/CodeGen/IfConversion.cpp index f1ab6815eb9..b17a253fe23 100644 --- a/lib/CodeGen/IfConversion.cpp +++ b/lib/CodeGen/IfConversion.cpp @@ -1316,7 +1316,7 @@ void IfConverter::AnalyzeBlocks( AnalyzeBlock(MBB, Tokens); // Sort to favor more complex ifcvt scheme. - std::stable_sort(Tokens.begin(), Tokens.end(), IfcvtTokenCmp); + llvm::stable_sort(Tokens, IfcvtTokenCmp); } /// Returns true either if ToMBB is the next block after MBB or that all the diff --git a/lib/CodeGen/MachineBlockPlacement.cpp b/lib/CodeGen/MachineBlockPlacement.cpp index b1806ad968f..c6766f48a39 100644 --- a/lib/CodeGen/MachineBlockPlacement.cpp +++ b/lib/CodeGen/MachineBlockPlacement.cpp @@ -941,8 +941,8 @@ MachineBlockPlacement::getBestNonConflictingEdges( // Sort for highest frequency. auto Cmp = [](WeightedEdge A, WeightedEdge B) { return A.Weight > B.Weight; }; - std::stable_sort(Edges[0].begin(), Edges[0].end(), Cmp); - std::stable_sort(Edges[1].begin(), Edges[1].end(), Cmp); + llvm::stable_sort(Edges[0], Cmp); + llvm::stable_sort(Edges[1], Cmp); auto BestA = Edges[0].begin(); auto BestB = Edges[1].begin(); // Arrange for the correct answer to be in BestA and BestB @@ -1530,15 +1530,12 @@ MachineBlockPlacement::selectBestSuccessor( // profitable than BestSucc. Position is important because we preserve it and // prefer first best match. Here we aren't comparing in order, so we capture // the position instead. - if (DupCandidates.size() != 0) { - auto cmp = - [](const std::tuple &a, - const std::tuple &b) { - return std::get<0>(a) > std::get<0>(b); - }; - std::stable_sort(DupCandidates.begin(), DupCandidates.end(), cmp); - } - for(auto &Tup : DupCandidates) { + llvm::stable_sort(DupCandidates, + [](std::tuple L, + std::tuple R) { + return std::get<0>(L) > std::get<0>(R); + }); + for (auto &Tup : DupCandidates) { BranchProbability DupProb; MachineBasicBlock *Succ; std::tie(DupProb, Succ) = Tup; diff --git a/lib/CodeGen/MachineOutliner.cpp b/lib/CodeGen/MachineOutliner.cpp index 7b1750a170d..0f3ed8a7191 100644 --- a/lib/CodeGen/MachineOutliner.cpp +++ b/lib/CodeGen/MachineOutliner.cpp @@ -1198,11 +1198,10 @@ bool MachineOutliner::outline(Module &M, unsigned OutlinedFunctionNum = 0; // Sort by benefit. The most beneficial functions should be outlined first. - std::stable_sort( - FunctionList.begin(), FunctionList.end(), - [](const OutlinedFunction &LHS, const OutlinedFunction &RHS) { - return LHS.getBenefit() > RHS.getBenefit(); - }); + llvm::stable_sort(FunctionList, [](const OutlinedFunction &LHS, + const OutlinedFunction &RHS) { + return LHS.getBenefit() > RHS.getBenefit(); + }); // Walk over each function, outlining them as we go along. Functions are // outlined greedily, based off the sort above. diff --git a/lib/CodeGen/MachinePipeliner.cpp b/lib/CodeGen/MachinePipeliner.cpp index fde6531e160..62760d222a8 100644 --- a/lib/CodeGen/MachinePipeliner.cpp +++ b/lib/CodeGen/MachinePipeliner.cpp @@ -428,7 +428,7 @@ void SwingSchedulerDAG::schedule() { } }); - std::stable_sort(NodeSets.begin(), NodeSets.end(), std::greater()); + llvm::stable_sort(NodeSets, std::greater()); groupRemainingNodes(NodeSets); diff --git a/lib/CodeGen/MachineSink.cpp b/lib/CodeGen/MachineSink.cpp index fc61a34354c..41db2c88ce5 100644 --- a/lib/CodeGen/MachineSink.cpp +++ b/lib/CodeGen/MachineSink.cpp @@ -584,9 +584,8 @@ MachineSinking::GetAllSortedSuccessors(MachineInstr &MI, MachineBasicBlock *MBB, AllSuccs.push_back(DTChild->getBlock()); // Sort Successors according to their loop depth or block frequency info. - std::stable_sort( - AllSuccs.begin(), AllSuccs.end(), - [this](const MachineBasicBlock *L, const MachineBasicBlock *R) { + llvm::stable_sort( + AllSuccs, [this](const MachineBasicBlock *L, const MachineBasicBlock *R) { uint64_t LHSFreq = MBFI ? MBFI->getBlockFreq(L).getFrequency() : 0; uint64_t RHSFreq = MBFI ? MBFI->getBlockFreq(R).getFrequency() : 0; bool HasBlockFreq = LHSFreq != 0 && RHSFreq != 0; diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp index 93c5c34b67a..10f8f5032ae 100644 --- a/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp +++ b/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp @@ -921,7 +921,7 @@ EmitSchedule(MachineBasicBlock::iterator &InsertPos) { // Sort the source order instructions and use the order to insert debug // values. Use stable_sort so that DBG_VALUEs are inserted in the same order // regardless of the host's implementation fo std::sort. - std::stable_sort(Orders.begin(), Orders.end(), less_first()); + llvm::stable_sort(Orders, less_first()); std::stable_sort(DAG->DbgBegin(), DAG->DbgEnd(), [](const SDDbgValue *LHS, const SDDbgValue *RHS) { return LHS->getOrder() < RHS->getOrder(); diff --git a/lib/CodeGen/StackColoring.cpp b/lib/CodeGen/StackColoring.cpp index 30e70660cda..641b54205d6 100644 --- a/lib/CodeGen/StackColoring.cpp +++ b/lib/CodeGen/StackColoring.cpp @@ -1220,11 +1220,12 @@ bool StackColoring::runOnMachineFunction(MachineFunction &Func) { // Sort the slots according to their size. Place unused slots at the end. // Use stable sort to guarantee deterministic code generation. - std::stable_sort(SortedSlots.begin(), SortedSlots.end(), - [this](int LHS, int RHS) { + llvm::stable_sort(SortedSlots, [this](int LHS, int RHS) { // We use -1 to denote a uninteresting slot. Place these slots at the end. - if (LHS == -1) return false; - if (RHS == -1) return true; + if (LHS == -1) + return false; + if (RHS == -1) + return true; // Sort according to size. return MFI->getObjectSize(LHS) > MFI->getObjectSize(RHS); }); diff --git a/lib/CodeGen/StackSlotColoring.cpp b/lib/CodeGen/StackSlotColoring.cpp index 60893f49070..99b533e10b8 100644 --- a/lib/CodeGen/StackSlotColoring.cpp +++ b/lib/CodeGen/StackSlotColoring.cpp @@ -242,7 +242,7 @@ void StackSlotColoring::InitializeSlots() { LLVM_DEBUG(dbgs() << '\n'); // Sort them by weight. - std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter()); + llvm::stable_sort(SSIntervals, IntervalSorter()); NextColors.resize(AllColors.size()); @@ -347,7 +347,7 @@ bool StackSlotColoring::ColorSlots(MachineFunction &MF) { li->weight = SlotWeights[SS]; } // Sort them by new weight. - std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter()); + llvm::stable_sort(SSIntervals, IntervalSorter()); #ifndef NDEBUG for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) diff --git a/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp b/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp index 69e831570e3..de453ee4b84 100644 --- a/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp @@ -262,8 +262,7 @@ static std::vector computeAddrMap(ArrayRef Records) { SymOffsets.push_back(SymOffset); SymOffset += Sym.length(); } - std::stable_sort(PublicsByAddr.begin(), PublicsByAddr.end(), - comparePubSymByAddrAndName); + llvm::stable_sort(PublicsByAddr, comparePubSymByAddrAndName); // Fill in the symbol offsets in the appropriate order. std::vector AddrMap; diff --git a/lib/IR/MDBuilder.cpp b/lib/IR/MDBuilder.cpp index f65ac31ca5a..14bcb3a29b0 100644 --- a/lib/IR/MDBuilder.cpp +++ b/lib/IR/MDBuilder.cpp @@ -68,9 +68,7 @@ MDNode *MDBuilder::createFunctionEntryCount( Ops.push_back(createConstant(ConstantInt::get(Int64Ty, Count))); if (Imports) { SmallVector OrderID(Imports->begin(), Imports->end()); - std::stable_sort(OrderID.begin(), OrderID.end(), - [] (GlobalValue::GUID A, GlobalValue::GUID B) { - return A < B;}); + llvm::stable_sort(OrderID); for (auto ID : OrderID) Ops.push_back(createConstant(ConstantInt::get(Int64Ty, ID))); } diff --git a/lib/IR/Metadata.cpp b/lib/IR/Metadata.cpp index 70ffa652bfb..748a2238e64 100644 --- a/lib/IR/Metadata.cpp +++ b/lib/IR/Metadata.cpp @@ -1179,10 +1179,7 @@ void MDGlobalAttachmentMap::getAll( // Sort the resulting array so it is stable with respect to metadata IDs. We // need to preserve the original insertion order though. - std::stable_sort( - Result.begin(), Result.end(), - [](const std::pair &A, - const std::pair &B) { return A.first < B.first; }); + llvm::stable_sort(Result, less_first()); } void Instruction::setMetadata(StringRef Kind, MDNode *Node) { diff --git a/lib/MC/MCDwarf.cpp b/lib/MC/MCDwarf.cpp index e8edf6ba1d4..aae6fdf9093 100644 --- a/lib/MC/MCDwarf.cpp +++ b/lib/MC/MCDwarf.cpp @@ -1865,11 +1865,10 @@ void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB, // but the Android libunwindstack rejects eh_frame sections where // an FDE refers to a CIE other than the closest previous CIE. std::vector FrameArrayX(FrameArray.begin(), FrameArray.end()); - std::stable_sort( - FrameArrayX.begin(), FrameArrayX.end(), - [&](const MCDwarfFrameInfo &X, const MCDwarfFrameInfo &Y) -> bool { - return CIEKey(X) < CIEKey(Y); - }); + llvm::stable_sort(FrameArrayX, + [](const MCDwarfFrameInfo &X, const MCDwarfFrameInfo &Y) { + return CIEKey(X) < CIEKey(Y); + }); for (auto I = FrameArrayX.begin(), E = FrameArrayX.end(); I != E;) { const MCDwarfFrameInfo &Frame = *I; ++I; diff --git a/lib/MC/WasmObjectWriter.cpp b/lib/MC/WasmObjectWriter.cpp index 2994772c519..dab5bb329bc 100644 --- a/lib/MC/WasmObjectWriter.cpp +++ b/lib/MC/WasmObjectWriter.cpp @@ -934,9 +934,8 @@ void WasmObjectWriter::writeRelocSection( // order, but for the code section we combine many MC sections into single // wasm section, and this order is determined by the order of Asm.Symbols() // not the sections order. - std::stable_sort( - Relocs.begin(), Relocs.end(), - [](const WasmRelocationEntry &A, const WasmRelocationEntry &B) { + llvm::stable_sort( + Relocs, [](const WasmRelocationEntry &A, const WasmRelocationEntry &B) { return (A.Offset + A.FixupSection->getSectionOffset()) < (B.Offset + B.FixupSection->getSectionOffset()); }); diff --git a/lib/ProfileData/Coverage/CoverageMappingWriter.cpp b/lib/ProfileData/Coverage/CoverageMappingWriter.cpp index 0ef6744e64f..432b20f217c 100644 --- a/lib/ProfileData/Coverage/CoverageMappingWriter.cpp +++ b/lib/ProfileData/Coverage/CoverageMappingWriter.cpp @@ -124,15 +124,14 @@ void CoverageMappingWriter::write(raw_ostream &OS) { // Sort the regions in an ascending order by the file id and the starting // location. Sort by region kinds to ensure stable order for tests. - std::stable_sort( - MappingRegions.begin(), MappingRegions.end(), - [](const CounterMappingRegion &LHS, const CounterMappingRegion &RHS) { - if (LHS.FileID != RHS.FileID) - return LHS.FileID < RHS.FileID; - if (LHS.startLoc() != RHS.startLoc()) - return LHS.startLoc() < RHS.startLoc(); - return LHS.Kind < RHS.Kind; - }); + llvm::stable_sort(MappingRegions, [](const CounterMappingRegion &LHS, + const CounterMappingRegion &RHS) { + if (LHS.FileID != RHS.FileID) + return LHS.FileID < RHS.FileID; + if (LHS.startLoc() != RHS.startLoc()) + return LHS.startLoc() < RHS.startLoc(); + return LHS.Kind < RHS.Kind; + }); // Write out the fileid -> filename mapping. encodeULEB128(VirtualFileMapping.size(), OS); diff --git a/lib/ProfileData/GCOV.cpp b/lib/ProfileData/GCOV.cpp index af4527024b4..fa4e433d7aa 100644 --- a/lib/ProfileData/GCOV.cpp +++ b/lib/ProfileData/GCOV.cpp @@ -396,10 +396,10 @@ void GCOVBlock::addCount(size_t DstEdgeNo, uint64_t N) { /// sortDstEdges - Sort destination edges by block number, nop if already /// sorted. This is required for printing branch info in the correct order. void GCOVBlock::sortDstEdges() { - if (!DstEdgesAreSorted) { - SortDstEdgesFunctor SortEdges; - std::stable_sort(DstEdges.begin(), DstEdges.end(), SortEdges); - } + if (!DstEdgesAreSorted) + llvm::stable_sort(DstEdges, [](const GCOVEdge *E1, const GCOVEdge *E2) { + return E1->Dst.Number < E2->Dst.Number; + }); } /// collectLineCounts - Collect line counts. This must be used after diff --git a/lib/ProfileData/SampleProfWriter.cpp b/lib/ProfileData/SampleProfWriter.cpp index 8135febdf86..8b876e0aa5d 100644 --- a/lib/ProfileData/SampleProfWriter.cpp +++ b/lib/ProfileData/SampleProfWriter.cpp @@ -50,9 +50,8 @@ SampleProfileWriter::write(const StringMap &ProfileMap) { for (const auto &I : ProfileMap) V.push_back(std::make_pair(I.getKey(), &I.second)); - std::stable_sort( - V.begin(), V.end(), - [](const NameFunctionSamples &A, const NameFunctionSamples &B) { + llvm::stable_sort( + V, [](const NameFunctionSamples &A, const NameFunctionSamples &B) { if (A.second->getTotalSamples() == B.second->getTotalSamples()) return A.first > B.first; return A.second->getTotalSamples() > B.second->getTotalSamples(); diff --git a/lib/Support/Statistic.cpp b/lib/Support/Statistic.cpp index 0d8b5b2e0ab..e4f0535d21a 100644 --- a/lib/Support/Statistic.cpp +++ b/lib/Support/Statistic.cpp @@ -135,8 +135,7 @@ bool llvm::AreStatisticsEnabled() { } void StatisticInfo::sort() { - std::stable_sort(Stats.begin(), Stats.end(), - [](const Statistic *LHS, const Statistic *RHS) { + llvm::stable_sort(Stats, [](const Statistic *LHS, const Statistic *RHS) { if (int Cmp = std::strcmp(LHS->getDebugType(), RHS->getDebugType())) return Cmp < 0; diff --git a/lib/Target/X86/X86FrameLowering.cpp b/lib/Target/X86/X86FrameLowering.cpp index 581df4345a7..f4ef796e80c 100644 --- a/lib/Target/X86/X86FrameLowering.cpp +++ b/lib/Target/X86/X86FrameLowering.cpp @@ -3088,8 +3088,7 @@ void X86FrameLowering::orderFrameObjects( // Sort the objects using X86FrameSortingAlgorithm (see its comment for // info). - std::stable_sort(SortingObjects.begin(), SortingObjects.end(), - X86FrameSortingComparator()); + llvm::stable_sort(SortingObjects, X86FrameSortingComparator()); // Now modify the original list to represent the final order that // we want. The order will depend on whether we're going to access them diff --git a/lib/Transforms/IPO/LowerTypeTests.cpp b/lib/Transforms/IPO/LowerTypeTests.cpp index 398005d2234..f7371284f47 100644 --- a/lib/Transforms/IPO/LowerTypeTests.cpp +++ b/lib/Transforms/IPO/LowerTypeTests.cpp @@ -548,10 +548,10 @@ ByteArrayInfo *LowerTypeTestsModule::createByteArray(BitSetInfo &BSI) { } void LowerTypeTestsModule::allocateByteArrays() { - std::stable_sort(ByteArrayInfos.begin(), ByteArrayInfos.end(), - [](const ByteArrayInfo &BAI1, const ByteArrayInfo &BAI2) { - return BAI1.BitSize > BAI2.BitSize; - }); + llvm::stable_sort(ByteArrayInfos, + [](const ByteArrayInfo &BAI1, const ByteArrayInfo &BAI2) { + return BAI1.BitSize > BAI2.BitSize; + }); std::vector ByteArrayOffsets(ByteArrayInfos.size()); @@ -1552,11 +1552,10 @@ void LowerTypeTestsModule::buildBitSetsFromDisjointSet( // Order the sets of indices by size. The GlobalLayoutBuilder works best // when given small index sets first. - std::stable_sort( - TypeMembers.begin(), TypeMembers.end(), - [](const std::set &O1, const std::set &O2) { - return O1.size() < O2.size(); - }); + llvm::stable_sort(TypeMembers, [](const std::set &O1, + const std::set &O2) { + return O1.size() < O2.size(); + }); // Create a GlobalLayoutBuilder and provide it with index sets as layout // fragments. The GlobalLayoutBuilder tries to lay out members of fragments as diff --git a/lib/Transforms/IPO/MergeFunctions.cpp b/lib/Transforms/IPO/MergeFunctions.cpp index 08a6c4e9963..3a08069dcd4 100644 --- a/lib/Transforms/IPO/MergeFunctions.cpp +++ b/lib/Transforms/IPO/MergeFunctions.cpp @@ -401,7 +401,7 @@ bool MergeFunctions::runOnModule(Module &M) { } } - std::stable_sort(HashedFuncs.begin(), HashedFuncs.end(), less_first()); + llvm::stable_sort(HashedFuncs, less_first()); auto S = HashedFuncs.begin(); for (auto I = HashedFuncs.begin(), IE = HashedFuncs.end(); I != IE; ++I) { diff --git a/lib/Transforms/Instrumentation/CFGMST.h b/lib/Transforms/Instrumentation/CFGMST.h index b4164972be4..971e0004176 100644 --- a/lib/Transforms/Instrumentation/CFGMST.h +++ b/lib/Transforms/Instrumentation/CFGMST.h @@ -195,11 +195,10 @@ public: // Sort CFG edges based on its weight. void sortEdgesByWeight() { - std::stable_sort(AllEdges.begin(), AllEdges.end(), - [](const std::unique_ptr &Edge1, - const std::unique_ptr &Edge2) { - return Edge1->Weight > Edge2->Weight; - }); + llvm::stable_sort(AllEdges, [](const std::unique_ptr &Edge1, + const std::unique_ptr &Edge2) { + return Edge1->Weight > Edge2->Weight; + }); } // Traverse all the edges and compute the Minimum Weight Spanning Tree diff --git a/lib/Transforms/Instrumentation/ControlHeightReduction.cpp b/lib/Transforms/Instrumentation/ControlHeightReduction.cpp index c2482677470..fe96d4a8444 100644 --- a/lib/Transforms/Instrumentation/ControlHeightReduction.cpp +++ b/lib/Transforms/Instrumentation/ControlHeightReduction.cpp @@ -1416,7 +1416,7 @@ void CHR::sortScopes(SmallVectorImpl &Input, SmallVectorImpl &Output) { Output.resize(Input.size()); llvm::copy(Input, Output.begin()); - std::stable_sort(Output.begin(), Output.end(), CHRScopeSorter); + llvm::stable_sort(Output, CHRScopeSorter); } // Return true if V is already hoisted or was hoisted (along with its operands) diff --git a/lib/Transforms/Instrumentation/MaximumSpanningTree.h b/lib/Transforms/Instrumentation/MaximumSpanningTree.h index 19035ffb803..892a6a26da9 100644 --- a/lib/Transforms/Instrumentation/MaximumSpanningTree.h +++ b/lib/Transforms/Instrumentation/MaximumSpanningTree.h @@ -67,8 +67,7 @@ namespace llvm { /// MaximumSpanningTree() - Takes a vector of weighted edges and returns a /// spanning tree. MaximumSpanningTree(EdgeWeights &EdgeVector) { - - std::stable_sort(EdgeVector.begin(), EdgeVector.end(), EdgeWeightCompare()); + llvm::stable_sort(EdgeVector, EdgeWeightCompare()); // Create spanning tree, Forest contains a special data structure // that makes checking if two nodes are already in a common (sub-)tree diff --git a/lib/Transforms/Scalar/ConstantHoisting.cpp b/lib/Transforms/Scalar/ConstantHoisting.cpp index 683cf32eb30..98243a23f1e 100644 --- a/lib/Transforms/Scalar/ConstantHoisting.cpp +++ b/lib/Transforms/Scalar/ConstantHoisting.cpp @@ -647,8 +647,8 @@ void ConstantHoistingPass::findBaseConstants(GlobalVariable *BaseGV) { ConstGEPInfoMap[BaseGV] : ConstIntInfoVec; // Sort the constants by value and type. This invalidates the mapping! - std::stable_sort(ConstCandVec.begin(), ConstCandVec.end(), - [](const ConstantCandidate &LHS, const ConstantCandidate &RHS) { + llvm::stable_sort(ConstCandVec, [](const ConstantCandidate &LHS, + const ConstantCandidate &RHS) { if (LHS.ConstInt->getType() != RHS.ConstInt->getType()) return LHS.ConstInt->getType()->getBitWidth() < RHS.ConstInt->getType()->getBitWidth(); diff --git a/lib/Transforms/Scalar/GVNHoist.cpp b/lib/Transforms/Scalar/GVNHoist.cpp index ca8f92c3887..7614599653c 100644 --- a/lib/Transforms/Scalar/GVNHoist.cpp +++ b/lib/Transforms/Scalar/GVNHoist.cpp @@ -702,7 +702,7 @@ private: // Vector of PHIs contains PHIs for different instructions. // Sort the args according to their VNs, such that identical // instructions are together. - std::stable_sort(CHIs.begin(), CHIs.end(), cmpVN); + llvm::stable_sort(CHIs, cmpVN); auto TI = BB->getTerminator(); auto B = CHIs.begin(); // [PreIt, PHIIt) form a range of CHIs which have identical VNs. diff --git a/lib/Transforms/Scalar/GVNSink.cpp b/lib/Transforms/Scalar/GVNSink.cpp index 94cc219a4a7..bf5ec47fbbb 100644 --- a/lib/Transforms/Scalar/GVNSink.cpp +++ b/lib/Transforms/Scalar/GVNSink.cpp @@ -790,10 +790,7 @@ unsigned GVNSink::sinkBB(BasicBlock *BBEnd) { --LRI; } - std::stable_sort( - Candidates.begin(), Candidates.end(), - [](const SinkingInstructionCandidate &A, - const SinkingInstructionCandidate &B) { return A > B; }); + llvm::stable_sort(Candidates, std::greater()); LLVM_DEBUG(dbgs() << " -- Sinking candidates:\n"; for (auto &C : Candidates) dbgs() << " " << C << "\n";); diff --git a/lib/Transforms/Scalar/LoopSink.cpp b/lib/Transforms/Scalar/LoopSink.cpp index 3235b639c9e..975452e13f0 100644 --- a/lib/Transforms/Scalar/LoopSink.cpp +++ b/lib/Transforms/Scalar/LoopSink.cpp @@ -290,10 +290,9 @@ static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, ColdLoopBBs.push_back(B); LoopBlockNumber[B] = ++i; } - std::stable_sort(ColdLoopBBs.begin(), ColdLoopBBs.end(), - [&](BasicBlock *A, BasicBlock *B) { - return BFI.getBlockFreq(A) < BFI.getBlockFreq(B); - }); + llvm::stable_sort(ColdLoopBBs, [&](BasicBlock *A, BasicBlock *B) { + return BFI.getBlockFreq(A) < BFI.getBlockFreq(B); + }); // Traverse preheader's instructions in reverse order becaue if A depends // on B (A appears after B), A needs to be sinked first before B can be diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 34066aea27d..7cdfce84559 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -1328,8 +1328,7 @@ Value *ReassociatePass::OptimizeXor(Instruction *I, // So, if Rank(X) < Rank(Y) < Rank(Z), it means X is defined earlier // than Y which is defined earlier than Z. Permute "x | 1", "Y & 2", // "z" in the order of X-Y-Z is better than any other orders. - std::stable_sort(OpndPtrs.begin(), OpndPtrs.end(), - [](XorOpnd *LHS, XorOpnd *RHS) { + llvm::stable_sort(OpndPtrs, [](XorOpnd *LHS, XorOpnd *RHS) { return LHS->getSymbolicRank() < RHS->getSymbolicRank(); }); @@ -1686,8 +1685,7 @@ static bool collectMultiplyFactors(SmallVectorImpl &Ops, // below our mininum of '4'. assert(FactorPowerSum >= 4); - std::stable_sort(Factors.begin(), Factors.end(), - [](const Factor &LHS, const Factor &RHS) { + llvm::stable_sort(Factors, [](const Factor &LHS, const Factor &RHS) { return LHS.Power > RHS.Power; }); return true; @@ -2141,7 +2139,7 @@ void ReassociatePass::ReassociateExpression(BinaryOperator *I) { // positions maintained (and so the compiler is deterministic). Note that // this sorts so that the highest ranking values end up at the beginning of // the vector. - std::stable_sort(Ops.begin(), Ops.end()); + llvm::stable_sort(Ops); // Now that we have the expression tree in a convenient // sorted form, optimize it globally if possible. diff --git a/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp b/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp index d748d967a5e..06d65b55890 100644 --- a/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp +++ b/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp @@ -1722,10 +1722,9 @@ static bool rebuildLoopAfterUnswitch(Loop &L, ArrayRef ExitBlocks, // Sort the exits in ascending loop depth, we'll work backwards across these // to process them inside out. - std::stable_sort(ExitsInLoops.begin(), ExitsInLoops.end(), - [&](BasicBlock *LHS, BasicBlock *RHS) { - return LI.getLoopDepth(LHS) < LI.getLoopDepth(RHS); - }); + llvm::stable_sort(ExitsInLoops, [&](BasicBlock *LHS, BasicBlock *RHS) { + return LI.getLoopDepth(LHS) < LI.getLoopDepth(RHS); + }); // We'll build up a set for each exit loop. SmallPtrSet NewExitLoopBlocks; diff --git a/lib/Transforms/Utils/ASanStackFrameLayout.cpp b/lib/Transforms/Utils/ASanStackFrameLayout.cpp index a7de158e65c..01912297324 100644 --- a/lib/Transforms/Utils/ASanStackFrameLayout.cpp +++ b/lib/Transforms/Utils/ASanStackFrameLayout.cpp @@ -62,7 +62,7 @@ ComputeASanStackFrameLayout(SmallVectorImpl &Vars, for (size_t i = 0; i < NumVars; i++) Vars[i].Alignment = std::max(Vars[i].Alignment, kMinAlignment); - std::stable_sort(Vars.begin(), Vars.end(), CompareVars); + llvm::stable_sort(Vars, CompareVars); ASanStackFrameLayout Layout; Layout.Granularity = Granularity; diff --git a/lib/Transforms/Utils/PredicateInfo.cpp b/lib/Transforms/Utils/PredicateInfo.cpp index f1c0792da78..6f041ace6d1 100644 --- a/lib/Transforms/Utils/PredicateInfo.cpp +++ b/lib/Transforms/Utils/PredicateInfo.cpp @@ -634,7 +634,7 @@ void PredicateInfo::renameUses(SmallPtrSetImpl &OpSet) { // uses in the same instruction do not have a strict sort order // currently and will be considered equal. We could get rid of the // stable sort by creating one if we wanted. - std::stable_sort(OrderedUses.begin(), OrderedUses.end(), Compare); + llvm::stable_sort(OrderedUses, Compare); SmallVector RenameStack; // For each use, sorted into dfs order, push values and replaces uses with // top of stack, which will represent the reaching def. diff --git a/lib/Transforms/Vectorize/SLPVectorizer.cpp b/lib/Transforms/Vectorize/SLPVectorizer.cpp index 3c00f648d83..621ea1d2e7f 100644 --- a/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ b/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -4120,10 +4120,10 @@ void BoUpSLP::optimizeGatherSequence() { // Sort blocks by domination. This ensures we visit a block after all blocks // dominating it are visited. - std::stable_sort(CSEWorkList.begin(), CSEWorkList.end(), - [this](const DomTreeNode *A, const DomTreeNode *B) { - return DT->properlyDominates(A, B); - }); + llvm::stable_sort(CSEWorkList, + [this](const DomTreeNode *A, const DomTreeNode *B) { + return DT->properlyDominates(A, B); + }); // Perform O(N^2) search over the gather sequences and merge identical // instructions. TODO: We can further optimize this scan if we split the @@ -6601,7 +6601,7 @@ bool SLPVectorizerPass::vectorizeChainsInBlock(BasicBlock *BB, BoUpSLP &R) { } // Sort by type. - std::stable_sort(Incoming.begin(), Incoming.end(), PhiTypeSorterFunc); + llvm::stable_sort(Incoming, PhiTypeSorterFunc); // Try to vectorize elements base on their type. for (SmallVector::iterator IncIt = Incoming.begin(), diff --git a/lib/XRay/Trace.cpp b/lib/XRay/Trace.cpp index eba6ff2c7fb..f0a70038d3b 100644 --- a/lib/XRay/Trace.cpp +++ b/lib/XRay/Trace.cpp @@ -461,10 +461,9 @@ Expected llvm::xray::loadTrace(const DataExtractor &DE, bool Sort) { } if (Sort) - std::stable_sort(T.Records.begin(), T.Records.end(), - [&](const XRayRecord &L, const XRayRecord &R) { - return L.TSC < R.TSC; - }); + llvm::stable_sort(T.Records, [&](const XRayRecord &L, const XRayRecord &R) { + return L.TSC < R.TSC; + }); return std::move(T); } diff --git a/utils/TableGen/AsmMatcherEmitter.cpp b/utils/TableGen/AsmMatcherEmitter.cpp index df089cbf0ea..1229b65b24b 100644 --- a/utils/TableGen/AsmMatcherEmitter.cpp +++ b/utils/TableGen/AsmMatcherEmitter.cpp @@ -3131,10 +3131,10 @@ void AsmMatcherEmitter::run(raw_ostream &OS) { // Sort the instruction table using the partial order on classes. We use // stable_sort to ensure that ambiguous instructions are still // deterministically ordered. - std::stable_sort(Info.Matchables.begin(), Info.Matchables.end(), - [](const std::unique_ptr &a, - const std::unique_ptr &b){ - return *a < *b;}); + llvm::stable_sort( + Info.Matchables, + [](const std::unique_ptr &a, + const std::unique_ptr &b) { return *a < *b; }); #ifdef EXPENSIVE_CHECKS // Verify that the table is sorted and operator < works transitively. diff --git a/utils/TableGen/CodeGenRegisters.cpp b/utils/TableGen/CodeGenRegisters.cpp index 7d8efbf8b96..f87c6d6c945 100644 --- a/utils/TableGen/CodeGenRegisters.cpp +++ b/utils/TableGen/CodeGenRegisters.cpp @@ -2101,8 +2101,7 @@ void CodeGenRegBank::computeDerivedInfo() { for (unsigned Idx = 0, EndIdx = RegUnitSets.size(); Idx != EndIdx; ++Idx) RegUnitSetOrder.push_back(Idx); - std::stable_sort(RegUnitSetOrder.begin(), RegUnitSetOrder.end(), - [this](unsigned ID1, unsigned ID2) { + llvm::stable_sort(RegUnitSetOrder, [this](unsigned ID1, unsigned ID2) { return getRegPressureSet(ID1).Units.size() < getRegPressureSet(ID2).Units.size(); }); diff --git a/utils/TableGen/GlobalISelEmitter.cpp b/utils/TableGen/GlobalISelEmitter.cpp index 1e71d1317ed..839529601b9 100644 --- a/utils/TableGen/GlobalISelEmitter.cpp +++ b/utils/TableGen/GlobalISelEmitter.cpp @@ -4501,8 +4501,7 @@ void GlobalISelEmitter::run(raw_ostream &OS) { << ", // " << Record->getName() << "\n"; OS << "};\n\n"; - std::stable_sort(Rules.begin(), Rules.end(), [&](const RuleMatcher &A, - const RuleMatcher &B) { + llvm::stable_sort(Rules, [&](const RuleMatcher &A, const RuleMatcher &B) { int ScoreA = RuleMatcherScores[A.getRuleID()]; int ScoreB = RuleMatcherScores[B.getRuleID()]; if (ScoreA > ScoreB) diff --git a/utils/TableGen/RISCVCompressInstEmitter.cpp b/utils/TableGen/RISCVCompressInstEmitter.cpp index f95b3bf9cb4..10778893b4a 100644 --- a/utils/TableGen/RISCVCompressInstEmitter.cpp +++ b/utils/TableGen/RISCVCompressInstEmitter.cpp @@ -543,15 +543,15 @@ void RISCVCompressInstEmitter::emitCompressInstEmitter(raw_ostream &o, // transformed to a C_ADD or a C_MV. When emitting 'uncompress()' function the // source and destination are flipped and the sort key needs to change // accordingly. - std::stable_sort(CompressPatterns.begin(), CompressPatterns.end(), - [Compress](const CompressPat &LHS, const CompressPat &RHS) { - if (Compress) - return (LHS.Source.TheDef->getName().str() < - RHS.Source.TheDef->getName().str()); - else - return (LHS.Dest.TheDef->getName().str() < - RHS.Dest.TheDef->getName().str()); - }); + llvm::stable_sort(CompressPatterns, + [Compress](const CompressPat &LHS, const CompressPat &RHS) { + if (Compress) + return (LHS.Source.TheDef->getName().str() < + RHS.Source.TheDef->getName().str()); + else + return (LHS.Dest.TheDef->getName().str() < + RHS.Dest.TheDef->getName().str()); + }); // A list of MCOperandPredicates for all operands in use, and the reverse map. std::vector MCOpPredicates;