|
236
|
1 //===----------------------------------------------------------------------===//
|
|
150
|
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
|
|
173
|
15 // UNSUPPORTED: no-exceptions
|
|
150
|
16
|
|
236
|
17 // Compilers emit warnings about exceptions of type 'Child' being caught by
|
|
|
18 // an earlier handler of type 'Base'. Congrats, you've just diagnosed the
|
|
|
19 // behavior under test.
|
|
|
20 // ADDITIONAL_COMPILE_FLAGS: -Wno-exceptions
|
|
221
|
21
|
|
150
|
22 #include <exception>
|
|
|
23 #include <stdlib.h>
|
|
|
24 #include <assert.h>
|
|
|
25
|
|
|
26 struct B
|
|
|
27 {
|
|
|
28 static int count;
|
|
|
29 int id_;
|
|
|
30 explicit B(int id) : id_(id) {count++;}
|
|
|
31 B(const B& a) : id_(a.id_) {count++;}
|
|
|
32 ~B() {count--;}
|
|
|
33 };
|
|
|
34
|
|
|
35 int B::count = 0;
|
|
|
36
|
|
|
37 struct C1
|
|
|
38 : virtual B
|
|
|
39 {
|
|
|
40 static int count;
|
|
|
41 int id_;
|
|
|
42 explicit C1(int id) : B(id-2), id_(id) {count++;}
|
|
|
43 C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;}
|
|
|
44 ~C1() {count--;}
|
|
|
45 };
|
|
|
46
|
|
|
47 int C1::count = 0;
|
|
|
48
|
|
|
49 struct C2
|
|
|
50 : virtual private B
|
|
|
51 {
|
|
|
52 static int count;
|
|
|
53 int id_;
|
|
|
54 explicit C2(int id) : B(id-2), id_(id) {count++;}
|
|
|
55 C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;}
|
|
|
56 ~C2() {count--;}
|
|
|
57 };
|
|
|
58
|
|
|
59 int C2::count = 0;
|
|
|
60
|
|
|
61 struct A
|
|
|
62 : C1, C2
|
|
|
63 {
|
|
|
64 static int count;
|
|
|
65 int id_;
|
|
|
66 explicit A(int id) : B(id+3), C1(id-1), C2(id-2), id_(id) {count++;}
|
|
|
67 A(const A& a) : B(a.id_+3), C1(a.id_-1), C2(a.id_-2), id_(a.id_) {count++;}
|
|
|
68 ~A() {count--;}
|
|
|
69 };
|
|
|
70
|
|
|
71 int A::count = 0;
|
|
|
72
|
|
221
|
73 A global_a(5);
|
|
150
|
74
|
|
|
75 void f1()
|
|
|
76 {
|
|
221
|
77 throw &global_a;
|
|
150
|
78 assert(false);
|
|
|
79 }
|
|
|
80
|
|
|
81 void f2()
|
|
|
82 {
|
|
|
83 try
|
|
|
84 {
|
|
|
85 f1();
|
|
|
86 assert(false);
|
|
|
87 }
|
|
|
88 catch (const A* a) // can catch A
|
|
|
89 {
|
|
|
90 assert(a->id_ == 5);
|
|
|
91 assert(static_cast<const C1*>(a)->id_ == 4);
|
|
|
92 assert(static_cast<const C2*>(a)->id_ == 3);
|
|
|
93 assert(static_cast<const B*>(a)->id_ == 8);
|
|
|
94 throw;
|
|
|
95 }
|
|
|
96 catch (const C1*)
|
|
|
97 {
|
|
|
98 assert(false);
|
|
|
99 }
|
|
|
100 catch (const C2*)
|
|
|
101 {
|
|
|
102 assert(false);
|
|
|
103 }
|
|
|
104 catch (const B*)
|
|
|
105 {
|
|
|
106 assert(false);
|
|
|
107 }
|
|
|
108 }
|
|
|
109
|
|
|
110 void f3()
|
|
|
111 {
|
|
|
112 try
|
|
|
113 {
|
|
|
114 f2();
|
|
|
115 assert(false);
|
|
|
116 }
|
|
|
117 catch (const B* a) // can catch B
|
|
|
118 {
|
|
|
119 assert(static_cast<const B*>(a)->id_ == 8);
|
|
|
120 throw;
|
|
|
121 }
|
|
|
122 catch (const C1* c1)
|
|
|
123 {
|
|
|
124 assert(false);
|
|
|
125 }
|
|
|
126 catch (const C2*)
|
|
|
127 {
|
|
|
128 assert(false);
|
|
|
129 }
|
|
|
130 }
|
|
|
131
|
|
|
132 void f4()
|
|
|
133 {
|
|
|
134 try
|
|
|
135 {
|
|
|
136 f3();
|
|
|
137 assert(false);
|
|
|
138 }
|
|
|
139 catch (const C2* c2) // can catch C2
|
|
|
140 {
|
|
|
141 assert(c2->id_ == 3);
|
|
|
142 throw;
|
|
|
143 }
|
|
|
144 catch (const B* a)
|
|
|
145 {
|
|
|
146 assert(false);
|
|
|
147 }
|
|
|
148 catch (const C1*)
|
|
|
149 {
|
|
|
150 assert(false);
|
|
|
151 }
|
|
|
152 }
|
|
|
153
|
|
|
154 void f5()
|
|
|
155 {
|
|
|
156 try
|
|
|
157 {
|
|
|
158 f4();
|
|
|
159 assert(false);
|
|
|
160 }
|
|
|
161 catch (const C1* c1) // can catch C1
|
|
|
162 {
|
|
|
163 assert(c1->id_ == 4);
|
|
|
164 assert(static_cast<const B*>(c1)->id_ == 8);
|
|
|
165 throw;
|
|
|
166 }
|
|
|
167 catch (const B* a)
|
|
|
168 {
|
|
|
169 assert(false);
|
|
|
170 }
|
|
|
171 catch (const C2*)
|
|
|
172 {
|
|
|
173 assert(false);
|
|
|
174 }
|
|
|
175 }
|
|
|
176
|
|
221
|
177 int main(int, char**)
|
|
150
|
178 {
|
|
|
179 try
|
|
|
180 {
|
|
|
181 f5();
|
|
|
182 assert(false);
|
|
|
183 }
|
|
|
184 catch (...)
|
|
|
185 {
|
|
|
186 }
|
|
221
|
187
|
|
|
188 return 0;
|
|
150
|
189 }
|
