[DebugInfo] 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.

Note: This patch is one of a series of patches to replace *all* std::sort to llvm::sort.
Refer the comments section in D44363 for a list of all the required patches.

[echristo]

As the general idea was already approved, LGTM.

llvm/trunk/lib/DebugInfo/CodeView/DebugCrossImpSubsection.cpp

Error DebugCrossModuleImportsSubsection::commit(
     BinaryStreamWriter &Writer) const {
   using T = decltype(&*Mappings.begin());
   std::vector<T> Ids;
   Ids.reserve(Mappings.size());
 
   for (const auto &M : Mappings)
     Ids.push_back(&M);
 
-  std::sort(Ids.begin(), Ids.end(), [this](const T &L1, const T &L2) {
+  llvm::sort(Ids.begin(), Ids.end(), [this](const T &L1, const T &L2) {
     return Strings.getIdForString(L1->getKey()) <
            Strings.getIdForString(L2->getKey());
   });
 
   for (const auto &Item : Ids) {
     CrossModuleImport Imp;
     Imp.ModuleNameOffset = Strings.getIdForString(Item->getKey());
     Imp.Count = Item->getValue().size();
     if (auto EC = Writer.writeObject(Imp))
       return EC;
     if (auto EC = Writer.writeArray(makeArrayRef(Item->getValue())))
       return EC;
   }
   return Error::success();
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

for (const auto &CU : CUs)
     Contributions.push_back(CU->getStringOffsetsTableContribution());
   for (const auto &TUS : TUSs)
     for (const auto &TU : TUS)
       Contributions.push_back(TU->getStringOffsetsTableContribution());
 
   // Sort the contributions so that any invalid ones are placed at
   // the start of the contributions vector. This way they are reported
   // first.
-  std::sort(Contributions.begin(), Contributions.end(),
+  llvm::sort(Contributions.begin(), Contributions.end(),
              [](const Optional<StrOffsetsContributionDescriptor> &L,
                 const Optional<StrOffsetsContributionDescriptor> &R) {
                if (L && R) return L->Base < R->Base;
                return R.hasValue();
              });
 
   // Uniquify contributions, as it is possible that units (specifically
   // type units in dwo or dwp files) share contributions. We don't want
   // to report them more than once.
   Contributions.erase(
       std::unique(Contributions.begin(), Contributions.end(),
                   [](const Optional<StrOffsetsContributionDescriptor> &L,
                      const Optional<StrOffsetsContributionDescriptor> &R) {

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

if (LowPC >= HighPC)
     return;
   Endpoints.emplace_back(LowPC, CUOffset, true);
   Endpoints.emplace_back(HighPC, CUOffset, false);
 }
 
 void DWARFDebugAranges::construct() {
   std::multiset<uint32_t> ValidCUs;  // Maintain the set of CUs describing
                                      // a current address range.
-  std::sort(Endpoints.begin(), Endpoints.end());
+  llvm::sort(Endpoints.begin(), Endpoints.end());
   uint64_t PrevAddress = -1ULL;
   for (const auto &E : Endpoints) {
     if (PrevAddress < E.Address && !ValidCUs.empty()) {
       // If the address range between two endpoints is described by some
       // CU, first try to extend the last range in Aranges. If we can't
       // do it, start a new range.
       if (!Aranges.empty() && Aranges.back().HighPC() == PrevAddress &&
           ValidCUs.find(Aranges.back().CUOffset) != ValidCUs.end()) {

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

bool DWARFDebugLine::LineTable::parse(DWARFDataExtractor &DebugLineData,
 
   if (!State.Sequence.Empty) {
     fprintf(stderr, "warning: last sequence in debug line table is not"
                     "terminated!\n");
   }
 
   // Sort all sequences so that address lookup will work faster.
   if (!Sequences.empty()) {
-    std::sort(Sequences.begin(), Sequences.end(), Sequence::orderByLowPC);
+    llvm::sort(Sequences.begin(), Sequences.end(), Sequence::orderByLowPC);
     // Note: actually, instruction address ranges of sequences should not
     // overlap (in shared objects and executables). If they do, the address
     // lookup would still work, though, but result would be ambiguous.
     // We don't report warning in this case. For example,
     // sometimes .so compiled from multiple object files contains a few
     // rudimentary sequences for address ranges [0x0, 0xsomething).
   }