[ELF] - Never use std::sort.

It turns out we should not use the std::sort anymore.
r327219 added a new wrapper llvm::sort (D39245).
When EXPENSIVE_CHECKS is defined, it shuffles the
input container and that helps to find non-deterministic
ordering.

Patch changes code to use llvm::sort and std::stable_sort
instead of std::sort

Differential revision: https://reviews.llvm.org/D45969

llvm-svn: 330702

lld/ELF/CallGraphSort.cpp

@@ -219,10 +219,10 @@ void CallGraphSort::groupClusters() {
   });
 
   // Sort by density.
-  std::sort(Clusters.begin(), Clusters.end(),
+  std::stable_sort(Clusters.begin(), Clusters.end(),
-            [](const Cluster &A, const Cluster &B) {
+                   [](const Cluster &A, const Cluster &B) {
-              return A.getDensity() > B.getDensity();
+                     return A.getDensity() > B.getDensity();
-            });
+                   });
 }
 
 DenseMap<const InputSectionBase *, int> CallGraphSort::run() {

lld/ELF/MapFile.cpp

@@ -90,8 +90,9 @@ static SymbolMapTy getSectionSyms(ArrayRef<Symbol *> Syms) {
   // in the input files.
   for (auto &It : Ret) {
     SmallVectorImpl<Symbol *> &V = It.second;
-    std::sort(V.begin(), V.end(),
+    std::stable_sort(V.begin(), V.end(), [](Symbol *A, Symbol *B) {
-              [](Symbol *A, Symbol *B) { return A->getVA() < B->getVA(); });
+      return A->getVA() < B->getVA();
+    });
   }
   return Ret;
 }

lld/ELF/SyntheticSections.cpp

@@ -1393,10 +1393,10 @@ bool AndroidPackedRelocationSection<ELFT>::updateAllocSize() {
       NonRelatives.push_back(R);
   }
 
-  std::sort(Relatives.begin(), Relatives.end(),
+  llvm::sort(Relatives.begin(), Relatives.end(),
-            [](const Elf_Rel &A, const Elf_Rel &B) {
+             [](const Elf_Rel &A, const Elf_Rel &B) {
-              return A.r_offset < B.r_offset;
+               return A.r_offset < B.r_offset;
-            });
+             });
 
   // Try to find groups of relative relocations which are spaced one word
   // apart from one another. These generally correspond to vtable entries. The
@@ -1474,10 +1474,10 @@ bool AndroidPackedRelocationSection<ELFT>::updateAllocSize() {
   }
 
   // Finally the non-relative relocations.
-  std::sort(NonRelatives.begin(), NonRelatives.end(),
+  llvm::sort(NonRelatives.begin(), NonRelatives.end(),
-            [](const Elf_Rela &A, const Elf_Rela &B) {
+             [](const Elf_Rela &A, const Elf_Rela &B) {
-              return A.r_offset < B.r_offset;
+               return A.r_offset < B.r_offset;
-            });
+             });
   if (!NonRelatives.empty()) {
     Add(NonRelatives.size());
     Add(HasAddendIfRela);

lld/ELF/Writer.cpp

@@ -1106,7 +1106,7 @@ sortISDBySectionOrder(InputSectionDescription *ISD,
     }
     OrderedSections.push_back({IS, I->second});
   }
-  std::sort(
+  llvm::sort(
       OrderedSections.begin(), OrderedSections.end(),
       [&](std::pair<InputSection *, int> A, std::pair<InputSection *, int> B) {
         return A.second < B.second;
@@ -2056,10 +2056,10 @@ struct SectionOffset {
 // Check whether sections overlap for a specific address range (file offsets,
 // load and virtual adresses).
 static void checkOverlap(StringRef Name, std::vector<SectionOffset> &Sections) {
-  std::sort(Sections.begin(), Sections.end(),
+  llvm::sort(Sections.begin(), Sections.end(),
-            [=](const SectionOffset &A, const SectionOffset &B) {
+             [=](const SectionOffset &A, const SectionOffset &B) {
-              return A.Offset < B.Offset;
+               return A.Offset < B.Offset;
-            });
+             });
 
   // Finding overlap is easy given a vector is sorted by start position.
   // If an element starts before the end of the previous element, they overlap.