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
4 // This check logically is attached to 'template int S<int>::i;' below.
5 // CHECK: @_ZN1SIiE1iE = weak_odr global i32
6
7 template<typename T, typename U, typename Result>
8 struct plus {
9 Result operator()(const T& t, const U& u) const;
10 };
11
12 template<typename T, typename U, typename Result>
operator ()(const T & t,const U & u) const13 Result plus<T, U, Result>::operator()(const T& t, const U& u) const {
14 return t + u;
15 }
16
17 // CHECK-LABEL: define weak_odr i32 @_ZNK4plusIillEclERKiRKl
18 template struct plus<int, long, long>;
19
20 namespace EarlyInstantiation {
21 // Check that we emit definitions if we instantiate a function definition before
22 // it gets explicitly instantiatied.
23 template<typename T> struct S {
constexpr_functionEarlyInstantiation::S24 constexpr int constexpr_function() { return 0; }
deduced_return_typeEarlyInstantiation::S25 auto deduced_return_type() { return 0; }
26 };
27
28 // From an implicit instantiation.
29 constexpr int a = S<char>().constexpr_function();
30 int b = S<char>().deduced_return_type();
31
32 // From an explicit instantiation declaration.
33 extern template struct S<int>;
34 constexpr int c = S<int>().constexpr_function();
35 int d = S<int>().deduced_return_type();
36
37 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE18constexpr_functionEv(
38 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIcE19deduced_return_typeEv(
39 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE18constexpr_functionEv(
40 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation1SIiE19deduced_return_typeEv(
41 template struct S<char>;
42 template struct S<int>;
43
constexpr_function()44 template<typename T> constexpr int constexpr_function() { return 0; }
deduced_return_type()45 template<typename T> auto deduced_return_type() { return 0; }
46
47 // From an implicit instantiation.
48 constexpr int e = constexpr_function<char>();
49 int f = deduced_return_type<char>();
50
51 // From an explicit instantiation declaration.
52 extern template int constexpr_function<int>();
53 extern template auto deduced_return_type<int>();
54 constexpr int g = constexpr_function<int>();
55 int h = deduced_return_type<int>();
56
57 // The FIXMEs below are for PR19551.
58 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIcEEiv(
59 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIcEEiv(
60 // CHECK: define weak_odr i32 @_ZN18EarlyInstantiation18constexpr_functionIiEEiv(
61 // FIXME: define weak_odr i32 @_ZN18EarlyInstantiation19deduced_return_typeIiEEiv(
62 template int constexpr_function<char>();
63 // FIXME template auto deduced_return_type<char>();
64 template int constexpr_function<int>();
65 // FIXME template auto deduced_return_type<int>();
66 }
67
68 namespace LateInstantiation {
69 // Check that we downgrade the linkage to available_externally if we see an
70 // explicit instantiation declaration after the function template is
71 // instantiated.
fLateInstantiation::S72 template<typename T> struct S { constexpr int f() { return 0; } };
f()73 template<typename T> constexpr int f() { return 0; }
74
75 // Trigger eager instantiation of the function definitions.
76 int a, b = S<char>().f() + f<char>() + a;
77 int c, d = S<int>().f() + f<int>() + a;
78
79 // Don't allow some of those definitions to be emitted.
80 extern template struct S<int>;
81 extern template int f<int>();
82
83 // Check that we declare, define, or provide an available-externally
84 // definition as appropriate.
85 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1SIcE1fEv(
86 // CHECK: define linkonce_odr i32 @_ZN17LateInstantiation1fIcEEiv(
87 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1SIiE1fEv(
88 // CHECK-NO-OPT: declare i32 @_ZN17LateInstantiation1fIiEEiv(
89 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1SIiE1fEv(
90 // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1fIiEEiv(
91 }
92
93 namespace PR21718 {
94 // The linkage of a used constexpr member function can change from linkonce_odr
95 // to weak_odr after explicit instantiation without errors about defining the
96 // same function twice.
97 template <typename T>
98 struct S {
99 // CHECK-LABEL: define weak_odr i32 @_ZN7PR217181SIiE1fEv
fPR21718::S100 __attribute__((used)) constexpr int f() { return 0; }
101 };
g()102 int g() { return S<int>().f(); }
103 template struct S<int>;
104 }
105
106 // Check that we emit definitions from explicit instantiations even when they
107 // occur prior to the definition itself.
108 template <typename T> struct S {
109 void f();
110 static void g();
111 static int i;
112 struct S2 {
113 void h();
114 };
115 };
116
117 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1fEv
118 template void S<int>::f();
119
120 // CHECK-LABEL: define weak_odr void @_ZN1SIiE1gEv
121 template void S<int>::g();
122
123 // See the check line at the top of the file.
124 template int S<int>::i;
125
126 // CHECK-LABEL: define weak_odr void @_ZN1SIiE2S21hEv
127 template void S<int>::S2::h();
128
f()129 template <typename T> void S<T>::f() {}
g()130 template <typename T> void S<T>::g() {}
131 template <typename T> int S<T>::i;
h()132 template <typename T> void S<T>::S2::h() {}
133