Introduce a new array_pod_sort function and switch LSR to use it

instead of std::sort.  This shrinks the release-asserts LSR.o file
by 1100 bytes of code on my system.

We should start using array_pod_sort where possible.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60335 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h
index e009939cec190726e5808f431ed7cadefd59295c..ae1a1abefda45cbb9a9c4bfe668627db1420016e 100644 (file)
--- a/include/llvm/ADT/STLExtras.h
+++ b/include/llvm/ADT/STLExtras.h
@@ -204,7 +204,7 @@ inline tier<T1, T2> tie(T1& f, T2& s) {
 }
 
 //===----------------------------------------------------------------------===//
-//     Extra additions to arrays
+//     Extra additions for arrays
 //===----------------------------------------------------------------------===//
 
 /// Find where an array ends (for ending iterators)
@@ -221,6 +221,43 @@ inline size_t array_lengthof(T (&x)[N]) {
   return N;
 }
 
+/// array_pod_sort_comparator - This is helper function for array_pod_sort,
+/// which does a memcmp of a specific size.
+template<unsigned Size>
+static inline int array_pod_sort_comparator(const void *P1, const void *P2) {
+  if (Size == sizeof(char))
+    return *(const char*)P1 - *(const char*)P2;
+  if (Size == sizeof(int))
+    return *(const int*)P1 - *(const int*)P2;
+  if (Size == sizeof(long long))
+    return *(const long long*)P1 - *(const long long*)P2;
+  if (Size == sizeof(intptr_t))
+    return *(intptr_t*)P1 - *(intptr_t*)P2;
+  return memcmp(P1, P2, Size);
+}
+
+/// array_pod_sort - This sorts an array with the specified start and end
+/// extent.  This is just like std::sort, except that it calls qsort instead of
+/// using an inlined template.  qsort is slightly slower than std::sort, but
+/// most sorts are not performance critical in LLVM and std::sort has to be
+/// template instantiated for each type, leading to significant measured code
+/// bloat.  This function should generally be used instead of std::sort where
+/// possible.
+///
+/// This function assumes that you have simple POD-like types that can be
+/// compared with memcmp and can be moved with memcpy.  If this isn't true, you
+/// should use std::sort.
+///
+/// NOTE: If qsort_r were portable, we could allow a custom comparator and
+/// default to std::less.
+template<class IteratorTy>
+static inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
+  // Don't dereference start iterator of empty sequence.
+  if (Start == End) return;
+  qsort(Start, End-Start, sizeof(*Start),
+        array_pod_sort_comparator<sizeof(*Start)>);
+}
+  
 } // End llvm namespace
 
 #endif

diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index 11c56ffebdcdefefd5896a194f8d9a8d5ffa08d8..78bd50e98a41f6379b240ac8f0023651b77a7acf 100644 (file)
--- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -243,7 +243,7 @@ void LoopStrengthReduce::DeleteTriviallyDeadInstructions() {
   // Sort the deadinsts list so that we can trivially eliminate duplicates as we
   // go.  The code below never adds a non-dead instruction to the worklist, but
   // callers may not be so careful.
-  std::sort(DeadInsts.begin(), DeadInsts.end());
+  array_pod_sort(DeadInsts.begin(), DeadInsts.end());
 
   // Drop duplicate instructions and those with uses.
   for (unsigned i = 0, e = DeadInsts.size()-1; i < e; ++i) {