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
|
// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -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(); }; // expected-note{{declared private here}}
template<typename T>
class B {
public:
class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
static Inner i;
static const unsigned value = sizeof(i) == 4;
};
int f() { return B<int>::value; }
#ifdef MSABI
void test_typeid(B<float>::Inner bfi) { // expected-note{{implicit destructor}}
(void)typeid(bfi);
#else
void test_typeid(B<float>::Inner bfi) {
(void)typeid(bfi); // expected-note{{implicit destructor}}
#endif
}
template<typename T>
struct X : A {
void f() { }
};
void test_X(X<int> &xi, X<float> &xf) {
xi.f();
}
}
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}}
};
}
|
