1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // UNSUPPORTED: no-exceptions
10
11 // mps2-an385 machine used for testing of picolibc has just 4 MB of "flash"
12 // memory and this test requires almost 5 MB
13 // UNSUPPORTED: LIBCXX-PICOLIBC-FIXME
14
15 #include <cassert>
16 #include <cstdio>
17 #include <cstdlib>
18
19 // Roll our own assertion macro to get better error messages out of the tests.
20 // In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
21 #define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)
22
do_assert(bool assert_passed,const char * msg,int line,const char * func)23 void do_assert(bool assert_passed, const char* msg, int line, const char* func) {
24 if (assert_passed)
25 return;
26 std::printf("%s:%d %s: Assertion Failed '%s'\n\n", __FILE__, line, func, msg);
27 std::abort();
28 }
29
30 struct A {};
31 struct Base {};
32 struct Derived : public Base {};
33
34 template <class To>
test_conversion(To)35 bool test_conversion(To) { return true; }
36
37 template <class To>
test_conversion(...)38 bool test_conversion(...) { return false; }
39
40 template <class Pointer>
41 struct CreatePointer {
operator ()CreatePointer42 Pointer operator()() const {
43 return (Pointer)0;
44 }
45 };
46
47 template <class Tp>
48 struct CreatePointer<Tp*> {
operator ()CreatePointer49 Tp* operator()() const {
50 return (Tp*)42;
51 }
52 };
53
54 template <class Throw, class Catch>
catch_pointer_test()55 void catch_pointer_test() {
56 Throw throw_ptr = CreatePointer<Throw>()();
57 // Use the compiler to determine if the exception of type Throw can be
58 // implicitly converted to type Catch.
59 const bool can_convert = test_conversion<Catch>(throw_ptr);
60 try {
61 throw throw_ptr;
62 assert(false);
63 } catch (Catch catch_ptr) {
64 Catch catch2 = CreatePointer<Catch>()();
65 my_assert(can_convert, "non-convertible type incorrectly caught");
66 my_assert(catch_ptr == catch2,
67 "Thrown pointer does not match caught ptr");
68 } catch (...) {
69 my_assert(!can_convert, "convertible type incorrectly not caught");
70 }
71 }
72
73 // Generate CV qualified pointer typedefs.
74 template <class Tp, bool First = false>
75 struct TestTypes {
76 typedef Tp* Type;
77 typedef Tp const* CType;
78 typedef Tp volatile* VType;
79 typedef Tp const volatile* CVType;
80 };
81
82 // Special case for cv-qualifying a pointer-to-member without adding an extra
83 // pointer to it.
84 template <class Member, class Class>
85 struct TestTypes<Member Class::*, true> {
86 typedef Member (Class::*Type);
87 typedef const Member (Class::*CType);
88 typedef volatile Member (Class::*VType);
89 typedef const volatile Member (Class::*CVType);
90 };
91
92 template <class Throw, class Catch, int level, bool first = false>
93 struct generate_tests_imp {
94 typedef TestTypes<Throw, first> ThrowTypes;
95 typedef TestTypes<Catch, first> CatchTypes;
operator ()generate_tests_imp96 void operator()() {
97 typedef typename ThrowTypes::Type Type;
98 typedef typename ThrowTypes::CType CType;
99 typedef typename ThrowTypes::VType VType;
100 typedef typename ThrowTypes::CVType CVType;
101
102 run_catch_tests<Type>();
103 run_catch_tests<CType>();
104 run_catch_tests<VType>();
105 run_catch_tests<CVType>();
106 }
107
108 template <class ThrowTp>
run_catch_testsgenerate_tests_imp109 void run_catch_tests() {
110 typedef typename CatchTypes::Type Type;
111 typedef typename CatchTypes::CType CType;
112 typedef typename CatchTypes::VType VType;
113 typedef typename CatchTypes::CVType CVType;
114
115 catch_pointer_test<ThrowTp, Type>();
116 catch_pointer_test<ThrowTp, CType>();
117 catch_pointer_test<ThrowTp, VType>();
118 catch_pointer_test<ThrowTp, CVType>();
119
120 generate_tests_imp<ThrowTp, Type, level-1>()();
121 generate_tests_imp<ThrowTp, CType, level-1>()();
122 generate_tests_imp<ThrowTp, VType, level-1>()();
123 generate_tests_imp<ThrowTp, CVType, level-1>()();
124 }
125 };
126
127 template <class Throw, class Catch, bool first>
128 struct generate_tests_imp<Throw, Catch, 0, first> {
operator ()generate_tests_imp129 void operator()() {
130 catch_pointer_test<Throw, Catch>();
131 }
132 };
133
134 template <class Throw, class Catch, int level>
135 struct generate_tests : generate_tests_imp<Throw, Catch, level, true> {};
136
main(int,char **)137 int main(int, char**)
138 {
139 generate_tests<int, int, 3>()();
140 generate_tests<Base, Derived, 2>()();
141 generate_tests<Derived, Base, 2>()();
142 generate_tests<int, void, 2>()();
143 generate_tests<void, int, 2>()();
144
145 generate_tests<int A::*, int A::*, 3>()();
146 generate_tests<int A::*, void, 2>()();
147 generate_tests<void, int A::*, 2>()();
148
149 return 0;
150 }
151