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> 14 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 { 25 constexpr int constexpr_function() { return 0; } 26 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 45 template<typename T> constexpr int constexpr_function() { return 0; } 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. 73 template<typename T> struct S { constexpr int f() { return 0; } }; 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 101 __attribute__((used)) constexpr int f() { return 0; } 102 }; 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 { 111 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 152 template <typename T> void S<T>::f() {} 153 template <typename T> void S<T>::g() {} 154 template <typename T> int S<T>::i; 155 template <typename T> void S<T>::S2::h() {} 156
