From 99d0015735f8e2aee1a4b99e39ffdaadc8a1dba8 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 1 Dec 2008 06:49:59 +0000 Subject: 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 --- include/llvm/ADT/STLExtras.h | 39 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) (limited to 'include/llvm/ADT/STLExtras.h') diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h index e009939..ae1a1ab 100644 --- a/include/llvm/ADT/STLExtras.h +++ b/include/llvm/ADT/STLExtras.h @@ -204,7 +204,7 @@ inline tier 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 +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 +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); +} + } // End llvm namespace #endif -- cgit v1.1