1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++98 %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++11 %s
// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++98 -verify %s
// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++11 -verify %s
namespace PR5557 {
template <class T> struct A {
A(); // expected-note{{instantiation}}
virtual int a(T x);
};
template<class T> A<T>::A() {}
template<class T> int A<T>::a(T x) {
return *x; // expected-error{{requires pointer operand}}
}
void f() {
A<int> x; // expected-note{{instantiation}}
}
template<typename T>
struct X {
virtual void f();
};
template<>
void X<int>::f() { }
}
// Like PR5557, but with a defined destructor instead of a defined constructor.
namespace PR5557_dtor {
template <class T> struct A {
A(); // Don't have an implicit constructor.
~A(); // expected-note{{instantiation}}
virtual int a(T x);
};
template<class T> A<T>::~A() {}
template<class T> int A<T>::a(T x) {
return *x; // expected-error{{requires pointer operand}}
}
void f() {
A<int> x; // expected-note{{instantiation}}
}
}
template<typename T>
struct Base {
virtual ~Base() {
int *ptr = 0;
T t = ptr; // expected-error{{cannot initialize}}
}
};
template<typename T>
struct Derived : Base<T> {
virtual void foo() { }
};
template struct Derived<int>; // expected-note {{in instantiation of member function 'Base<int>::~Base' requested here}}
template<typename T>
struct HasOutOfLineKey {
HasOutOfLineKey() { } // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::f' requested here}}
virtual T *f(float *fp);
};
template<typename T>
T *HasOutOfLineKey<T>::f(float *fp) {
return fp; // expected-error{{cannot initialize return object of type 'int *' with an lvalue of type 'float *'}}
}
HasOutOfLineKey<int> out_of_line; // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::HasOutOfLineKey' requested here}}
namespace std {
class type_info;
}
namespace PR7114 {
class A { virtual ~A(); };
#if __cplusplus <= 199711L
// expected-note@-2{{declared private here}}
#else
// expected-note@-4 3 {{overridden virtual function is here}}
#endif
template<typename T>
class B {
public:
class Inner : public A { };
#if __cplusplus <= 199711L
// expected-error@-2{{base class 'PR7114::A' has private destructor}}
#else
// expected-error@-4 2 {{deleted function '~Inner' cannot override a non-deleted function}}
// expected-note@-5 2 {{destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor}}
#ifdef MSABI
// expected-note@-7 1 {{destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor}}
#endif
#endif
static Inner i;
static const unsigned value = sizeof(i) == 4;
#if __cplusplus >= 201103L
// expected-note@-2 {{in instantiation of member class 'PR7114::B<int>::Inner' requested here}}
// expected-note@-3 {{in instantiation of member class 'PR7114::B<float>::Inner' requested here}}
#endif
};
int f() { return B<int>::value; }
#if __cplusplus >= 201103L
// expected-note@-2 {{in instantiation of template class 'PR7114::B<int>' requested here}}
#endif
#ifdef MSABI
void test_typeid(B<float>::Inner bfi) {
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor}}
#else
// expected-error@-4 {{attempt to use a deleted function}}
// expected-note@-5 {{in instantiation of template class 'PR7114::B<float>' requested here}}
#endif
(void)typeid(bfi);
#else
void test_typeid(B<float>::Inner bfi) {
#if __cplusplus >= 201103L
// expected-note@-2 {{in instantiation of template class 'PR7114::B<float>' requested here}}
#endif
(void)typeid(bfi);
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor}}
#endif
#endif
}
template<typename T>
struct X : A {
#if __cplusplus >= 201103L
// expected-error@-2 {{deleted function '~X' cannot override a non-deleted function}}
// expected-note@-3 {{destructor of 'X<int>' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor}}
#endif
void f() { }
};
void test_X(X<int> &xi, X<float> &xf) {
xi.f();
#if __cplusplus >= 201103L
// expected-note@-2 {{in instantiation of template class 'PR7114::X<int>' requested here}}
#endif
}
}
namespace DynamicCast {
struct Y {};
template<typename T> struct X : virtual Y {
virtual void foo() { T x; }
};
template<typename T> struct X2 : virtual Y {
virtual void foo() { T x; }
};
Y* f(X<void>* x) { return dynamic_cast<Y*>(x); }
Y* f2(X<void>* x) { return dynamic_cast<Y*>(x); }
}
namespace avoid_using_vtable {
// We shouldn't emit the vtable for this code, in any ABI. If we emit the
// vtable, we emit an implicit virtual dtor, which calls ~RefPtr, which requires
// a complete type for DeclaredOnly.
//
// Previously we would reference the vtable in the MS C++ ABI, even though we
// don't need to emit either the ctor or the dtor. In the Itanium C++ ABI, the
// 'trace' method is the key function, so even though we use the vtable, we
// don't emit it.
template <typename T>
struct RefPtr {
T *m_ptr;
~RefPtr() { m_ptr->deref(); }
};
struct DeclaredOnly;
struct Base {
virtual ~Base();
};
struct AvoidVTable : Base {
RefPtr<DeclaredOnly> m_insertionStyle;
virtual void trace();
AvoidVTable();
};
// Don't call the dtor, because that will emit an implicit dtor, and require a
// complete type for DeclaredOnly.
void foo() { new AvoidVTable; }
}
namespace vtable_uses_incomplete {
// Opposite of the previous test that avoids a vtable, this one tests that we
// use the vtable when the ctor is defined inline.
template <typename T>
struct RefPtr {
T *m_ptr;
~RefPtr() { m_ptr->deref(); } // expected-error {{member access into incomplete type 'vtable_uses_incomplete::DeclaredOnly'}}
};
struct DeclaredOnly; // expected-note {{forward declaration of 'vtable_uses_incomplete::DeclaredOnly'}}
struct Base {
virtual ~Base();
};
struct UsesVTable : Base {
RefPtr<DeclaredOnly> m_insertionStyle;
virtual void trace();
UsesVTable() {} // expected-note {{in instantiation of member function 'vtable_uses_incomplete::RefPtr<vtable_uses_incomplete::DeclaredOnly>::~RefPtr' requested here}}
};
}
|
