[lldb] Use llvm::stable_sort (NFC)

lldb/include/lldb/Utility/RangeMap.h

@@ -216,7 +216,7 @@ template <typename B, typename S, unsigned N = 0> class RangeVector {
 
   void Sort() {
     if (m_entries.size() > 1)
-      std::stable_sort(m_entries.begin(), m_entries.end());
+      llvm::stable_sort(m_entries);
   }
 
 #ifdef ASSERT_RANGEMAP_ARE_SORTED
@@ -484,14 +484,14 @@ class RangeDataVector {
 
   void Sort() {
     if (m_entries.size() > 1)
-      std::stable_sort(m_entries.begin(), m_entries.end(),
-                       [&compare = m_compare](const Entry &a, const Entry &b) {
-                         if (a.base != b.base)
-                           return a.base < b.base;
-                         if (a.size != b.size)
-                           return a.size < b.size;
-                         return compare(a.data, b.data);
-                       });
+      llvm::stable_sort(m_entries,
+                        [&compare = m_compare](const Entry &a, const Entry &b) {
+                          if (a.base != b.base)
+                            return a.base < b.base;
+                          if (a.size != b.size)
+                            return a.size < b.size;
+                          return compare(a.data, b.data);
+                        });
     if (!m_entries.empty())
       ComputeUpperBounds(0, m_entries.size());
   }

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

@@ -919,8 +919,7 @@ ObjectFilePECOFF::AppendFromExportTable(SectionList *sect_list,
     uint32_t idx = symtab.AddSymbol(symbol);
     export_list.push_back(std::make_pair(function_rva, idx));
   }
-  std::stable_sort(export_list.begin(), export_list.end(),
-                   RVASymbolListCompareRVA);
+  llvm::stable_sort(export_list, RVASymbolListCompareRVA);
   return export_list;
 }
 

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

@@ -2758,11 +2758,10 @@ Status ProcessGDBRemote::WriteObjectFile(
   Status error;
   // Sort the entries by address because some writes, like those to flash
   // memory, must happen in order of increasing address.
-  std::stable_sort(
-      std::begin(entries), std::end(entries),
-      [](const ObjectFile::LoadableData a, const ObjectFile::LoadableData b) {
-        return a.Dest < b.Dest;
-      });
+  llvm::stable_sort(entries, [](const ObjectFile::LoadableData a,
+                                const ObjectFile::LoadableData b) {
+    return a.Dest < b.Dest;
+  });
   m_allow_flash_writes = true;
   error = Process::WriteObjectFile(entries);
   if (error.Success())

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

@@ -8631,10 +8631,9 @@ static bool DumpEnumValue(const clang::QualType &qual_type, Stream &s,
   // Sort in reverse order of the number of the population count,  so that in
   // `enum {A, B, ALL = A|B }` we visit ALL first. Use a stable sort so that
   // A | C where A is declared before C is displayed in this order.
-  std::stable_sort(values.begin(), values.end(),
-                   [](const auto &a, const auto &b) {
-                     return llvm::popcount(a.first) > llvm::popcount(b.first);
-                   });
+  llvm::stable_sort(values, [](const auto &a, const auto &b) {
+    return llvm::popcount(a.first) > llvm::popcount(b.first);
+  });
 
   for (const auto &val : values) {
     if ((remaining_value & val.first) != val.first)

lldb/source/Symbol/Symtab.cpp

@@ -638,7 +638,7 @@ void Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
   std::vector<lldb::addr_t> addr_cache(m_symbols.size(), LLDB_INVALID_ADDRESS);
 
   SymbolIndexComparator comparator(m_symbols, addr_cache);
-  std::stable_sort(indexes.begin(), indexes.end(), comparator);
+  llvm::stable_sort(indexes, comparator);
 
   // Remove any duplicates if requested
   if (remove_duplicates) {

lldb/source/Utility/DiagnosticsRendering.cpp

@@ -140,7 +140,7 @@ void RenderDiagnosticDetails(Stream &stream,
 
   // Sort the diagnostics.
   auto sort = [](std::vector<DiagnosticDetail> &ds) {
-    std::stable_sort(ds.begin(), ds.end(), [](auto &d1, auto &d2) {
+    llvm::stable_sort(ds, [](auto &d1, auto &d2) {
       auto l1 = d1.source_location.value_or(DiagnosticDetail::SourceLocation{});
       auto l2 = d2.source_location.value_or(DiagnosticDetail::SourceLocation{});
       return std::tie(l1.line, l1.column) < std::tie(l2.line, l2.column);