1250 lines · cpp
1// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -fblocks -std=c++11 | FileCheck %s2struct X { };3struct Y { };4 5// CHECK: @unmangled_variable ={{.*}} global6// CHECK: @_ZN1N1iE ={{.*}} global7// CHECK: @_ZZN1N1fEiiE1b = internal global8// CHECK: @_ZZN1N1gEvE1a = internal global9// CHECK: @_ZGVZN1N1gEvE1a = internal global10 11//CHECK: @pr5966_i = external global12//CHECK: @_ZL8pr5966_j = internal global13 14// CHECK-LABEL: define{{.*}} zeroext i1 @_ZplRK1YRA100_P1X15bool operator+(const Y&, X* (&xs)[100]) { return false; }16 17// CHECK-LABEL: define{{.*}} void @_Z1f1s18typedef struct { int a; } s;19void f(s) { }20 21// CHECK-LABEL: define{{.*}} void @_Z1f1e22typedef enum { foo } e;23void f(e) { }24 25// CHECK-LABEL: define{{.*}} void @_Z1f1u26typedef union { int a; } u;27void f(u) { }28 29// CHECK-LABEL: define{{.*}} void @_Z1f1x30typedef struct { int a; } x,y;31void f(y) { }32 33// CHECK-LABEL: define{{.*}} void @_Z1fv34void f() { }35 36// CHECK-LABEL: define{{.*}} void @_ZN1N1fEv37namespace N { void f() { } }38 39// CHECK-LABEL: define{{.*}} void @_ZN1N1N1fEv40namespace N { namespace N { void f() { } } }41 42// CHECK-LABEL: define{{.*}} void @unmangled_function43extern "C" { namespace N { void unmangled_function() { } } }44 45extern "C" { namespace N { int unmangled_variable = 10; } }46 47namespace N { int i; }48 49namespace N { int f(int, int) { static int b; return b; } }50 51namespace N { int h(); void g() { static int a = h(); } }52 53// CHECK-LABEL: define{{.*}} void @_Z1fno54void f(__int128_t, __uint128_t) {}55 56template <typename T> struct S1 {};57 58// CHECK-LABEL: define{{.*}} void @_Z1f2S1IiE59void f(S1<int>) {}60 61// CHECK-LABEL: define{{.*}} void @_Z1f2S1IdE62void f(S1<double>) {}63 64template <int N> struct S2 {};65// CHECK-LABEL: define{{.*}} void @_Z1f2S2ILi100EE66void f(S2<100>) {}67 68// CHECK-LABEL: define{{.*}} void @_Z1f2S2ILin100EE69void f(S2<-100>) {}70 71template <bool B> struct S3 {};72 73// CHECK-LABEL: define{{.*}} void @_Z1f2S3ILb1EE74void f(S3<true>) {}75 76// CHECK-LABEL: define{{.*}} void @_Z1f2S3ILb0EE77void f(S3<false>) {}78 79struct S;80 81// CHECK-LABEL: define{{.*}} void @_Z1fM1SKFvvE82void f(void (S::*)() const) {}83 84// CHECK-LABEL: define{{.*}} void @_Z1fM1SFvvE85void f(void (S::*)()) {}86 87// CHECK-LABEL: define{{.*}} void @_Z1fi88void f(const int) { }89 90template<typename T, typename U> void ft1(U u, T t) { }91 92template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { }93 94template<typename T, typename U = S1<T> > struct S4 { };95template<typename T> void ft3(S4<T>*) { }96 97namespace NS {98 template<typename T> void ft1(T) { }99}100 101void g1() {102 // CHECK: @_Z3ft1IidEvT0_T_103 ft1<int, double>(1, 0);104 105 // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_106 ft2<char>(1, 0, 0);107 108 // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE109 ft3<int>(0);110 111 // CHECK: @_ZN2NS3ft1IiEEvT_112 NS::ft1<int>(1);113}114 115// Expressions116template<int I> struct S5 { };117 118template<int I> void ft4(S5<I>) { }119void g2() {120 // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE121 ft4(S5<10>());122 123 // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE124 ft4(S5<20>());125}126 127extern "C++" {128 // CHECK: @_Z1hv129void h() {}130}131 132// PR5019133extern "C" { struct a { int b; }; }134 135// CHECK: @_Z1fP1a136int f(struct a *x) {137 return x->b;138}139 140// PR5017141extern "C" {142struct Debug {143 const Debug& operator<< (unsigned a) const { return *this; }144};145Debug dbg;146// CHECK: @_ZNK5DebuglsEj147int main(void) { dbg << 32 ;}148}149 150template<typename T> struct S6 {151 typedef int B;152};153 154template<typename T> void ft5(typename S6<T>::B) { }155// CHECK: @_Z3ft5IiEvN2S6IT_E1BE156template void ft5<int>(int);157 158template<typename T> class A {};159 160namespace NS {161template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }162}163 164// CHECK: @_ZN2NSeqIcEEbRK1AIT_ES5_165template bool NS::operator==(const ::A<char>&, const ::A<char>&);166 167namespace std {168template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }169}170 171// CHECK: @_ZSteqIcEbRK1AIT_ES4_172template bool std::operator==(const ::A<char>&, const ::A<char>&);173 174struct S {175 typedef int U;176};177 178template <typename T> typename T::U ft6(const T&) { return 0; }179 180// CHECK: @_Z3ft6I1SENT_1UERKS1_181template int ft6<S>(const S&);182 183template<typename> struct __is_scalar_type {184 enum { __value = 1 };185};186 187template<bool, typename> struct __enable_if { };188 189template<typename T> struct __enable_if<true, T> {190 typedef T __type;191};192 193// PR5063194template<typename T> typename __enable_if<__is_scalar_type<T>::__value, void>::__type ft7() { }195 196// CHECK: @_Z3ft7IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv197template void ft7<int>();198// CHECK: @_Z3ft7IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv199template void ft7<void*>();200 201// PR5144202extern "C" {203void extern_f(void);204};205 206// CHECK: @extern_f207void extern_f(void) { }208 209struct S7 {210 S7();211 212 struct S { S(); };213 struct {214 S s;215 } a;216};217 218// PR5139219// CHECK: @_ZN2S7C2Ev220// CHECK: @_ZN2S7Ut_C1Ev221// CHECK: @_ZN2S7C1Ev222S7::S7() {}223 224// PR5063225template<typename T> typename __enable_if<(__is_scalar_type<T>::__value), void>::__type ft8() { }226// CHECK: @_Z3ft8IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv227template void ft8<int>();228// CHECK: @_Z3ft8IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv229template void ft8<void*>();230 231// PR5796232namespace PR5796 {233template<typename> struct __is_scalar_type {234 enum { __value = 0 };235};236 237template<bool, typename> struct __enable_if {};238template<typename T> struct __enable_if<true, T> { typedef T __type; };239template<typename T>240 241// CHECK-LABEL: define linkonce_odr void @_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv242typename __enable_if<!__is_scalar_type<T>::__value, void>::__type __fill_a() { };243 244void f() { __fill_a<int>(); }245}246 247namespace Expressions {248// Unary operators.249 250// CHECK-LABEL: define weak_odr void @_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i251template <int i> void f1(int (*)[(-i) + 2]) { };252template void f1<1>(int (*)[1]);253 254// CHECK-LABEL: define weak_odr void @_ZN11Expressions2f2ILi1EEEvPApsT__i255template <int i> void f2(int (*)[+i]) { };256template void f2<1>(int (*)[1]);257 258// Binary operators.259 260// CHECK-LABEL: define weak_odr void @_ZN11Expressions2f3ILi1EEEvPAplT_T__i261template <int i> void f3(int (*)[i+i]) { };262template void f3<1>(int (*)[2]);263 264// CHECK-LABEL: define weak_odr void @_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i265template <int i> void f4(int (*)[2 + i+i]) { };266template void f4<1>(int (*)[4]);267 268// The ternary operator.269// CHECK-LABEL: define weak_odr void @_ZN11Expressions2f4ILb1EEEvPAquT_Li1ELi2E_i270template <bool b> void f4(int (*)[b ? 1 : 2]) { };271template void f4<true>(int (*)[1]);272}273 274struct Ops {275 Ops& operator+(const Ops&);276 Ops& operator-(const Ops&);277 Ops& operator&(const Ops&);278 Ops& operator*(const Ops&);279 280 void *v;281};282 283// CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr @_ZN3OpsplERKS_284Ops& Ops::operator+(const Ops&) { return *this; }285// CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr @_ZN3OpsmiERKS_286Ops& Ops::operator-(const Ops&) { return *this; }287// CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr @_ZN3OpsanERKS_288Ops& Ops::operator&(const Ops&) { return *this; }289// CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr @_ZN3OpsmlERKS_290Ops& Ops::operator*(const Ops&) { return *this; }291 292// PR5861293namespace PR5861 {294template<bool> class P;295template<> class P<true> {};296 297template<template <bool> class, bool>298struct Policy { };299 300template<typename T, typename = Policy<P, true> > class Alloc301{302 T *allocate(int, const void*) { return 0; }303};304 305// CHECK-LABEL: define weak_odr noundef ptr @_ZN6PR58615AllocIcNS_6PolicyINS_1PELb1EEEE8allocateEiPKv306template class Alloc<char>;307}308 309// CHECK-LABEL: define{{.*}} void @_Z1fU13block_pointerFiiiE310void f(int (^)(int, int)) { }311 312void pr5966_foo() {313 extern int pr5966_i;314 pr5966_i = 0;315}316 317static int pr5966_j;318 319void pr5966_bar() {320 pr5966_j = 0;321}322 323namespace test0 {324 int ovl(int x);325 char ovl(double x);326 327 template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {}328 329 void test0() {330 char buffer[1];331 f(0.0, buffer);332 }333 // CHECK-LABEL: define{{.*}} void @_ZN5test05test0Ev()334 // CHECK-LABEL: define linkonce_odr void @_ZN5test01fIdEEvT_RAszcl3ovlcvS1__EE_c(335 336 void test1() {337 char buffer[sizeof(int)];338 f(1, buffer);339 }340 // CHECK-LABEL: define{{.*}} void @_ZN5test05test1Ev()341 // CHECK-LABEL: define linkonce_odr void @_ZN5test01fIiEEvT_RAszcl3ovlcvS1__EE_c(342 343 template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {}344 void test2() {345 char buffer[sizeof(float)];346 g<float>(buffer);347 }348 // CHECK-LABEL: define linkonce_odr void @_ZN5test01gIfEEvRAszplcvT__ELf40a00000E_c(349 350 template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {}351 void test3() {352 char buffer[sizeof(double)];353 h<float>(buffer);354 }355 // CHECK-LABEL: define linkonce_odr void @_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c(356 357 template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {}358 struct A { double buffer[128]; };359 void test4() {360 char buffer[1024];361 j<A>(buffer);362 }363 // CHECK-LABEL: define linkonce_odr void @_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c(364 365 template <class T> void k(char (&buffer)[sizeof(T() + 0.0f)]) {}366 void test5() {367 char buffer[sizeof(float)];368 k<float>(buffer);369 }370 // CHECK-LABEL: define linkonce_odr void @_ZN5test01kIfEEvRAszplcvT__ELf00000000E_c(371 372}373 374namespace test1 {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_E378 template void f(X<int>);379}380 381// CHECK-LABEL: define internal void @_ZL27functionWithInternalLinkagev()382static void functionWithInternalLinkage() { }383void g() { functionWithInternalLinkage(); }384 385namespace test2 {386 template <class T> decltype(((T*) 0)->member) read_member(T& obj) {387 return obj.member;388 }389 390 struct A { int member; } obj;391 int test() {392 return read_member(obj);393 }394 395 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZN5test211read_memberINS_1AEEEDtptcvPT_Li0E6memberERS2_(396}397 398namespace test3 {399 struct AmbiguousBase { int ab; };400 struct Path1 : AmbiguousBase { float p; };401 struct Path2 : AmbiguousBase { double p; };402 struct Derived : Path1, Path2 { };403 404 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZN5test38get_ab_1INS_7DerivedEEEDtptcvPT_Li0Esr5Path1E2abERS2_(405 template <class T> decltype(((T*) 0)->Path1::ab) get_ab_1(T &ref) { return ref.Path1::ab; }406 407 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZN5test38get_ab_2INS_7DerivedEEEDtptcvPT_Li0Esr5Path2E2abERS2_(408 template <class T> decltype(((T*) 0)->Path2::ab) get_ab_2(T &ref) { return ref.Path2::ab; }409 410 // CHECK-LABEL: define linkonce_odr noundef float @_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0Esr5Path1E1pERS2_(411 template <class T> decltype(((T*) 0)->Path1::p) get_p_1(T &ref) { return ref.Path1::p; }412 413 // CHECK-LABEL: define linkonce_odr noundef double @_ZN5test37get_p_2INS_7DerivedEEEDtptcvPT_Li0Esr5Path2E1pERS2_(414 template <class T> decltype(((T*) 0)->Path2::p) get_p_2(T &ref) { return ref.Path2::p; }415 416 Derived obj;417 void test() {418 get_ab_1(obj);419 get_ab_2(obj);420 get_p_1(obj);421 get_p_2(obj);422 }423}424 425// CHECK-LABEL: define{{.*}} void @_ZN5test41gEPNS_3zedIXadL_ZNS_3foo3barEEEEE426namespace test4 {427 struct foo { int bar; };428 template <int (foo::*)>429 struct zed {};430 void g(zed<&foo::bar>*)431 {}432}433// CHECK-LABEL: define{{.*}} void @_ZN5test51gEPNS_3zedIXadL_ZNS_3foo3barEEEEE434namespace test5 {435 struct foo { static int bar; };436 template <int *>437 struct zed {};438 void g(zed<&foo::bar>*)439 {}440}441// CHECK-LABEL: define{{.*}} void @_ZN5test61gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE442namespace test6 {443 struct foo { int bar(); };444 template <int (foo::*)()>445 struct zed {};446 void g(zed<&foo::bar>*)447 {}448}449// CHECK-LABEL: define{{.*}} void @_ZN5test71gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE450namespace test7 {451 struct foo { static int bar(); };452 template <int (*f)()>453 struct zed {};454 void g(zed<&foo::bar>*)455 {}456}457// CHECK-LABEL: define weak_odr void @_ZN5test81AIL_ZNS_1B5valueEEE3incEv458namespace test8 {459 template <int &counter> class A { void inc() { counter++; } };460 class B { public: static int value; };461 template class A<B::value>;462}463// CHECK: declare void @_ZN5test91fIiNS_3barEEEvRKNT0_3baz1XE464namespace test9 {465 template<class T>466 struct foo {467 typedef T X;468 };469 struct bar {470 typedef foo<int> baz;471 };472 template <class zaz, class zed>473 void f(const typename zed::baz::X&);474 void g() {475 f<int, bar>( 0);476 }477}478 479namespace test10 {480 template <char P1> struct S {};481 template <char P2> void f(struct S<false ? 'a' : P2> ) {}482 483 // CHECK-LABEL: define weak_odr void @_ZN6test101fILc3EEEvNS_1SIXquLb0ELc97ET_EEE(484 template void f<(char) 3>(struct S<3>);485}486 487namespace test11 {488 // CHECK: @_ZN6test111fEz489 void f(...) { }490 491 struct A {492 void f(...);493 };494 495 // CHECK: @_ZN6test111A1fEz496 void A::f(...) { }497}498 499namespace test12 {500 501 // CHECK: _ZN6test121fENS_1AILt33000EEE502 template <unsigned short> struct A { };503 void f(A<33000>) { }504}505 506// PR7446507namespace test13 {508 template <template <class> class T> class A {};509 template <class U> class B {};510 511 template <template<class> class T> void foo(const A<T> &a) {}512 513 // CHECK-LABEL: define weak_odr void @_ZN6test133fooINS_1BEEEvRKNS_1AIT_EE(514 template void foo(const A<B> &a);515}516 517namespace test14 {518 extern "C" {519 struct S {520 static int a(), x;521 };522 // CHECK-LABEL: define{{.*}} i32 @_ZN6test141S1aEv523 // CHECK: load i32, ptr @_ZN6test141S1xE524 int S::a() { return S::x; }525 }526}527 528namespace test15 {529 enum E { e = 3 };530 template <int I> struct S {};531 532 template <int I> void f(S<I + e>) {}533 534 // CHECK-LABEL: define weak_odr void @_ZN6test151fILi7EEEvNS_1SIXplT_LNS_1EE3EEEE(535 template void f<7>(S<7 + e>);536}537 538namespace test17 {539 template <int N> struct A {};540 541 struct B {542 static int foo(void);543 };544 545 template <class T> A<sizeof(T::foo())> func(void);546 547 // CHECK-LABEL: define{{.*}} void @_ZN6test174testEv()548 // CHECK: call {{.*}} @_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv()549 void test() {550 func<B>();551 }552}553 554// PR7891555namespace test18 {556 struct A {557 int operator+();558 int operator-();559 int operator*();560 int operator&();561 };562 template <int (A::*)()> struct S {};563 564 template <typename T> void f(S<&T::operator+>) {}565 template void f<A>(S<&A::operator+>);566 567 template <typename T> void f(S<&T::operator- >) {}568 template void f<A>(S<&A::operator- >);569 570 template <typename T> void f(S<&T::operator*>) {}571 template void f<A>(S<&A::operator*>);572 573 template <typename T> void f(S<&T::operator&>) {}574 template void f<A>(S<&A::operator&>);575 576 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onplEEE577 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onmiEEE578 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onmlEEE579 // CHECK-LABEL: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_onanEEE580}581 582namespace test19 {583 struct A {584 template <typename T> int f();585 int operator+();586 operator int();587 template <typename T> int operator-();588 };589 590 template <int (A::*)()> struct S {};591 592 template <typename T> void g (S<&T::template f<int> >) {}593 template <typename T> void g (S<&T::operator+ >) {}594 template <typename T> void g (S<&T::operator int>) {}595 template <typename T> void g (S<&T::template operator- <double> >) {}596 597 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE(598 template void g<A>(S<&A::f<int> >);599 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_onplEEE(600 template void g<A>(S<&A::operator+>);601 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_oncviEEE(602 template void g<A>(S<&A::operator int>);603 // CHECK-LABEL: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_onmiIdEEEE(604 template void g<A>(S<&A::operator-<double> >);605}606 607namespace test20 {608 template <class T> T *f(const T&);609 template <class T> T *f(T*);610 611 // CHECK-LABEL: define weak_odr void @_ZN6test205test0IiEEvDTcl1fIPT_ELi0EEE(612 template <class T> void test0(decltype(f<T*>(0))) {}613 template void test0<int>(decltype(f<int*>(0)));614 615 // CHECK-LABEL: define weak_odr void @_ZN6test205test1IiEEvDTcl1fIEcvT__EEE(616 template <class T> void test1(decltype(f<>(T()))) {}617 template void test1<int>(decltype(f<>(int())));618}619 620namespace test21 {621 // CHECK-LABEL: define{{.*}} void @_ZN6test2112vla_arg_funcEiPA_i(622 void vla_arg_func(int X, int a[X][X]) {}623}624 625namespace test22 {626 // CHECK-LABEL: define{{.*}} void @_ZN6test221fEDn(627 void f(decltype(nullptr)) { }628}629 630namespace test23 {631 typedef void * const vpc;632 633 // CHECK-LABEL: define{{.*}} void @_ZN6test231fERA10_KPv(634 void f(vpc (&)[10]) {}635 636 typedef vpc vpca5[5];637 void f(vpca5 volatile (&)[10]) {}638 // CHECK-LABEL: define{{.*}} void @_ZN6test231fERA10_A5_VKPv(639}640 641namespace test24 {642 void test0() {643 extern int foo();644 // CHECK: call noundef i32 @_ZN6test243fooEv()645 foo();646 }647 648 static char bar() { return 0; }649 void test1() {650 // CHECK: call noundef signext i8 @_ZN6test24L3barEv()651 bar();652 }653}654 655namespace test25 {656 template <void (*fn)()> struct A {657 static void call() { fn(); }658 };659 void foo();660 void test() {661 // CHECK: call void @_ZN6test251AIXadL_ZNS_3fooEvEEE4callEv()662 A<foo>::call();663 }664}665 666namespace test26 {667 template <template <class> class T> void foo(decltype(T<float>::object) &object) {}668 669 template <class T> struct holder { static T object; };670 671 void test() {672 float f;673 674 // CHECK: call void @_ZN6test263fooINS_6holderEEEvRDtsrT_IfE6objectE(675 foo<holder>(f);676 }677}678 679namespace test27 {680 struct A {681 struct inner {682 float object;683 };684 685 float meth();686 };687 typedef A Alias;688 689 template <class T> void a(decltype(T::inner::object) &object) {}690 template <class T> void b(decltype(T().Alias::meth()) &object) {}691 692 void test() {693 float f;694 // CHECK: call void @_ZN6test271aINS_1AEEEvRDtsrNT_5innerE6objectE(695 a<A>(f);696 // CHECK: call void @_ZN6test271bINS_1AEEEvRDTcldtcvT__Esr5AliasE4methEE(697 b<A>(f);698 }699}700 701// An injected class name type in a unresolved-name.702namespace test28 {703 template <class T> struct A {704 enum { bit };705 };706 707 template <class T> void foo(decltype(A<T>::A::bit) x);708 709 void test() {710 foo<char>(A<char>::bit);711 // CHECK: call void @_ZN6test283fooIcEEvDtsr1AIT_E1AE3bitE(712 }713}714 715// An enclosing template type parameter in an unresolved-name.716namespace test29 {717 template <class T> struct A {718 template <class U> static void foo(decltype(T::fn(U())) x);719 };720 struct B { static int fn(int); static long fn(long); };721 722 void test() {723 A<B>::foo<int>(0);724 // CHECK: call void @_ZN6test291AINS_1BEE3fooIiEEvDTclsrS1_2fncvT__EEE(725 }726}727 728// An enclosing template template parameter in an unresolved-name.729namespace test30 {730 template <template <class> class T> struct A {731 template <class U> static void foo(decltype(T<U>::fn()) x);732 };733 template <class T> struct B { static T fn(); };734 735 void test() {736 A<B>::foo<int>(0);737 // CHECK: call void @_ZN6test301AINS_1BEE3fooIiEEvDTclsrS1_IT_EE2fnEE(738 }739}740 741namespace test31 { // instantiation-dependent mangling of decltype742 int x;743 template<class T> auto f1(T p)->decltype(x) { return 0; }744 // The return type in the mangling of the template signature745 // is encoded as "i".746 template<class T> auto f2(T p)->decltype(p) { return 0; }747 // The return type in the mangling of the template signature748 // is encoded as "Dtfp_E".749 void g(int);750 template<class T> auto f3(T p)->decltype(g(p)) {}751 752 // CHECK-LABEL: define weak_odr noundef i32 @_ZN6test312f1IiEEiT_(753 template int f1(int);754 // CHECK-LABEL: define weak_odr noundef i32 @_ZN6test312f2IiEEDtfp_ET_755 template int f2(int);756 // CHECK-LABEL: define weak_odr void @_ZN6test312f3IiEEDTcl1gfp_EET_757 template void f3(int);758}759 760// PR10205761namespace test32 {762 template<typename T, int=T::value> struct A {763 typedef int type;764 };765 struct B { enum { value = 4 }; };766 767 template <class T> typename A<T>::type foo() { return 0; }768 void test() {769 foo<B>();770 // CHECK: call noundef i32 @_ZN6test323fooINS_1BEEENS_1AIT_XsrS3_5valueEE4typeEv()771 }772}773 774namespace test33 {775 template <class T> struct X {776 enum { value = T::value };777 };778 779 template<typename T, int=X<T>::value> struct A {780 typedef int type;781 };782 struct B { enum { value = 4 }; };783 784 template <class T> typename A<T>::type foo() { return 0; }785 786 void test() {787 foo<B>();788 // CHECK: call noundef i32 @_ZN6test333fooINS_1BEEENS_1AIT_Xsr1XIS3_EE5valueEE4typeEv()789 }790}791 792namespace test34 {793 // Mangling for instantiation-dependent decltype expressions.794 template<typename T>795 void f(decltype(sizeof(decltype(T() + T())))) {}796 797 // CHECK-LABEL: define weak_odr void @_ZN6test341fIiEEvDTstDTplcvT__EcvS1__EEE798 template void f<int>(decltype(sizeof(1)));799 800 // Mangling for non-instantiation-dependent sizeof expressions.801 template<unsigned N>802 void f2(int (&)[N + sizeof(int*)]) {}803 804 // CHECK-LABEL: define weak_odr void @_ZN6test342f2ILj4EEEvRAplT_Lm8E_i805 template void f2<4>(int (&)[4 + sizeof(int*)]);806 807 // Mangling for non-instantiation-dependent sizeof expressions808 // involving an implicit conversion of the result of the sizeof.809 template<unsigned long long N>810 void f3(int (&)[N + sizeof(int*)]) {}811 812 // CHECK-LABEL: define weak_odr void @_ZN6test342f3ILy4EEEvRAplT_Ly8E_i813 template void f3<4>(int (&)[4 + sizeof(int*)]);814 815 // Mangling for instantiation-dependent sizeof() expressions as816 // template arguments.817 template<unsigned> struct A { };818 819 template<typename T> void f4(::test34::A<sizeof(sizeof(decltype(T() + T())))>) { }820 821 // CHECK-LABEL: define weak_odr void @_ZN6test342f4IiEEvNS_1AIXszstDTplcvT__EcvS2__EEEEE822 template void f4<int>(A<sizeof(sizeof(int))>);823}824 825namespace test35 {826 // Dependent operator names of unknown arity.827struct A {828 template <typename U> A operator+(U) const;829};830 831 template<typename T>832 void f1(decltype(sizeof(&T::template operator+<int>))) {}833 834 // CHECK-LABEL: define weak_odr void @_ZN6test352f1INS_1AEEEvDTszadsrT_onplIiEE835 template void f1<A>(__SIZE_TYPE__);836}837 838namespace test36 {839 template<unsigned> struct A { };840 841 template<typename ...Types>842 auto f1(Types... values) -> A<sizeof...(values)> { return {}; }843 844 // CHECK: define weak_odr {{.*}} @_ZN6test362f1IJifEEENS_1AIXsZfp_EEEDpT_845 template A<2> f1(int, float);846}847 848namespace test37 {849 struct foo {850 struct {851 } a;852 typedef struct { } b;853 typedef struct { } *c;854 struct {855 } d;856 };857 template<typename T> void func(T) { }858 void test() {859 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt_EEEvT_860 func(foo().a);861 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt0_EEEvT_862 func(*foo::c());863 // CHECK-LABEL: define linkonce_odr void @_ZN6test374funcINS_3fooUt1_EEEvT_864 func(foo().d);865 }866}867 868// CHECK-LABEL: define{{.*}} void @_Z6ASfuncPU3AS3i869void ASfunc(__attribute__((address_space(3))) int* x) {}870 871namespace test38 {872 // CHECK-LABEL: define linkonce_odr void @_ZN6test384funcINS_3fooUt_EEEvT_873 typedef struct {874 struct {875 } a;876 } foo;877 878 template <typename T> void func(T) {}879 void test() { func(foo().a); }880}881 882namespace test39 {883 // CHECK-LABEL: define internal void @"_ZN6test394funcINS_3$_03$_1EEEvT_"884 typedef struct {885 struct {} a;886 } *foo;887 template<typename T> void func(T) {}888 void test() {889 foo x;890 func(x->a);891 }892}893 894namespace test40 {895 // CHECK: ptr {{.*}} @_ZZN6test401fEvE1a_0896 void h(int&);897 inline void f() {898 if (0) {899 static int a;900 }901 static int a;902 h(a);903 };904 void g() { f(); }905}906 907namespace test41 {908 // CHECK: define linkonce_odr void @_ZN6test414funcINS_1XEEEvNS_3fooILi20ES1_EE909 template <int i, class T> struct foo {910 template <class T2 = T> friend void func(foo x) {}911 };912 913 struct X {};914 915 void g() { func(foo<20, X>()); }916}917 918namespace test42 {919 // CHECK: define linkonce_odr void @_ZN6test424funcINS_1XEEEvNS_3fooILi20ES1_EE920 template <int i, template <class> class T> struct foo {921 template <template <class> class T2 = T> friend void func(foo x) {}922 };923 924 template <class V> struct X {925 };926 927 void g() { func(foo<20, X>()); }928}929 930namespace test43 {931 // CHECK-LABEL: define{{.*}} void @_ZN6test431gEPNS_3zedIXadL_ZNS_3fooUt_3barEEEEE932 struct foo { union { int bar; }; };933 template <int (foo::*)>934 struct zed {};935 void g(zed<&foo::bar>*)936 {}937}938 939namespace test44 {940 struct foo { void bar() __restrict { }; } obj;941 942 void f() {943 obj.bar();944 }945 // CHECK-LABEL: define linkonce_odr void @_ZN6test443foo3barEv(ptr {{[^,]*}} %this)946}947 948namespace test45 {949 struct S {950 enum e {};951 };952 template <typename T>953 void f(enum T::e *) {}954 template void f<S>(S::e *);955 // CHECK-LABEL: define weak_odr void @_ZN6test451fINS_1SEEEvPTeNT_1eE(ptr noundef %0)956}957 958namespace test46 {959 struct S {960 struct s {};961 };962 template <typename T>963 void f(struct T::s *) {}964 template void f<S>(S::s *);965 // CHECK-LABEL: define weak_odr void @_ZN6test461fINS_1SEEEvPTsNT_1sE(ptr noundef %0)966}967 968namespace test47 {969 struct S {970 class c {};971 };972 template <typename T>973 void f(class T::c *) {}974 template void f<S>(S::c *);975 // CHECK-LABEL: define weak_odr void @_ZN6test471fINS_1SEEEvPTsNT_1cE(ptr noundef %0)976}977 978namespace test48 {979 struct S {980 union u {};981 };982 template <typename T>983 void f(union T::u *) {}984 template void f<S>(S::u *);985 // CHECK-LABEL: define weak_odr void @_ZN6test481fINS_1SEEEvPTuNT_1uE(ptr noundef %0)986}987 988namespace test49 {989 template <int>990 struct S {};991 992 template <template <int> class T>993 T<3> fin(T<3>);994 995 auto v = fin<S>;996 // CHECK-LABEL: declare void @_ZN6test493finINS_1SEEET_ILi3EES3_()997}998 999namespace test50 {1000 template <int>1001 struct S {};1002 1003 template <template <int> class T>1004 T<3> fin(T<4>);1005 1006 auto v = fin<S>;1007 // CHECK-LABEL: declare void @_ZN6test503finINS_1SEEET_ILi3EES2_ILi4EE()1008}1009 1010namespace test51 {1011 template <typename T>1012 decltype(T().~T()) fun() {}1013 template void fun<int>();1014 // CHECK-LABEL: @_ZN6test513funIiEEDTcldtcvT__EdnS1_EEv1015 template void fun<X>();1016 // CHECK-LABEL: @_ZN6test513funI1XEEDTcldtcvT__EdnS2_EEv1017 template void fun<S1<int> >();1018 // CHECK-LABEL: @_ZN6test513funI2S1IiEEEDTcldtcvT__EdnS3_EEv1019 1020 enum E {};1021 template <typename T>1022 struct X {1023 struct Y {};1024 };1025 1026 template <typename T>1027 decltype(S1<T>().~S1<T>()) fun1() {};1028 template <typename U, typename T>1029 decltype(U().~S1<T>()) fun2() {}1030 template <typename U, typename T>1031 decltype(S1<T>().~U()) fun3() {}1032 template <typename T>1033 decltype(S1<T>().~S1<T>(), S1<T>().~S1<T>()) fun4() {};1034 template <typename T>1035 decltype(E().E::~T()) fun7() {}1036 template <template <typename> class U>1037 decltype(X<int>::Y().U<int>::Y::~Y()) fun8() {}1038 template void fun1<int>();1039 // CHECK-LABEL: @_ZN6test514fun1IiEEDTcldtcv2S1IT_E_Edn2S1IS2_EEEv1040 template void fun2<S1<int>, int>();1041 // CHECK-LABEL: @_ZN6test514fun2I2S1IiEiEEDTcldtcvT__Edn2S1IT0_EEEv1042 template void fun3<S1<int>, int>();1043 // CHECK-LABEL: @_ZN6test514fun3I2S1IiEiEEDTcldtcvS1_IT0_E_EdnT_EEv1044 template void fun4<int>();1045 // CHECK-LABEL: @_ZN6test514fun4IiEEDTcmcldtcv2S1IT_E_Edn2S1IS2_EEcldtcvS3__Edn2S1IS2_EEEv1046 template void fun7<E>();1047 // CHECK-LABEL: @_ZN6test514fun7INS_1EEEEDTcldtcvS1__Esr1EEdnT_EEv1048 template void fun8<X>();1049}1050 1051namespace test52 {1052struct X {};1053void operator+(X);1054template <typename... T>1055auto f4(T... x) -> decltype(operator+(x...));1056// CHECK-LABEL: @_ZN6test522f4IJNS_1XEEEEDTclonplspfp_EEDpT_1057void use() { f4(X{}); }1058}1059 1060namespace test53 {1061struct c {1062 using t1 = struct { int z; };1063 using t2 = struct { double z; };1064 using t3 = struct { float z; };1065 using t4 = struct { float z; };1066 1067 __attribute__((used)) c(t1) {}1068 __attribute__((used)) c(t2) {}1069 __attribute__((used)) c(t3) {}1070 __attribute__((used)) c(t4) {}1071 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t1E1072 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t2E1073 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t3E1074 // CHECK-LABEL: @_ZN6test531cC2ENS0_2t4E1075};1076}1077 1078namespace test54 {1079struct c {1080 using t1 = struct { int z; } *;1081 using t2 = struct { double z; } *;1082 1083 __attribute__((used)) c(t1) {}1084 __attribute__((used)) c(t2) {}1085 // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut_E1086 // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut0_E1087};1088}1089 1090namespace test55 {1091enum E { R };1092 1093template <typename T>1094void f1(T, __underlying_type(T)) {}1095template void f1<E>(E, __underlying_type(E));1096// CHECK-LABEL: @_ZN6test552f1INS_1EEEEvT_u17__underlying_typeIS2_E1097 1098template <typename T> void f2(T, __add_lvalue_reference(T)) {}1099template void f2<int>(int, __add_lvalue_reference(int));1100// CHECK-LABEL: @_ZN6test552f2IiEEvT_u22__add_lvalue_referenceIS1_E1101 1102template <typename T> void f3(T, __add_pointer(T)) {}1103template void f3<int>(int, __add_pointer(int));1104// CHECK-LABEL: @_ZN6test552f3IiEEvT_u13__add_pointerIS1_E1105 1106template <typename T> void f4(T, __add_rvalue_reference(T)) {}1107template void f4<int>(int, __add_rvalue_reference(int));1108// CHECK-LABEL: @_ZN6test552f4IiEEvT_u22__add_rvalue_referenceIS1_E1109 1110template <typename T> void f5(T, __decay(T)) {}1111template void f5<int>(int, __decay(int));1112// CHECK-LABEL: @_ZN6test552f5IiEEvT_u7__decayIS1_E1113 1114template <typename T> void f6(T, __make_signed(T)) {}1115template void f6<int>(int, __make_signed(int));1116// CHECK-LABEL: @_ZN6test552f6IiEEvT_u13__make_signedIS1_E1117 1118template <typename T> void f7(T, __make_unsigned(T)) {}1119template void f7<int>(int, __make_unsigned(int));1120// CHECK-LABEL: @_ZN6test552f7IiEEvT_u15__make_unsignedIS1_E1121 1122template <typename T> void f8(T, __remove_const(T)) {}1123template void f8<int>(int, __remove_const(int));1124// CHECK-LABEL: @_ZN6test552f8IiEEvT_u14__remove_constIS1_E1125 1126template <typename T> void f9(T, __remove_cv(T)) {}1127template void f9<int>(int, __remove_cv(int));1128// CHECK-LABEL: @_ZN6test552f9IiEEvT_u11__remove_cvIS1_E1129 1130template <typename T> void f10(T, __remove_cvref(T)) {}1131template void f10<int>(int, __remove_cvref(int));1132// CHECK-LABEL: @_ZN6test553f10IiEEvT_u14__remove_cvrefIS1_E1133 1134template <typename T> void f11(T, __remove_volatile(T)) {}1135template void f11<int>(int, __remove_volatile(int));1136// CHECK-LABEL: @_ZN6test553f11IiEEvT_u17__remove_volatileIS1_E1137 1138template <typename T> void f12(T, __remove_extent(T)) {}1139template void f12<int>(int, __remove_extent(int));1140// CHECK-LABEL: @_ZN6test553f12IiEEvT_u15__remove_extentIS1_E1141 1142template <typename T> void f13(T, __remove_all_extents(T)) {}1143template void f13<int>(int, __remove_all_extents(int));1144// CHECK-LABEL: @_ZN6test553f13IiEEvT_u20__remove_all_extentsIS1_E1145 1146template <typename T> void f14(T, __remove_pointer(T)) {}1147template void f14<int>(int, __remove_pointer(int));1148// CHECK-LABEL: @_ZN6test553f14IiEEvT_u16__remove_pointerIS1_E1149 1150template <typename T> void f15(T, __remove_reference_t(T)) {}1151template void f15<int>(int, __remove_reference_t(int));1152// CHECK-LABEL: @_ZN6test553f15IiEEvT_u20__remove_reference_tIS1_E1153 1154template <typename T> void f16(T, __remove_volatile(T)) {}1155template void f16<int>(int, __remove_volatile(int));1156// CHECK-LABEL: @_ZN6test553f16IiEEvT_u17__remove_volatileIS1_E1157 1158template <typename T> void f17(T, __remove_restrict(T)) {}1159template void f17<int>(int, __remove_restrict(int));1160// CHECK-LABEL: @_ZN6test553f17IiEEvT_u17__remove_restrictIS1_E1161 1162struct S{};1163template <class T> void f18(decltype(__builtin_structured_binding_size(T))) {}1164template void f18<S>(__SIZE_TYPE__);1165// CHECK: void @_ZN6test553f18INS_1SEEEvDTu33__builtin_structured_binding_sizeT_EE1166 1167} // namespace test551168 1169namespace test56 {1170 struct A { A *operator->(); int n; } a;1171 template<int N> void f(decltype(a->n + N)) {}1172 // CHECK-LABEL: @_ZN6test561fILi0EEEvDTplptL_ZNS_1aEE1nT_E1173 template void f<0>(int);1174}1175 1176namespace test57 {1177 struct X { template <int N> int f(); } x;1178 template<int N> void f(decltype(x.f<0>() + N)) {}1179 // CHECK-LABEL: @_ZN6test571fILi0EEEvDTplcldtL_ZNS_1xEE1fILi0EEET_E1180 template void f<0>(int);1181}1182 1183namespace test58 {1184 struct State {1185 bool m_fn1();1186 } a;1187 template <class T> struct identity { typedef T type; };1188 struct A {1189 template <typename T> A(T, bool (identity<T>::type::*)());1190 };1191 // CHECK-LABEL: @_ZN6test581AC1INS_5StateEEET_MNS_8identityIS3_E4typeEFbvE1192 void fn1() { A(a, &State::m_fn1); }1193}1194 1195namespace test59 {1196 // verify no crash.1197 template<typename T>1198 void f(T g) {1199 auto [e] = g;1200 [](decltype(e)) {};1201 }1202}1203 1204namespace test60 {1205 struct X { int i, j; };1206 auto [a,b] = X{1,2};1207 template<typename T> void f(decltype(a + T())) {}1208 // CHECK-LABEL: @_ZN6test601fIiEEvDTplL_ZNS_1aEEcvT__EE1209 template void f<int>(int);1210}1211 1212namespace test61 {1213 struct X {1214 struct Y {1215 using a = int;1216 using b = int;1217 };1218 };1219 template <typename T> void f(typename T::Y::a, typename T::Y::b) {}1220 // CHECK-LABEL: @_ZN6test611fINS_1XEEEvNT_1Y1aENS3_1bE1221 template void f<X>(int, int);1222}1223 1224namespace test62 {1225 template <class> struct integral_constant {1226 static const int value = true;1227 };1228 template <int> struct _OrImpl {};1229 template <class _Args> using _Or = _OrImpl<_Args::value>;1230 template <class _Up>1231 void f(_Or<integral_constant<_Up>>) {}1232 // CHECK-LABEL: @_ZN6test621fIiEEvNS_7_OrImplIXsr17integral_constantIT_EE5valueEEE1233 template void f<int>(_OrImpl<1>);1234} // namespace test621235 1236namespace test63 {1237 namespace {1238 template <class, class> struct integral_constant {1239 static const int value = true;1240 };1241 template <class, class> struct _And {};1242 template <int> struct _OrImpl {};1243 template <class _First> using _Or = _OrImpl<_First::value>;1244 template <class _Up>1245 void f(_And<integral_constant<int, void>, _Or<integral_constant<_Up, int>>>);1246 } // namespace1247 // CHECK-LABEL: @_ZN6test6312_GLOBAL__N_11fIiEEvNS0_4_AndINS0_17integral_constantIivEENS0_7_OrImplIXsr17integral_constantIT_iEE5valueEEEEE1248 void g() { f<int>({}); }1249} // namespace test631250