qsort_chk: call from gcc_qsort instead of wrapping it

	* sort.cc (gcc_qsort) [CHECKING_P]: Call qsort_chk.
	* system.h (qsort): Always redirect to gcc_qsort.  Update comment.
	* vec.c (qsort_chk): Do not call gcc_qsort.  Update comment.

From-SVN: r264065

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4b5669c88e9313a5a20147927c763de2e32df2cd..bfa9ce6a76e297c248c013a4af22f53459a92ad8 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2018-09-03  Alexander Monakov  <amonakov@ispras.ru>
+
+       * sort.cc (gcc_qsort) [CHECKING_P]: Call qsort_chk.
+       * system.h (qsort): Always redirect to gcc_qsort.  Update comment.
+       * vec.c (qsort_chk): Do not call gcc_qsort.  Update comment.
+
 2018-09-03  Segher Boessenkool  <segher@kernel.crashing.org>
 
        * config/rs6000/rs6000.md (*mov<mode>_hardfloat32): Remove %U from the

diff --git a/gcc/sort.cc b/gcc/sort.cc
index 293e2058f8944c66c60f56cf15c14f2ec4381182..9f8ee12e13b323c2a6d33216360a41f7490d8c31 100644 (file)
--- a/gcc/sort.cc
+++ b/gcc/sort.cc
@@ -229,4 +229,7 @@ gcc_qsort (void *vbase, size_t n, size_t size, cmp_fn *cmp)
   mergesort (base, &c, n, base, (char *)buf);
   if (buf != scratch)
     free (buf);
+#if CHECKING_P
+  qsort_chk (vbase, n, size, cmp);
+#endif
 }

diff --git a/gcc/system.h b/gcc/system.h
index f87fbaae69efcce254eacbb1f4418d2b6de29254..203c6a4f0cfc0b6e8fea8e2522f27727f54d66dc 100644 (file)
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -1197,17 +1197,13 @@ helper_const_non_const_cast (const char *p)
 /* Get definitions of HOST_WIDE_INT.  */
 #include "hwint.h"
 
-/* qsort comparator consistency checking: except in release-checking compilers,
-   redirect 4-argument qsort calls to qsort_chk; keep 1-argument invocations
+/* GCC qsort API-compatible functions: except in release-checking compilers,
+   redirect 4-argument qsort calls to gcc_qsort; keep 1-argument invocations
    corresponding to vec::qsort (cmp): they use C qsort internally anyway.  */
 void qsort_chk (void *, size_t, size_t, int (*)(const void *, const void *));
 void gcc_qsort (void *, size_t, size_t, int (*)(const void *, const void *));
 #define PP_5th(a1, a2, a3, a4, a5, ...) a5
 #undef qsort
-#if CHECKING_P
-#define qsort(...) PP_5th (__VA_ARGS__, qsort_chk, 3, 2, qsort, 0) (__VA_ARGS__)
-#else
 #define qsort(...) PP_5th (__VA_ARGS__, gcc_qsort, 3, 2, qsort, 0) (__VA_ARGS__)
-#endif
 
 #endif /* ! GCC_SYSTEM_H */

diff --git a/gcc/vec.c b/gcc/vec.c
index beb857fd83885ba2282b393899581f461f1decfd..ac3226b5fcbf5f57f3b14f56ff3383f1fd77f4bb 100644 (file)
--- a/gcc/vec.c
+++ b/gcc/vec.c
@@ -201,21 +201,12 @@ qsort_chk_error (const void *p1, const void *p2, const void *p3,
   internal_error ("qsort checking failed");
 }
 
-/* Wrapper around qsort with checking that CMP is consistent on given input.
-
-   Strictly speaking, passing invalid (non-transitive, non-anti-commutative)
-   comparators to libc qsort can result in undefined behavior.  Therefore we
-   should ideally perform consistency checks prior to invoking qsort, but in
-   order to do that optimally we'd need to sort the array ourselves beforehand
-   with a sorting routine known to be "safe".  Instead, we expect that most
-   implementations in practice will still produce some permutation of input
-   array even for invalid comparators, which enables us to perform checks on
-   the output array.  */
+/* Verify anti-symmetry and transitivity for comparator CMP on sorted array
+   of N SIZE-sized elements pointed to by BASE.  */
 void
 qsort_chk (void *base, size_t n, size_t size,
           int (*cmp)(const void *, const void *))
 {
-  gcc_qsort (base, n, size, cmp);
 #if 0
 #define LIM(n) (n)
 #else