Index: src/private_typeinfo.h
===================================================================
--- src/private_typeinfo.h
+++ src/private_typeinfo.h
@@ -230,6 +230,7 @@
 public:
     __attribute__ ((__visibility__("hidden"))) virtual ~__pointer_type_info();
     __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+    __attribute__ ((__visibility__("hidden"))) bool can_catch_nested(const __shim_type_info*) const;
 };
 
 class __attribute__ ((__visibility__("default"))) __pointer_to_member_type_info
@@ -239,6 +240,8 @@
     const __class_type_info* __context;
 
     __attribute__ ((__visibility__("hidden"))) virtual ~__pointer_to_member_type_info();
+    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+    __attribute__ ((__visibility__("hidden"))) bool can_catch_nested(const __shim_type_info*) const;
 };
 
 #pragma GCC visibility pop
Index: src/private_typeinfo.cpp
===================================================================
--- src/private_typeinfo.cpp
+++ src/private_typeinfo.cpp
@@ -389,6 +389,24 @@
     // bullet 3A
     if (is_equal(__pointee, &typeid(void), false))
         return true;
+
+    // Handle pointer to pointer
+    const __pointer_type_info* nested_pointer_type =
+        dynamic_cast<const __pointer_type_info*>(__pointee);
+    if (nested_pointer_type) {
+        if (~__flags & __const_mask) return false;
+        return nested_pointer_type->can_catch_nested(thrown_pointer_type->__pointee);
+    }
+
+    // Handle pointer to pointer to member
+    const __pointer_to_member_type_info* member_ptr_type =
+        dynamic_cast<const __pointer_to_member_type_info*>(__pointee);
+    if (member_ptr_type) {
+        if (~__flags & __const_mask) return false;
+        return member_ptr_type->can_catch_nested(thrown_pointer_type->__pointee);
+    }
+
+    // Handle pointer to class type
     const __class_type_info* catch_class_type =
         dynamic_cast<const __class_type_info*>(__pointee);
     if (catch_class_type == 0)
@@ -409,6 +427,83 @@
     return false;
 }
 
+bool __pointer_type_info::can_catch_nested(
+    const __shim_type_info* thrown_type) const
+{
+  const __pointer_type_info* thrown_pointer_type =
+        dynamic_cast<const __pointer_type_info*>(thrown_type);
+    if (thrown_pointer_type == 0)
+        return false;
+    // bullet 3B
+    if (thrown_pointer_type->__flags & ~__flags)
+        return false;
+    if (is_equal(__pointee, thrown_pointer_type->__pointee, false))
+        return true;
+    // If the pointed to types differ then the catch type must be const
+    // qualified.
+    if (~__flags & __const_mask)
+        return false;
+
+    // Handle pointer to pointer
+    const __pointer_type_info* nested_pointer_type =
+        dynamic_cast<const __pointer_type_info*>(__pointee);
+    if (nested_pointer_type) {
+        return nested_pointer_type->can_catch_nested(
+            thrown_pointer_type->__pointee);
+    }
+
+    // Handle pointer to pointer to member
+    const __pointer_to_member_type_info* member_ptr_type =
+        dynamic_cast<const __pointer_to_member_type_info*>(__pointee);
+    if (member_ptr_type) {
+        return member_ptr_type->can_catch_nested(thrown_pointer_type->__pointee);
+    }
+
+    return false;
+}
+
+bool __pointer_to_member_type_info::can_catch(
+    const __shim_type_info* thrown_type, void*& adjustedPtr) const {
+    // bullets 1 and 4
+    if (__pbase_type_info::can_catch(thrown_type, adjustedPtr))
+        return true;
+
+    const __pointer_to_member_type_info* thrown_pointer_type =
+        dynamic_cast<const __pointer_to_member_type_info*>(thrown_type);
+    if (thrown_pointer_type == 0)
+        return false;
+    if (thrown_pointer_type->__flags & ~__flags)
+        return false;
+    if (!is_equal(__pointee, thrown_pointer_type->__pointee, false))
+        return false;
+    if (is_equal(__context, thrown_pointer_type->__context, false))
+        return true;
+
+    __dynamic_cast_info info = {__context, 0, thrown_pointer_type->__context, -1, 0};
+    info.number_of_dst_type = 1;
+    __context->has_unambiguous_public_base(&info, adjustedPtr, public_path);
+    if (info.path_dst_ptr_to_static_ptr == public_path)
+        return true;
+
+    return false;
+}
+
+bool __pointer_to_member_type_info::can_catch_nested(
+    const __shim_type_info* thrown_type) const
+{
+    const __pointer_to_member_type_info* thrown_member_ptr_type =
+        dynamic_cast<const __pointer_to_member_type_info*>(thrown_type);
+    if (thrown_member_ptr_type == 0)
+        return false;
+    if (~__flags & thrown_member_ptr_type->__flags)
+        return false;
+    if (!is_equal(__pointee, thrown_member_ptr_type->__pointee, false))
+        return false;
+    if (!is_equal(__context, thrown_member_ptr_type->__context, false))
+        return false;
+    return true;
+}
+
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
Index: test/catch_member_data_pointer_01.pass.cpp
===================================================================
--- test/catch_member_data_pointer_01.pass.cpp
+++ test/catch_member_data_pointer_01.pass.cpp
@@ -18,6 +18,15 @@
 typedef const int A::*md1;
 typedef       int A::*md2;
 
+struct B : public A
+{
+    const int k;
+    int l;
+};
+
+typedef const int B::*der1;
+typedef       int B::*der2;
+
 void test1()
 {
     try
@@ -34,19 +43,126 @@
     }
 }
 
+// Check that cv qualified conversions are allowed.
 void test2()
 {
     try
     {
         throw &A::j;
+    }
+    catch (md2)
+    {
+    }
+    catch (...)
+    {
+        assert(false);
+    }
+
+    try
+    {
+        throw &A::j;
         assert(false);
     }
     catch (md1)
     {
+    }
+    catch (...)
+    {
+        assert(false);
+    }
+}
+
+// Check that Base -> Derived conversions are allowed.
+void test3()
+{
+    try
+    {
+        throw &A::i;
         assert(false);
     }
     catch (md2)
     {
+        assert(false);
+    }
+    catch (der2)
+    {
+        assert(false);
+    }
+    catch (der1)
+    {
+    }
+    catch (md1)
+    {
+        assert(false);
+    }
+}
+
+// Check that Base -> Derived conversions are allowed with different cv
+// qualifiers.
+void test4()
+{
+    try
+    {
+        throw &A::j;
+        assert(false);
+    }
+    catch (der2)
+    {
+    }
+    catch (...)
+    {
+        assert(false);
+    }
+
+    try
+    {
+        throw &A::j;
+        assert(false);
+    }
+    catch (der1)
+    {
+    }
+    catch (...)
+    {
+        assert(false);
+    }
+}
+
+// Check that no Derived -> Base conversions are allowed.
+void test5()
+{
+    try
+    {
+        throw &B::k;
+        assert(false);
+    }
+    catch (md1)
+    {
+        assert(false);
+    }
+    catch (md2)
+    {
+        assert(false);
+    }
+    catch (der1)
+    {
+    }
+
+    try
+    {
+        throw &B::l;
+        assert(false);
+    }
+    catch (md1)
+    {
+        assert(false);
+    }
+    catch (md2)
+    {
+        assert(false);
+    }
+    catch (der2)
+    {
     }
 }
 
@@ -54,4 +170,7 @@
 {
     test1();
     test2();
+    test3();
+    test4();
+    test5();
 }
Index: test/catch_multi_level_pointer.pass.cpp
===================================================================
--- /dev/null
+++ test/catch_multi_level_pointer.pass.cpp
@@ -0,0 +1,145 @@
+//===--------------------- catch_pointer_nullptr.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+
+// Roll our own assertion macro to get better error messages out of the tests.
+// In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
+#define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)
+
+void do_assert(bool assert_passed, const char* msg, int line, const char* func) {
+  if (assert_passed) return;
+  std::cerr << __FILE__ << ":" << line << " " << func
+            << ": Assertion Failed `" << msg << "'\n\n";
+  std::abort();
+}
+
+struct A {};
+struct Base {};
+struct Derived : public Base {};
+
+template <class To>
+bool test_conversion(To) { return true; }
+
+template <class To>
+bool test_conversion(...) { return false; }
+
+template <class Pointer>
+struct CreatePointer {
+  Pointer operator()() const {
+      return (Pointer)0;
+  }
+};
+
+template <class Tp>
+struct CreatePointer<Tp*> {
+  Tp* operator()() const {
+      return (Tp*)42;
+  }
+};
+
+template <class Throw, class Catch>
+void catch_pointer_test() {
+  Throw throw_ptr = CreatePointer<Throw>()();
+  // Use the compiler to determine if the exception of type Throw can be
+  // implicitly converted to type Catch.
+  const bool can_convert = test_conversion<Catch>(throw_ptr);
+  try {
+    throw throw_ptr;
+    assert(false);
+  } catch (Catch catch_ptr) {
+    Catch catch2 = CreatePointer<Catch>()();
+    my_assert(can_convert, "non-convertible type incorrectly caught");
+    my_assert(catch_ptr == catch2,
+              "Thrown pointer does not match caught ptr");
+  } catch (...) {
+    my_assert(!can_convert, "convertible type incorrectly not caught");
+  }
+}
+
+// Generate CV qualified pointer typedefs.
+template <class Tp, bool First = false>
+struct TestTypes {
+  typedef Tp* Type;
+  typedef Tp const* CType;
+  typedef Tp volatile* VType;
+  typedef Tp const volatile* CVType;
+};
+
+// Special case for cv-qualifying a pointer-to-member without adding an extra
+// pointer to it.
+template <class Member, class Class>
+struct TestTypes<Member Class::*, true> {
+  typedef Member (Class::*Type);
+  typedef const Member (Class::*CType);
+  typedef volatile Member (Class::*VType);
+  typedef const volatile Member (Class::*CVType);
+};
+
+template <class Throw, class Catch, int level, bool first = false>
+struct generate_tests_imp {
+  typedef TestTypes<Throw, first> ThrowTypes;
+  typedef TestTypes<Catch, first> CatchTypes;
+  void operator()() {
+      typedef typename ThrowTypes::Type Type;
+      typedef typename ThrowTypes::CType CType;
+      typedef typename ThrowTypes::VType VType;
+      typedef typename ThrowTypes::CVType CVType;
+
+      run_catch_tests<Type>();
+      run_catch_tests<CType>();
+      run_catch_tests<VType>();
+      run_catch_tests<CVType>();
+  }
+
+  template <class ThrowTp>
+  void run_catch_tests() {
+      typedef typename CatchTypes::Type Type;
+      typedef typename CatchTypes::CType CType;
+      typedef typename CatchTypes::VType VType;
+      typedef typename CatchTypes::CVType CVType;
+
+      catch_pointer_test<ThrowTp, Type>();
+      catch_pointer_test<ThrowTp, CType>();
+      catch_pointer_test<ThrowTp, VType>();
+      catch_pointer_test<ThrowTp, CVType>();
+
+      generate_tests_imp<ThrowTp, Type, level-1>()();
+      generate_tests_imp<ThrowTp, CType, level-1>()();
+      generate_tests_imp<ThrowTp, VType, level-1>()();
+      generate_tests_imp<ThrowTp, CVType, level-1>()();
+  }
+};
+
+template <class Throw, class Catch, bool first>
+struct generate_tests_imp<Throw, Catch, 0, first> {
+  void operator()() {
+      catch_pointer_test<Throw, Catch>();
+  }
+};
+
+template <class Throw, class Catch, int level>
+struct generate_tests : generate_tests_imp<Throw, Catch, level, true> {};
+
+int main()
+{
+  generate_tests<int, int, 3>()();
+  generate_tests<Base, Derived, 2>()();
+  generate_tests<Derived, Base, 2>()();
+  generate_tests<int, void, 2>()();
+  generate_tests<void, int, 2>()();
+
+  generate_tests<int A::*, int A::*, 3>()();
+  generate_tests<int A::*, void, 2>()();
+  generate_tests<void, int A::*, 2>()();
+  generate_tests<int Base::*, int Derived::*, 2>()();
+  generate_tests<int Derived::*, int Base::*, 2>()();
+}
Index: test/catch_pointer_nullptr.pass.cpp
===================================================================
--- test/catch_pointer_nullptr.pass.cpp
+++ test/catch_pointer_nullptr.pass.cpp
@@ -8,6 +8,13 @@
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
+#include <cstdlib>
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+struct A {};
 
 #if __has_feature(cxx_nullptr)
 
@@ -27,8 +34,6 @@
     }
 }
 
-struct A {};
-
 void test2()
 {
     try
@@ -45,6 +50,18 @@
     }
 }
 
+template <class Catch>
+void catch_nullptr_test() {
+  try {
+    throw nullptr;
+    assert(false);
+  } catch (Catch) {
+    // nothing todo
+  } catch (...) {
+    assert(false);
+  }
+}
+
 #else
 
 void test1()
@@ -55,10 +72,22 @@
 {
 }
 
+template <class Catch>
+void catch_nullptr_test()
+{
+}
+
 #endif
 
 int main()
 {
-    test1();
-    test2();
+  // catch naked nullptrs
+  test1();
+  test2();
+
+  catch_nullptr_test<int*>();
+  catch_nullptr_test<int**>();
+  catch_nullptr_test<int A::*>();
+  catch_nullptr_test<const int A::*>();
+  catch_nullptr_test<int A::**>();
 }