1 // RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s 2 namespace test1 { 3 int x; 4 template <int& D> class T { }; 5 // CHECK: void @_ZN5test12f0ENS_1TILZNS_1xEEEE( 6 void f0(T<x> a0) {} 7 } 8 9 namespace test1 { 10 // CHECK: void @_ZN5test12f0Ef 11 void f0(float) {} 12 template<void (&)(float)> struct t1 {}; 13 // CHECK: void @_ZN5test12f1ENS_2t1ILZNS_2f0EfEEE( 14 void f1(t1<f0> a0) {} 15 } 16 17 namespace test2 { 18 // CHECK: void @_ZN5test22f0Ef 19 void f0(float) {} 20 template<void (*)(float)> struct t1 {}; 21 // FIXME: Fails because we don't treat as an expression. 22 // CHECK-FIXME: void @_ZN5test22f1ENS_2t1IXadL_ZNS_2f0EfEEEE( 23 void f1(t1<f0> a0) {} 24 } 25 26 namespace test3 { 27 // CHECK: void @test3_f0 28 extern "C" void test3_f0(float) {} 29 template<void (&)(float)> struct t1 {}; 30 // FIXME: Fails because we tack on a namespace. 31 // CHECK-FIXME: void @_ZN5test32f1ENS_2t1ILZ8test3_f0EEE( 32 void f1(t1<test3_f0> a0) {} 33 } 34 35 namespace test4 { 36 // CHECK: void @test4_f0 37 extern "C" void test4_f0(float) {} 38 template<void (*)(float)> struct t1 {}; 39 // FIXME: Fails because we don't treat as an expression. 40 // CHECK-FIXME: void @_ZN5test42f1ENS_2t1IXadL_Z8test4_f0EEEE( 41 void f1(t1<test4_f0> a0) {} 42 } 43 44 // CHECK: void @test5_f0 45 extern "C" void test5_f0(float) {} 46 int main(int) {} 47 48 namespace test5 { 49 template<void (&)(float)> struct t1 {}; 50 // CHECK: void @_ZN5test52f1ENS_2t1ILZ8test5_f0EEE( 51 void f1(t1<test5_f0> a0) {} 52 53 template<int (&)(int)> struct t2 {}; 54 // CHECK: void @_ZN5test52f2ENS_2t2ILZ4mainEEE 55 void f2(t2<main> a0) {} 56 } 57 58 // FIXME: This fails. 59 namespace test6 { 60 struct A { void im0(float); }; 61 // CHECK: void @_ZN5test61A3im0Ef 62 void A::im0(float) {} 63 template <void(A::*)(float)> class T { }; 64 // FIXME: Fails because we don't treat as an expression. 65 // CHECK-FAIL: void @_ZN5test62f0ENS_1TIXadL_ZNS_1A3im0EfEEEE( 66 void f0(T<&A::im0> a0) {} 67 } 68 69 namespace test7 { 70 template<typename T> 71 struct meta { 72 static const unsigned value = sizeof(T); 73 }; 74 75 template<unsigned> struct int_c { 76 typedef float type; 77 }; 78 79 template<typename T> 80 struct X { 81 template<typename U> 82 X(U*, typename int_c<(meta<T>::value + meta<U>::value)>::type *) { } 83 }; 84 85 // CHECK: define weak_odr {{.*}} @_ZN5test71XIiEC1IdEEPT_PNS_5int_cIXplL_ZNS_4metaIiE5valueEEsr4metaIS3_EE5valueEE4typeE( 86 template X<int>::X(double*, float*); 87 } 88 89 namespace test8 { 90 template<typename T> 91 struct meta { 92 struct type { 93 static const unsigned value = sizeof(T); 94 }; 95 }; 96 97 template<unsigned> struct int_c { 98 typedef float type; 99 }; 100 101 template<typename T> 102 void f(int_c<meta<T>::type::value>) { } 103 104 // CHECK-LABEL: define weak_odr void @_ZN5test81fIiEEvNS_5int_cIXsr4metaIT_E4typeE5valueEEE( 105 template void f<int>(int_c<sizeof(int)>); 106 } 107 108 namespace test9 { 109 template<typename T> 110 struct supermeta { 111 template<typename U> 112 struct apply { 113 typedef T U::*type; 114 }; 115 }; 116 117 struct X { }; 118 119 template<typename T, typename U> 120 typename supermeta<T>::template apply<U>::type f(); 121 122 void test_f() { 123 // CHECK: @_ZN5test91fIiNS_1XEEENS_9supermetaIT_E5applyIT0_E4typeEv() 124 // Note: GCC incorrectly mangles this as 125 // _ZN5test91fIiNS_1XEEENS_9supermetaIT_E5apply4typeEv, while EDG 126 // gets it right. 127 f<int, X>(); 128 } 129 } 130 131 namespace test10 { 132 template<typename T> 133 struct X { 134 template<typename U> 135 struct definition { 136 }; 137 }; 138 139 // CHECK: _ZN6test101fIidEENS_1XIT_E10definitionIT0_EES2_S5_ 140 template<typename T, typename U> 141 typename X<T>::template definition<U> f(T, U) { } 142 143 void g(int i, double d) { 144 f(i, d); 145 } 146 } 147 148 // Report from Jason Merrill on cxx-abi-dev, 2012.01.04. 149 namespace test11 { 150 int cmp(char a, char b); 151 template <typename T, int (*cmp)(T, T)> struct A {}; 152 template <typename T> void f(A<T,cmp> &) {} 153 template void f<char>(A<char,cmp> &); 154 // CHECK: @_ZN6test111fIcEEvRNS_1AIT_L_ZNS_3cmpEccEEE( 155 } 156 157 namespace test12 { 158 // Make sure we can mangle non-type template args with internal linkage. 159 static int f(); 160 const int n = 10; 161 template<typename T, T v> void test() {} 162 void use() { 163 // CHECK-LABEL: define internal void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv( 164 test<int(), &f>(); 165 // CHECK-LABEL: define internal void @_ZN6test124testIRFivELZNS_L1fEvEEEvv( 166 test<int(&)(), f>(); 167 // CHECK-LABEL: define internal void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv( 168 test<const int*, &n>(); 169 // CHECK-LABEL: define internal void @_ZN6test124testIRKiLZNS_L1nEEEEvv( 170 test<const int&, n>(); 171 } 172 } 173 174 // rdar://problem/12072531 175 // Test the boundary condition of minimal signed integers. 176 namespace test13 { 177 template <char c> char returnChar() { return c; } 178 template char returnChar<-128>(); 179 // CHECK: @_ZN6test1310returnCharILcn128EEEcv() 180 181 template <short s> short returnShort() { return s; } 182 template short returnShort<-32768>(); 183 // CHECK: @_ZN6test1311returnShortILsn32768EEEsv() 184 } 185