1 //===---------------------- catch_class_04.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 /*
10     This test checks that adjustedPtr is correct as there exist offsets in this
11     object for the various subobjects, all of which have a unique id_ to
12     check against.  It also checks that virtual bases work properly
13 */
14 
15 // UNSUPPORTED: no-exceptions
16 
17 // FIXME: GCC doesn't allow turning off the warning for exceptions being caught
18 //        by earlier handlers, which this test is exercising. We have to disable
19 //        warnings altogether to remove the error.
20 //        See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97675.
21 // ADDITIONAL_COMPILE_FLAGS: -Wno-error
22 
23 #include <exception>
24 #include <stdlib.h>
25 #include <assert.h>
26 
27 // Clang emits  warnings about exceptions of type 'Child' being caught by
28 // an earlier handler of type 'Base'. Congrats clang, you've just
29 // diagnosed the behavior under test.
30 #if defined(__clang__)
31 #pragma clang diagnostic ignored "-Wexceptions"
32 #endif
33 
34 struct B
35 {
36     static int count;
37     int id_;
38     explicit B(int id) : id_(id) {count++;}
39     B(const B& a) : id_(a.id_) {count++;}
40     ~B() {count--;}
41 };
42 
43 int B::count = 0;
44 
45 struct C1
46     : virtual B
47 {
48     static int count;
49     int id_;
50     explicit C1(int id) : B(id-2), id_(id) {count++;}
51     C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;}
52     ~C1() {count--;}
53 };
54 
55 int C1::count = 0;
56 
57 struct C2
58     : virtual private B
59 {
60     static int count;
61     int id_;
62     explicit C2(int id) : B(id-2), id_(id) {count++;}
63     C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;}
64     ~C2() {count--;}
65 };
66 
67 int C2::count = 0;
68 
69 struct A
70     : C1, C2
71 {
72     static int count;
73     int id_;
74     explicit A(int id) : B(id+3), C1(id-1), C2(id-2), id_(id) {count++;}
75     A(const A& a) : B(a.id_+3), C1(a.id_-1), C2(a.id_-2),  id_(a.id_) {count++;}
76     ~A() {count--;}
77 };
78 
79 int A::count = 0;
80 
81 A global_a(5);
82 
83 void f1()
84 {
85     throw &global_a;
86     assert(false);
87 }
88 
89 void f2()
90 {
91     try
92     {
93         f1();
94         assert(false);
95     }
96     catch (const A* a)  // can catch A
97     {
98         assert(a->id_ == 5);
99         assert(static_cast<const C1*>(a)->id_ == 4);
100         assert(static_cast<const C2*>(a)->id_ == 3);
101         assert(static_cast<const B*>(a)->id_ == 8);
102         throw;
103     }
104     catch (const C1*)
105     {
106         assert(false);
107     }
108     catch (const C2*)
109     {
110         assert(false);
111     }
112     catch (const B*)
113     {
114         assert(false);
115     }
116 }
117 
118 void f3()
119 {
120     try
121     {
122         f2();
123         assert(false);
124     }
125     catch (const B* a)  // can catch B
126     {
127         assert(static_cast<const B*>(a)->id_ == 8);
128         throw;
129     }
130     catch (const C1* c1)
131     {
132         assert(false);
133     }
134     catch (const C2*)
135     {
136         assert(false);
137     }
138 }
139 
140 void f4()
141 {
142     try
143     {
144         f3();
145         assert(false);
146     }
147     catch (const C2* c2)  // can catch C2
148     {
149         assert(c2->id_ == 3);
150         throw;
151     }
152     catch (const B* a)
153     {
154         assert(false);
155     }
156     catch (const C1*)
157     {
158         assert(false);
159     }
160 }
161 
162 void f5()
163 {
164     try
165     {
166         f4();
167         assert(false);
168     }
169     catch (const C1* c1)  // can catch C1
170     {
171         assert(c1->id_ == 4);
172         assert(static_cast<const B*>(c1)->id_ == 8);
173         throw;
174     }
175     catch (const B* a)
176     {
177         assert(false);
178     }
179     catch (const C2*)
180     {
181         assert(false);
182     }
183 }
184 
185 int main(int, char**)
186 {
187     try
188     {
189         f5();
190         assert(false);
191     }
192     catch (...)
193     {
194     }
195 
196     return 0;
197 }
198