1// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
2namespace test1 {
3int x;
4template <int& D> class T { };
5// CHECK: void @_ZN5test12f0ENS_1TILZNS_1xEEEE(
6void f0(T<x> a0) {}
7}
8
9namespace test1 {
10// CHECK: void @_ZN5test12f0Ef
11void f0(float) {}
12template<void (&)(float)> struct t1 {};
13// CHECK: void @_ZN5test12f1ENS_2t1ILZNS_2f0EfEEE(
14void f1(t1<f0> a0) {}
15}
16
17namespace test2 {
18// CHECK: void @_ZN5test22f0Ef
19void f0(float) {}
20template<void (*)(float)> struct t1 {};
21// FIXME: Fails because we don't treat as an expression.
22// CHECK-FIXME: void @_ZN5test22f1ENS_2t1IXadL_ZNS_2f0EfEEEE(
23void f1(t1<f0> a0) {}
24}
25
26namespace test3 {
27// CHECK: void @test3_f0
28extern "C" void test3_f0(float) {}
29template<void (&)(float)> struct t1 {};
30// FIXME: Fails because we tack on a namespace.
31// CHECK-FIXME: void @_ZN5test32f1ENS_2t1ILZ8test3_f0EEE(
32void f1(t1<test3_f0> a0) {}
33}
34
35namespace test4 {
36// CHECK: void @test4_f0
37extern "C" void test4_f0(float) {}
38template<void (*)(float)> struct t1 {};
39// FIXME: Fails because we don't treat as an expression.
40// CHECK-FIXME: void @_ZN5test42f1ENS_2t1IXadL_Z8test4_f0EEEE(
41void f1(t1<test4_f0> a0) {}
42}
43
44// CHECK: void @test5_f0
45extern "C" void test5_f0(float) {}
46int main(int) {}
47
48namespace test5 {
49template<void (&)(float)> struct t1 {};
50// CHECK: void @_ZN5test52f1ENS_2t1ILZ8test5_f0EEE(
51void f1(t1<test5_f0> a0) {}
52
53template<int (&)(int)> struct t2 {};
54// CHECK: void @_ZN5test52f2ENS_2t2ILZ4mainEEE
55void f2(t2<main> a0) {}
56}
57
58// FIXME: This fails.
59namespace test6 {
60struct A { void im0(float); };
61// CHECK: void @_ZN5test61A3im0Ef
62void A::im0(float) {}
63template <void(A::*)(float)> class T { };
64// FIXME: Fails because we don't treat as an expression.
65// CHECK-FAIL: void @_ZN5test62f0ENS_1TIXadL_ZNS_1A3im0EfEEEE(
66void f0(T<&A::im0> a0) {}
67}
68
69namespace 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(%"struct.test7::X"* %this, double*, float*) unnamed_addr
86  template X<int>::X(double*, float*);
87}
88
89namespace 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: define weak_odr void @_ZN5test81fIiEEvNS_5int_cIXsr4metaIT_E4typeE5valueEEE
105  template void f<int>(int_c<sizeof(int)>);
106}
107
108namespace 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
131namespace 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.
149namespace 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
157namespace 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: define internal void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv(
164    test<int(), &f>();
165    // CHECK: define internal void @_ZN6test124testIRFivEXadL_ZNS_L1fEvEEEEvv(
166    test<int(&)(), f>();
167    // CHECK: define internal void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv(
168    test<const int*, &n>();
169    // CHECK: define internal void @_ZN6test124testIRKiXadL_ZNS_L1nEEEEEvv(
170    test<const int&, n>();
171  }
172}
173