Index: include/__functional_03
===================================================================
--- include/__functional_03
+++ include/__functional_03
@@ -451,15 +451,6 @@
     aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
-    template <class _Fp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const _Fp&) {return true;}
-    template <class _R2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (*__p)()) {return __p;}
-    template <class _R2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const function<_R2()>& __p) {return __p;}
 public:
     typedef _Rp result_type;
 
@@ -558,7 +549,7 @@
                                      typename enable_if<!is_integral<_Fp>::value>::type*)
     : __f_(0)
 {
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp()> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -585,7 +576,7 @@
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp()> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -736,27 +727,6 @@
     aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
-    template <class _Fp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const _Fp&) {return true;}
-    template <class _R2, class _B0>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (*__p)(_B0)) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)()) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() const) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() volatile) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() const volatile) {return __p;}
-    template <class _R2, class _B0>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const function<_R2(_B0)>& __p) {return __p;}
 public:
     typedef _Rp result_type;
 
@@ -855,7 +825,7 @@
                                      typename enable_if<!is_integral<_Fp>::value>::type*)
     : __f_(0)
 {
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -882,7 +852,7 @@
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp(_A0)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -1033,27 +1003,6 @@
     aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
-    template <class _Fp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const _Fp&) {return true;}
-    template <class _R2, class _B0, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (*__p)(_B0, _B1)) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1)) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) const) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) volatile) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) const volatile) {return __p;}
-    template <class _R2, class _B0, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const function<_R2(_B0, _B1)>& __p) {return __p;}
 public:
     typedef _Rp result_type;
 
@@ -1152,7 +1101,7 @@
                                  typename enable_if<!is_integral<_Fp>::value>::type*)
     : __f_(0)
 {
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -1179,7 +1128,7 @@
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -1329,27 +1278,6 @@
     aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
-    template <class _Fp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const _Fp&) {return true;}
-    template <class _R2, class _B0, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (*__p)(_B0, _B1, _B2)) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2)) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) volatile) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const volatile) {return __p;}
-    template <class _R2, class _B0, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const function<_R2(_B0, _B1, _B2)>& __p) {return __p;}
 public:
     typedef _Rp result_type;
 
@@ -1449,7 +1377,7 @@
                                      typename enable_if<!is_integral<_Fp>::value>::type*)
     : __f_(0)
 {
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1, _A2)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
@@ -1476,7 +1404,7 @@
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_))
Index: include/functional
===================================================================
--- include/functional
+++ include/functional
@@ -1331,6 +1331,22 @@
 {
 };
 
+template <class _Fp>
+_LIBCPP_INLINE_VISIBILITY
+bool __not_null(_Fp const&) { return true; }
+
+template <class _Fp>
+_LIBCPP_INLINE_VISIBILITY
+bool __not_null(_Fp* __ptr) { return __ptr; }
+
+template <class _Ret, class _Class>
+_LIBCPP_INLINE_VISIBILITY
+bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
+
+template <class _Fp>
+_LIBCPP_INLINE_VISIBILITY
+bool __not_null(function<_Fp> const& __f) { return !!__f; }
+
 } // namespace __function
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -1472,28 +1488,6 @@
     typename aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
-    template <class _Fp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const _Fp&) {return true;}
-    template <class _R2, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
-    template <class _R2, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(const function<_R2(_Ap...)>& __p) {return !!__p;}
-
     template <class _Fp, bool = !is_same<_Fp, function>::value &&
                                 __invokable<_Fp&, _ArgTypes...>::value>
         struct __callable;
@@ -1658,7 +1652,7 @@
                                      >::type*)
     : __f_(0)
 {
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
@@ -1685,7 +1679,7 @@
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    if (__not_null(__f))
+    if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
         typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
@@ -0,0 +1,247 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// class function<R(ArgTypes...)>
+
+// function(Fp);
+
+// Ensure that __not_null works for all function types.
+// See https://llvm.org/bugs/show_bug.cgi?id=23589
+
+//------------------------------------------------------------------------------
+// TESTING std::function<...>::__not_null(Callable)
+//
+// Concerns:
+//  1) The call __not_null(Callable) is well formed and correct for each
+//     possible 'Callable' type category. These categories include:
+//      1a) function pointers
+//      1b) member function pointer
+//      1c) member data pointer
+//      1d) callable class type
+//      1e) lambdas
+//    Categories 1a, 1b, and 1c are 'Nullable' types. Only objects of these
+//    types can be null. The other categories are not tested here.
+//  3) '__not_null(Callable)' is well formed when the call signature includes
+//      varargs.
+//  4) '__not_null(Callable)' works for Callable types with all aritys less
+//     than or equal to 3 in C++03.
+//  5) '__not_null(Callable)' works when 'Callable' is a member function
+//     pointer to a cv or ref qualified function type.
+//
+// Plan:
+//  1 For categories 1a, 1b and 1c define a set of
+//    'Callable' objects for this category. This set should include examples
+//    of arity 0, 1, 2 and possible 3 including versions with varargs as the
+//    last parameter.
+//
+//  2 For each 'Callable' object in categories 1a, 1b and 1c do the following.
+//
+//    1 Define a type 'std::function<Sig>' as 'F' where 'Sig' is compatible with
+//      the signature of the 'Callable' object.
+//
+//    2 Create an object of type 'F' using a null pointer of type 'Callable'.
+//      Check that 'F.target<Callable>()' is null.
+//
+//    3 Create an object of type 'F' that is not null. Check that
+//      'F.target<Callable>()' is not null and is equal to the original
+//      argument.
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+///////////////////////////////////////////////////////////////////////////////
+int foo() { return 42; }
+int foo(int) { return 42; }
+int foo(int, int) { return 42; }
+int foo(int, int, int) { return 42; }
+
+int foo(...) { return 42; }
+int foo(int, ...) { return 42; }
+int foo(int, int, ...) { return 42; }
+int foo(int, int, int, ...) { return 42; }
+
+///////////////////////////////////////////////////////////////////////////////
+struct MemFun03 {
+    int foo() { return 42; }
+    int foo() const { return 42; }
+    int foo() volatile { return 42; }
+    int foo() const volatile { return 42; }
+
+    int foo(int) { return 42; }
+    int foo(int) const { return 42; }
+    int foo(int) volatile { return 42; }
+    int foo(int) const volatile { return 42; }
+
+    int foo(int, int) { return 42; }
+    int foo(int, int) const { return 42; }
+    int foo(int, int) volatile { return 42; }
+    int foo(int, int) const volatile { return 42; }
+
+    int foo(int, int, int) { return 42; }
+    int foo(int, int, int) const { return 42; }
+    int foo(int, int, int) volatile { return 42; }
+    int foo(int, int, int) const volatile { return 42; }
+
+    int foo(...) { return 42; }
+    int foo(...) const { return 42; }
+    int foo(...) volatile { return 42; }
+    int foo(...) const volatile { return 42; }
+
+    int foo(int, ...) { return 42; }
+    int foo(int, ...) const { return 42; }
+    int foo(int, ...) volatile { return 42; }
+    int foo(int, ...) const volatile { return 42; }
+
+    int foo(int, int, ...) { return 42; }
+    int foo(int, int, ...) const { return 42; }
+    int foo(int, int, ...) volatile { return 42; }
+    int foo(int, int, ...) const volatile { return 42; }
+
+    int foo(int, int, int, ...) { return 42; }
+    int foo(int, int, int, ...) const { return 42; }
+    int foo(int, int, int, ...) volatile { return 42; }
+    int foo(int, int, int, ...) const volatile { return 42; }
+};
+
+#if TEST_STD_VER >= 11
+struct MemFun11 {
+    int foo() & { return 42; }
+    int foo() const & { return 42; }
+    int foo() volatile & { return 42; }
+    int foo() const volatile & { return 42; }
+
+    int foo(...) & { return 42; }
+    int foo(...) const & { return 42; }
+    int foo(...) volatile & { return 42; }
+    int foo(...) const volatile & { return 42; }
+
+    int foo() && { return 42; }
+    int foo() const && { return 42; }
+    int foo() volatile && { return 42; }
+    int foo() const volatile && { return 42; }
+
+    int foo(...) && { return 42; }
+    int foo(...) const && { return 42; }
+    int foo(...) volatile && { return 42; }
+    int foo(...) const volatile && { return 42; }
+};
+#endif // TEST_STD_VER >= 11
+
+struct MemData {
+    int foo;
+};
+
+// Create a non-null free function by taking the address of
+// &static_cast<Tp&>(foo);
+template <class Tp>
+struct Creator {
+    static Tp create() {
+        return &foo;
+    }
+};
+
+// Create a non-null member pointer.
+template <class Ret, class Class>
+struct Creator<Ret Class::*> {
+    typedef Ret Class::*ReturnType;
+    static ReturnType create() {
+        return &Class::foo;
+    }
+};
+
+template <class TestFn, class Fn>
+void test_imp() {
+    { // Check that the null value is detected
+        TestFn tf = nullptr;
+        std::function<Fn> f = tf;
+        assert(f.template target<TestFn>() == nullptr);
+    }
+    { // Check that the non-null value is detected.
+        TestFn tf = Creator<TestFn>::create();
+        assert(tf != nullptr);
+        std::function<Fn> f = tf;
+        assert(f.template target<TestFn>() != nullptr);
+        assert(*f.template target<TestFn>() == tf);
+    }
+}
+
+void test_func() {
+    test_imp<int(*)(), int()>();
+    test_imp<int(*)(...), int()>();
+    test_imp<int(*)(int), int(int)>();
+    test_imp<int(*)(int, ...), int(int)>();
+    test_imp<int(*)(int, int), int(int, int)>();
+    test_imp<int(*)(int, int, ...), int(int, int)>();
+    test_imp<int(*)(int, int, int), int(int, int, int)>();
+    test_imp<int(*)(int, int, int, ...), int(int, int, int)>();
+}
+
+void test_mf() {
+    test_imp<int(MemFun03::*)(), int(MemFun03&)>();
+    test_imp<int(MemFun03::*)(...), int(MemFun03&)>();
+    test_imp<int(MemFun03::*)() const, int(MemFun03&)>();
+    test_imp<int(MemFun03::*)(...) const, int(MemFun03&)>();
+    test_imp<int(MemFun03::*)() volatile, int(MemFun03&)>();
+    test_imp<int(MemFun03::*)(...) volatile, int(MemFun03&)>();
+    test_imp<int(MemFun03::*)() const volatile, int(MemFun03&)>();
+    test_imp<int(MemFun03::*)(...) const volatile, int(MemFun03&)>();
+
+    test_imp<int(MemFun03::*)(int), int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int, ...), int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int) const, int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int, ...) const, int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int) volatile, int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int, ...) volatile, int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int) const volatile, int(MemFun03&, int)>();
+    test_imp<int(MemFun03::*)(int, ...) const volatile, int(MemFun03&, int)>();
+
+    test_imp<int(MemFun03::*)(int, int), int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int, ...), int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int) const, int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int, ...) const, int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int) volatile, int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int, ...) volatile, int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int) const volatile, int(MemFun03&, int, int)>();
+    test_imp<int(MemFun03::*)(int, int, ...) const volatile, int(MemFun03&, int, int)>();
+
+#if TEST_STD_VER >= 11
+    test_imp<int(MemFun11::*)() &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)(...) &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)() const &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)(...) const &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)() volatile &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)(...) volatile &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)() const volatile &, int(MemFun11&)>();
+    test_imp<int(MemFun11::*)(...) const volatile &, int(MemFun11&)>();
+
+    test_imp<int(MemFun11::*)() &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)(...) &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)() const &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)(...) const &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)() volatile &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)(...) volatile &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)() const volatile &&, int(MemFun11&&)>();
+    test_imp<int(MemFun11::*)(...) const volatile &&, int(MemFun11&&)>();
+#endif
+}
+
+void test_md() {
+    test_imp<int MemData::*, int(MemData&)>();
+}
+
+int main() {
+    test_func();
+    test_mf();
+    test_md();
+}