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