[libcxx] Add global assertion handler for debug mode.

[EricWF]

Summary

This patch adds a global assertion handler that is called when _LIBCPP_ASSERT fails. This allows us to test debug mode features without _LIBCPP_ASSERT always calling abort().

This patch also fixes PR17147 and uses the new assertion handlers in the tests. (see https://llvm.org/bugs/show_bug.cgi?id=17147)

[EricWF]

Remove all functions in the dylib and make them inline.

[EricWF]

Cleanup the diff and remove extra changes.

[dexonsmith]

This patch looks correct to me. Is there any reason it wasn't committed?

[EricWF]

In D12354#331776, @dexonsmith wrote:

This patch looks correct to me. Is there any reason it wasn't committed?

I was concerned about using a function-local static in the library headers, I don't think libc++ does that anywhere else and I wanted to make sure it was safe to do.

include/__debug

 #   include <cstdio>
 #   include <cstddef>
 #   ifndef _LIBCPP_ASSERT
-#      define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::fprintf(stderr, "%s\n", m), _VSTD::abort()))
+#      define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::__debug_assert(__FILE__, __func__, __LINE__, m)))
 #   endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __debug_assertion_info {
+    const char* __file_;
+    const char* __func_;
+    unsigned long __line_;
+    const char* __msg_;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void __print() const {
+        _VSTD::fprintf(stderr, "%s:%lu: %s: %s\n", __file_, __line_, __func_, __msg_);
+    }
+};
+
+typedef void (*__debug_assertion_handler_t)(__debug_assertion_info const&);
+
+inline void __default_debug_handler(__debug_assertion_info const& __info) {
+    __info.__print();
+    _VSTD::abort();
+}
+
+inline __debug_assertion_handler_t
+__debug_assertion_handler(__debug_assertion_handler_t __new_handle = nullptr) {
+    static __debug_assertion_handler_t __handle_ = &__default_debug_handler;
+    __debug_assertion_handler_t __old = __handle_;
+    if (__new_handle) __handle_ = __new_handle;
+    return __old;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline void __debug_assert(const char* __file, const char* __func,
+                          unsigned long __line, const char* __msg)
+{
+    __debug_assertion_info __info = {__file, __func, __line, __msg};
+    __debug_assertion_handler()(__info);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
 #endif
 
 #ifndef _LIBCPP_ASSERT

include/algorithm

 
 #ifdef _LIBCPP_DEBUG
 
+template <class _Compare, class _LHS, class _RHS, class = void>
+struct __debug_is_comparable : false_type {};
+
+template <class _Compare, class _LHS, class _RHS>
+struct __debug_is_comparable<_Compare, _LHS, _RHS,
+    typename __void_t<decltype(
+        _VSTD::declval<_Compare>()(_VSTD::declval<_LHS>(), _VSTD::declval<_RHS>())
+    )>::type
+> : true_type {};
+
+
 template <class _Compare>
 struct __debug_less
 {

     template <class _Tp, class _Up>
     bool operator()(const _Tp& __x, const _Up& __y)
     {
+        typedef typename __debug_is_comparable<_Compare, _Up const&, _Tp const&>::type
+            _CanCompare;
         bool __r = __comp_(__x, __y);
         if (__r)
-            _LIBCPP_ASSERT(!__comp_(__y, __x), "Comparator does not induce a strict weak ordering");
+            __do_compare_assert(__y, __x, _CanCompare());
         return __r;
     }
+
+    template <class _LHS, class _RHS>
+    void __do_compare_assert(_LHS const&, _RHS const&, false_type) {}
+
+    template <class _LHS, class _RHS>
+    void __do_compare_assert(_LHS const& __l, _RHS const& __r, true_type) {
+        _LIBCPP_ASSERT(!__comp_(__l, __r), "Comparator does not induce a strict weak ordering");
+    }
+
 };
 
 #endif  // _LIBCPP_DEBUG

test/libcxx/algorithms/debug_less.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// template <class _Compare> struct __debug_less
+
+// __debug_less checks that a comparator actually provides a strict-weak ordering.
+
+#define _LIBCPP_DEBUG 0
+#include "debug_mode.h"
+
+#include <algorithm>
+#include <cassert>
+
+template <int ID>
+struct MyType {
+    int value;
+    explicit MyType(int xvalue = 0) : value(xvalue) {}
+};
+
+template <int ID1, int ID2>
+bool operator<(MyType<ID1> const& LHS, MyType<ID2> const& RHS) {
+    return LHS.value < RHS.value;
+}
+
+struct CompareBase {
+    static int called;
+    static void reset() {
+        called = 0;
+    }
+};
+
+int CompareBase::called = 0;
+
+template <class ValueType>
+struct GoodComparator : public CompareBase {
+    bool operator()(ValueType const& lhs, ValueType const& rhs) const {
+        ++CompareBase::called;
+        return lhs < rhs;
+    }
+};
+
+template <class ValueType>
+struct BadComparator : public CompareBase {
+    bool operator()(ValueType const&, ValueType const&) const {
+        ++CompareBase::called;
+        return true;
+    }
+};
+
+template <class T1, class T2>
+struct TwoWayHomoComparator : public CompareBase {
+    bool operator()(T1 const& lhs, T2 const& rhs) const {
+        ++CompareBase::called;
+        return lhs < rhs;
+    }
+
+    bool operator()(T2 const& lhs, T1 const& rhs) const {
+        ++CompareBase::called;
+        return lhs < rhs;
+    }
+};
+
+template <class T1, class T2>
+struct OneWayHomoComparator : public CompareBase {
+    bool operator()(T1 const& lhs, T2 const& rhs) const {
+        ++CompareBase::called;
+        return lhs < rhs;
+    }
+};
+
+using std::__debug_less;
+
+typedef MyType<0> MT0;
+typedef MyType<1> MT1;
+
+void test_passing() {
+    int& called = CompareBase::called;
+    called = 0;
+    MT0 one(1);
+    MT0 two(2);
+    MT1 three(3);
+    MT1 four(4);
+
+    {
+        typedef GoodComparator<MT0> C;
+        typedef __debug_less<C> D;
+
+        C c;
+        D d(c);
+
+        assert(d(one, two) == true);
+        assert(called == 2);
+        called = 0;
+
+        assert(d(one, one) == false);
+        assert(called == 1);
+        called = 0;
+
+        assert(d(two, one) == false);
+        assert(called == 1);
+        called = 0;
+    }
+    {
+        typedef TwoWayHomoComparator<MT0, MT1> C;
+        typedef __debug_less<C> D;
+        C c;
+        D d(c);
+
+        assert(d(one, three) == true);
+        assert(called == 2);
+        called = 0;
+
+        assert(d(three, one) == false);
+        assert(called == 1);
+        called = 0;
+    }
+    {
+        typedef OneWayHomoComparator<MT0, MT1> C;
+        typedef __debug_less<C> D;
+        C c;
+        D d(c);
+
+        assert(d(one, three) == true);
+        assert(called == 1);
+        called = 0;
+    }
+}
+
+void test_failing() {
+    int& called = CompareBase::called;
+    called = 0;
+    MT0 one(1);
+    MT0 two(2);
+
+    {
+        typedef BadComparator<MT0> C;
+        typedef __debug_less<C> D;
+        C c;
+        D d(c);
+
+        try {
+            d(one, two);
+            assert(false);
+        } catch (DebugException const&) {
+        }
+
+        assert(called == 2);
+        called = 0;
+    }
+}
+
+int main() {
+    getDebugHandler(&throwingDebugHandler);
+    test_passing();
+    test_failing();
+}
 No newline at end of file

test/support/debug_mode.h

+#ifndef SUPPORT_DEBUG_MODE_H
+#define SUPPORT_DEBUG_MODE_H
+
+#ifndef _LIBCPP_DEBUG
+#error _LIBCPP_DEBUG must be defined before including the header
+#endif
+#ifdef _LIBCPP_CONFIG
+#error debug_mode.h must be included before any libc++ files
+#endif
+
+#include <__debug>
+#include <cstdlib>
+
+typedef std::__debug_assertion_handler_t DebugHandlerT;
+typedef std::__debug_assertion_info DebugInfo;
+
+inline DebugHandlerT getDebugHandler(DebugHandlerT new_h = nullptr) {
+    return std::__debug_assertion_handler(new_h);
+}
+
+void exitZeroHandler(DebugInfo const&) {
+    std::exit(0);
+}
+
+struct DebugException {
+    DebugInfo info;
+    DebugException(DebugInfo xinfo) : info(xinfo) {}
+};
+
+inline void throwingDebugHandler(DebugInfo const& info) {
+    throw DebugException(info);
+}
+
+#endif // SUPPORT_DEBUG_MODE_H