mangle.cpp revision 6dbce19fdae4cfae4eb5f826284978e723a04e61
1// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -fblocks -std=c++0x | FileCheck %s 2struct X { }; 3struct Y { }; 4 5// CHECK: @unmangled_variable = global 6// CHECK: @_ZN1N1iE = global 7// CHECK: @_ZZN1N1fEiiE1b = internal global 8// CHECK: @_ZZN1N1gEvE1a = internal global 9// CHECK: @_ZGVZN1N1gEvE1a = internal global 10 11//CHECK: @pr5966_i = external global 12//CHECK: @_ZL8pr5966_i = internal global 13 14// CHECK: define zeroext i1 @_ZplRK1YRA100_P1X 15bool operator+(const Y&, X* (&xs)[100]) { return false; } 16 17// CHECK: define void @_Z1f1s 18typedef struct { int a; } s; 19void f(s) { } 20 21// CHECK: define void @_Z1f1e 22typedef enum { foo } e; 23void f(e) { } 24 25// CHECK: define void @_Z1f1u 26typedef union { int a; } u; 27void f(u) { } 28 29// CHECK: define void @_Z1f1x 30typedef struct { int a; } x,y; 31void f(y) { } 32 33// CHECK: define void @_Z1fv 34void f() { } 35 36// CHECK: define void @_ZN1N1fEv 37namespace N { void f() { } } 38 39// CHECK: define void @_ZN1N1N1fEv 40namespace N { namespace N { void f() { } } } 41 42// CHECK: define void @unmangled_function 43extern "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: define void @_Z1fno 54void f(__int128_t, __uint128_t) { } 55 56template <typename T> struct S1 {}; 57 58// CHECK: define void @_Z1f2S1IiE 59void f(S1<int>) {} 60 61// CHECK: define void @_Z1f2S1IdE 62void f(S1<double>) {} 63 64template <int N> struct S2 {}; 65// CHECK: define void @_Z1f2S2ILi100EE 66void f(S2<100>) {} 67 68// CHECK: define void @_Z1f2S2ILin100EE 69void f(S2<-100>) {} 70 71template <bool B> struct S3 {}; 72 73// CHECK: define void @_Z1f2S3ILb1EE 74void f(S3<true>) {} 75 76// CHECK: define void @_Z1f2S3ILb0EE 77void f(S3<false>) {} 78 79// CHECK: define void @_Z2f22S3ILb1EE 80void f2(S3<100>) {} 81 82struct S; 83 84// CHECK: define void @_Z1fM1SKFvvE 85void f(void (S::*)() const) {} 86 87// CHECK: define void @_Z1fM1SFvvE 88void f(void (S::*)()) {} 89 90// CHECK: define void @_Z1fi 91void f(const int) { } 92 93template<typename T, typename U> void ft1(U u, T t) { } 94 95template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { } 96 97template<typename T, typename U = S1<T> > struct S4 { }; 98template<typename T> void ft3(S4<T>*) { } 99 100namespace NS { 101 template<typename T> void ft1(T) { } 102} 103 104void g1() { 105 // CHECK: @_Z3ft1IidEvT0_T_ 106 ft1<int, double>(1, 0); 107 108 // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_ 109 ft2<char>(1, 0, 0); 110 111 // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE 112 ft3<int>(0); 113 114 // CHECK: @_ZN2NS3ft1IiEEvT_ 115 NS::ft1<int>(1); 116} 117 118// Expressions 119template<int I> struct S5 { }; 120 121template<int I> void ft4(S5<I>) { } 122void g2() { 123 // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE 124 ft4(S5<10>()); 125 126 // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE 127 ft4(S5<20>()); 128} 129 130extern "C++" { 131 // CHECK: @_Z1hv 132 void h() { } 133} 134 135// PR5019 136extern "C" { struct a { int b; }; } 137 138// CHECK: @_Z1fP1a 139int f(struct a *x) { 140 return x->b; 141} 142 143// PR5017 144extern "C" { 145struct Debug { 146 const Debug& operator<< (unsigned a) const { return *this; } 147}; 148Debug dbg; 149// CHECK: @_ZNK5DebuglsEj 150int main(void) { dbg << 32 ;} 151} 152 153template<typename T> struct S6 { 154 typedef int B; 155}; 156 157template<typename T> void ft5(typename S6<T>::B) { } 158// CHECK: @_Z3ft5IiEvN2S6IT_E1BE 159template void ft5<int>(int); 160 161template<typename T> class A {}; 162 163namespace NS { 164template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; } 165} 166 167// CHECK: @_ZN2NSeqIcEEbRK1AIT_ES5_ 168template bool NS::operator==(const ::A<char>&, const ::A<char>&); 169 170namespace std { 171template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; } 172} 173 174// CHECK: @_ZSteqIcEbRK1AIT_ES4_ 175template bool std::operator==(const ::A<char>&, const ::A<char>&); 176 177struct S { 178 typedef int U; 179}; 180 181template <typename T> typename T::U ft6(const T&) { return 0; } 182 183// CHECK: @_Z3ft6I1SENT_1UERKS1_ 184template int ft6<S>(const S&); 185 186template<typename> struct __is_scalar { 187 enum { __value = 1 }; 188}; 189 190template<bool, typename> struct __enable_if { }; 191 192template<typename T> struct __enable_if<true, T> { 193 typedef T __type; 194}; 195 196// PR5063 197template<typename T> typename __enable_if<__is_scalar<T>::__value, void>::__type ft7() { } 198 199// CHECK: @_Z3ft7IiEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv 200template void ft7<int>(); 201// CHECK: @_Z3ft7IPvEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv 202template void ft7<void*>(); 203 204// PR5144 205extern "C" { 206void extern_f(void); 207}; 208 209// CHECK: @extern_f 210void extern_f(void) { } 211 212struct S7 { 213 S7(); 214 215 struct S { S(); }; 216 struct { 217 S s; 218 } a; 219}; 220 221// PR5139 222// CHECK: @_ZN2S7C1Ev 223// CHECK: @_ZN2S7C2Ev 224// CHECK: @"_ZN2S73$_0C1Ev" 225S7::S7() {} 226 227// PR5063 228template<typename T> typename __enable_if<(__is_scalar<T>::__value), void>::__type ft8() { } 229// CHECK: @_Z3ft8IiEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv 230template void ft8<int>(); 231// CHECK: @_Z3ft8IPvEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv 232template void ft8<void*>(); 233 234// PR5796 235namespace PR5796 { 236template<typename> struct __is_scalar { 237 enum { __value = 0 }; 238}; 239 240template<bool, typename> struct __enable_if {}; 241template<typename T> struct __enable_if<true, T> { typedef T __type; }; 242template<typename T> 243 244// CHECK: define linkonce_odr void @_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsrNS_11__is_scalarIT_EE7__valueEvE6__typeEv 245typename __enable_if<!__is_scalar<T>::__value, void>::__type __fill_a() { }; 246 247void f() { __fill_a<int>(); } 248} 249 250namespace Expressions { 251// Unary operators. 252 253// CHECK: define weak_odr void @_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i 254template <int i> void f1(int (*)[(-i) + 2]) { }; 255template void f1<1>(int (*)[1]); 256 257// CHECK: define weak_odr void @_ZN11Expressions2f2ILi1EEEvPApsT__i 258template <int i> void f2(int (*)[+i]) { }; 259template void f2<1>(int (*)[1]); 260 261// Binary operators. 262 263// CHECK: define weak_odr void @_ZN11Expressions2f3ILi1EEEvPAplT_T__i 264template <int i> void f3(int (*)[i+i]) { }; 265template void f3<1>(int (*)[2]); 266 267// CHECK: define weak_odr void @_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i 268template <int i> void f4(int (*)[2 + i+i]) { }; 269template void f4<1>(int (*)[4]); 270 271// The ternary operator. 272// CHECK: define weak_odr void @_ZN11Expressions2f4ILb1EEEvPAquT_Li1ELi2E_i 273template <bool b> void f4(int (*)[b ? 1 : 2]) { }; 274template void f4<true>(int (*)[1]); 275} 276 277struct Ops { 278 Ops& operator+(const Ops&); 279 Ops& operator-(const Ops&); 280 Ops& operator&(const Ops&); 281 Ops& operator*(const Ops&); 282 283 void *v; 284}; 285 286// CHECK: define %struct.Ops* @_ZN3OpsplERKS_ 287Ops& Ops::operator+(const Ops&) { return *this; } 288// CHECK: define %struct.Ops* @_ZN3OpsmiERKS_ 289Ops& Ops::operator-(const Ops&) { return *this; } 290// CHECK: define %struct.Ops* @_ZN3OpsanERKS_ 291Ops& Ops::operator&(const Ops&) { return *this; } 292// CHECK: define %struct.Ops* @_ZN3OpsmlERKS_ 293Ops& Ops::operator*(const Ops&) { return *this; } 294 295// PR5861 296namespace PR5861 { 297template<bool> class P; 298template<> class P<true> {}; 299 300template<template <bool> class, bool> 301struct Policy { }; 302 303template<typename T, typename = Policy<P, true> > class Alloc 304{ 305 T *allocate(int, const void*) { return 0; } 306}; 307 308// CHECK: define weak_odr i8* @_ZN6PR58615AllocIcNS_6PolicyINS_1PELb1EEEE8allocateEiPKv 309template class Alloc<char>; 310} 311 312// CHECK: define void @_Z1fU13block_pointerFiiiE 313void f(int (^)(int, int)) { } 314 315void pr5966_foo() { 316 extern int pr5966_i; 317 pr5966_i = 0; 318} 319 320static int pr5966_i; 321 322void pr5966_bar() { 323 pr5966_i = 0; 324} 325 326namespace test0 { 327 int ovl(int x); 328 char ovl(double x); 329 330 template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {} 331 332 void test0() { 333 char buffer[1]; 334 f(0.0, buffer); 335 } 336 // CHECK: define void @_ZN5test05test0Ev() 337 // CHECK: define linkonce_odr void @_ZN5test01fIdEEvT_RAszcl3ovlcvS1__EE_c( 338 339 void test1() { 340 char buffer[sizeof(int)]; 341 f(1, buffer); 342 } 343 // CHECK: define void @_ZN5test05test1Ev() 344 // CHECK: define linkonce_odr void @_ZN5test01fIiEEvT_RAszcl3ovlcvS1__EE_c( 345 346 template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {} 347 void test2() { 348 char buffer[sizeof(float)]; 349 g<float>(buffer); 350 } 351 // CHECK: define linkonce_odr void @_ZN5test01gIfEEvRAszplcvT__ELf40A00000E_c( 352 353 template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {} 354 void test3() { 355 char buffer[sizeof(double)]; 356 h<float>(buffer); 357 } 358 // CHECK: define linkonce_odr void @_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c( 359 360 template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {} 361 struct A { double buffer[128]; }; 362 void test4() { 363 char buffer[1024]; 364 j<A>(buffer); 365 } 366 // CHECK: define linkonce_odr void @_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c( 367} 368 369namespace test1 { 370 template<typename T> struct X { }; 371 template<template<class> class Y, typename T> void f(Y<T>) { } 372 // CHECK: define weak_odr void @_ZN5test11fINS_1XEiEEvT_IT0_E 373 template void f(X<int>); 374} 375 376// CHECK: define internal void @_Z27functionWithInternalLinkagev() 377static void functionWithInternalLinkage() { } 378void g() { functionWithInternalLinkage(); } 379 380namespace test2 { 381 template <class T> decltype(((T*) 0)->member) read_member(T& obj) { 382 return obj.member; 383 } 384 385 struct A { int member; } obj; 386 int test() { 387 return read_member(obj); 388 } 389 390 // CHECK: define linkonce_odr i32 @_ZN5test211read_memberINS_1AEEEDtptcvPT_Li0E6memberERS2_( 391} 392 393namespace test3 { 394 struct AmbiguousBase { int ab; }; 395 struct Path1 : AmbiguousBase { float p; }; 396 struct Path2 : AmbiguousBase { double p; }; 397 struct Derived : Path1, Path2 { }; 398 399 //template <class T> decltype(((T*) 0)->Path1::ab) get_ab_1(T &ref) { return ref.Path1::ab; } 400 //template <class T> decltype(((T*) 0)->Path2::ab) get_ab_2(T &ref) { return ref.Path2::ab; } 401 402 // define weak_odr float @_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0E5Path11pERS2_( 403 template <class T> decltype(((T*) 0)->Path1::p) get_p_1(T &ref) { return ref.Path1::p; } 404 405 // define weak_odr double @_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0E5Path21pERS2_( 406 template <class T> decltype(((T*) 0)->Path2::p) get_p_2(T &ref) { return ref.Path2::p; } 407 408 Derived obj; 409 void test() { 410 // FIXME: uncomment these when we support diamonds competently 411 //get_ab_1(obj); 412 //get_ab_2(obj); 413 get_p_1(obj); 414 get_p_2(obj); 415 } 416} 417 418// CHECK: define void @_ZN5test41gEPNS_3zedIXadL_ZNS_3foo3barEEEEE 419namespace test4 { 420 struct foo { int bar; }; 421 template <int (foo::*)> 422 struct zed {}; 423 void g(zed<&foo::bar>*) 424 {} 425} 426// CHECK: define void @_ZN5test51gEPNS_3zedIXadL_ZNS_3foo3barEEEEE 427namespace test5 { 428 struct foo { static int bar; }; 429 template <int *> 430 struct zed {}; 431 void g(zed<&foo::bar>*) 432 {} 433} 434// CHECK: define void @_ZN5test61gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE 435namespace test6 { 436 struct foo { int bar(); }; 437 template <int (foo::*)()> 438 struct zed {}; 439 void g(zed<&foo::bar>*) 440 {} 441} 442// CHECK: define void @_ZN5test71gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE 443namespace test7 { 444 struct foo { static int bar(); }; 445 template <int (*f)()> 446 struct zed {}; 447 void g(zed<&foo::bar>*) 448 {} 449} 450// CHECK: define weak_odr void @_ZN5test81AILZNS_1B5valueEEE3incEv 451namespace test8 { 452 template <int &counter> class A { void inc() { counter++; } }; 453 class B { public: static int value; }; 454 template class A<B::value>; 455} 456// CHECK: declare void @_ZN5test91fIiNS_3barEEEvRKNT0_3baz1XE 457namespace test9 { 458 template<class T> 459 struct foo { 460 typedef T X; 461 }; 462 struct bar { 463 typedef foo<int> baz; 464 }; 465 template <class zaz, class zed> 466 void f(const typename zed::baz::X&); 467 void g() { 468 f<int, bar>( 0); 469 } 470} 471 472// <rdar://problem/7825453> 473namespace test10 { 474 template <char P1> struct S {}; 475 template <char P2> void f(struct S<false ? 'a' : P2> ) {} 476 477 // CHECK: define weak_odr void @_ZN6test101fILc3EEEvNS_1SIXquLb0ELc97ET_EEE( 478 template void f<(char) 3>(struct S<3>); 479} 480 481namespace test11 { 482 // CHECK: @_ZN6test111fEz 483 void f(...) { } 484 485 struct A { 486 void f(...); 487 }; 488 489 // CHECK: @_ZN6test111A1fEz 490 void A::f(...) { } 491} 492 493namespace test12 { 494 495 // CHECK: _ZN6test121fENS_1AILt33000EEE 496 template <unsigned short> struct A { }; 497 void f(A<33000>) { } 498} 499 500// PR7446 501namespace test13 { 502 template <template <class> class T> class A {}; 503 template <class U> class B {}; 504 505 template <template<class> class T> void foo(const A<T> &a) {} 506 507 // CHECK: define weak_odr void @_ZN6test133fooINS_1BEEEvRKNS_1AIT_EE( 508 template void foo(const A<B> &a); 509} 510 511namespace test14 { 512 extern "C" { 513 struct S { 514 static int a(), x; 515 }; 516 // CHECK: define i32 @_ZN6test141S1aEv 517 // CHECK: load i32* @_ZN6test141S1xE 518 int S::a() { return S::x; } 519 } 520} 521 522// rdar://problem/8204122 523namespace test15 { 524 enum E { e = 3 }; 525 template <int I> struct S {}; 526 527 template <int I> void f(S<I + e>) {} 528 529 // CHECK: define weak_odr void @_ZN6test151fILi7EEEvNS_1SIXplT_LNS_1EE3EEEE( 530 template void f<7>(S<7 + e>); 531} 532 533// rdar://problem/8125400. Don't crash. 534namespace test16 { 535 static union {}; 536 static union { union {}; }; 537 static union { struct {}; }; 538 static union { union { union {}; }; }; 539 static union { union { struct {}; }; }; 540 static union { struct { union {}; }; }; 541 static union { struct { struct {}; }; }; 542} 543 544// rdar://problem/8302148 545namespace test17 { 546 template <int N> struct A {}; 547 548 struct B { 549 static int foo(void); 550 }; 551 552 template <class T> A<sizeof(T::foo())> func(void); 553 554 // CHECK: define void @_ZN6test174testEv() 555 // CHECK: call {{.*}} @_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv() 556 void test() { 557 func<B>(); 558 } 559} 560 561// PR7891 562namespace test18 { 563 struct A { 564 int operator+(); 565 int operator-(); 566 int operator*(); 567 int operator&(); 568 }; 569 template <int (A::*)()> struct S {}; 570 571 template <typename T> void f(S<&T::operator+>) {} 572 template void f<A>(S<&A::operator+>); 573 574 template <typename T> void f(S<&T::operator- >) {} 575 template void f<A>(S<&A::operator- >); 576 577 template <typename T> void f(S<&T::operator*>) {} 578 template void f<A>(S<&A::operator*>); 579 580 template <typename T> void f(S<&T::operator&>) {} 581 template void f<A>(S<&A::operator&>); 582 583 // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_plEEE 584 // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_miEEE 585 // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_mlEEE 586 // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_anEEE 587} 588 589// rdar://problem/8332117 590namespace test19 { 591 struct A { 592 template <typename T> int f(); 593 int operator+(); 594 operator int(); 595 template <typename T> int operator-(); 596 }; 597 598 template <int (A::*)()> struct S {}; 599 600 template <typename T> void g (S<&T::template f<int> >) {} 601 template <typename T> void g (S<&T::operator+ >) {} 602 template <typename T> void g (S<&T::operator int>) {} 603 template <typename T> void g (S<&T::template operator- <double> >) {} 604 605 // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE( 606 template void g<A>(S<&A::f<int> >); 607 // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_plEEE( 608 template void g<A>(S<&A::operator+>); 609 // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_cviEEE( 610 template void g<A>(S<&A::operator int>); 611 // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_miIdEEEE( 612 template void g<A>(S<&A::operator-<double> >); 613} 614 615namespace test20 { 616 template <class T> T *f(const T&); 617 template <class T> T *f(T*); 618 619 // CHECK: define weak_odr void @_ZN6test205test0IiEEvDTcl1fIPT_ELi0EEE( 620 template <class T> void test0(decltype(f<T*>(0))) {} 621 template void test0<int>(decltype(f<int*>(0))); 622 623 // CHECK: define weak_odr void @_ZN6test205test1IiEEvDTcl1fIEcvT__EEE( 624 template <class T> void test1(decltype(f<>(T()))) {} 625 template void test1<int>(decltype(f<>(int()))); 626} 627