[libcxxabi] When catching an exception of type nullptr_t with a handler of pointer-to-member type, produce a null value of the right type

[rsmith]

Summary

This fixes a bug where throwing an exception of type nullptr_t and catching it as a pointer-to-member would not guarantee to produce a null value in the catch handler. The fix is pretty simple: we statically allocate a constant null pointer-to-data-member representation and a constant null pointer-to-member-function representation, and produce the address of the relevant value as the adjusted pointer for the exception.

[rsmith]

src/CMakeLists.txt

94

Err, ignore this :)

[EricWF]

LGTM.

[rsmith]

Committed as r276016.

src/CMakeLists.txt

 string(REPLACE ";" " " LIBCXXABI_LINK_FLAGS "${LIBCXXABI_LINK_FLAGS}")
 string(REPLACE ";" " " LIBCXXABI_SHARED_LINK_FLAGS "${LIBCXXABI_SHARED_LINK_FLAGS}")
 
 # Add a object library that contains the compiled source files.
 add_library(cxxabi_objects OBJECT ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
 
 set_target_properties(cxxabi_objects
   PROPERTIES
-    COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
+    COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS} -fno-modules"
   )
 
 set(LIBCXXABI_TARGETS)
 
 # Build the shared library.
 if (LIBCXXABI_ENABLE_SHARED)
   add_library(cxxabi_shared SHARED $<TARGET_OBJECTS:cxxabi_objects>)
   target_link_libraries(cxxabi_shared ${libraries})

src/private_typeinfo.cpp

 // 
 // catch (A& a) : adjustedPtr == &a
 // catch (A* a) : adjustedPtr == a
 // catch (A** a) : adjustedPtr == a
 // 
 // catch (D2& d2) : adjustedPtr == &d2  (d2 is base class of thrown object)
 // catch (D2* d2) : adjustedPtr == d2
 // catch (D2*& d2) : adjustedPtr == d2
-// 
+//
 // catch (...) : adjustedPtr == & of the exception
+//
+// If the thrown type is nullptr_t and the caught type is a pointer to
+// member type, adjustedPtr points to a statically-allocated null pointer
+// representation of that type.
 
 // Handles bullet 1
 bool
 __fundamental_type_info::can_catch(const __shim_type_info* thrown_type,
                                    void*&) const
 {
     return is_equal(this, thrown_type, false);
 }
else
                 p->has_unambiguous_public_base(info, adjustedPtr, path_below);
                 if (info->search_done)
                     break;
             } while (++p < e);
         }
     }
 }
 
-// Handles bullets 1 and 4 for both pointers and member pointers
+// Handles bullet 1 for both pointers and member pointers
 bool
 __pbase_type_info::can_catch(const __shim_type_info* thrown_type,
                              void*&) const
 {
-    if (is_equal(thrown_type, &typeid(std::nullptr_t), false)) return true;
     bool use_strcmp = this->__flags & (__incomplete_class_mask |
                                        __incomplete_mask);
     if (!use_strcmp) {
         const __pbase_type_info* thrown_pbase = dynamic_cast<const __pbase_type_info*>(
                 thrown_type);
         if (!thrown_pbase) return false;
         use_strcmp = thrown_pbase->__flags & (__incomplete_class_mask |
                                               __incomplete_mask);
     }
     return is_equal(this, thrown_type, use_strcmp);
 }
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
 #endif
 
 // Handles bullets 1, 3 and 4
 // NOTE: It might not be safe to adjust the pointer if it is not not a pointer
 // type. Only adjust the pointer after we know it is safe to do so.
 bool
 __pointer_type_info::can_catch(const __shim_type_info* thrown_type,
                                void*& adjustedPtr) const
 {
-    // bullets 1 and 4
+    // bullet 4
+    if (is_equal(thrown_type, &typeid(std::nullptr_t), false)) {
+      adjustedPtr = nullptr;
+      return true;
+    }
+
+    // bullet 1
     if (__pbase_type_info::can_catch(thrown_type, adjustedPtr)) {
         if (adjustedPtr != NULL)
             adjustedPtr = *static_cast<void**>(adjustedPtr);
         return true;
     }
     // bullet 3
     const __pointer_type_info* thrown_pointer_type =
         dynamic_cast<const __pointer_type_info*>(thrown_type);
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
+    // bullet 4
+    if (is_equal(thrown_type, &typeid(std::nullptr_t), false)) {
+      // We assume that the pointer to member representation is the same for
+      // all pointers to data members and for all pointers to member functions.
+      struct X {};
+      if (dynamic_cast<const __function_type_info*>(__pointee)) {
+        static int (X::*const null_ptr_rep)() = nullptr;
+        adjustedPtr = const_cast<int (X::**)()>(&null_ptr_rep);
+      } else {
+        static int X::*const null_ptr_rep = nullptr;
+        adjustedPtr = const_cast<int X::**>(&null_ptr_rep);
+      }
+      return true;
+    }
+
+    // bullet 1
     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)

test/catch_const_pointer_nullptr.pass.cpp

 
 void test1()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (A*)
+    catch (A* p)
     {
+        assert(!p);
     }
     catch (const A*)
     {
         assert(false);
     }
 }
 
 
 void test2()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (const A*)
+    catch (const A* p)
     {
+        assert(!p);
     }
     catch (A*)
     {
         assert(false);
     }
 }
 
 void test3()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (const A* const)
+    catch (const A* const p)
     {
+        assert(!p);
     }
     catch (A*)
     {
         assert(false);
     }
 }
 
 void test4()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (A*)
+    catch (A* p)
     {
+        assert(!p);
     }
     catch (const A* const)
     {
         assert(false);
     }
 }
 
 void test5()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (A const*)
+    catch (A const* p)
     {
+        assert(!p);
     }
     catch (A*)
     {
         assert(false);
     }
 }
 
 void test6()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (A*)
+    catch (A* p)
     {
+        assert(!p);
     }
     catch (A const*)
     {
         assert(false);
     }
 }
 
 

test/catch_member_pointer_nullptr.pass.cpp

 
 void test1()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (md2)
+    catch (md2 p)
     {
+        assert(!p);
     }
     catch (md1)
     {
         assert(false);
     }
 }
 
 void test2()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (md1)
+    catch (md1 p)
     {
+        assert(!p);
     }
     catch (md2)
     {
         assert(false);
     }
 }
 
 #else

test/catch_pointer_nullptr.pass.cpp

 
 void test1()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (int*)
+    catch (int* p)
     {
+        assert(!p);
     }
     catch (long*)
     {
         assert(false);
     }
 }
 
 void test2()
 {
     try
     {
         throw nullptr;
         assert(false);
     }
-    catch (A*)
+    catch (A* p)
     {
+        assert(!p);
     }
     catch (int*)
     {
         assert(false);
     }
 }
 
 template <class Catch>
 void catch_nullptr_test() {
   try {
     throw nullptr;
     assert(false);
-  } catch (Catch) {
-    // nothing todo
+  } catch (Catch c) {
+    assert(!c);
   } catch (...) {
     assert(false);
   }
 }
 
 
 int main()
 {

test/catch_reference_nullptr.pass.cpp

+//===--------------------- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
+
+#include <cassert>
+#include <cstdlib>
+
+struct A {};
+
+template<typename T, bool CanCatchNullptr>
+static void catch_nullptr_test() {
+  try {
+    throw nullptr;
+  } catch (T &p) {
+    assert(CanCatchNullptr && !p);
+  } catch (...) {
+    assert(!CanCatchNullptr);
+  }
+}
+
+int main()
+{
+  using nullptr_t = decltype(nullptr);
+
+  // A reference to nullptr_t can catch nullptr.
+  catch_nullptr_test<nullptr_t, true>();
+  catch_nullptr_test<const nullptr_t, true>();
+  catch_nullptr_test<volatile nullptr_t, true>();
+  catch_nullptr_test<const volatile nullptr_t, true>();
+
+  // No other reference type can.
+#if 0
+  // FIXME: These tests fail, because the ABI provides no way for us to
+  // distinguish this from catching by value.
+  catch_nullptr_test<void *, false>();
+  catch_nullptr_test<void * const, false>();
+  catch_nullptr_test<int *, false>();
+  catch_nullptr_test<A *, false>();
+  catch_nullptr_test<int A::*, false>();
+  catch_nullptr_test<int (A::*)(), false>();
+#endif
+}

test/incomplete_type.sh.cpp

int main() {
   AssertIncompleteTypeInfoEquals(ReturnTypeInfoNeverDefinedMP(), typeid(int NeverDefined::*));
   try {
     ThrowNeverDefinedMP();
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
   } catch (int CompleteAtThrow::*) {
     assert(false);
-  } catch (int NeverDefined::*) {}
+  } catch (int NeverDefined::*p) {
+    assert(!p);
+  }
   AssertIncompleteTypeInfoEquals(ReturnTypeInfoIncompleteMP(), typeid(int IncompleteAtThrow::*));
   try {
     ThrowIncompleteMP();
     assert(false);
   } catch (CompleteAtThrow**) {
     assert(false);
   } catch (int CompleteAtThrow::*) {
     assert(false);
   } catch (IncompleteAtThrow**) {
     assert(false);
-  } catch (int IncompleteAtThrow::*) {}
+  } catch (int IncompleteAtThrow::*p) {
+    assert(!p);
+  }
 
   AssertIncompleteTypeInfoEquals(ReturnTypeInfoIncompletePP(), typeid(IncompleteAtThrow**));
   try {
     ThrowIncompletePP();
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
-  } catch (IncompleteAtThrow**) {}
+  } catch (IncompleteAtThrow** p) {
+    assert(!p);
+  }
 
   try {
     ThrowIncompletePMP();
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
   } catch (IncompleteAtThrow**) {
     assert(false);
-  } catch (int IncompleteAtThrow::**) {}
+  } catch (int IncompleteAtThrow::**p) {
+    assert(!p);
+  }
 
   AssertIncompleteTypeInfoEquals(ReturnTypeInfoCompleteMP(), typeid(int CompleteAtThrow::*));
   try {
     ThrowCompleteMP();
     assert(false);
   } catch (IncompleteAtThrow**) {
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
   } catch (CompleteAtThrow**) {
     assert(false);
-  } catch (int CompleteAtThrow::*) {}
+  } catch (int CompleteAtThrow::*p) {
+    assert(!p);
+  }
 
   AssertIncompleteTypeInfoEquals(ReturnTypeInfoCompletePP(), typeid(CompleteAtThrow**));
   try {
     ThrowCompletePP();
     assert(false);
   } catch (IncompleteAtThrow**) {
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
   } catch (int CompleteAtThrow::*) {
     assert(false);
-  } catch (CompleteAtThrow**) {}
+  } catch (CompleteAtThrow**p) {
+    assert(!p);
+  }
 
   try {
     ThrowCompletePMP();
     assert(false);
   } catch (IncompleteAtThrow**) {
     assert(false);
   } catch (int IncompleteAtThrow::*) {
     assert(false);
   } catch (int CompleteAtThrow::*) {
     assert(false);
   } catch (CompleteAtThrow**) {
     assert(false);
-  } catch (int CompleteAtThrow::**) {}
+  } catch (int CompleteAtThrow::**p) {
+    assert(!p);
+  }
 
 #if __cplusplus >= 201103L
   // Catch nullptr as complete type
   try {
     ThrowNullptr();
-  } catch (int IncompleteAtThrow::*) {}
+  } catch (int IncompleteAtThrow::*p) {
+    assert(!p);
+  }
 
   // Catch nullptr as an incomplete type
   try {
     ThrowNullptr();
-  } catch (int CompleteAtThrow::*) {}
+  } catch (int CompleteAtThrow::*p) {
+    assert(!p);
+  }
   // Catch nullptr as a type that is never complete.
   try {
     ThrowNullptr();
-  } catch (int NeverDefined::*) {}
+  } catch (int NeverDefined::*p) {
+    assert(!p);
+  }
 #endif
 }
 #endif