forked from OSchip/llvm-project
447 lines
23 KiB
C++
447 lines
23 KiB
C++
//===---------------------- catch_pointer_referece.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.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This test case checks specifically the cases under bullet 3.1 & 3.2:
|
|
//
|
|
// C++ ABI 15.3:
|
|
// A handler is a match for an exception object of type E if
|
|
// * The handler is of type cv T or cv T& and E and T are the same type
|
|
// (ignoring the top-level cv-qualifiers), or
|
|
// * the handler is of type cv T or cv T& and T is an unambiguous base
|
|
// class of E, or
|
|
// / * the handler is of type cv1 T* cv2 and E is a pointer type that can \
|
|
// | be converted to the type of the handler by either or both of |
|
|
// | o a standard pointer conversion (4.10 [conv.ptr]) not involving |
|
|
// | conversions to private or protected or ambiguous classes |
|
|
// \ o a qualification conversion /
|
|
// * the handler is a pointer or pointer to member type and E is
|
|
// std::nullptr_t
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// UNSUPPORTED: libcxxabi-no-exceptions
|
|
|
|
#include <exception>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
|
|
struct Base {};
|
|
struct Derived : Base {};
|
|
struct Derived2 : Base {};
|
|
struct Ambiguous : Derived, Derived2 {};
|
|
struct Private : private Base {};
|
|
struct Protected : protected Base {};
|
|
|
|
template <typename T // Handler type
|
|
,typename E // Thrown exception type
|
|
,typename O // Object type
|
|
>
|
|
void assert_catches()
|
|
{
|
|
try
|
|
{
|
|
O o;
|
|
throw static_cast<E>(&o);
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "Statements after throw must be unreachable");
|
|
}
|
|
catch (T t)
|
|
{
|
|
assert(true);
|
|
return;
|
|
}
|
|
catch (...)
|
|
{
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "Should not have entered catch-all");
|
|
}
|
|
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "The catch should have returned");
|
|
}
|
|
|
|
template <typename T // Handler type
|
|
,typename E // Thrown exception type
|
|
,typename O // Object type
|
|
>
|
|
void assert_cannot_catch()
|
|
{
|
|
try
|
|
{
|
|
O o;
|
|
throw static_cast<E>(&o);
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "Statements after throw must be unreachable");
|
|
}
|
|
catch (T t)
|
|
{
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "Should not have entered the catch");
|
|
}
|
|
catch (...)
|
|
{
|
|
assert(true);
|
|
return;
|
|
}
|
|
|
|
printf("%s\n", __PRETTY_FUNCTION__);
|
|
assert(false && "The catch-all should have returned");
|
|
}
|
|
|
|
void f1()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2
|
|
// catches an exception of type:
|
|
// Derived *
|
|
assert_catches< Base * , Derived *, Derived>();
|
|
assert_catches<const Base * , Derived *, Derived>();
|
|
assert_catches< volatile Base * , Derived *, Derived>();
|
|
assert_catches<const volatile Base * , Derived *, Derived>();
|
|
assert_catches< Base * const , Derived *, Derived>();
|
|
assert_catches<const Base * const , Derived *, Derived>();
|
|
assert_catches< volatile Base * const , Derived *, Derived>();
|
|
assert_catches<const volatile Base * const , Derived *, Derived>();
|
|
assert_catches< Base * volatile, Derived *, Derived>();
|
|
assert_catches<const Base * volatile, Derived *, Derived>();
|
|
assert_catches< volatile Base * volatile, Derived *, Derived>();
|
|
assert_catches<const volatile Base * volatile, Derived *, Derived>();
|
|
assert_catches< Base * const volatile, Derived *, Derived>();
|
|
assert_catches<const Base * const volatile, Derived *, Derived>();
|
|
assert_catches< volatile Base * const volatile, Derived *, Derived>();
|
|
assert_catches<const volatile Base * const volatile, Derived *, Derived>();
|
|
}
|
|
|
|
void f2()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2
|
|
// catches an exception of type:
|
|
// Base *
|
|
assert_catches< Base * , Base *, Derived>();
|
|
assert_catches<const Base * , Base *, Derived>();
|
|
assert_catches< volatile Base * , Base *, Derived>();
|
|
assert_catches<const volatile Base * , Base *, Derived>();
|
|
assert_catches< Base * const , Base *, Derived>();
|
|
assert_catches<const Base * const , Base *, Derived>();
|
|
assert_catches< volatile Base * const , Base *, Derived>();
|
|
assert_catches<const volatile Base * const , Base *, Derived>();
|
|
assert_catches< Base * volatile, Base *, Derived>();
|
|
assert_catches<const Base * volatile, Base *, Derived>();
|
|
assert_catches< volatile Base * volatile, Base *, Derived>();
|
|
assert_catches<const volatile Base * volatile, Base *, Derived>();
|
|
assert_catches< Base * const volatile, Base *, Derived>();
|
|
assert_catches<const Base * const volatile, Base *, Derived>();
|
|
assert_catches< volatile Base * const volatile, Base *, Derived>();
|
|
assert_catches<const volatile Base * const volatile, Base *, Derived>();
|
|
}
|
|
|
|
void f3()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Derived * cv2
|
|
// catches an exception of type:
|
|
// Derived *
|
|
assert_catches< Derived * , Derived *, Derived>();
|
|
assert_catches<const Derived * , Derived *, Derived>();
|
|
assert_catches< volatile Derived * , Derived *, Derived>();
|
|
assert_catches<const volatile Derived * , Derived *, Derived>();
|
|
assert_catches< Derived * const , Derived *, Derived>();
|
|
assert_catches<const Derived * const , Derived *, Derived>();
|
|
assert_catches< volatile Derived * const , Derived *, Derived>();
|
|
assert_catches<const volatile Derived * const , Derived *, Derived>();
|
|
assert_catches< Derived * volatile, Derived *, Derived>();
|
|
assert_catches<const Derived * volatile, Derived *, Derived>();
|
|
assert_catches< volatile Derived * volatile, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * volatile, Derived *, Derived>();
|
|
assert_catches< Derived * const volatile, Derived *, Derived>();
|
|
assert_catches<const Derived * const volatile, Derived *, Derived>();
|
|
assert_catches< volatile Derived * const volatile, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * const volatile, Derived *, Derived>();
|
|
}
|
|
|
|
void f4()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Derived * cv2
|
|
// cannot catch an exception of type:
|
|
// Base *
|
|
assert_cannot_catch< Derived * , Base *, Derived>();
|
|
assert_cannot_catch<const Derived * , Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * , Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * , Base *, Derived>();
|
|
assert_cannot_catch< Derived * const , Base *, Derived>();
|
|
assert_cannot_catch<const Derived * const , Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * const , Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * const , Base *, Derived>();
|
|
assert_cannot_catch< Derived * volatile, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * volatile, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * volatile, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * volatile, Base *, Derived>();
|
|
assert_cannot_catch< Derived * const volatile, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * const volatile, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * const volatile, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * const volatile, Base *, Derived>();
|
|
}
|
|
|
|
void f5()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Derived * cv2 &
|
|
// catches an exception of type:
|
|
// Derived *
|
|
assert_catches< Derived * &, Derived *, Derived>();
|
|
assert_catches<const Derived * &, Derived *, Derived>();
|
|
assert_catches< volatile Derived * &, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * &, Derived *, Derived>();
|
|
assert_catches< Derived * const &, Derived *, Derived>();
|
|
assert_catches<const Derived * const &, Derived *, Derived>();
|
|
assert_catches< volatile Derived * const &, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * const &, Derived *, Derived>();
|
|
assert_catches< Derived * volatile &, Derived *, Derived>();
|
|
assert_catches<const Derived * volatile &, Derived *, Derived>();
|
|
assert_catches< volatile Derived * volatile &, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * volatile &, Derived *, Derived>();
|
|
assert_catches< Derived * const volatile &, Derived *, Derived>();
|
|
assert_catches<const Derived * const volatile &, Derived *, Derived>();
|
|
assert_catches< volatile Derived * const volatile &, Derived *, Derived>();
|
|
assert_catches<const volatile Derived * const volatile &, Derived *, Derived>();
|
|
}
|
|
|
|
void f6()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2 &
|
|
// catches an exception of type:
|
|
// Base *
|
|
assert_catches< Base * &, Base *, Derived>();
|
|
assert_catches<const Base * &, Base *, Derived>();
|
|
assert_catches< volatile Base * &, Base *, Derived>();
|
|
assert_catches<const volatile Base * &, Base *, Derived>();
|
|
assert_catches< Base * const &, Base *, Derived>();
|
|
assert_catches<const Base * const &, Base *, Derived>();
|
|
assert_catches< volatile Base * const &, Base *, Derived>();
|
|
assert_catches<const volatile Base * const &, Base *, Derived>();
|
|
assert_catches< Base * volatile &, Base *, Derived>();
|
|
assert_catches<const Base * volatile &, Base *, Derived>();
|
|
assert_catches< volatile Base * volatile &, Base *, Derived>();
|
|
assert_catches<const volatile Base * volatile &, Base *, Derived>();
|
|
assert_catches< Base * const volatile &, Base *, Derived>();
|
|
assert_catches<const Base * const volatile &, Base *, Derived>();
|
|
assert_catches< volatile Base * const volatile &, Base *, Derived>();
|
|
assert_catches<const volatile Base * const volatile &, Base *, Derived>();
|
|
|
|
}
|
|
|
|
void f7()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Derived * cv2 &
|
|
// cannot catch an exception of type:
|
|
// Base *
|
|
assert_cannot_catch< Derived * &, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * &, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * &, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * &, Base *, Derived>();
|
|
assert_cannot_catch< Derived * const &, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * const &, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * const &, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * const &, Base *, Derived>();
|
|
assert_cannot_catch< Derived * volatile &, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * volatile &, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * volatile &, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * volatile &, Base *, Derived>();
|
|
assert_cannot_catch< Derived * const volatile &, Base *, Derived>();
|
|
assert_cannot_catch<const Derived * const volatile &, Base *, Derived>();
|
|
assert_cannot_catch< volatile Derived * const volatile &, Base *, Derived>();
|
|
assert_cannot_catch<const volatile Derived * const volatile &, Base *, Derived>();
|
|
}
|
|
|
|
void f8()
|
|
{
|
|
// This test case has a caveat noted in the discussion here:
|
|
// https://gcc.gnu.org/ml/gcc-patches/2009-08/msg00264.html
|
|
// Specifically:
|
|
// This [test exposes a] corner case of the ARM C++ ABI. The generic C++
|
|
// ABI also gets this wrong, because I failed to notice the subtlety here.
|
|
// The issue is that 15.3/3 3rd bullet says:
|
|
// The handler is of type cv1 T* cv2 and E is a pointer type that
|
|
// can be converted to the type of the handler by either or both of:
|
|
// * a standard pointer conversion (4.10) not involving conversions
|
|
// to pointers to private or protected or ambiguous classes
|
|
// Notice that the handlers of type "cv1 T*cv2&" are not allowed such
|
|
// freedom to find a base class. The ABI error is that we treat handlers
|
|
// of reference type exactly the same as the corresponding hander of
|
|
// non-reference type. Elsewhere in the exception handling this makes no
|
|
// difference (for instance bullet 1 explicitly says 'cv T or cv T&').
|
|
//
|
|
// See also: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#388
|
|
//
|
|
// TL;DR: it is an unresolved C++ ABI defect that these do catch
|
|
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2 &
|
|
// catches an exception of type:
|
|
// Derived *
|
|
assert_catches< Base * &, Derived *, Derived>();
|
|
assert_catches<const Base * &, Derived *, Derived>();
|
|
assert_catches< volatile Base * &, Derived *, Derived>();
|
|
assert_catches<const volatile Base * &, Derived *, Derived>();
|
|
assert_catches< Base * const &, Derived *, Derived>();
|
|
assert_catches<const Base * const &, Derived *, Derived>();
|
|
assert_catches< volatile Base * const &, Derived *, Derived>();
|
|
assert_catches<const volatile Base * const &, Derived *, Derived>();
|
|
assert_catches< Base * volatile &, Derived *, Derived>();
|
|
assert_catches<const Base * volatile &, Derived *, Derived>();
|
|
assert_catches< volatile Base * volatile &, Derived *, Derived>();
|
|
assert_catches<const volatile Base * volatile &, Derived *, Derived>();
|
|
assert_catches< Base * const volatile &, Derived *, Derived>();
|
|
assert_catches<const Base * const volatile &, Derived *, Derived>();
|
|
assert_catches< volatile Base * const volatile &, Derived *, Derived>();
|
|
assert_catches<const volatile Base * const volatile &, Derived *, Derived>();
|
|
}
|
|
|
|
void f9()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2
|
|
// cannot catch an exception of type:
|
|
// Ambiguous *
|
|
assert_cannot_catch< Base * , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const Base * , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< volatile Base * , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const volatile Base * , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< Base * const , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const Base * const , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< volatile Base * const , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const volatile Base * const , Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< Base * volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const Base * volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< volatile Base * volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const volatile Base * volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< Base * const volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const Base * const volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch< volatile Base * const volatile, Ambiguous *, Ambiguous>();
|
|
assert_cannot_catch<const volatile Base * const volatile, Ambiguous *, Ambiguous>();
|
|
}
|
|
|
|
void f10()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2
|
|
// cannot catch an exception of type:
|
|
// Private *
|
|
assert_cannot_catch< Base * , Private *, Private>();
|
|
assert_cannot_catch<const Base * , Private *, Private>();
|
|
assert_cannot_catch< volatile Base * , Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * , Private *, Private>();
|
|
assert_cannot_catch< Base * const , Private *, Private>();
|
|
assert_cannot_catch<const Base * const , Private *, Private>();
|
|
assert_cannot_catch< volatile Base * const , Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * const , Private *, Private>();
|
|
assert_cannot_catch< Base * volatile, Private *, Private>();
|
|
assert_cannot_catch<const Base * volatile, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * volatile, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * volatile, Private *, Private>();
|
|
assert_cannot_catch< Base * const volatile, Private *, Private>();
|
|
assert_cannot_catch<const Base * const volatile, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * const volatile, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * const volatile, Private *, Private>();
|
|
}
|
|
|
|
void f11()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2
|
|
// cannot catch an exception of type:
|
|
// Protected *
|
|
assert_cannot_catch< Base * , Protected *, Protected>();
|
|
assert_cannot_catch<const Base * , Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * , Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * , Protected *, Protected>();
|
|
assert_cannot_catch< Base * const , Protected *, Protected>();
|
|
assert_cannot_catch<const Base * const , Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * const , Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * const , Protected *, Protected>();
|
|
assert_cannot_catch< Base * volatile, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * volatile, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * volatile, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * volatile, Protected *, Protected>();
|
|
assert_cannot_catch< Base * const volatile, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * const volatile, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * const volatile, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * const volatile, Protected *, Protected>();
|
|
}
|
|
|
|
void f12()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2 &
|
|
// cannot catch an exception of type:
|
|
// Private *
|
|
assert_cannot_catch< Base * &, Private *, Private>();
|
|
assert_cannot_catch<const Base * &, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * &, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * &, Private *, Private>();
|
|
assert_cannot_catch< Base * const &, Private *, Private>();
|
|
assert_cannot_catch<const Base * const &, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * const &, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * const &, Private *, Private>();
|
|
assert_cannot_catch< Base * volatile &, Private *, Private>();
|
|
assert_cannot_catch<const Base * volatile &, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * volatile &, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * volatile &, Private *, Private>();
|
|
assert_cannot_catch< Base * const volatile &, Private *, Private>();
|
|
assert_cannot_catch<const Base * const volatile &, Private *, Private>();
|
|
assert_cannot_catch< volatile Base * const volatile &, Private *, Private>();
|
|
assert_cannot_catch<const volatile Base * const volatile &, Private *, Private>();
|
|
}
|
|
|
|
void f13()
|
|
{
|
|
// Test that every combination of handler of type:
|
|
// cv1 Base * cv2 &
|
|
// cannot catch an exception of type:
|
|
// Protected *
|
|
assert_cannot_catch< Base * &, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * &, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * &, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * &, Protected *, Protected>();
|
|
assert_cannot_catch< Base * const &, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * const &, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * const &, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * const &, Protected *, Protected>();
|
|
assert_cannot_catch< Base * volatile &, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * volatile &, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * volatile &, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * volatile &, Protected *, Protected>();
|
|
assert_cannot_catch< Base * const volatile &, Protected *, Protected>();
|
|
assert_cannot_catch<const Base * const volatile &, Protected *, Protected>();
|
|
assert_cannot_catch< volatile Base * const volatile &, Protected *, Protected>();
|
|
assert_cannot_catch<const volatile Base * const volatile &, Protected *, Protected>();
|
|
}
|
|
|
|
int main()
|
|
{
|
|
f1();
|
|
f2();
|
|
f3();
|
|
f4();
|
|
f5();
|
|
f6();
|
|
f7();
|
|
f8();
|
|
f9();
|
|
f10();
|
|
f11();
|
|
f12();
|
|
f13();
|
|
}
|