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
| // RUN: %clang_cc1 %s -O1 -disable-llvm-passes -triple=x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -O1 -disable-llvm-passes -triple=x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK2
// Instantiation order varies on different C++ dialects (IE, between C++98 and C++11).
// CHECK-DAG: @_ZN7PR100011xE = global
// CHECK-DAG: @_ZTVN5test018stdio_sync_filebufIA3_iEE = weak_odr unnamed_addr constant
// CHECK-DAG: @_ZN7PR100011SIiE3arrE = linkonce_odr global [3 x i32]
// CHECK-DAG: @_ZTVN5test018stdio_sync_filebufIA4_iEE = linkonce_odr unnamed_addr constant
// Negative checks go under prefix "CHECK2" to avoid interference with CHECK and CHECK-DAG.
// CHECK2-NOT: @_ZN7PR100014kBarE = external global i32
// CHECK2-NOT: @_ZTVN5test118stdio_sync_filebufIwEE = constant
// CHECK2-NOT: _ZTVN5test315basic_fstreamXXIcEE
// CHECK2-NOT: @_ZTVN5test018stdio_sync_filebufIA1_iEE
// CHECK2-NOT: @_ZTVN5test018stdio_sync_filebufIA2_iEE
// CHECK2-NOT: @_ZN7PR100011SIiE3arr2E = linkonce_odr global [3 x i32]A
// CHECK2-NOT: _ZTVN5test31SIiEE
// CHECK2-NOT: _ZTSN5test31SIiEE
// CHECK-LABEL: define linkonce_odr void @_ZN5test21CIiEC1Ev(%"class.test2::C"* %this) unnamed_addr
// CHECK-LABEL: define linkonce_odr void @_ZN5test21CIiE6foobarIdEEvT_(
// CHECK-LABEL: define available_externally void @_ZN5test21CIiE6zedbarEd(
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g1ENS_1SILi1EEE()
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g1ENS_1SILi2EEE()
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g1ENS_1SILi3EEE()
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g2ENS_1SILi1EEE()
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g2ENS_1SILi2EEE()
// CHECK-LABEL: define linkonce_odr void @_ZN7PR106662g2ENS_1SILi3EEE()
// CHECK: declare void @_ZN7PR106662h1ENS_1SILi1EEE()
// CHECK: declare void @_ZN7PR106662h1ENS_1SILi2EEE()
// CHECK: declare void @_ZN7PR106662h1ENS_1SILi3EEE()
// CHECK: declare void @_ZN7PR106662h2ENS_1SILi1EEE()
// CHECK: declare void @_ZN7PR106662h2ENS_1SILi2EEE()
// CHECK: declare void @_ZN7PR106662h2ENS_1SILi3EEE()
namespace test0 {
struct basic_streambuf {
virtual ~basic_streambuf();
};
template<typename _CharT >
struct stdio_sync_filebuf : public basic_streambuf {
virtual void xsgetn();
};
// This specialization is not a key function, so doesn't cause the vtable to
// be instantiated unless we're instantiating a class definition anyway.
template<> void stdio_sync_filebuf<int[1]>::xsgetn() {
}
template<> void stdio_sync_filebuf<int[2]>::xsgetn() {
}
template<> void stdio_sync_filebuf<int[3]>::xsgetn() {
}
template<> void stdio_sync_filebuf<int[4]>::xsgetn() {
}
extern template class stdio_sync_filebuf<int[2]>;
// These two both cause vtables to be emitted.
template class stdio_sync_filebuf<int[3]>;
stdio_sync_filebuf<int[4]> implicit_instantiation;
}
namespace test1 {
struct basic_streambuf {
virtual ~basic_streambuf();
};
template<typename _CharT >
struct stdio_sync_filebuf : public basic_streambuf {
virtual void xsgetn();
};
// Just a declaration should not force the vtable to be emitted.
template<> void stdio_sync_filebuf<wchar_t>::xsgetn();
}
namespace test2 {
template<typename T1>
class C {
public:
virtual ~C();
void zedbar(double) {
}
template<typename T2>
void foobar(T2 foo) {
}
};
extern template class C<int>;
void g() {
// The extern template declaration should not prevent us from producing
// the implicit constructor (test at the top).
C<int> a;
// or foobar(test at the top).
a.foobar(0.0);
// But it should prevent zebbar
// (test at the top).
a.zedbar(0.0);
}
}
namespace test3 {
template<typename T>
class basic_fstreamXX {
virtual void foo(){}
virtual void is_open() const { }
};
extern template class basic_fstreamXX<char>;
// This template instantiation should not cause us to produce a vtable.
// (test at the top).
template void basic_fstreamXX<char>::is_open() const;
}
namespace test3 {
template <typename T>
struct S {
virtual void m();
};
template<typename T>
void S<T>::m() { }
// Should not cause us to produce vtable because template instantiations
// don't have key functions.
template void S<int>::m();
}
namespace test4 {
template <class T> struct A { static void foo(); };
class B {
template <class T> friend void A<T>::foo();
B();
};
template <class T> void A<T>::foo() {
B b;
}
unsigned test() {
A<int>::foo();
}
}
namespace PR8505 {
// Hits an assertion due to bogus instantiation of class B.
template <int i> class A {
class B* g;
};
class B {
void f () {}
};
// Should not instantiate class B since it is introduced in namespace scope.
// CHECK2-NOT: _ZN6PR85051AILi0EE1B1fEv
template class A<0>;
}
// Ensure that when instantiating initializers for static data members to
// complete their type in an unevaluated context, we *do* emit initializers with
// side-effects, but *don't* emit initializers and variables which are otherwise
// unused in the program.
namespace PR10001 {
template <typename T> struct S {
static const int arr[];
static const int arr2[];
static const int x, y;
static int f();
};
extern int foo();
extern int kBar;
template <typename T> const int S<T>::arr[] = { 1, 2, foo() }; // possible side effects
template <typename T> const int S<T>::arr2[] = { 1, 2, kBar }; // no side effects
template <typename T> const int S<T>::x = sizeof(arr) / sizeof(arr[0]);
template <typename T> const int S<T>::y = sizeof(arr2) / sizeof(arr2[0]);
template <typename T> int S<T>::f() { return x + y; }
int x = S<int>::f();
}
// Ensure that definitions are emitted for all friend functions defined within
// class templates. Order of declaration is extremely important here. Different
// instantiations of the class happen at different points during the deferred
// method body parsing and afterward. Those different points of instantiation
// change the exact form the class template appears to have.
namespace PR10666 {
template <int N> struct S {
void f1() { S<1> s; }
friend void g1(S s) {}
friend void h1(S s);
void f2() { S<2> s; }
friend void g2(S s) {}
friend void h2(S s);
void f3() { S<3> s; }
};
void test(S<1> s1, S<2> s2, S<3> s3) {
g1(s1); g1(s2); g1(s3);
g2(s1); g2(s2); g2(s3);
h1(s1); h1(s2); h1(s3);
h2(s1); h2(s2); h2(s3);
}
}
|