1 //===------------------------- incomplete_type.cpp --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 // http://mentorembedded.github.io/cxx-abi/abi.html#rtti-layout
10 
11 // Two abi::__pbase_type_info objects can always be compared for equality
12 // (i.e. of the types represented) or ordering by comparison of their name
13 // NTBS addresses. In addition, unless either or both have either of the
14 // incomplete flags set, equality can be tested by comparing the type_info
15 // addresses.
16 
17 // UNSUPPORTED: libcxxabi-no-exceptions
18 
19 // NOTE: Pass -lc++abi explicitly and before -lc++ so that -lc++ doesn't drag
20 // in the system libc++abi installation on OS X. (DYLD_LIBRARY_PATH is ignored
21 // for shell tests because of Apple security features).
22 
23 // RUN: %cxx %flags %compile_flags -c %s -o %t.one.o
24 // RUN: %cxx %flags %compile_flags -c %s -o %t.two.o -DTU_ONE
25 // RUN: %cxx %flags %t.one.o %t.two.o -lc++abi %link_flags -o %t.exe
26 // RUN: %t.exe
27 
28 #include <stdio.h>
29 #include <cstring>
30 #include <cassert>
31 #include <typeinfo>
32 
33 // Check that the addresses of the typeinfo differ but still compare equal
34 // via their NTBS.
35 inline void
36 AssertIncompleteTypeInfoEquals(std::type_info const& LHS, std::type_info const& RHS)
37 {
38   assert(&LHS != &RHS);
39   assert(strcmp(LHS.name(), RHS.name()) == 0);
40 }
41 
42 struct NeverDefined;
43 void ThrowNeverDefinedMP();
44 std::type_info const& ReturnTypeInfoNeverDefinedMP();
45 
46 struct IncompleteAtThrow;
47 void ThrowIncompleteMP();
48 void ThrowIncompletePP();
49 void ThrowIncompletePMP();
50 std::type_info const& ReturnTypeInfoIncompleteMP();
51 std::type_info const& ReturnTypeInfoIncompletePP();
52 
53 struct CompleteAtThrow;
54 void ThrowCompleteMP();
55 void ThrowCompletePP();
56 void ThrowCompletePMP();
57 std::type_info const& ReturnTypeInfoCompleteMP();
58 std::type_info const& ReturnTypeInfoCompletePP();
59 
60 void ThrowNullptr();
61 
62 #ifndef TU_ONE
63 
64 void ThrowNeverDefinedMP() { throw (int NeverDefined::*)nullptr; }
65 std::type_info const& ReturnTypeInfoNeverDefinedMP() { return typeid(int NeverDefined::*); }
66 
67 void ThrowIncompleteMP() { throw (int IncompleteAtThrow::*)nullptr; }
68 void ThrowIncompletePP() { throw (IncompleteAtThrow**)nullptr; }
69 void ThrowIncompletePMP() { throw (int IncompleteAtThrow::**)nullptr; }
70 std::type_info const& ReturnTypeInfoIncompleteMP() { return typeid(int IncompleteAtThrow::*); }
71 std::type_info const& ReturnTypeInfoIncompletePP() { return typeid(IncompleteAtThrow**); }
72 
73 struct CompleteAtThrow {};
74 void ThrowCompleteMP() { throw (int CompleteAtThrow::*)nullptr; }
75 void ThrowCompletePP() { throw (CompleteAtThrow**)nullptr; }
76 void ThrowCompletePMP() { throw (int CompleteAtThrow::**)nullptr; }
77 std::type_info const& ReturnTypeInfoCompleteMP() { return typeid(int CompleteAtThrow::*); }
78 std::type_info const& ReturnTypeInfoCompletePP() { return typeid(CompleteAtThrow**); }
79 
80 void ThrowNullptr() { throw nullptr; }
81 
82 #else
83 
84 struct IncompleteAtThrow {};
85 
86 int main() {
87   AssertIncompleteTypeInfoEquals(ReturnTypeInfoNeverDefinedMP(), typeid(int NeverDefined::*));
88   try {
89     ThrowNeverDefinedMP();
90     assert(false);
91   } catch (int IncompleteAtThrow::*) {
92     assert(false);
93   } catch (int CompleteAtThrow::*) {
94     assert(false);
95   } catch (int NeverDefined::*p) {
96     assert(!p);
97   }
98   catch(...) { assert(!"FAIL: Didn't catch NeverDefined::*" ); }
99 
100   AssertIncompleteTypeInfoEquals(ReturnTypeInfoIncompleteMP(), typeid(int IncompleteAtThrow::*));
101   try {
102     ThrowIncompleteMP();
103     assert(false);
104   } catch (CompleteAtThrow**) {
105     assert(false);
106   } catch (int CompleteAtThrow::*) {
107     assert(false);
108   } catch (IncompleteAtThrow**) {
109     assert(false);
110   } catch (int IncompleteAtThrow::*p) {
111     assert(!p);
112   }
113   catch(...) { assert(!"FAIL: Didn't catch IncompleteAtThrow::*" ); }
114 
115   AssertIncompleteTypeInfoEquals(ReturnTypeInfoIncompletePP(), typeid(IncompleteAtThrow**));
116   try {
117     ThrowIncompletePP();
118     assert(false);
119   } catch (int IncompleteAtThrow::*) {
120     assert(false);
121   } catch (IncompleteAtThrow** p) {
122     assert(!p);
123   }
124   catch(...) { assert(!"FAIL: Didn't catch IncompleteAtThrow**" ); }
125 
126   try {
127     ThrowIncompletePMP();
128     assert(false);
129   } catch (int IncompleteAtThrow::*) {
130     assert(false);
131   } catch (IncompleteAtThrow**) {
132     assert(false);
133   } catch (int IncompleteAtThrow::**p) {
134     assert(!p);
135   }
136   catch(...) { assert(!"FAIL: Didn't catch IncompleteAtThrow::**" ); }
137 
138   AssertIncompleteTypeInfoEquals(ReturnTypeInfoCompleteMP(), typeid(int CompleteAtThrow::*));
139   try {
140     ThrowCompleteMP();
141     assert(false);
142   } catch (IncompleteAtThrow**) {
143     assert(false);
144   } catch (int IncompleteAtThrow::*) {
145     assert(false);
146   } catch (CompleteAtThrow**) {
147     assert(false);
148   } catch (int CompleteAtThrow::*p) {
149     assert(!p);
150   }
151   catch(...) { assert(!"FAIL: Didn't catch CompleteAtThrow::" ); }
152 
153   AssertIncompleteTypeInfoEquals(ReturnTypeInfoCompletePP(), typeid(CompleteAtThrow**));
154   try {
155     ThrowCompletePP();
156     assert(false);
157   } catch (IncompleteAtThrow**) {
158     assert(false);
159   } catch (int IncompleteAtThrow::*) {
160     assert(false);
161   } catch (int CompleteAtThrow::*) {
162     assert(false);
163   } catch (CompleteAtThrow**p) {
164     assert(!p);
165   }
166   catch(...) { assert(!"FAIL: Didn't catch CompleteAtThrow**" ); }
167 
168   try {
169     ThrowCompletePMP();
170     assert(false);
171   } catch (IncompleteAtThrow**) {
172     assert(false);
173   } catch (int IncompleteAtThrow::*) {
174     assert(false);
175   } catch (int CompleteAtThrow::*) {
176     assert(false);
177   } catch (CompleteAtThrow**) {
178     assert(false);
179   } catch (int CompleteAtThrow::**p) {
180     assert(!p);
181   }
182   catch(...) { assert(!"FAIL: Didn't catch CompleteAtThrow::**" ); }
183 
184 #if __cplusplus >= 201103L
185   // Catch nullptr as complete type
186   try {
187     ThrowNullptr();
188   } catch (int IncompleteAtThrow::*p) {
189     assert(!p);
190   }
191   catch(...) { assert(!"FAIL: Didn't catch nullptr as IncompleteAtThrow::*" ); }
192 
193   // Catch nullptr as an incomplete type
194   try {
195     ThrowNullptr();
196   } catch (int CompleteAtThrow::*p) {
197     assert(!p);
198   }
199   catch(...) { assert(!"FAIL: Didn't catch nullptr as CompleteAtThrow::*" ); }
200 
201   // Catch nullptr as a type that is never complete.
202   try {
203     ThrowNullptr();
204   } catch (int NeverDefined::*p) {
205     assert(!p);
206   }
207   catch(...) { assert(!"FAIL: Didn't catch nullptr as NeverDefined::*" ); }
208 
209 #endif
210 }
211 #endif
212