[mlir] use stable_sort for OperationLegalizer::computeOpLegalizationDepth

[python3kgae]

Summary

For https://github.com/llvm/llvm-project/issues/60070.
llvm::array_pod_sort will cause non-determinism when select pattern.
It is exposed by difference between windows build and linux build.

[mehdi_amini]

Nice find!

mlir/lib/Transforms/Utils/DialectConversion.cpp

unsigned OperationLegalizer::applyCostModelToPatterns(
   }
 
   // If the operation only has one legalization pattern, there is no need to
   // sort them.
   if (patternsByDepth.size() == 1)
     return minDepth;
 
   // Sort the patterns by those likely to be the most beneficial.
-  llvm::array_pod_sort(patternsByDepth.begin(), patternsByDepth.end(),
-                       [](const std::pair<const Pattern *, unsigned> *lhs,
-                          const std::pair<const Pattern *, unsigned> *rhs) {
-                         // First sort by the smaller pattern legalization
-                         // depth.
-                         if (lhs->second != rhs->second)
-                           return llvm::array_pod_sort_comparator<unsigned>(
-                               &lhs->second, &rhs->second);
+  std::stable_sort(patternsByDepth.begin(), patternsByDepth.end(),
+                   [](const std::pair<const Pattern *, unsigned> &lhs,
+                      const std::pair<const Pattern *, unsigned> &rhs) {
+                     if (lhs.second != rhs.second)
+                       return lhs.second < rhs.second;
 
-                         // Then sort by the larger pattern benefit.
-                         auto lhsBenefit = lhs->first->getBenefit();
-                         auto rhsBenefit = rhs->first->getBenefit();
-                         return llvm::array_pod_sort_comparator<PatternBenefit>(
-                             &rhsBenefit, &lhsBenefit);
-                       });
+                     auto lhsBenefit = lhs.first->getBenefit();
+                     auto rhsBenefit = rhs.first->getBenefit();
+                     return lhsBenefit > rhsBenefit;
 
   // Update the legalization pattern to use the new sorted list.
   patterns.clear();
   for (auto &patternIt : patternsByDepth)
     patterns.push_back(patternIt.first);
   return minDepth;
 }