1 //===--------------------- catch_pointer_nullptr.cpp ----------------------===//
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 #include <cassert>
12 #include <cstdio>
13 #include <cstdlib>
14
15 // Roll our own assertion macro to get better error messages out of the tests.
16 // In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
17 #define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)
18
do_assert(bool assert_passed,const char * msg,int line,const char * func)19 void do_assert(bool assert_passed, const char* msg, int line, const char* func) {
20 if (assert_passed)
21 return;
22 std::printf("%s:%d %s: Assertion Failed '%s'\n\n", __FILE__, line, func, msg);
23 std::abort();
24 }
25
26 struct A {};
27 struct Base {};
28 struct Derived : public Base {};
29
30 template <class To>
test_conversion(To)31 bool test_conversion(To) { return true; }
32
33 template <class To>
test_conversion(...)34 bool test_conversion(...) { return false; }
35
36 template <class Pointer>
37 struct CreatePointer {
operator ()CreatePointer38 Pointer operator()() const {
39 return (Pointer)0;
40 }
41 };
42
43 template <class Tp>
44 struct CreatePointer<Tp*> {
operator ()CreatePointer45 Tp* operator()() const {
46 return (Tp*)42;
47 }
48 };
49
50 template <class Throw, class Catch>
catch_pointer_test()51 void catch_pointer_test() {
52 Throw throw_ptr = CreatePointer<Throw>()();
53 // Use the compiler to determine if the exception of type Throw can be
54 // implicitly converted to type Catch.
55 const bool can_convert = test_conversion<Catch>(throw_ptr);
56 try {
57 throw throw_ptr;
58 assert(false);
59 } catch (Catch catch_ptr) {
60 Catch catch2 = CreatePointer<Catch>()();
61 my_assert(can_convert, "non-convertible type incorrectly caught");
62 my_assert(catch_ptr == catch2,
63 "Thrown pointer does not match caught ptr");
64 } catch (...) {
65 my_assert(!can_convert, "convertible type incorrectly not caught");
66 }
67 }
68
69 // Generate CV qualified pointer typedefs.
70 template <class Tp, bool First = false>
71 struct TestTypes {
72 typedef Tp* Type;
73 typedef Tp const* CType;
74 typedef Tp volatile* VType;
75 typedef Tp const volatile* CVType;
76 };
77
78 // Special case for cv-qualifying a pointer-to-member without adding an extra
79 // pointer to it.
80 template <class Member, class Class>
81 struct TestTypes<Member Class::*, true> {
82 typedef Member (Class::*Type);
83 typedef const Member (Class::*CType);
84 typedef volatile Member (Class::*VType);
85 typedef const volatile Member (Class::*CVType);
86 };
87
88 template <class Throw, class Catch, int level, bool first = false>
89 struct generate_tests_imp {
90 typedef TestTypes<Throw, first> ThrowTypes;
91 typedef TestTypes<Catch, first> CatchTypes;
operator ()generate_tests_imp92 void operator()() {
93 typedef typename ThrowTypes::Type Type;
94 typedef typename ThrowTypes::CType CType;
95 typedef typename ThrowTypes::VType VType;
96 typedef typename ThrowTypes::CVType CVType;
97
98 run_catch_tests<Type>();
99 run_catch_tests<CType>();
100 run_catch_tests<VType>();
101 run_catch_tests<CVType>();
102 }
103
104 template <class ThrowTp>
run_catch_testsgenerate_tests_imp105 void run_catch_tests() {
106 typedef typename CatchTypes::Type Type;
107 typedef typename CatchTypes::CType CType;
108 typedef typename CatchTypes::VType VType;
109 typedef typename CatchTypes::CVType CVType;
110
111 catch_pointer_test<ThrowTp, Type>();
112 catch_pointer_test<ThrowTp, CType>();
113 catch_pointer_test<ThrowTp, VType>();
114 catch_pointer_test<ThrowTp, CVType>();
115
116 generate_tests_imp<ThrowTp, Type, level-1>()();
117 generate_tests_imp<ThrowTp, CType, level-1>()();
118 generate_tests_imp<ThrowTp, VType, level-1>()();
119 generate_tests_imp<ThrowTp, CVType, level-1>()();
120 }
121 };
122
123 template <class Throw, class Catch, bool first>
124 struct generate_tests_imp<Throw, Catch, 0, first> {
operator ()generate_tests_imp125 void operator()() {
126 catch_pointer_test<Throw, Catch>();
127 }
128 };
129
130 template <class Throw, class Catch, int level>
131 struct generate_tests : generate_tests_imp<Throw, Catch, level, true> {};
132
main(int,char **)133 int main(int, char**)
134 {
135 generate_tests<int, int, 3>()();
136 generate_tests<Base, Derived, 2>()();
137 generate_tests<Derived, Base, 2>()();
138 generate_tests<int, void, 2>()();
139 generate_tests<void, int, 2>()();
140
141 generate_tests<int A::*, int A::*, 3>()();
142 generate_tests<int A::*, void, 2>()();
143 generate_tests<void, int A::*, 2>()();
144
145 return 0;
146 }
147