mangle.cpp revision de81063acdc999fbe1225f466ead12f7e9107acf
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