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

source code of libcxxabi/test/incomplete_type.sh.cpp