1 //===------------------------- dynamic_cast.pass.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 // XFAIL: gcc-7, gcc-8, gcc-9
10
11 #include <cassert>
12
13 // This test explicitly tests dynamic cast with types that have inaccessible
14 // bases.
15 #if defined(__clang__)
16 # pragma clang diagnostic ignored "-Winaccessible-base"
17 #elif defined(__GNUC__) && (__GNUC__ >= 10)
18 # pragma GCC diagnostic ignored "-Winaccessible-base"
19 #endif
20
21 typedef char Pad1[43981];
22 typedef char Pad2[34981];
23 typedef char Pad3[93481];
24 typedef char Pad4[13489];
25 typedef char Pad5[81349];
26 typedef char Pad6[34819];
27 typedef char Pad7[3489];
28
29 namespace t1
30 {
31
32 // PR33425
~C3t1::C333 struct C3 { virtual ~C3() {} Pad1 _; };
34 struct C5 : protected virtual C3 { Pad2 _; };
35 struct C6 : virtual C5 { Pad3 _; };
36 struct C7 : virtual C3 { Pad4 _; };
37 struct C9 : C6, C7 { Pad5 _; };
38
39 C9 c9;
40 C3 *c3 = &c9;
41
test()42 void test()
43 {
44 assert(dynamic_cast<C3*>(c3) == static_cast<C3*>(&c9));
45 assert(dynamic_cast<C5*>(c3) == static_cast<C5*>(&c9));
46 assert(dynamic_cast<C6*>(c3) == static_cast<C6*>(&c9));
47 assert(dynamic_cast<C7*>(c3) == static_cast<C7*>(&c9));
48 assert(dynamic_cast<C9*>(c3) == static_cast<C9*>(&c9));
49 }
50
51 } // t1
52
53 namespace t2
54 {
55
56 // PR33425
~Srct2::Src57 struct Src { virtual ~Src() {} Pad1 _; };
58 struct Mask : protected virtual Src { Pad2 _; };
59 struct Dest : Mask { Pad3 _; };
60 struct Root : Dest, virtual Src { Pad4 _; };
61
62 Root root;
63 Src *src = &root;
64
test()65 void test()
66 {
67 assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
68 assert(dynamic_cast<Mask*>(src) == static_cast<Mask*>(&root));
69 assert(dynamic_cast<Dest*>(src) == static_cast<Dest*>(&root));
70 assert(dynamic_cast<Root*>(src) == static_cast<Root*>(&root));
71 }
72
73 } // t2
74
75 namespace t3
76 {
77
78 // PR33487
~Class1t3::Class179 struct Class1 { virtual ~Class1() {} Pad1 _; };
80 struct Shared : virtual Class1 { Pad2 _; };
81 struct Class6 : virtual Shared { Pad3 _; };
82 struct Left : Class6 { Pad4 _; };
83 struct Right : Class6 { Pad5 _; };
84 struct Main : Left, Right { Pad6 _; };
85
86 Main m;
87 Class1 *c1 = &m;
88
test()89 void test()
90 {
91 assert(dynamic_cast<Class1*>(c1) == static_cast<Class1*>(&m));
92 assert(dynamic_cast<Shared*>(c1) == static_cast<Shared*>(&m));
93 assert(dynamic_cast<Class6*>(c1) == 0);
94 assert(dynamic_cast<Left*>(c1) == static_cast<Left*>(&m));
95 assert(dynamic_cast<Right*>(c1) == static_cast<Right*>(&m));
96 assert(dynamic_cast<Main*>(c1) == static_cast<Main*>(&m));
97 }
98
99 } // t3
100
101 namespace t4
102 {
103
104 // PR33439
~C2t4::C2105 struct C2 { virtual ~C2() {} Pad1 _; };
~C3t4::C3106 struct C3 { virtual ~C3() {} Pad2 _; };
107 struct C4 : C3 { Pad3 _; };
108 struct C8 : C2, virtual C4 { Pad4 _; };
109 struct C9 : C4, C8 { Pad5 _; };
110
111 C9 c9;
112 C2 *c2 = &c9;
113
test()114 void test()
115 {
116 assert(dynamic_cast<C2*>(c2) == static_cast<C2*>(&c9));
117 assert(dynamic_cast<C3*>(c2) == 0);
118 assert(dynamic_cast<C4*>(c2) == 0);
119 assert(dynamic_cast<C8*>(c2) == static_cast<C8*>(&c9));
120 assert(dynamic_cast<C9*>(c2) == static_cast<C9*>(&c9));
121 }
122
123 } // t4
124
125 namespace t5
126 {
127
128 // PR33439
~Dummyt5::Dummy129 struct Dummy { virtual ~Dummy() {} Pad1 _; };
~Srct5::Src130 struct Src { virtual ~Src() {} Pad2 _; };
131 struct Dest : Dummy { Pad3 _; };
132 struct A1 : Dest { Pad4 _; };
133 struct A2 : Dest { Pad5 _; };
134 struct Root : Src, A1, A2 { Pad6 _; };
135
136 Root root;
137 Src *src = &root;
138
test()139 void test()
140 {
141 assert(dynamic_cast<Dummy*>(src) == 0);
142 assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
143 assert(dynamic_cast<Dest*>(src) == 0);
144 assert(dynamic_cast<A1*>(src) == static_cast<A1*>(&root));
145 assert(dynamic_cast<A2*>(src) == static_cast<A2*>(&root));
146 }
147
148 } // t5
149
main(int,char **)150 int main(int, char**)
151 {
152 t1::test();
153 t2::test();
154 t3::test();
155 t4::test();
156 t5::test();
157
158 return 0;
159 }
160