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-optzns -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 template<typename T, typename U, typename Result>
9 struct plus {
10 Result operator()(const T& t, const U& u) const;
11 };
12
13 template<typename T, typename U, typename Result>
operator ()(const T & t,const U & u) const14 Result plus<T, U, Result>::operator()(const T& t, const U& u) const {
15 return t + u;
16 }
17
18 // CHECK-LABEL: define weak_odr i32 @_ZNK4plusIillEclERKiRKl
19 template struct plus<int, long, long>;
20
21 namespace EarlyInstantiation {
22 // Check that we emit definitions if we instantiate a function definition before
23 // it gets explicitly instantiatied.
24 template<typename T> struct S {
constexpr_functionEarlyInstantiation::S25 constexpr int constexpr_function() { return 0; }
deduced_return_typeEarlyInstantiation::S26 auto deduced_return_type() { return 0; }
27 };
28
29 // From an implicit instantiation.
30 constexpr int a = S<char>().constexpr_function();
31 int b = S<char>().deduced_return_type();
32
33 // From an explicit instantiation declaration.
34 extern template struct S<int>;
35 constexpr int c = S<int>().constexpr_function();
36 int d = S<int>().deduced_return_type();
37
38 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE18constexpr_functionEv(
39 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE19deduced_return_typeEv(
40 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE18constexpr_functionEv(
41 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE19deduced_return_typeEv(
42 template struct S<char>;
43 template struct S<int>;
44
constexpr_function()45 template<typename T> constexpr int constexpr_function() { return 0; }
deduced_return_type()46 template<typename T> auto deduced_return_type() { return 0; }
47
48 // From an implicit instantiation.
49 constexpr int e = constexpr_function<char>();
50 int f = deduced_return_type<char>();
51
52 // From an explicit instantiation declaration.
53 extern template int constexpr_function<int>();
54 extern template auto deduced_return_type<int>();
55 constexpr int g = constexpr_function<int>();
56 int h = deduced_return_type<int>();
57
58 // The FIXMEs below are for PR19551.
59 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIcEEiv(
60 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIcEEiv(
61 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIiEEiv(
62 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIiEEiv(
63 template int constexpr_function<char>();
64 // FIXME template auto deduced_return_type<char>();
65 template int constexpr_function<int>();
66 // FIXME template auto deduced_return_type<int>();
67 }
68
69 namespace LateInstantiation {
70 // Check that we downgrade the linkage to available_externally if we see an
71 // explicit instantiation declaration after the function template is
72 // instantiated.
fLateInstantiation::S73 template<typename T> struct S { constexpr int f() { return 0; } };
f()74 template<typename T> constexpr int f() { return 0; }
75
76 // Trigger eager instantiation of the function definitions.
77 int a, b = S<char>().f() + f<char>() + a;
78 int c, d = S<int>().f() + f<int>() + a;
79
80 // Don't allow some of those definitions to be emitted.
81 extern template struct S<int>;
82 extern template int f<int>();
83
84 // Check that we declare, define, or provide an available-externally
85 // definition as appropriate.
86 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1SIcE1fEv(
87 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1fIcEEiv(
88 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1SIiE1fEv(
89 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1fIiEEiv(
90 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1SIiE1fEv(
91 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1fIiEEiv(
92 }
93
94 namespace PR21718 {
95 // The linkage of a used constexpr member function can change from linkonce_odr
96 // to weak_odr after explicit instantiation without errors about defining the
97 // same function twice.
98 template <typename T>
99 struct S {
100 // CHECK-LABEL: define weak_odr i32 @_ZN7PR217181SIiE1fEv
fPR21718::S101 __attribute__((used)) constexpr int f() { return 0; }
102 };
g()103 int g() { return S<int>().f(); }
104 template struct S<int>;
105 }
106
107 namespace NestedClasses {
108 // Check how explicit instantiation of an outer class affects the inner class.
109 template <typename T> struct Outer {
110 struct Inner {
fNestedClasses::Outer::Inner111 void f() {}
112 };
113 };
114
115 // Explicit instantiation definition of Outer causes explicit instantiation
116 // definition of Inner.
117 template struct Outer<int>;
118 // CHECK: define weak_odr void @_ZN13NestedClasses5OuterIiE5Inner1fEv
119 // CHECK-MS: define weak_odr x86_thiscallcc void @"\01?f@Inner@?$Outer@H@NestedClasses@@QAEXXZ"
120
121 // Explicit instantiation declaration of Outer causes explicit instantiation
122 // declaration of Inner, but not in MSVC mode.
123 extern template struct Outer<char>;
124 auto use = &Outer<char>::Inner::f;
125 // CHECK: {{declare|define available_externally}} void @_ZN13NestedClasses5OuterIcE5Inner1fEv
126 // CHECK-MS: define linkonce_odr x86_thiscallcc void @"\01?f@Inner@?$Outer@D@NestedClasses@@QAEXXZ"
127 }
128
129 // Check that we emit definitions from explicit instantiations even when they
130 // occur prior to the definition itself.
131 template <typename T> struct S {
132 void f();
133 static void g();
134 static int i;
135 struct S2 {
136 void h();
137 };
138 };
139
140 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1fEv
141 template void S<int>::f();
142
143 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1gEv
144 template void S<int>::g();
145
146 // See the check line at the top of the file.
147 template int S<int>::i;
148
149 // CHECK-LABEL: define weak_odr void @_ZN1SIiE2S21hEv
150 template void S<int>::S2::h();
151
f()152 template <typename T> void S<T>::f() {}
g()153 template <typename T> void S<T>::g() {}
154 template <typename T> int S<T>::i;
h()155 template <typename T> void S<T>::S2::h() {}
156