1563 lines · cpp
1// RUN: %clang_cc1 %s -std=c++11 -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s2// RUN: %clang_cc1 %s -std=c++11 -triple=x86_64-apple-darwin10 -fvisibility=hidden -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-HIDDEN3// For clang, "internal" is just an alias for "hidden". We could use it for some4// optimization purposes on 32-bit x86, but it's not worth it.5// RUN: %clang_cc1 %s -std=c++11 -triple=x86_64-apple-darwin10 -fvisibility=internal -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-HIDDEN6 7#define HIDDEN __attribute__((visibility("hidden")))8#define PROTECTED __attribute__((visibility("protected")))9#define DEFAULT __attribute__((visibility("default")))10 11namespace test30 {12 // When H is hidden, it should make X hidden, even if the template argument13 // is not.14 struct H {15 };16 template<H *T>17 struct X {18 };19 H DEFAULT a;20 X<&a> b;21 // CHECK: _ZN6test301bE = global22 // CHECK-HIDDEN: _ZN6test301bE = hidden global23}24 25namespace test25 {26 template<typename T>27 struct X {28 template<typename U>29 struct definition {30 };31 };32 33 class DEFAULT A { };34 35 X<int>::definition<A> a;36 // CHECK: @_ZN6test251aE = global37 // CHECK-HIDDEN: @_ZN6test251aE = hidden global38}39 40namespace test28 {41 class DEFAULT foo {42 };43 foo myvec;44 // CHECK: @_ZN6test285myvecE = global45 // CHECK-HIDDEN: @_ZN6test285myvecE = hidden global46}47 48namespace test29 {49#pragma GCC visibility push(hidden)50 struct RECT {51 int top;52 };53 DEFAULT extern RECT data_rect;54 RECT data_rect = { -1};55#pragma GCC visibility pop56 // CHECK: @_ZN6test299data_rectE = global57 // CHECK-HIDDEN: @_ZN6test299data_rectE = global58}59 60namespace test40 {61 template<typename T>62 struct foo {63 DEFAULT static int bar;64 };65 template<typename T>66 int foo<T>::bar;67 template struct foo<int>;68 // CHECK: _ZN6test403fooIiE3barE = weak_odr global69 // CHECK-HIDDEN: _ZN6test403fooIiE3barE = weak_odr global70}71 72namespace test41 {73 // Unlike gcc we propagate the information that foo not only is hidden, but74 // has been explicitly marked as so. This lets us produce a hidden undefined75 // reference to bar.76 struct HIDDEN foo {};77 extern foo bar;78 foo *zed() {79 return &bar;80 }81 // CHECK: @_ZN6test413barE = external hidden global82 // CHECK-HIDDEN: @_ZN6test413barE = external hidden global83}84 85namespace test48 {86 // Test that we use the visibility of struct foo when instantiating the87 // template. Note that is a case where we disagree with gcc, it produces88 // a default symbol.89 struct HIDDEN foo {90 };91 DEFAULT foo x;92 93 struct bar {94 template<foo *z>95 struct zed {96 };97 };98 99 bar::zed<&x> y;100 // CHECK: _ZN6test481yE = hidden global101 // CHECK-HIDDEN: _ZN6test481yE = hidden global102}103 104namespace test72 {105 template <class T>106 struct foo {107 HIDDEN static int var1;108 template <class U> HIDDEN static U var2;109 };110 template <class T> template <class U>111 U foo<T>::var2;112 113 extern template struct DEFAULT foo<int>;114 115 int use() {116 foo<int> o;117 foo<long> p;118 return o.var1 + o.var2<int> + p.var1 + p.var2<int>;119 }120 // CHECK: @_ZN6test723fooIiE4var1E = external hidden global i32121 // CHECK-NEXT: @_ZN6test723fooIiE4var2IiEE = linkonce_odr global i32 0122 // CHECK-NEXT: @_ZN6test723fooIlE4var1E = external hidden global i32123 // CHECK-NEXT: @_ZN6test723fooIlE4var2IiEE = linkonce_odr global i32 0124}125 126namespace test73 {127 struct HIDDEN foo {};128 DEFAULT foo da, db, dc, dd;129 HIDDEN foo ha, hb, hc, hd;130 template<foo *z> DEFAULT int var;131 132 template int var<&da>;133 template int DEFAULT var<&db>;134 template int HIDDEN var<&dc>;135 template int var<&ha>;136 template int DEFAULT var<&hb>;137 template int HIDDEN var<&hc>;138 139 int use() { return var<&dd> + var<&hd>; }140 // CHECK: @_ZN6test733varIXadL_ZNS_2daEEEEE = weak_odr hidden global i32 0141 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2dbEEEEE = weak_odr global i32 0142 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2dcEEEEE = weak_odr hidden global i32 0143 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2haEEEEE = weak_odr hidden global i32 0144 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2hbEEEEE = weak_odr global i32 0145 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2hcEEEEE = weak_odr hidden global i32 0146 // CHECK: @_ZN6test733varIXadL_ZNS_2ddEEEEE = linkonce_odr hidden global i32 0147 // CHECK-NEXT: @_ZN6test733varIXadL_ZNS_2hdEEEEE = linkonce_odr hidden global i32 0148 149 // CHECK-HIDDEN: @_ZN6test733varIXadL_ZNS_2daEEEEE = weak_odr hidden global i32 0150 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2dbEEEEE = weak_odr global i32 0151 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2dcEEEEE = weak_odr hidden global i32 0152 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2haEEEEE = weak_odr hidden global i32 0153 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2hbEEEEE = weak_odr global i32 0154 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2hcEEEEE = weak_odr hidden global i32 0155 // CHECK-HIDDEN: @_ZN6test733varIXadL_ZNS_2ddEEEEE = linkonce_odr hidden global i32 0156 // CHECK-HIDDEN-NEXT: @_ZN6test733varIXadL_ZNS_2hdEEEEE = linkonce_odr hidden global i32 0157}158 159// CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10160// CHECK: @_ZN5Test71aE = hidden global161// CHECK: @_ZN5Test71bE = global162// CHECK: @test9_var = global163// CHECK-HIDDEN: @test9_var = global164// CHECK: @_ZN6Test121A6hiddenE = external hidden global165// CHECK: @_ZN6Test121A7visibleE = external global166// CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global167// CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global168// CHECK: @_ZN6Test131B1aE = hidden global169// CHECK: @_ZN6Test131C1aE = global170// CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global171// CHECK-HIDDEN: @_ZN6Test131C1aE = global172// CHECK: @_ZN6Test143varE = external global173// CHECK-HIDDEN: @_ZN6Test143varE = external global174// CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]175// CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]176// CHECK: @_ZTVN6test701BE = external hidden unnamed_addr constant { [5 x ptr] }, align 8177// CHECK: @_ZTTN6test701BE = external hidden unnamed_addr constant [2 x ptr], align 8178 179namespace test27 {180 template<typename T>181 class C {182 class DEFAULT D {183 void f();184 };185 };186 187 template<>188 class C<int>::D {189 virtual void g();190 };191 192 void C<int>::D::g() {193 }194 // CHECK: _ZTVN6test271CIiE1DE = unnamed_addr constant195 // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = unnamed_addr constant196}197 198// CHECK: @_ZTVN5Test63fooE = linkonce_odr hidden unnamed_addr constant199 200// CHECK-HIDDEN: @_ZTVN6Test161AIcEE = external unnamed_addr constant201// CHECK-HIDDEN: @_ZTTN6Test161AIcEE = external unnamed_addr constant202 203// CHECK: @_ZZN6test681fC1EvE4test = linkonce_odr global204// CHECK-HIDDEN: @_ZZN6test681fC1EvE4test = linkonce_odr hidden global205 206// CHECK: @_ZGVZN6test681fC1EvE4test = linkonce_odr global207// CHECK-HIDDEN: @_ZGVZN6test681fC1EvE4test = linkonce_odr hidden global208 209// CHECK-HIDDEN: @_ZTVN6test701DE = linkonce_odr hidden unnamed_addr constant { [3 x ptr] } { [3 x ptr] [ptr null, ptr null, ptr @_ZTIN6test701DE] }, align 8210// CHECK-HIDDEN: @_ZTTN6test701DE = linkonce_odr hidden unnamed_addr constant [1 x ptr] [ptr getelementptr inbounds inrange(-24, 0) ({ [3 x ptr] }, ptr @_ZTVN6test701DE, i32 0, i32 0, i32 3)], align 8211 212// CHECK: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr global213// CHECK-HIDDEN: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr hidden global214 215// CHECK: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr global i64216// CHECK-HIDDEN: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr hidden global i64217 218namespace Test1 {219 // CHECK-LABEL: define hidden void @_ZN5Test11fEv220 void HIDDEN f() { }221 222}223 224namespace Test2 {225 struct HIDDEN A {226 void f();227 };228 229 // A::f is a member function of a hidden class.230 // CHECK-LABEL: define hidden void @_ZN5Test21A1fEv231 void A::f() { }232}233 234namespace Test3 {235 struct HIDDEN A {236 struct B {237 void f();238 };239 };240 241 // B is a nested class where its parent class is hidden.242 // CHECK-LABEL: define hidden void @_ZN5Test31A1B1fEv243 void A::B::f() { }244}245 246namespace Test4 HIDDEN {247 int VariableInHiddenNamespace = 10;248 249 // Test4::g is in a hidden namespace.250 // CHECK-LABEL: define hidden void @_ZN5Test41gEv251 void g() { }252 253 struct DEFAULT A {254 void f();255 };256 257 // A has default visibility.258 // CHECK-LABEL: define void @_ZN5Test41A1fEv259 void A::f() { }260}261 262namespace Test5 {263 264 namespace NS HIDDEN {265 // f is in NS which is hidden.266 // CHECK-LABEL: define hidden void @_ZN5Test52NS1fEv()267 void f() { }268 }269 270 namespace NS {271 // g is in NS, but this NS decl is not hidden.272 // CHECK-LABEL: define void @_ZN5Test52NS1gEv273 void g() { }274 }275}276 277namespace Test6 {278 struct HIDDEN foo {279 foo() { }280 void bonk();281 virtual void bar() = 0;282 283 virtual void zonk() {}284 };285 286 struct barc : public foo {287 barc();288 virtual void bar();289 };290 291 barc::barc() {}292}293 294namespace Test7 {295 class HIDDEN A {};296 A a; // top of file297 298 template <A&> struct Aref {299 static void foo() {}300 };301 302 class B : public A {};303 B b; // top of file304 305 // CHECK-LABEL: define linkonce_odr hidden void @_ZN5Test74ArefIL_ZNS_1aEEE3fooEv()306 void test() {307 Aref<a>::foo();308 }309}310 311namespace Test8 {312 void foo();313 void bar() {}314 // CHECK-HIDDEN-LABEL: define hidden void @_ZN5Test83barEv()315 // CHECK-HIDDEN: declare void @_ZN5Test83fooEv()316 317 void test() {318 foo();319 bar();320 }321}322 323// PR8457324namespace Test9 {325 extern "C" {326 struct A { int field; };327 void DEFAULT test9_fun(struct A *a) { }328 struct A DEFAULT test9_var; // above329 }330 // CHECK-LABEL: define void @test9_fun(331 // CHECK-HIDDEN-LABEL: define void @test9_fun(332 333 void test() {334 A a = test9_var;335 test9_fun(&a);336 }337}338 339// PR8478340namespace Test10 {341 struct A;342 343 class DEFAULT B {344 void foo(A*);345 };346 347 // CHECK-LABEL: define void @_ZN6Test101B3fooEPNS_1AE(348 // CHECK-HIDDEN-LABEL: define void @_ZN6Test101B3fooEPNS_1AE(349 void B::foo(A*) {}350}351 352// PR8492353namespace Test11 {354 struct A {355 void foo() {}356 void DEFAULT bar() {}357 };358 359 void test() {360 A a;361 a.foo();362 a.bar();363 }364 365 // CHECK-LABEL: define linkonce_odr void @_ZN6Test111A3fooEv(366 // CHECK-LABEL: define linkonce_odr void @_ZN6Test111A3barEv(367 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6Test111A3fooEv(368 // CHECK-HIDDEN-LABEL: define linkonce_odr void @_ZN6Test111A3barEv(369}370 371// Tested at top of file.372namespace Test12 {373 struct A {374 // This is hidden in all cases: the explicit attribute takes375 // priority over -fvisibility on the parent.376 static int hidden HIDDEN;377 378 // This is default in all cases because it's only a declaration.379 static int visible;380 };381 382 void test() {383 A::hidden = 0;384 A::visible = 0;385 }386}387 388// Tested at top of file.389namespace Test13 {390 struct HIDDEN A {};391 392 // Should be hidden in all cases.393 struct B {394 static A a;395 };396 A B::a;397 398 // Should be default in all cases.399 struct DEFAULT C {400 static A a;401 };402 A C::a;403};404 405// Tested at top of file.406namespace Test14 {407 // Neither the visibility of the type nor -fvisibility=hidden should408 // apply to declarations.409 extern struct A *var;410 411 struct A *test() { return var; }412}413 414namespace Test15 {415 struct A {};416 template <class T> struct Temp {417 struct Inner {418 static char buffer[0];419 };420 };421 422 char *test() {423 return Temp<A>::Inner::buffer;424 }425}426 427namespace Test16 {428 struct Base1 { virtual void foo(); };429 struct Base2 : virtual Base1 { virtual void foo(); };430 template <class T> struct A : virtual Base1, Base2 {431 virtual void foo();432 };433 extern template struct A<char>;434 435 void test() {436 A<char> a;437 a.foo();438 }439}440 441namespace Test17 {442 struct HIDDEN A {443 static void foo();444 static void DEFAULT bar();445 static void HIDDEN baz();446 447 struct DEFAULT B {448 static void foo();449 static void DEFAULT bar();450 static void HIDDEN baz();451 };452 };453 454 void test() {455 A::foo();456 A::bar();457 A::baz();458 A::B::foo();459 A::B::bar();460 A::B::baz();461 }462 // CHECK: declare hidden void @_ZN6Test171A3fooEv()463 // CHECK: declare void @_ZN6Test171A3barEv()464 // CHECK: declare hidden void @_ZN6Test171A3bazEv()465 // CHECK: declare void @_ZN6Test171A1B3fooEv()466 // CHECK: declare void @_ZN6Test171A1B3barEv()467 // CHECK: declare hidden void @_ZN6Test171A1B3bazEv()468 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3fooEv()469 // CHECK-HIDDEN: declare void @_ZN6Test171A3barEv()470 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3bazEv()471 // CHECK-HIDDEN: declare void @_ZN6Test171A1B3fooEv()472 // CHECK-HIDDEN: declare void @_ZN6Test171A1B3barEv()473 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A1B3bazEv()474}475 476namespace Test18 {477 template <class T> struct HIDDEN A {478 static void foo();479 static void DEFAULT bar();480 static void HIDDEN baz();481 482 struct DEFAULT B {483 static void foo();484 static void DEFAULT bar();485 static void HIDDEN baz();486 };487 };488 struct HIDDEN H;489 490 void test() {491 A<int>::foo();492 A<int>::bar();493 A<int>::baz();494 A<int>::B::foo();495 A<int>::B::bar();496 A<int>::B::baz();497 A<H>::foo();498 A<H>::bar();499 A<H>::baz();500 A<H>::B::foo();501 A<H>::B::bar();502 A<H>::B::baz();503 }504 // CHECK: declare hidden void @_ZN6Test181AIiE3fooEv()505 // CHECK: declare void @_ZN6Test181AIiE3barEv()506 // CHECK: declare hidden void @_ZN6Test181AIiE3bazEv()507 // CHECK: declare void @_ZN6Test181AIiE1B3fooEv()508 // CHECK: declare void @_ZN6Test181AIiE1B3barEv()509 // CHECK: declare hidden void @_ZN6Test181AIiE1B3bazEv()510 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3fooEv()511 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3barEv()512 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3bazEv()513 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv()514 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv()515 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv()516 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3fooEv()517 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE3barEv()518 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3bazEv()519 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3fooEv()520 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3barEv()521 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE1B3bazEv()522 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3fooEv()523 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3barEv()524 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3bazEv()525 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv()526 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv()527 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv()528}529 530namespace Test19 {531 struct A { A(); ~A(); };532 533 // Tested at top of file.534 template <class T> void foo() {535 static A a;536 }537 538 void test() {539 foo<int>();540 }541}542 543// Various things with class template specializations.544namespace Test20 {545 template <unsigned> struct HIDDEN A {};546 547 // An explicit specialization inherits the explicit visibility of548 // the template.549 template <> struct A<0> {550 static void test0();551 static void test1();552 };553 554 // CHECK-LABEL: define hidden void @_ZN6Test201AILj0EE5test0Ev()555 void A<0>::test0() {}556 557 // CHECK: declare hidden void @_ZN6Test201AILj0EE5test1Ev()558 void test1() {559 A<0>::test1();560 }561 562 // ...unless that's explicitly overridden.563 template <> struct DEFAULT A<1> {564 static void test2();565 static void test3();566 };567 568 // CHECK-LABEL: define void @_ZN6Test201AILj1EE5test2Ev()569 void A<1>::test2() {}570 571 // CHECK: declare void @_ZN6Test201AILj1EE5test3Ev()572 void test3() {573 A<1>::test3();574 }575 576 // But we should assume that an unknown specialization has the577 // explicit visibility settings of the template.578 template <class T> struct B {579 static void test4() {}580 static void test5();581 };582 583 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6Test201BINS_1AILj2EEEE5test4Ev()584 void test4() {585 B<A<2> >::test4();586 }587 588 // CHECK: declare hidden void @_ZN6Test201BINS_1AILj2EEEE5test5Ev()589 void test5() {590 B<A<2> >::test5();591 }592}593 594// PR9371595namespace test21 {596 enum En { en };597 template<En> struct A {598 DEFAULT void foo() {}599 };600 601 // CHECK-LABEL: define weak_odr void @_ZN6test211AILNS_2EnE0EE3fooEv(602 template void A<en>::foo();603}604 605// Visibility on explicit specializations should take precedence.606namespace test22 {607 class A1 {};608 class A2 {};609 610 template <class T> struct B {};611 template <> struct DEFAULT B<A1> {612 static void foo();613 static void bar() {}614 };615 template <> struct B<A2> {616 static void foo();617 static void bar() {}618 };619 620 void test() {621 B<A1>::foo();622 B<A1>::bar();623 B<A2>::foo();624 B<A2>::bar();625 }626 // CHECK: declare void @_ZN6test221BINS_2A1EE3fooEv()627 // CHECK-LABEL: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv()628 // CHECK: declare void @_ZN6test221BINS_2A2EE3fooEv()629 // CHECK-LABEL: define linkonce_odr void @_ZN6test221BINS_2A2EE3barEv()630 // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A1EE3fooEv()631 // CHECK-HIDDEN-LABEL: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv()632 // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A2EE3fooEv()633 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test221BINS_2A2EE3barEv()634}635 636namespace PR10113 {637 namespace foo DEFAULT {638 template<typename T>639 class bar {640 void zed() {}641 };642 }643 template class foo::bar<char>;644 // CHECK-LABEL: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv645 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv646 647 struct zed {648 };649 template class foo::bar<zed>;650 // CHECK-LABEL: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv651 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN7PR101133foo3barINS_3zedEE3zedEv652}653 654namespace PR11690 {655 template<class T> struct Class {656 void size() const {657 }658 };659 template class DEFAULT Class<char>;660 // CHECK-LABEL: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv661 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv662 663 template<class T> void Method() {}664 template DEFAULT void Method<char>();665 // CHECK-LABEL: define weak_odr void @_ZN7PR116906MethodIcEEvv666 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN7PR116906MethodIcEEvv667}668 669namespace PR11690_2 {670 namespace foo DEFAULT {671 class bar;672 template<typename T1, typename T2 = bar>673 class zed {674 void bar() {675 }676 };677 }678 struct baz {679 };680 template class foo::zed<baz>;681 // CHECK-LABEL: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv682 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv683}684 685namespace test23 {686 // Having a template argument that is explicitly visible should not make687 // the template instantiation visible.688 template <typename T>689 struct X {690 static void f() {691 }692 };693 694 class DEFAULT A;695 696 void g() {697 X<A> y;698 y.f();699 }700 // CHECK-LABEL: define linkonce_odr void @_ZN6test231XINS_1AEE1fEv701 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test231XINS_1AEE1fEv702}703 704namespace PR12001 {705 template <typename P1>706 void Bind(const P1& p1) {707 }708 709 class DEFAULT Version { };710 711 void f() {712 Bind(Version());713 }714 // CHECK-LABEL: define linkonce_odr void @_ZN7PR120014BindINS_7VersionEEEvRKT_715 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN7PR120014BindINS_7VersionEEEvRKT_716}717 718namespace test24 {719 class DEFAULT A { };720 721 struct S {722 template <typename T>723 void mem() {}724 };725 726 void test() {727 S s;728 s.mem<A>();729 }730 // CHECK-LABEL: define linkonce_odr void @_ZN6test241S3memINS_1AEEEvv731 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test241S3memINS_1AEEEvv732}733 734namespace test26 {735 template<typename T>736 class C {737 DEFAULT void f();738 };739 740 template<>741 void C<int>::f() { }742 743 // CHECK-LABEL: define void @_ZN6test261CIiE1fEv744 // CHECK-HIDDEN-LABEL: define void @_ZN6test261CIiE1fEv745}746 747namespace test31 {748 struct A {749 struct HIDDEN B {750 static void DEFAULT baz();751 };752 };753 void f() {754 A::B::baz();755 }756 // CHECK: declare void @_ZN6test311A1B3bazEv()757 // CHECK-HIDDEN: declare void @_ZN6test311A1B3bazEv()758}759 760namespace test32 {761 struct HIDDEN A {762 struct DEFAULT B {763 void DEFAULT baz();764 };765 };766 void A::B::baz() {767 }768 // CHECK-LABEL: define void @_ZN6test321A1B3bazEv769 // CHECK-HIDDEN-LABEL: define void @_ZN6test321A1B3bazEv770}771 772namespace test33 {773 template<typename T>774 class foo {775 void bar() {}776 };777 struct HIDDEN zed {778 };779 template class DEFAULT foo<zed>;780 // CHECK-LABEL: define weak_odr void @_ZN6test333fooINS_3zedEE3barEv781 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test333fooINS_3zedEE3barEv782}783 784namespace test34 {785 struct foo {786 };787 template<class T>788 void bar() {}789 template DEFAULT void bar<foo>();790 // CHECK-LABEL: define weak_odr void @_ZN6test343barINS_3fooEEEvv791 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test343barINS_3fooEEEvv792}793 794namespace test35 {795 // This is a really ugly testcase. GCC propagates the DEFAULT in zed's796 // definition. It's not really clear what we can do here, because we797 // produce the symbols before even seeing the DEFAULT definition of zed.798 // FIXME: Maybe the best thing to do here is error? It's certainly hard799 // to argue that this ought to be valid.800 template<typename T>801 struct DEFAULT foo {802 void bar() {}803 };804 class zed;805 template class foo<zed>;806 class DEFAULT zed {807 };808 // CHECK-LABEL: define weak_odr void @_ZN6test353fooINS_3zedEE3barEv809 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test353fooINS_3zedEE3barEv810}811 812namespace test36 {813 template<typename T1, typename T2>814 class foo {815 void bar() {}816 };817 class DEFAULT S1 {};818 struct HIDDEN S2 {};819 template class foo<S1, S2>;820 // CHECK-LABEL: define weak_odr hidden void @_ZN6test363fooINS_2S1ENS_2S2EE3barEv821 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test363fooINS_2S1ENS_2S2EE3barEv822}823 824namespace test37 {825 struct HIDDEN foo {826 };827 template<class T>828 DEFAULT void bar() {}829 template DEFAULT void bar<foo>();830 // CHECK-LABEL: define weak_odr void @_ZN6test373barINS_3fooEEEvv831 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test373barINS_3fooEEEvv832}833 834namespace test38 {835 template<typename T>836 class DEFAULT foo {837 void bar() {}838 };839 struct HIDDEN zed {840 };841 template class foo<zed>;842 // CHECK-LABEL: define weak_odr hidden void @_ZN6test383fooINS_3zedEE3barEv843 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test383fooINS_3zedEE3barEv844}845 846namespace test39 {847 class DEFAULT default_t;848 class HIDDEN hidden_t;849 template <class T> class A {850 template <class U> class B {851 HIDDEN void hidden() {}852 void noattr() {}853 template <class V> void temp() {}854 };855 };856 template class DEFAULT A<hidden_t>;857 template class DEFAULT A<hidden_t>::B<hidden_t>;858 template void A<hidden_t>::B<hidden_t>::temp<default_t>();859 template void A<hidden_t>::B<hidden_t>::temp<hidden_t>();860 861 // CHECK-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E6hiddenEv862 // CHECK-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E6noattrEv863 // CHECK-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempINS_9default_tEEEvv864 865 // GCC produces a default for this one. Why?866 // CHECK-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempIS1_EEvv867 868 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E6hiddenEv869 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E6noattrEv870 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempINS_9default_tEEEvv871 872 // GCC produces a default for this one. Why?873 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempIS1_EEvv874}875 876namespace test42 {877 struct HIDDEN foo {878 };879 template <class P>880 struct bar {881 };882 template <>883 struct HIDDEN bar<foo> {884 DEFAULT static void zed();885 };886 void bar<foo>::zed() {887 }888 // CHECK-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv889 // CHECK-HIDDEN-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv890}891 892namespace test43 {893 struct HIDDEN foo {894 };895 template <class P>896 void bar() {897 }898 template <>899 DEFAULT void bar<foo>() {900 }901 // CHECK-LABEL: define void @_ZN6test433barINS_3fooEEEvv902 // CHECK-HIDDEN-LABEL: define void @_ZN6test433barINS_3fooEEEvv903}904 905namespace test44 {906 template <typename T>907 struct foo {908 foo() {}909 };910 namespace {911 struct bar;912 }913 template struct DEFAULT foo<bar>;914 foo<bar> x;915 // CHECK-LABEL: define internal void @_ZN6test443fooINS_12_GLOBAL__N_13barEEC1Ev916 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test443fooINS_12_GLOBAL__N_13barEEC1Ev917}918 919namespace test45 {920 template <typename T>921 struct foo {922 template <typename T2>923 struct bar {924 bar() {};925 };926 };927 namespace {928 struct zed;929 }930 template struct DEFAULT foo<int>::bar<zed>;931 foo<int>::bar<zed> x;932 // CHECK-LABEL: define internal void @_ZN6test453fooIiE3barINS_12_GLOBAL__N_13zedEEC1Ev933 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test453fooIiE3barINS_12_GLOBAL__N_13zedEEC1Ev934}935 936namespace test46 {937 template <typename T>938 void foo() {939 }940 namespace {941 struct bar;942 }943 template DEFAULT void foo<bar>();944 void zed() {945 foo<bar>();946 }947 // CHECK-LABEL: define internal void @_ZN6test463fooINS_12_GLOBAL__N_13barEEEvv948 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test463fooINS_12_GLOBAL__N_13barEEEvv949}950 951namespace test47 {952 struct foo {953 template <typename T>954 static void bar() {955 }956 };957 namespace {958 struct zed;959 }960 template DEFAULT void foo::bar<zed>();961 void baz() {962 foo::bar<zed>();963 }964 // CHECK-LABEL: define internal void @_ZN6test473foo3barINS_12_GLOBAL__N_13zedEEEvv965 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test473foo3barINS_12_GLOBAL__N_13zedEEEvv966}967 968namespace test49 {969 // Test that we use the visibility of struct foo when instantiating the970 // template. Note that is a case where we disagree with gcc, it produces971 // a default symbol.972 973 struct HIDDEN foo {974 };975 976 DEFAULT foo x;977 978 struct bar {979 template<foo *z>980 void zed() {981 }982 };983 984 template void bar::zed<&x>();985 // CHECK-LABEL: define weak_odr hidden void @_ZN6test493bar3zedIXadL_ZNS_1xEEEEEvv986 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test493bar3zedIXadL_ZNS_1xEEEEEvv987}988 989namespace test50 {990 // Test that we use the visibility of struct foo when instantiating the991 // template. Note that is a case where we disagree with gcc, it produces992 // a default symbol.993 994 struct HIDDEN foo {995 };996 DEFAULT foo x;997 template<foo *z>998 struct DEFAULT bar {999 void zed() {1000 }1001 };1002 template void bar<&x>::zed();1003 // CHECK-LABEL: define weak_odr hidden void @_ZN6test503barIXadL_ZNS_1xEEEE3zedEv1004 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test503barIXadL_ZNS_1xEEEE3zedEv1005}1006 1007namespace test51 {1008 // Test that we use the visibility of struct foo when instantiating the1009 // template. Note that is a case where we disagree with gcc, it produces1010 // a default symbol.1011 1012 struct HIDDEN foo {};1013 DEFAULT foo da, db, dc, dd, de, df;1014 HIDDEN foo ha, hb, hc, hd, he, hf;1015 template<foo *z>1016 void DEFAULT zed() {1017 }1018 template void zed<&da>();1019 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2daEEEEEvv(1020 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2daEEEEEvv(1021 1022 template void DEFAULT zed<&db>();1023 // CHECK-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2dbEEEEEvv(1024 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2dbEEEEEvv(1025 1026 template void HIDDEN zed<&dc>();1027 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2dcEEEEEvv(1028 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2dcEEEEEvv(1029 1030 template void zed<&ha>();1031 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2haEEEEEvv(1032 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2haEEEEEvv(1033 1034 template void DEFAULT zed<&hb>();1035 // CHECK-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2hbEEEEEvv(1036 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2hbEEEEEvv(1037 1038 template void HIDDEN zed<&hc>();1039 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2hcEEEEEvv(1040 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2hcEEEEEvv(1041 1042#pragma GCC visibility push(hidden)1043 template void zed<&dd>();1044 template void zed<&hd>();1045 template void DEFAULT zed<&he>();1046#pragma GCC visibility pop1047 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2ddEEEEEvv(1048 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2hdEEEEEvv(1049 // CHECK-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2heEEEEEvv(1050 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2ddEEEEEvv(1051 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_2hdEEEEEvv(1052 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test513zedIXadL_ZNS_2heEEEEEvv(1053 1054 void use() {1055 zed<&df>();1056 zed<&hf>();1057 }1058 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test513zedIXadL_ZNS_2dfEEEEEvv(1059 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test513zedIXadL_ZNS_2hfEEEEEvv(1060 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test513zedIXadL_ZNS_2dfEEEEEvv(1061 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test513zedIXadL_ZNS_2hfEEEEEvv(1062}1063 1064namespace test52 {1065 // Test that we use the linkage of struct foo when instantiating the1066 // template. Note that is a case where we disagree with gcc, it produces1067 // an external symbol.1068 1069 namespace {1070 struct foo {1071 };1072 }1073 template<foo *x>1074 void zed() {1075 }1076 void f() {1077 zed<nullptr>();1078 }1079 // CHECK-LABEL: define internal void @_ZN6test523zedILPNS_12_GLOBAL__N_13fooE0EEEvv1080 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test523zedILPNS_12_GLOBAL__N_13fooE0EEEvv1081}1082 1083namespace test53 {1084 template<typename _Tp > struct vector {1085 static void _M_fill_insert();1086 };1087#pragma GCC visibility push(hidden)1088 // GCC doesn't seem to use the visibility of enums at all, we do.1089 enum zed {v1};1090 1091 // GCC fails to mark this specialization hidden, we mark it.1092 template<>1093 struct vector<int> {1094 static void _M_fill_insert();1095 };1096 void foo() {1097 vector<unsigned>::_M_fill_insert();1098 vector<int>::_M_fill_insert();1099 vector<zed>::_M_fill_insert();1100 }1101#pragma GCC visibility pop1102 // CHECK: declare void @_ZN6test536vectorIjE14_M_fill_insertEv1103 // CHECK-HIDDEN: declare void @_ZN6test536vectorIjE14_M_fill_insertEv1104 // CHECK: declare hidden void @_ZN6test536vectorIiE14_M_fill_insertEv1105 // CHECK-HIDDEN: declare hidden void @_ZN6test536vectorIiE14_M_fill_insertEv1106 // CHECK: declare hidden void @_ZN6test536vectorINS_3zedEE14_M_fill_insertEv1107 // CHECK-HIDDEN: declare hidden void @_ZN6test536vectorINS_3zedEE14_M_fill_insertEv1108}1109 1110namespace test54 {1111 template <class T>1112 struct foo {1113 static void bar();1114 };1115#pragma GCC visibility push(hidden)1116 class zed {1117 zed(const zed &);1118 };1119 void bah() {1120 foo<zed>::bar();1121 }1122#pragma GCC visibility pop1123 // CHECK: declare hidden void @_ZN6test543fooINS_3zedEE3barEv1124 // CHECK-HIDDEN: declare hidden void @_ZN6test543fooINS_3zedEE3barEv1125}1126 1127namespace test55 {1128 template <class T>1129 struct HIDDEN foo {1130 static void bar();1131 };1132 template <class T> struct foo;1133 void foobar() {1134 foo<int>::bar();1135 }1136 // CHECK: declare hidden void @_ZN6test553fooIiE3barEv1137 // CHECK-HIDDEN: declare hidden void @_ZN6test553fooIiE3barEv1138}1139 1140namespace test56 {1141 template <class T> struct foo;1142 template <class T>1143 struct HIDDEN foo {1144 static void bar();1145 };1146 void foobar() {1147 foo<int>::bar();1148 }1149 // CHECK: declare hidden void @_ZN6test563fooIiE3barEv1150 // CHECK-HIDDEN: declare hidden void @_ZN6test563fooIiE3barEv1151}1152 1153namespace test57 {1154#pragma GCC visibility push(hidden)1155 template <class T>1156 struct foo;1157 void bar(foo<int>*);1158 template <class T>1159 struct foo {1160 static void zed();1161 };1162 void bah() {1163 foo<int>::zed();1164 }1165#pragma GCC visibility pop1166 // CHECK: declare hidden void @_ZN6test573fooIiE3zedEv1167 // CHECK-HIDDEN: declare hidden void @_ZN6test573fooIiE3zedEv1168}1169 1170namespace test58 {1171#pragma GCC visibility push(hidden)1172 struct foo;1173 template<typename T>1174 struct DEFAULT bar {1175 static void zed() {1176 }1177 };1178 void bah() {1179 bar<foo>::zed();1180 }1181#pragma GCC visibility pop1182 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test583barINS_3fooEE3zedEv1183 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test583barINS_3fooEE3zedEv1184}1185 1186namespace test59 {1187 DEFAULT int f();1188 HIDDEN int g();1189 typedef int (*foo)();1190 template<foo x, foo y>1191 void test() {}1192 void use() {1193 test<&g, &f>();1194 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1gEvEEXadL_ZNS_1fEvEEEEvv1195 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1gEvEEXadL_ZNS_1fEvEEEEvv1196 1197 test<&f, &g>();1198 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1fEvEEXadL_ZNS_1gEvEEEEvv1199 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1fEvEEXadL_ZNS_1gEvEEEEvv1200 }1201}1202 1203namespace test60 {1204 template<int i>1205 class HIDDEN a {};1206 template<int i>1207 class DEFAULT b {};1208 template<template<int> class x, template<int> class y>1209 void test() {}1210 void use() {1211 test<a, b>();1212 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1aENS_1bEEEvv1213 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1aENS_1bEEEvv1214 1215 test<b, a>();1216 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1bENS_1aEEEvv1217 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1bENS_1aEEEvv1218 }1219}1220 1221namespace test61 {1222 template <typename T1>1223 struct Class11224 {1225 void f1() { f2(); }1226 inline void f2();1227 };1228 template<>1229 inline void Class1<int>::f2()1230 {1231 }1232 void g(Class1<int> *x) {1233 x->f1();1234 }1235}1236namespace test61 {1237 // Just test that we don't crash. Currently we apply this attribute. Current1238 // gcc issues a warning about it being unused since "the type is already1239 // defined". We should probably do the same.1240 template class HIDDEN Class1<int>;1241}1242 1243namespace test62 {1244 template <typename T1>1245 struct Class11246 {1247 void f1() { f2(); }1248 inline void f2() {}1249 };1250 template<>1251 inline void Class1<int>::f2()1252 {1253 }1254 void g(Class1<int> *x) {1255 x->f2();1256 }1257}1258namespace test62 {1259 template class HIDDEN Class1<int>;1260 // Just test that we don't crash. Currently we apply this attribute. Current1261 // gcc issues a warning about it being unused since "the type is already1262 // defined". We should probably do the same.1263}1264 1265namespace test63 {1266 enum HIDDEN E { E0 };1267 struct A {1268 template <E> static void foo() {}1269 1270 template <E> struct B {1271 static void foo() {}1272 };1273 };1274 1275 void test() {1276 A::foo<E0>();1277 A::B<E0>::foo();1278 }1279 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test631A3fooILNS_1EE0EEEvv()1280 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test631A1BILNS_1EE0EE3fooEv()1281}1282 1283// Don't ignore the visibility of template arguments just because we1284// explicitly instantiated something.1285namespace test64 {1286 struct HIDDEN A {};1287 template <class P> struct B {1288 static DEFAULT void foo() {}1289 };1290 1291 template class B<A>;1292 // CHECK-LABEL: define weak_odr hidden void @_ZN6test641BINS_1AEE3fooEv()1293}1294 1295namespace test65 {1296 class HIDDEN A {};1297 template <class T> struct B {1298 static void func();1299 template <class U> static void funcT1();1300 template <class U> static void funcT2();1301 class Inner {};1302 template <class U> class InnerT {};1303 };1304 template <template <class T> class Temp> struct C {1305 static void foo() {}1306 };1307 1308 // CHECK-LABEL: define void @_ZN6test651BINS_1AEE4funcEv()1309 template <> DEFAULT void B<A>::func() {}1310 1311 // CHECK-LABEL: define void @_ZN6test651BINS_1AEE6funcT2IS1_EEvv()1312 template <> template <> DEFAULT void B<A>::funcT2<A>() {}1313 1314 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE6funcT1IiEEvv()1315 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test651BINS_1AEE6funcT1IS1_EEvv()1316 template <> template <class T> DEFAULT void B<A>::funcT1() {}1317 1318 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE5Inner3fooEv()1319 template <> struct DEFAULT B<A>::Inner {1320 static void foo() {}1321 };1322 1323 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE6InnerTIiE3fooEv()1324 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test651BINS_1AEE6InnerTIS1_E3fooEv()1325 template <> template <class U> struct DEFAULT B<A>::InnerT {1326 static void foo() {}1327 };1328 1329 void test() {1330 B<A>::funcT1<int>();1331 B<A>::funcT1<A>();1332 B<A>::Inner::foo();1333 B<A>::InnerT<int>::foo();1334 B<A>::InnerT<A>::foo();1335 }1336 1337 template class C<B<A>::InnerT>;1338}1339 1340namespace test66 {1341 template <typename T>1342 struct DEFAULT barT {1343 static void zed() {}1344 };1345 class foo;1346 class DEFAULT foo;1347 template struct barT<foo>;1348 // CHECK-LABEL: define weak_odr void @_ZN6test664barTINS_3fooEE3zedEv1349 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barTINS_3fooEE3zedEv1350 1351 template <int* I>1352 struct DEFAULT barI {1353 static void zed() {}1354 };1355 extern int I;1356 extern int I DEFAULT;1357 template struct barI<&I>;1358 // CHECK-LABEL: define weak_odr void @_ZN6test664barIIXadL_ZNS_1IEEEE3zedEv1359 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barIIXadL_ZNS_1IEEEE3zedEv1360 1361 typedef void (*fType)(void);1362 template<fType F>1363 struct DEFAULT barF {1364 static void zed() {}1365 };1366 void F();1367 void F() DEFAULT;1368 template struct barF<F>;1369 // CHECK-LABEL: define weak_odr void @_ZN6test664barFIXadL_ZNS_1FEvEEE3zedEv1370 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barFIXadL_ZNS_1FEvEEE3zedEv1371}1372 1373namespace test67 {1374 template <typename T>1375 struct DEFAULT bar {1376 static void zed() {}1377 };1378 1379 class foo;1380 class compute {1381 void f(foo *rootfoo);1382 };1383 class DEFAULT foo;1384 1385 template struct bar<foo>;1386 // CHECK-LABEL: define weak_odr void @_ZN6test673barINS_3fooEE3zedEv1387 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test673barINS_3fooEE3zedEv1388}1389 1390namespace test68 {1391 class A { public: ~A(); };1392 class f {1393 public:1394 f() {1395 static A test;1396 }1397 };1398 void g() {1399 f a;1400 }1401 // Check lines at top of file.1402}1403 1404namespace test69 {1405 // PR181741406 namespace foo {1407 void f();1408 }1409 namespace foo {1410 void f() {};1411 }1412 namespace foo __attribute__((visibility("hidden"))) {1413 }1414 // CHECK-LABEL: define void @_ZN6test693foo1fEv1415 // CHECK-HIDDEN-LABEL: define hidden void @_ZN6test693foo1fEv1416}1417 1418namespace test70 {1419 // Make sure both the vtable and VTT declarations are marked "hidden"1420 class HIDDEN A {1421 virtual void a();1422 };1423 class HIDDEN B : virtual A {1424 void a() override;1425 ~B();1426 };1427 B::~B() {}1428 1429 // Make sure both the vtable and VTT declarations are marked "hidden"1430 // when "-fvisibilty=hidden" is in use.1431 class C {};1432 class D : virtual C {};1433 D d;1434 // Check lines at top of file.1435}1436 1437// https://github.com/llvm/llvm-project/issues/314621438namespace test71 {1439 template <class T>1440 struct foo {1441 static HIDDEN T zed();1442 template <class U> HIDDEN U bar();1443 };1444 template <class T>1445 T foo<T>::zed() { return {}; }1446 template <class T> template <class U>1447 U foo<T>::bar() { return {}; }1448 1449 extern template struct DEFAULT foo<int>;1450 1451 int use() {1452 foo<int> o;1453 foo<long> p;1454 return o.zed() + o.bar<int>() + p.zed() + p.bar<int>();1455 }1456 /// FIXME: foo<int>::bar is hidden in GCC w/ or w/o -fvisibility=hidden.1457 // CHECK-LABEL: declare hidden noundef i32 @_ZN6test713fooIiE3zedEv(1458 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZN6test713fooIiE3barIiEET_v(1459 // CHECK-LABEL: define linkonce_odr hidden noundef i64 @_ZN6test713fooIlE3zedEv(1460 // CHECK-LABEL: define linkonce_odr hidden noundef i32 @_ZN6test713fooIlE3barIiEET_v(1461 // CHECK-HIDDEN-LABEL: declare hidden noundef i32 @_ZN6test713fooIiE3zedEv(1462 // CHECK-HIDDEN-LABEL: define linkonce_odr noundef i32 @_ZN6test713fooIiE3barIiEET_v(1463 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden noundef i64 @_ZN6test713fooIlE3zedEv(1464 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden noundef i32 @_ZN6test713fooIlE3barIiEET_v(1465}1466 1467// https://github.com/llvm/llvm-project/issues/1034771468namespace test72 {1469 template <class a>1470 struct t {1471 template <int>1472 static HIDDEN void bar() {}1473 };1474 1475 void test() {1476 t<char>::bar<1>();1477 }1478 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test721tIcE3barILi1EEEvv(1479 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test721tIcE3barILi1EEEvv(1480}1481 1482// https://github.com/llvm/llvm-project/issues/314621483namespace test73 {1484 template <class T> struct s {1485 template <class U>1486 __attribute__((__visibility__("hidden"))) U should_not_be_exported();1487 };1488 1489 template <class T> template <class U> U s<T>::should_not_be_exported() {1490 return U();1491 }1492 1493 extern template struct __attribute__((__visibility__("default"))) s<int>;1494 1495 int f() {1496 s<int> o;1497 return o.should_not_be_exported<int>();1498 }1499 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZN6test731sIiE22should_not_be_exportedIiEET_v(1500 // CHECK-HIDDEN-LABEL: define linkonce_odr noundef i32 @_ZN6test731sIiE22should_not_be_exportedIiEET_v(1501}1502 1503namespace test74 {1504 template <typename> struct T;1505 template <typename R>1506 struct T<void (R::*)()> {1507 template <typename M>1508 static __attribute__((__visibility__("hidden"))) void Invoke(M) {1509 }1510 };1511 1512 struct C;1513 void (C::*MM)();1514 1515 void Fun() {1516 T<decltype(MM)>::Invoke(0);1517 }1518 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test741TIMNS_1CEFvvEE6InvokeIiEEvT_(1519 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test741TIMNS_1CEFvvEE6InvokeIiEEvT_(1520}1521 1522namespace test75 {1523 template <class> struct T;1524 template <class C, class Ret>1525 struct T<Ret C::*> {1526 template <class M>1527 static __attribute__((__visibility__("hidden")))1528 void Invoke(M) {1529 }1530 };1531 1532 struct A;1533 void Fun() {1534 T<void (A::*)()>::Invoke(0);1535 }1536 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test751TIMNS_1AEFvvEE6InvokeIiEEvT_(1537 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test751TIMNS_1AEFvvEE6InvokeIiEEvT_(1538}1539 1540#pragma clang attribute push([[gnu::visibility("hidden")]], apply_to=function)1541 1542namespace pragma_test {1543 struct S {1544 S();1545 };1546 1547 S::S() = default;1548 // CHECK-LABEL: define hidden void @_ZN11pragma_test1SC2Ev(1549 // CHECK-HIDDEN-LABEL: define hidden void @_ZN11pragma_test1SC2Ev(1550}1551 1552#pragma clang attribute pop1553 1554namespace no_pragma_test {1555 struct S {1556 S();1557 };1558 1559 S::S() = default;1560 // CHECK-LABEL: define void @_ZN14no_pragma_test1SC2Ev(1561 // CHECK-HIDDEN-LABEL: define hidden void @_ZN14no_pragma_test1SC2Ev(1562}1563