1 // RUN: %clang_cc1 -emit-llvm -triple i686-pc-linux-gnu -std=c++1y -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO-OPT
2 // RUN: %clang_cc1 -emit-llvm -triple i686-pc-linux-gnu -std=c++1y -O3 -disable-llvm-passes -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-OPT
3 // RUN: %clang_cc1 -emit-llvm -triple i686-pc-win32 -std=c++1y -o - %s | FileCheck %s --check-prefix=CHECK-MS
4
5 // This check logically is attached to 'template int S<int>::i;' below.
6 // CHECK: @_ZN1SIiE1iE = weak_odr global i32
7
8 // This check is logically attached to 'template int ExportedStaticLocal::f<int>()' below.
9 // CHECK-OPT: @_ZZN19ExportedStaticLocal1fIiEEvvE1i = linkonce_odr global
10
11 template<typename T, typename U, typename Result>
12 struct plus {
13 Result operator()(const T& t, const U& u) const;
14 };
15
16 template<typename T, typename U, typename Result>
operator ()(const T & t,const U & u) const17 Result plus<T, U, Result>::operator()(const T& t, const U& u) const {
18 return t + u;
19 }
20
21 // CHECK-LABEL: define weak_odr i32 @_ZNK4plusIillEclERKiRKl
22 template struct plus<int, long, long>;
23
24 namespace EarlyInstantiation {
25 // Check that we emit definitions if we instantiate a function definition before
26 // it gets explicitly instantiatied.
27 template<typename T> struct S {
constexpr_functionEarlyInstantiation::S28 constexpr int constexpr_function() { return 0; }
deduced_return_typeEarlyInstantiation::S29 auto deduced_return_type() { return 0; }
30 };
31
32 // From an implicit instantiation.
33 constexpr int a = S<char>().constexpr_function();
34 int b = S<char>().deduced_return_type();
35
36 // From an explicit instantiation declaration.
37 extern template struct S<int>;
38 constexpr int c = S<int>().constexpr_function();
39 int d = S<int>().deduced_return_type();
40
41 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE18constexpr_functionEv(
42 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE19deduced_return_typeEv(
43 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE18constexpr_functionEv(
44 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE19deduced_return_typeEv(
45 template struct S<char>;
46 template struct S<int>;
47
constexpr_function()48 template<typename T> constexpr int constexpr_function() { return 0; }
deduced_return_type()49 template<typename T> auto deduced_return_type() { return 0; }
50
51 // From an implicit instantiation.
52 constexpr int e = constexpr_function<char>();
53 int f = deduced_return_type<char>();
54
55 // From an explicit instantiation declaration.
56 extern template int constexpr_function<int>();
57 extern template auto deduced_return_type<int>();
58 constexpr int g = constexpr_function<int>();
59 int h = deduced_return_type<int>();
60
61 // The FIXMEs below are for PR19551.
62 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIcEEiv(
63 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIcEEiv(
64 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIiEEiv(
65 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIiEEiv(
66 template int constexpr_function<char>();
67 // FIXME template auto deduced_return_type<char>();
68 template int constexpr_function<int>();
69 // FIXME template auto deduced_return_type<int>();
70 }
71
72 namespace LateInstantiation {
73 // Check that we downgrade the linkage to available_externally if we see an
74 // explicit instantiation declaration after the function template is
75 // instantiated.
fLateInstantiation::S76 template<typename T> struct S { constexpr int f() { return 0; } };
f()77 template<typename T> constexpr int f() { return 0; }
78
79 // Trigger eager instantiation of the function definitions.
80 int a, b = S<char>().f() + f<char>() + a;
81 int c, d = S<int>().f() + f<int>() + a;
82
83 // Don't allow some of those definitions to be emitted.
84 extern template struct S<int>;
85 extern template int f<int>();
86
87 // Check that we declare, define, or provide an available-externally
88 // definition as appropriate.
89 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1SIcE1fEv(
90 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1fIcEEiv(
91 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1SIiE1fEv(
92 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1fIiEEiv(
93 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1SIiE1fEv(
94 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1fIiEEiv(
95 }
96
97 namespace PR21718 {
98 // The linkage of a used constexpr member function can change from linkonce_odr
99 // to weak_odr after explicit instantiation without errors about defining the
100 // same function twice.
101 template <typename T>
102 struct S {
103 // CHECK-LABEL: define weak_odr i32 @_ZN7PR217181SIiE1fEv
fPR21718::S104 __attribute__((used)) constexpr int f() { return 0; }
105 };
g()106 int g() { return S<int>().f(); }
107 template struct S<int>;
108 }
109
110 namespace NestedClasses {
111 // Check how explicit instantiation of an outer class affects the inner class.
112 template <typename T> struct Outer {
113 struct Inner {
fNestedClasses::Outer::Inner114 void f() {}
115 };
116 };
117
118 // Explicit instantiation definition of Outer causes explicit instantiation
119 // definition of Inner.
120 template struct Outer<int>;
121 // CHECK: define weak_odr void @_ZN13NestedClasses5OuterIiE5Inner1fEv
122 // CHECK-MS: define weak_odr dso_local x86_thiscallcc void @"?f@Inner@?$Outer@H@NestedClasses@@QAEXXZ"
123
124 // Explicit instantiation declaration of Outer causes explicit instantiation
125 // declaration of Inner, but not in MSVC mode.
126 extern template struct Outer<char>;
127 auto use = &Outer<char>::Inner::f;
128 // CHECK: {{declare|define available_externally}} void @_ZN13NestedClasses5OuterIcE5Inner1fEv
129 // CHECK-MS: define linkonce_odr dso_local x86_thiscallcc void @"?f@Inner@?$Outer@D@NestedClasses@@QAEXXZ"
130 }
131
132 // Check that we emit definitions from explicit instantiations even when they
133 // occur prior to the definition itself.
134 template <typename T> struct S {
135 void f();
136 static void g();
137 static int i;
138 struct S2 {
139 void h();
140 };
141 };
142
143 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1fEv
144 template void S<int>::f();
145
146 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1gEv
147 template void S<int>::g();
148
149 // See the check line at the top of the file.
150 template int S<int>::i;
151
152 // CHECK-LABEL: define weak_odr void @_ZN1SIiE2S21hEv
153 template void S<int>::S2::h();
154
f()155 template <typename T> void S<T>::f() {}
g()156 template <typename T> void S<T>::g() {}
157 template <typename T> int S<T>::i;
h()158 template <typename T> void S<T>::S2::h() {}
159
160 namespace ExportedStaticLocal {
161 void sink(int&);
162 template <typename T>
f()163 inline void f() {
164 static int i;
165 sink(i);
166 }
167 // See the check line at the top of the file.
168 extern template void f<int>();
use()169 void use() {
170 f<int>();
171 }
172 }
173
174 namespace DefaultedMembers {
175 struct B { B(); B(const B&); ~B(); };
176 template<typename T> struct A : B {
177 A() = default;
178 ~A() = default;
179 };
180 extern template struct A<int>;
181
182 // CHECK-LABEL: define {{.*}} @_ZN16DefaultedMembers1AIiEC2Ev
183 // CHECK-LABEL: define {{.*}} @_ZN16DefaultedMembers1AIiED2Ev
184 A<int> ai;
185
186 // CHECK-LABEL: define {{.*}} @_ZN16DefaultedMembers1AIiEC2ERKS1_
187 A<int> ai2(ai);
188
189 // CHECK-NOT: @_ZN16DefaultedMembers1AIcE
190 template struct A<char>;
191 }
192