1 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -fblocks -std=c++11 | FileCheck %s
5 // CHECK: @unmangled_variable = global
6 // CHECK: @_ZN1N1iE = global
7 // CHECK: @_ZZN1N1fEiiE1b = internal global
8 // CHECK: @_ZZN1N1gEvE1a = internal global
9 // CHECK: @_ZGVZN1N1gEvE1a = internal global
11 //CHECK: @pr5966_i = external global
12 //CHECK: @_ZL8pr5966_j = internal global
14 // CHECK-LABEL: define zeroext i1 @_ZplRK1YRA100_P1X
15 bool operator+(const Y&, X* (&xs)[100]) { return false; }
17 // CHECK-LABEL: define void @_Z1f1s
18 typedef struct { int a; } s;
21 // CHECK-LABEL: define void @_Z1f1e
22 typedef enum { foo } e;
25 // CHECK-LABEL: define void @_Z1f1u
26 typedef union { int a; } u;
29 // CHECK-LABEL: define void @_Z1f1x
30 typedef struct { int a; } x,y;
33 // CHECK-LABEL: define void @_Z1fv
36 // CHECK-LABEL: define void @_ZN1N1fEv
37 namespace N { void f() { } }
39 // CHECK-LABEL: define void @_ZN1N1N1fEv
40 namespace N { namespace N { void f() { } } }
42 // CHECK-LABEL: define void @unmangled_function
43 extern "C" { namespace N { void unmangled_function() { } } }
45 extern "C" { namespace N { int unmangled_variable = 10; } }
47 namespace N { int i; }
49 namespace N { int f(int, int) { static int b; return b; } }
51 namespace N { int h(); void g() { static int a = h(); } }
53 // CHECK-LABEL: define void @_Z1fno
54 void f(__int128_t, __uint128_t) { }
56 template <typename T> struct S1 {};
58 // CHECK-LABEL: define void @_Z1f2S1IiE
61 // CHECK-LABEL: define void @_Z1f2S1IdE
64 template <int N> struct S2 {};
65 // CHECK-LABEL: define void @_Z1f2S2ILi100EE
68 // CHECK-LABEL: define void @_Z1f2S2ILin100EE
71 template <bool B> struct S3 {};
73 // CHECK-LABEL: define void @_Z1f2S3ILb1EE
76 // CHECK-LABEL: define void @_Z1f2S3ILb0EE
81 // CHECK-LABEL: define void @_Z1fM1SKFvvE
82 void f(void (S::*)() const) {}
84 // CHECK-LABEL: define void @_Z1fM1SFvvE
85 void f(void (S::*)()) {}
87 // CHECK-LABEL: define void @_Z1fi
90 template<typename T, typename U> void ft1(U u, T t) { }
92 template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { }
94 template<typename T, typename U = S1<T> > struct S4 { };
95 template<typename T> void ft3(S4<T>*) { }
98 template<typename T> void ft1(T) { }
102 // CHECK: @_Z3ft1IidEvT0_T_
103 ft1<int, double>(1, 0);
105 // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_
108 // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE
111 // CHECK: @_ZN2NS3ft1IiEEvT_
116 template<int I> struct S5 { };
118 template<int I> void ft4(S5<I>) { }
120 // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE
123 // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE
133 extern "C" { struct a { int b; }; }
143 const Debug& operator<< (unsigned a) const { return *this; }
146 // CHECK: @_ZNK5DebuglsEj
147 int main(void) { dbg << 32 ;}
150 template<typename T> struct S6 {
154 template<typename T> void ft5(typename S6<T>::B) { }
155 // CHECK: @_Z3ft5IiEvN2S6IT_E1BE
156 template void ft5<int>(int);
158 template<typename T> class A {};
161 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
164 // CHECK: @_ZN2NSeqIcEEbRK1AIT_ES5_
165 template bool NS::operator==(const ::A<char>&, const ::A<char>&);
168 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
171 // CHECK: @_ZSteqIcEbRK1AIT_ES4_
172 template bool std::operator==(const ::A<char>&, const ::A<char>&);
178 template <typename T> typename T::U ft6(const T&) { return 0; }
180 // CHECK: @_Z3ft6I1SENT_1UERKS1_
181 template int ft6<S>(const S&);
183 template<typename> struct __is_scalar_type {
184 enum { __value = 1 };
187 template<bool, typename> struct __enable_if { };
189 template<typename T> struct __enable_if<true, T> {
194 template<typename T> typename __enable_if<__is_scalar_type<T>::__value, void>::__type ft7() { }
196 // CHECK: @_Z3ft7IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv
197 template void ft7<int>();
198 // CHECK: @_Z3ft7IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv
199 template void ft7<void*>();
207 void extern_f(void) { }
219 // CHECK: @_ZN2S7C2Ev
220 // CHECK: @_ZN2S7Ut_C1Ev
221 // CHECK: @_ZN2S7C1Ev
225 template<typename T> typename __enable_if<(__is_scalar_type<T>::__value), void>::__type ft8() { }
226 // CHECK: @_Z3ft8IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv
227 template void ft8<int>();
228 // CHECK: @_Z3ft8IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv
229 template void ft8<void*>();
233 template<typename> struct __is_scalar_type {
234 enum { __value = 0 };
237 template<bool, typename> struct __enable_if {};
238 template<typename T> struct __enable_if<true, T> { typedef T __type; };
241 // CHECK-LABEL: define linkonce_odr void @_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv
242 typename __enable_if<!__is_scalar_type<T>::__value, void>::__type __fill_a() { };
244 void f() { __fill_a<int>(); }
247 namespace Expressions {
250 // CHECK-LABEL: define weak_odr void @_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i
251 template <int i> void f1(int (*)[(-i) + 2]) { };
252 template void f1<1>(int (*)[1]);
254 // CHECK-LABEL: define weak_odr void @_ZN11Expressions2f2ILi1EEEvPApsT__i
255 template <int i> void f2(int (*)[+i]) { };
256 template void f2<1>(int (*)[1]);
260 // CHECK-LABEL: define weak_odr void @_ZN11Expressions2f3ILi1EEEvPAplT_T__i
261 template <int i> void f3(int (*)[i+i]) { };
262 template void f3<1>(int (*)[2]);
264 // CHECK-LABEL: define weak_odr void @_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i
265 template <int i> void f4(int (*)[2 + i+i]) { };
266 template void f4<1>(int (*)[4]);
268 // The ternary operator.
269 // CHECK-LABEL: define weak_odr void @_ZN11Expressions2f4ILb1EEEvPAquT_Li1ELi2E_i
270 template <bool b> void f4(int (*)[b ? 1 : 2]) { };
271 template void f4<true>(int (*)[1]);
275 Ops& operator+(const Ops&);
276 Ops& operator-(const Ops&);
277 Ops& operator&(const Ops&);
278 Ops& operator*(const Ops&);
283 // CHECK-LABEL: define dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsplERKS_
284 Ops& Ops::operator+(const Ops&) { return *this; }
285 // CHECK-LABEL: define dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsmiERKS_
286 Ops& Ops::operator-(const Ops&) { return *this; }
287 // CHECK-LABEL: define dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsanERKS_
288 Ops& Ops::operator&(const Ops&) { return *this; }
289 // CHECK-LABEL: define dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsmlERKS_
290 Ops& Ops::operator*(const Ops&) { return *this; }
294 template<bool> class P;
295 template<> class P<true> {};
297 template<template <bool> class, bool>
300 template<typename T, typename = Policy<P, true> > class Alloc
302 T *allocate(int, const void*) { return 0; }
305 // CHECK-LABEL: define weak_odr i8* @_ZN6PR58615AllocIcNS_6PolicyINS_1PELb1EEEE8allocateEiPKv
306 template class Alloc<char>;
309 // CHECK-LABEL: define void @_Z1fU13block_pointerFiiiE
310 void f(int (^)(int, int)) { }
327 template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {}
333 // CHECK-LABEL: define void @_ZN5test05test0Ev()
334 // CHECK-LABEL: define linkonce_odr void @_ZN5test01fIdEEvT_RAszcl3ovlcvS1__EE_c(
337 char buffer[sizeof(int)];
340 // CHECK-LABEL: define void @_ZN5test05test1Ev()
341 // CHECK-LABEL: define linkonce_odr void @_ZN5test01fIiEEvT_RAszcl3ovlcvS1__EE_c(
343 template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {}
345 char buffer[sizeof(float)];
348 // CHECK-LABEL: define linkonce_odr void @_ZN5test01gIfEEvRAszplcvT__ELf40a00000E_c(
350 template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {}
352 char buffer[sizeof(double)];
355 // CHECK-LABEL: define linkonce_odr void @_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c(
357 template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {}
358 struct A { double buffer[128]; };
363 // CHECK-LABEL: define linkonce_odr void @_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c(
365 template <class T> void k(char (&buffer)[sizeof(T() + 0.0f)]) {}
367 char buffer[sizeof(float)];
370 // CHECK-LABEL: define linkonce_odr void @_ZN5test01kIfEEvRAszplcvT__ELf00000000E_c(
375 template<typename T> struct X { };
376 template<template<class> class Y, typename T> void f(Y<T>) { }
377 // CHECK-LABEL: define weak_odr void @_ZN5test11fINS_1XEiEEvT_IT0_E
378 template void f(X<int>);
381 // CHECK-LABEL: define internal void @_ZL27functionWithInternalLinkagev()
382 static void functionWithInternalLinkage() { }
383 void g() { functionWithInternalLinkage(); }
386 template <class T> decltype(((T*) 0)->member) read_member(T& obj) {
390 struct A { int member; } obj;
392 return read_member(obj);
395 // CHECK-LABEL: define linkonce_odr i32 @_ZN5test211read_memberINS_1AEEEDtptcvPT_Li0E6memberERS2_(
398 // rdar://problem/9280586
400 struct AmbiguousBase { int ab; };
401 struct Path1 : AmbiguousBase { float p; };
402 struct Path2 : AmbiguousBase { double p; };
403 struct Derived : Path1, Path2 { };
405 // CHECK-LABEL: define linkonce_odr i32 @_ZN5test38get_ab_1INS_7DerivedEEEDtptcvPT_Li0Esr5Path1E2abERS2_(
406 template <class T> decltype(((T*) 0)->Path1::ab) get_ab_1(T &ref) { return ref.Path1::ab; }
408 // CHECK-LABEL: define linkonce_odr i32 @_ZN5test38get_ab_2INS_7DerivedEEEDtptcvPT_Li0Esr5Path2E2abERS2_(
409 template <class T> decltype(((T*) 0)->Path2::ab) get_ab_2(T &ref) { return ref.Path2::ab; }
411 // CHECK-LABEL: define linkonce_odr float @_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0Esr5Path1E1pERS2_(
412 template <class T> decltype(((T*) 0)->Path1::p) get_p_1(T &ref) { return ref.Path1::p; }
414 // CHECK-LABEL: define linkonce_odr double @_ZN5test37get_p_2INS_7DerivedEEEDtptcvPT_Li0Esr5Path2E1pERS2_(
415 template <class T> decltype(((T*) 0)->Path2::p) get_p_2(T &ref) { return ref.Path2::p; }
426 // CHECK-LABEL: define void @_ZN5test41gEPNS_3zedIXadL_ZNS_3foo3barEEEEE
428 struct foo { int bar; };
429 template <int (foo::*)>
431 void g(zed<&foo::bar>*)
434 // CHECK-LABEL: define void @_ZN5test51gEPNS_3zedIXadL_ZNS_3foo3barEEEEE
436 struct foo { static int bar; };
439 void g(zed<&foo::bar>*)
442 // CHECK-LABEL: define void @_ZN5test61gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE
444 struct foo { int bar(); };
445 template <int (foo::*)()>
447 void g(zed<&foo::bar>*)
450 // CHECK-LABEL: define void @_ZN5test71gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE
452 struct foo { static int bar(); };
453 template <int (*f)()>
455 void g(zed<&foo::bar>*)
458 // CHECK-LABEL: define weak_odr void @_ZN5test81AIL_ZNS_1B5valueEEE3incEv
460 template <int &counter> class A { void inc() { counter++; } };
461 class B { public: static int value; };
462 template class A<B::value>;
464 // CHECK: declare void @_ZN5test91fIiNS_3barEEEvRKNT0_3baz1XE
471 typedef foo<int> baz;
473 template <class zaz, class zed>
474 void f(const typename zed::baz::X&);
480 // <rdar://problem/7825453>
482 template <char P1> struct S {};
483 template <char P2> void f(struct S<false ? 'a' : P2> ) {}
485 // CHECK-LABEL: define weak_odr void @_ZN6test101fILc3EEEvNS_1SIXquLb0ELc97ET_EEE(
486 template void f<(char) 3>(struct S<3>);
490 // CHECK: @_ZN6test111fEz
497 // CHECK: @_ZN6test111A1fEz
503 // CHECK: _ZN6test121fENS_1AILt33000EEE
504 template <unsigned short> struct A { };
510 template <template <class> class T> class A {};
511 template <class U> class B {};
513 template <template<class> class T> void foo(const A<T> &a) {}
515 // CHECK-LABEL: define weak_odr void @_ZN6test133fooINS_1BEEEvRKNS_1AIT_EE(
516 template void foo(const A<B> &a);
524 // CHECK-LABEL: define i32 @_ZN6test141S1aEv
525 // CHECK: load i32, i32* @_ZN6test141S1xE
526 int S::a() { return S::x; }
530 // rdar://problem/8204122
533 template <int I> struct S {};
535 template <int I> void f(S<I + e>) {}
537 // CHECK-LABEL: define weak_odr void @_ZN6test151fILi7EEEvNS_1SIXplT_LNS_1EE3EEEE(
538 template void f<7>(S<7 + e>);
541 // rdar://problem/8302148
543 template <int N> struct A {};
546 static int foo(void);
549 template <class T> A<sizeof(T::foo())> func(void);
551 // CHECK-LABEL: define void @_ZN6test174testEv()
552 // CHECK: call {{.*}} @_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv()
566 template <int (A::*)()> struct S {};
568 template <typename T> void f(S<&T::operator+>) {}
569 template void f<A>(S<&A::operator+>);
571 template <typename T> void f(S<&T::operator- >) {}
572 template void f<A>(S<&A::operator- >);
574 template <typename T> void f(S<&T::operator*>) {}
575 template void f<A>(S<&A::operator*>);
577 template <typename T> void f(S<&T::operator&>) {}
578 template void f<A>(S<&A::operator&>);
580 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onplEEE
581 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onmiEEE
582 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onmlEEE
583 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onanEEE
586 // rdar://problem/8332117
589 template <typename T> int f();
592 template <typename T> int operator-();
595 template <int (A::*)()> struct S {};
597 template <typename T> void g (S<&T::template f<int> >) {}
598 template <typename T> void g (S<&T::operator+ >) {}
599 template <typename T> void g (S<&T::operator int>) {}
600 template <typename T> void g (S<&T::template operator- <double> >) {}
602 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE(
603 template void g<A>(S<&A::f<int> >);
604 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_onplEEE(
605 template void g<A>(S<&A::operator+>);
606 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_oncviEEE(
607 template void g<A>(S<&A::operator int>);
608 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_onmiIdEEEE(
609 template void g<A>(S<&A::operator-<double> >);
613 template <class T> T *f(const T&);
614 template <class T> T *f(T*);
616 // CHECK-LABEL: define weak_odr void @_ZN6test205test0IiEEvDTcl1fIPT_ELi0EEE(
617 template <class T> void test0(decltype(f<T*>(0))) {}
618 template void test0<int>(decltype(f<int*>(0)));
620 // CHECK-LABEL: define weak_odr void @_ZN6test205test1IiEEvDTcl1fIEcvT__EEE(
621 template <class T> void test1(decltype(f<>(T()))) {}
622 template void test1<int>(decltype(f<>(int())));
627 // CHECK-LABEL: define void @_ZN6test2112vla_arg_funcEiPA_i(
628 void vla_arg_func(int X, int a[X][X]) {}
632 // CHECK-LABEL: define void @_ZN6test221fEDn(
633 void f(decltype(nullptr)) { }
636 // rdar://problem/8913416
638 typedef void * const vpc;
640 // CHECK-LABEL: define void @_ZN6test231fERA10_KPv(
641 void f(vpc (&)[10]) {}
643 typedef vpc vpca5[5];
644 void f(vpca5 volatile (&)[10]) {}
645 // CHECK-LABEL: define void @_ZN6test231fERA10_A5_VKPv(
651 // CHECK: call i32 @_ZN6test243fooEv()
657 // CHECK: call signext i8 @_ZN6test24L3barEv()
662 // rdar://problem/8806641
664 template <void (*fn)()> struct A {
665 static void call() { fn(); }
669 // CHECK: call void @_ZN6test251AIXadL_ZNS_3fooEvEEE4callEv()
675 template <template <class> class T> void foo(decltype(T<float>::object) &object) {}
677 template <class T> struct holder { static T object; };
682 // CHECK: call void @_ZN6test263fooINS_6holderEEEvRDtsrT_IfE6objectE(
697 template <class T> void a(decltype(T::inner::object) &object) {}
698 template <class T> void b(decltype(T().Alias::meth()) &object) {}
702 // CHECK: call void @_ZN6test271aINS_1AEEEvRDtsrNT_5innerE6objectE(
704 // CHECK: call void @_ZN6test271bINS_1AEEEvRDTcldtcvT__Esr5AliasE4methEE(
709 // An injected class name type in a unresolved-name.
711 template <class T> struct A {
715 template <class T> void foo(decltype(A<T>::A::bit) x);
718 foo<char>(A<char>::bit);
719 // CHECK: call void @_ZN6test283fooIcEEvDtsr1AIT_E1AE3bitE(
723 // An enclosing template type parameter in an unresolved-name.
725 template <class T> struct A {
726 template <class U> static void foo(decltype(T::fn(U())) x);
728 struct B { static int fn(int); static long fn(long); };
732 // CHECK: call void @_ZN6test291AINS_1BEE3fooIiEEvDTclsrS1_2fncvT__EEE(
736 // An enclosing template template parameter in an unresolved-name.
738 template <template <class> class T> struct A {
739 template <class U> static void foo(decltype(T<U>::fn()) x);
741 template <class T> struct B { static T fn(); };
745 // CHECK: call void @_ZN6test301AINS_1BEE3fooIiEEvDTclsrS1_IT_EE2fnEE(
749 namespace test31 { // instantiation-dependent mangling of decltype
751 template<class T> auto f1(T p)->decltype(x) { return 0; }
752 // The return type in the mangling of the template signature
753 // is encoded as "i".
754 template<class T> auto f2(T p)->decltype(p) { return 0; }
755 // The return type in the mangling of the template signature
756 // is encoded as "Dtfp_E".
758 template<class T> auto f3(T p)->decltype(g(p)) {}
760 // CHECK-LABEL: define weak_odr i32 @_ZN6test312f1IiEEiT_(
761 template int f1(int);
762 // CHECK-LABEL: define weak_odr i32 @_ZN6test312f2IiEEDtfp_ET_
763 template int f2(int);
764 // CHECK-LABEL: define weak_odr void @_ZN6test312f3IiEEDTcl1gfp_EET_
765 template void f3(int);
770 template<typename T, int=T::value> struct A {
773 struct B { enum { value = 4 }; };
775 template <class T> typename A<T>::type foo() { return 0; }
778 // CHECK: call i32 @_ZN6test323fooINS_1BEEENS_1AIT_XsrS3_5valueEE4typeEv()
783 template <class T> struct X {
784 enum { value = T::value };
787 template<typename T, int=X<T>::value> struct A {
790 struct B { enum { value = 4 }; };
792 template <class T> typename A<T>::type foo() { return 0; }
796 // CHECK: call i32 @_ZN6test333fooINS_1BEEENS_1AIT_Xsr1XIS3_EE5valueEE4typeEv()
801 // Mangling for instantiation-dependent decltype expressions.
803 void f(decltype(sizeof(decltype(T() + T())))) {}
805 // CHECK-LABEL: define weak_odr void @_ZN6test341fIiEEvDTstDTplcvT__EcvS1__EEE
806 template void f<int>(decltype(sizeof(1)));
808 // Mangling for non-instantiation-dependent sizeof expressions.
810 void f2(int (&)[N + sizeof(int*)]) {}
812 // CHECK-LABEL: define weak_odr void @_ZN6test342f2ILj4EEEvRAplT_Lm8E_i
813 template void f2<4>(int (&)[4 + sizeof(int*)]);
815 // Mangling for non-instantiation-dependent sizeof expressions
816 // involving an implicit conversion of the result of the sizeof.
817 template<unsigned long long N>
818 void f3(int (&)[N + sizeof(int*)]) {}
820 // CHECK-LABEL: define weak_odr void @_ZN6test342f3ILy4EEEvRAplT_Ly8E_i
821 template void f3<4>(int (&)[4 + sizeof(int*)]);
823 // Mangling for instantiation-dependent sizeof() expressions as
824 // template arguments.
825 template<unsigned> struct A { };
827 template<typename T> void f4(::test34::A<sizeof(sizeof(decltype(T() + T())))>) { }
829 // CHECK-LABEL: define weak_odr void @_ZN6test342f4IiEEvNS_1AIXszstDTplcvT__EcvS2__EEEEE
830 template void f4<int>(A<sizeof(sizeof(int))>);
834 // Dependent operator names of unknown arity.
836 template<typename U> A operator+(U) const;
840 void f1(decltype(sizeof(&T::template operator+<int>))) {}
842 // CHECK-LABEL: define weak_odr void @_ZN6test352f1INS_1AEEEvDTszadsrT_onplIiEE
843 template void f1<A>(__SIZE_TYPE__);
847 template<unsigned> struct A { };
849 template<typename ...Types>
850 auto f1(Types... values) -> A<sizeof...(values)> { }
852 // CHECK: define weak_odr {{.*}} @_ZN6test362f1IJifEEENS_1AIXsZfp_EEEDpT_
853 template A<2> f1(int, float);
860 typedef struct { } b;
861 typedef struct { } *c;
865 template<typename T> void func(T) { }
867 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt_EEEvT_
869 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt0_EEEvT_
871 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt1_EEEvT_
876 // CHECK-LABEL: define void @_Z6ASfuncPU3AS3i
877 void ASfunc(__attribute__((address_space(3))) int* x) {}
880 // CHECK-LABEL: define linkonce_odr void @_ZN6test384funcINS_3fooUt_EEEvT_
886 template <typename T> void func(T) {}
887 void test() { func(foo().a); }
891 // CHECK-LABEL: define internal void @"_ZN6test394funcINS_3$_03$_1EEEvT_"
895 template<typename T> void func(T) {}
902 // CHECK: i32* {{.*}} @_ZZN6test401fEvE1a_0
915 // CHECK: define linkonce_odr void @_ZN6test414funcINS_1XEEEvNS_3fooILi20ES1_EE
916 template <int i, class T> struct foo {
917 template <class T2 = T> friend void func(foo x) {}
922 void g() { func(foo<20, X>()); }
926 // CHECK: define linkonce_odr void @_ZN6test424funcINS_1XEEEvNS_3fooILi20ES1_EE
927 template <int i, template <class> class T> struct foo {
928 template <template <class> class T2 = T> friend void func(foo x) {}
931 template <class V> struct X {
934 void g() { func(foo<20, X>()); }
938 // CHECK-LABEL: define void @_ZN6test431gEPNS_3zedIXadL_ZNS_3fooUt_3barEEEEE
939 struct foo { union { int bar; }; };
940 template <int (foo::*)>
942 void g(zed<&foo::bar>*)
947 struct foo { void bar() __restrict { }; } obj;
952 // CHECK-LABEL: define linkonce_odr void @_ZN6test443foo3barEv(%"struct.test44::foo"* %this)
959 template <typename T>
960 void f(enum T::e *) {}
961 template void f<S>(S::e *);
962 // CHECK-LABEL: define weak_odr void @_ZN6test451fINS_1SEEEvPTeNT_1eE(i32*)
969 template <typename T>
970 void f(struct T::s *) {}
971 template void f<S>(S::s *);
972 // CHECK-LABEL: define weak_odr void @_ZN6test461fINS_1SEEEvPTsNT_1sE(%"struct.test46::S::s"*)
979 template <typename T>
980 void f(class T::c *) {}
981 template void f<S>(S::c *);
982 // CHECK-LABEL: define weak_odr void @_ZN6test471fINS_1SEEEvPTsNT_1cE(%"class.test47::S::c"*)
989 template <typename T>
990 void f(union T::u *) {}
991 template void f<S>(S::u *);
992 // CHECK-LABEL: define weak_odr void @_ZN6test481fINS_1SEEEvPTuNT_1uE(%"union.test48::S::u"*)
999 template <template <int> class T>
1003 // CHECK-LABEL: declare void @_ZN6test493finINS_1SEEET_ILi3EES3_()
1010 template <template <int> class T>
1014 // CHECK-LABEL: declare void @_ZN6test503finINS_1SEEET_ILi3EES2_ILi4EE()
1018 template <typename T>
1019 decltype(T().~T()) fun() {}
1020 template void fun<int>();
1021 // CHECK-LABEL: @_ZN6test513funIiEEDTcldtcvT__EdnS1_EEv
1022 template void fun<X>();
1023 // CHECK-LABEL: @_ZN6test513funI1XEEDTcldtcvT__EdnS2_EEv
1024 template void fun<S1<int> >();
1025 // CHECK-LABEL: @_ZN6test513funI2S1IiEEEDTcldtcvT__EdnS3_EEv
1028 template <typename T>
1033 template <typename T>
1034 decltype(S1<T>().~S1<T>()) fun1() {};
1035 template <typename U, typename T>
1036 decltype(U().~S1<T>()) fun2() {}
1037 template <typename U, typename T>
1038 decltype(S1<T>().~U()) fun3() {}
1039 template <typename T>
1040 decltype(S1<T>().~S1<T>(), S1<T>().~S1<T>()) fun4() {};
1041 template <typename T>
1042 decltype(S1<int>().~S1<T>()) fun5(){};
1043 template <template <typename T> class U>
1044 decltype(S1<int>().~U<int>()) fun6(){};
1045 template <typename T>
1046 decltype(E().E::~T()) fun7() {}
1047 template <template <typename> class U>
1048 decltype(X<int>::Y().U<int>::Y::~Y()) fun8() {}
1049 template void fun1<int>();
1050 // CHECK-LABEL: @_ZN6test514fun1IiEEDTcldtcv2S1IT_E_Edn2S1IS2_EEEv
1051 template void fun2<S1<int>, int>();
1052 // CHECK-LABEL: @_ZN6test514fun2I2S1IiEiEEDTcldtcvT__Edn2S1IT0_EEEv
1053 template void fun3<S1<int>, int>();
1054 // CHECK-LABEL: @_ZN6test514fun3I2S1IiEiEEDTcldtcvS1_IT0_E_EdnT_EEv
1055 template void fun4<int>();
1056 // CHECK-LABEL: @_ZN6test514fun4IiEEDTcmcldtcv2S1IT_E_Edn2S1IS2_EEcldtcvS3__Edn2S1IS2_EEEv
1057 template void fun5<int>();
1058 // CHECK-LABEL: @_ZN6test514fun5IiEEDTcldtcv2S1IiE_Edn2S1IT_EEEv
1059 template void fun6<S1>();
1060 // CHECK-LABEL: @_ZN6test514fun6I2S1EEDTcldtcvS1_IiE_EdnT_IiEEEv
1061 template void fun7<E>();
1062 // CHECK-LABEL: @_ZN6test514fun7INS_1EEEEDTcldtcvS1__Esr1EEdnT_EEv
1063 template void fun8<X>();
1069 template <typename... T>
1070 auto f4(T... x) -> decltype(operator+(x...));
1071 // CHECK-LABEL: @_ZN6test522f4IJNS_1XEEEEDTclonplspfp_EEDpT_
1072 void use() { f4(X{}); }
1077 using t1 = struct { int z; };
1078 using t2 = struct { double z; };
1079 using t3 = struct { float z; };
1080 using t4 = struct { float z; };
1082 __attribute__((used)) c(t1) {}
1083 __attribute__((used)) c(t2) {}
1084 __attribute__((used)) c(t3) {}
1085 __attribute__((used)) c(t4) {}
1086 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t1E
1087 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t2E
1088 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t3E
1089 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t4E
1095 using t1 = struct { int z; } *;
1096 using t2 = struct { double z; } *;
1098 __attribute__((used)) c(t1) {}
1099 __attribute__((used)) c(t2) {}
1100 // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut_E
1101 // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut0_E