Author: ericwf Date: Thu Apr 2 18:26:37 2015 New Revision: 233984 URL: http://llvm.org/viewvc/llvm-project?rev=233984&view=rev Log: [libcxxabi] Fix multi-level pointer conversions and pointer to member conversion detection.
Summary: Currently there are bugs in out detection of multi-level pointer conversions and pointer to member conversions. This patch fixes the following issues. * Allow multi-level pointers with different nested qualifiers. * Allow multi-level mixed pointers to objects and pointers to members with different nested qualifiers. * Allow conversions from `int Base::*` to `int Derived::*` but only for non-nested pointers. There is still some work that needs to be done to clean this patch up but I want to get some input on it. Open questions: * Does `__pointer_to_member_type_info::can_catch(...)` need to adjust the pointer if a base to derived conversion is performed? Reviewers: danalbert, compnerd, mclow.lists Reviewed By: mclow.lists Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D8758 Added: libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp Modified: libcxxabi/trunk/src/private_typeinfo.cpp libcxxabi/trunk/src/private_typeinfo.h libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp Modified: libcxxabi/trunk/src/private_typeinfo.cpp URL: http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/src/private_typeinfo.cpp?rev=233984&r1=233983&r2=233984&view=diff ============================================================================== --- libcxxabi/trunk/src/private_typeinfo.cpp (original) +++ libcxxabi/trunk/src/private_typeinfo.cpp Thu Apr 2 18:26:37 2015 @@ -389,6 +389,24 @@ __pointer_type_info::can_catch(const __s // 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 @@ __pointer_type_info::can_catch(const __s 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 Modified: libcxxabi/trunk/src/private_typeinfo.h URL: http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/src/private_typeinfo.h?rev=233984&r1=233983&r2=233984&view=diff ============================================================================== --- libcxxabi/trunk/src/private_typeinfo.h (original) +++ libcxxabi/trunk/src/private_typeinfo.h Thu Apr 2 18:26:37 2015 @@ -230,6 +230,7 @@ class __attribute__ ((__visibility__("de 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 @@ public: 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 Modified: libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp?rev=233984&r1=233983&r2=233984&view=diff ============================================================================== --- libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp (original) +++ libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp Thu Apr 2 18:26:37 2015 @@ -18,6 +18,15 @@ struct A 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,11 +43,114 @@ void test1() } } +// 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) @@ -47,6 +159,10 @@ void test2() } catch (md2) { + assert(false); + } + catch (der2) + { } } @@ -54,4 +170,7 @@ int main() { test1(); test2(); + test3(); + test4(); + test5(); } Added: libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp?rev=233984&view=auto ============================================================================== --- libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp (added) +++ libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp Thu Apr 2 18:26:37 2015 @@ -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>()(); +} Modified: libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp?rev=233984&r1=233983&r2=233984&view=diff ============================================================================== --- libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp (original) +++ libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp Thu Apr 2 18:26:37 2015 @@ -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 @@ void test1() } } -struct A {}; - void test2() { try @@ -45,6 +50,18 @@ void test2() } } +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 @@ void test2() { } +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::**>(); } _______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
