Commit 5b8be6aa authored by Tom Stellard's avatar Tom Stellard
Browse files

Merging r233984: 

------------------------------------------------------------------------
r233984 | ericwf | 2015-04-02 16:26:37 -0700 (Thu, 02 Apr 2015) | 22 lines

[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
------------------------------------------------------------------------

llvm-svn: 236862
parent bdb73c27

libcxxabi/src/private_typeinfo.cpp

+96 −0
Original line number Diff line number Diff line
@@ -383,6 +383,24 @@ __pointer_type_info::can_catch(const __shim_type_info* thrown_type, 
    // 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)
@@ -403,6 +421,84 @@ __pointer_type_info::can_catch(const __shim_type_info* thrown_type, 
    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



#pragma GCC visibility pop

libcxxabi/src/private_typeinfo.h

+3 −0
Original line number Diff line number Diff line
@@ -230,6 +230,7 @@ class __attribute__ ((__visibility__("default"))) __pointer_type_info 
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

libcxxabi/test/catch_multi_level_pointer.pass.cpp

0 → 100644
+145 −0
Original line number Diff line number Diff line 
//===--------------------- 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>()();

}