mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-12-28 02:37:37 +00:00
57b08b0944
to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
446 lines
23 KiB
C++
446 lines
23 KiB
C++
//===---------------------- catch_pointer_referece.cpp --------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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();
|
|
}
|