1 // RUN: %clang_cc1 %s -std=c++11 -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s 2 // RUN: %clang_cc1 %s -std=c++11 -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-HIDDEN 3 // For clang, "internal" is just an alias for "hidden". We could use it for some 4 // 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-HIDDEN 6 7 #define HIDDEN __attribute__((visibility("hidden"))) 8 #define PROTECTED __attribute__((visibility("protected"))) 9 #define DEFAULT __attribute__((visibility("default"))) 10 11 namespace test30 { 12 // When H is hidden, it should make X hidden, even if the template argument 13 // 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 = global 22 // CHECK-HIDDEN: _ZN6test301bE = hidden global 23 } 24 25 namespace 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 = global 37 // CHECK-HIDDEN: @_ZN6test251aE = hidden global 38 } 39 40 namespace test28 { 41 class DEFAULT foo { 42 }; 43 foo myvec; 44 // CHECK: @_ZN6test285myvecE = global 45 // CHECK-HIDDEN: @_ZN6test285myvecE = hidden global 46 } 47 48 namespace 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 pop 56 // CHECK: @_ZN6test299data_rectE = global 57 // CHECK-HIDDEN: @_ZN6test299data_rectE = global 58 } 59 60 namespace 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 global 69 // CHECK-HIDDEN: _ZN6test403fooIiE3barE = weak_odr global 70 } 71 72 namespace test41 { 73 // Unlike gcc we propagate the information that foo not only is hidden, but 74 // has been explicitly marked as so. This lets us produce a hidden undefined 75 // reference to bar. 76 struct HIDDEN foo {}; 77 extern foo bar; 78 foo *zed() { 79 return &bar; 80 } 81 // CHECK: @_ZN6test413barE = external hidden global 82 // CHECK-HIDDEN: @_ZN6test413barE = external hidden global 83 } 84 85 namespace test48 { 86 // Test that we use the visibility of struct foo when instantiating the 87 // template. Note that is a case where we disagree with gcc, it produces 88 // 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 global 101 // CHECK-HIDDEN: _ZN6test481yE = hidden global 102 } 103 104 // CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10 105 // CHECK: @_ZN5Test71aE = hidden global 106 // CHECK: @_ZN5Test71bE = global 107 // CHECK: @test9_var = global 108 // CHECK-HIDDEN: @test9_var = global 109 // CHECK: @_ZN6Test121A6hiddenE = external hidden global 110 // CHECK: @_ZN6Test121A7visibleE = external global 111 // CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global 112 // CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global 113 // CHECK: @_ZN6Test131B1aE = hidden global 114 // CHECK: @_ZN6Test131C1aE = global 115 // CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global 116 // CHECK-HIDDEN: @_ZN6Test131C1aE = global 117 // CHECK: @_ZN6Test143varE = external global 118 // CHECK-HIDDEN: @_ZN6Test143varE = external global 119 // CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8] 120 // CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8] 121 122 namespace test27 { 123 template<typename T> 124 class C { 125 class DEFAULT D { 126 void f(); 127 }; 128 }; 129 130 template<> 131 class C<int>::D { 132 virtual void g(); 133 }; 134 135 void C<int>::D::g() { 136 } 137 // CHECK: _ZTVN6test271CIiE1DE = unnamed_addr constant 138 // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = unnamed_addr constant 139 } 140 141 // CHECK: @_ZTVN5Test63fooE = linkonce_odr hidden unnamed_addr constant 142 143 // CHECK-HIDDEN: @_ZTVN6Test161AIcEE = external unnamed_addr constant 144 // CHECK-HIDDEN: @_ZTTN6Test161AIcEE = external unnamed_addr constant 145 146 // CHECK: @_ZZN6test681fC1EvE4test = linkonce_odr global 147 // CHECK-HIDDEN: @_ZZN6test681fC1EvE4test = linkonce_odr hidden global 148 149 // CHECK: @_ZGVZN6test681fC1EvE4test = linkonce_odr global 150 // CHECK-HIDDEN: @_ZGVZN6test681fC1EvE4test = linkonce_odr hidden global 151 152 // CHECK: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr global 153 // CHECK-HIDDEN: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr hidden global 154 155 // CHECK: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr global i64 156 // CHECK-HIDDEN: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr hidden global i64 157 158 namespace Test1 { 159 // CHECK-LABEL: define hidden void @_ZN5Test11fEv 160 void HIDDEN f() { } 161 162 } 163 164 namespace Test2 { 165 struct HIDDEN A { 166 void f(); 167 }; 168 169 // A::f is a member function of a hidden class. 170 // CHECK-LABEL: define hidden void @_ZN5Test21A1fEv 171 void A::f() { } 172 } 173 174 namespace Test3 { 175 struct HIDDEN A { 176 struct B { 177 void f(); 178 }; 179 }; 180 181 // B is a nested class where its parent class is hidden. 182 // CHECK-LABEL: define hidden void @_ZN5Test31A1B1fEv 183 void A::B::f() { } 184 } 185 186 namespace Test4 HIDDEN { 187 int VariableInHiddenNamespace = 10; 188 189 // Test4::g is in a hidden namespace. 190 // CHECK-LABEL: define hidden void @_ZN5Test41gEv 191 void g() { } 192 193 struct DEFAULT A { 194 void f(); 195 }; 196 197 // A has default visibility. 198 // CHECK-LABEL: define void @_ZN5Test41A1fEv 199 void A::f() { } 200 } 201 202 namespace Test5 { 203 204 namespace NS HIDDEN { 205 // f is in NS which is hidden. 206 // CHECK-LABEL: define hidden void @_ZN5Test52NS1fEv() 207 void f() { } 208 } 209 210 namespace NS { 211 // g is in NS, but this NS decl is not hidden. 212 // CHECK-LABEL: define void @_ZN5Test52NS1gEv 213 void g() { } 214 } 215 } 216 217 // <rdar://problem/8091955> 218 namespace Test6 { 219 struct HIDDEN foo { 220 foo() { } 221 void bonk(); 222 virtual void bar() = 0; 223 224 virtual void zonk() {} 225 }; 226 227 struct barc : public foo { 228 barc(); 229 virtual void bar(); 230 }; 231 232 barc::barc() {} 233 } 234 235 namespace Test7 { 236 class HIDDEN A {}; 237 A a; // top of file 238 239 template <A&> struct Aref { 240 static void foo() {} 241 }; 242 243 class B : public A {}; 244 B b; // top of file 245 246 // CHECK-LABEL: define linkonce_odr hidden void @_ZN5Test74ArefIL_ZNS_1aEEE3fooEv() 247 void test() { 248 Aref<a>::foo(); 249 } 250 } 251 252 namespace Test8 { 253 void foo(); 254 void bar() {} 255 // CHECK-HIDDEN-LABEL: define hidden void @_ZN5Test83barEv() 256 // CHECK-HIDDEN: declare void @_ZN5Test83fooEv() 257 258 void test() { 259 foo(); 260 bar(); 261 } 262 } 263 264 // PR8457 265 namespace Test9 { 266 extern "C" { 267 struct A { int field; }; 268 void DEFAULT test9_fun(struct A *a) { } 269 struct A DEFAULT test9_var; // above 270 } 271 // CHECK-LABEL: define void @test9_fun( 272 // CHECK-HIDDEN-LABEL: define void @test9_fun( 273 274 void test() { 275 A a = test9_var; 276 test9_fun(&a); 277 } 278 } 279 280 // PR8478 281 namespace Test10 { 282 struct A; 283 284 class DEFAULT B { 285 void foo(A*); 286 }; 287 288 // CHECK-LABEL: define void @_ZN6Test101B3fooEPNS_1AE( 289 // CHECK-HIDDEN-LABEL: define void @_ZN6Test101B3fooEPNS_1AE( 290 void B::foo(A*) {} 291 } 292 293 // PR8492 294 namespace Test11 { 295 struct A { 296 void foo() {} 297 void DEFAULT bar() {} 298 }; 299 300 void test() { 301 A a; 302 a.foo(); 303 a.bar(); 304 } 305 306 // CHECK-LABEL: define linkonce_odr void @_ZN6Test111A3fooEv( 307 // CHECK-LABEL: define linkonce_odr void @_ZN6Test111A3barEv( 308 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6Test111A3fooEv( 309 // CHECK-HIDDEN-LABEL: define linkonce_odr void @_ZN6Test111A3barEv( 310 } 311 312 // Tested at top of file. 313 namespace Test12 { 314 struct A { 315 // This is hidden in all cases: the explicit attribute takes 316 // priority over -fvisibility on the parent. 317 static int hidden HIDDEN; 318 319 // This is default in all cases because it's only a declaration. 320 static int visible; 321 }; 322 323 void test() { 324 A::hidden = 0; 325 A::visible = 0; 326 } 327 } 328 329 // Tested at top of file. 330 namespace Test13 { 331 struct HIDDEN A {}; 332 333 // Should be hidden in all cases. 334 struct B { 335 static A a; 336 }; 337 A B::a; 338 339 // Should be default in all cases. 340 struct DEFAULT C { 341 static A a; 342 }; 343 A C::a; 344 }; 345 346 // Tested at top of file. 347 namespace Test14 { 348 // Neither the visibility of the type nor -fvisibility=hidden should 349 // apply to declarations. 350 extern struct A *var; 351 352 struct A *test() { return var; } 353 } 354 355 // rdar://problem/8613093 356 namespace Test15 { 357 struct A {}; 358 template <class T> struct Temp { 359 struct Inner { 360 static char buffer[0]; 361 }; 362 }; 363 364 char *test() { 365 return Temp<A>::Inner::buffer; 366 } 367 } 368 369 namespace Test16 { 370 struct Base1 { virtual void foo(); }; 371 struct Base2 : virtual Base1 { virtual void foo(); }; 372 template <class T> struct A : virtual Base1, Base2 { 373 virtual void foo(); 374 }; 375 extern template struct A<char>; 376 377 void test() { 378 A<char> a; 379 a.foo(); 380 } 381 } 382 383 namespace Test17 { 384 struct HIDDEN A { 385 static void foo(); 386 static void DEFAULT bar(); 387 static void HIDDEN baz(); 388 389 struct DEFAULT B { 390 static void foo(); 391 static void DEFAULT bar(); 392 static void HIDDEN baz(); 393 }; 394 }; 395 396 void test() { 397 A::foo(); 398 A::bar(); 399 A::baz(); 400 A::B::foo(); 401 A::B::bar(); 402 A::B::baz(); 403 } 404 // CHECK: declare hidden void @_ZN6Test171A3fooEv() 405 // CHECK: declare void @_ZN6Test171A3barEv() 406 // CHECK: declare hidden void @_ZN6Test171A3bazEv() 407 // CHECK: declare void @_ZN6Test171A1B3fooEv() 408 // CHECK: declare void @_ZN6Test171A1B3barEv() 409 // CHECK: declare hidden void @_ZN6Test171A1B3bazEv() 410 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3fooEv() 411 // CHECK-HIDDEN: declare void @_ZN6Test171A3barEv() 412 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3bazEv() 413 // CHECK-HIDDEN: declare void @_ZN6Test171A1B3fooEv() 414 // CHECK-HIDDEN: declare void @_ZN6Test171A1B3barEv() 415 // CHECK-HIDDEN: declare hidden void @_ZN6Test171A1B3bazEv() 416 } 417 418 namespace Test18 { 419 template <class T> struct HIDDEN A { 420 static void foo(); 421 static void DEFAULT bar(); 422 static void HIDDEN baz(); 423 424 struct DEFAULT B { 425 static void foo(); 426 static void DEFAULT bar(); 427 static void HIDDEN baz(); 428 }; 429 }; 430 struct HIDDEN H; 431 432 void test() { 433 A<int>::foo(); 434 A<int>::bar(); 435 A<int>::baz(); 436 A<int>::B::foo(); 437 A<int>::B::bar(); 438 A<int>::B::baz(); 439 A<H>::foo(); 440 A<H>::bar(); 441 A<H>::baz(); 442 A<H>::B::foo(); 443 A<H>::B::bar(); 444 A<H>::B::baz(); 445 } 446 // CHECK: declare hidden void @_ZN6Test181AIiE3fooEv() 447 // CHECK: declare void @_ZN6Test181AIiE3barEv() 448 // CHECK: declare hidden void @_ZN6Test181AIiE3bazEv() 449 // CHECK: declare void @_ZN6Test181AIiE1B3fooEv() 450 // CHECK: declare void @_ZN6Test181AIiE1B3barEv() 451 // CHECK: declare hidden void @_ZN6Test181AIiE1B3bazEv() 452 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3fooEv() 453 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3barEv() 454 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3bazEv() 455 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv() 456 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv() 457 // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv() 458 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3fooEv() 459 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE3barEv() 460 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3bazEv() 461 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3fooEv() 462 // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3barEv() 463 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE1B3bazEv() 464 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3fooEv() 465 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3barEv() 466 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3bazEv() 467 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv() 468 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv() 469 // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv() 470 } 471 472 namespace Test19 { 473 struct A { A(); ~A(); }; 474 475 // Tested at top of file. 476 template <class T> void foo() { 477 static A a; 478 } 479 480 void test() { 481 foo<int>(); 482 } 483 } 484 485 // Various things with class template specializations. 486 namespace Test20 { 487 template <unsigned> struct HIDDEN A {}; 488 489 // An explicit specialization inherits the explicit visibility of 490 // the template. 491 template <> struct A<0> { 492 static void test0(); 493 static void test1(); 494 }; 495 496 // CHECK-LABEL: define hidden void @_ZN6Test201AILj0EE5test0Ev() 497 void A<0>::test0() {} 498 499 // CHECK: declare hidden void @_ZN6Test201AILj0EE5test1Ev() 500 void test1() { 501 A<0>::test1(); 502 } 503 504 // ...unless that's explicitly overridden. 505 template <> struct DEFAULT A<1> { 506 static void test2(); 507 static void test3(); 508 }; 509 510 // CHECK-LABEL: define void @_ZN6Test201AILj1EE5test2Ev() 511 void A<1>::test2() {} 512 513 // CHECK: declare void @_ZN6Test201AILj1EE5test3Ev() 514 void test3() { 515 A<1>::test3(); 516 } 517 518 // <rdar://problem/8778497> 519 // But we should assume that an unknown specialization has the 520 // explicit visibility settings of the template. 521 template <class T> struct B { 522 static void test4() {} 523 static void test5(); 524 }; 525 526 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6Test201BINS_1AILj2EEEE5test4Ev() 527 void test4() { 528 B<A<2> >::test4(); 529 } 530 531 // CHECK: declare hidden void @_ZN6Test201BINS_1AILj2EEEE5test5Ev() 532 void test5() { 533 B<A<2> >::test5(); 534 } 535 } 536 537 // PR9371 538 namespace test21 { 539 enum En { en }; 540 template<En> struct A { 541 DEFAULT void foo() {} 542 }; 543 544 // CHECK-LABEL: define weak_odr void @_ZN6test211AILNS_2EnE0EE3fooEv( 545 template void A<en>::foo(); 546 } 547 548 // rdar://problem/9616154 549 // Visibility on explicit specializations should take precedence. 550 namespace test22 { 551 class A1 {}; 552 class A2 {}; 553 554 template <class T> struct B {}; 555 template <> struct DEFAULT B<A1> { 556 static void foo(); 557 static void bar() {} 558 }; 559 template <> struct B<A2> { 560 static void foo(); 561 static void bar() {} 562 }; 563 564 void test() { 565 B<A1>::foo(); 566 B<A1>::bar(); 567 B<A2>::foo(); 568 B<A2>::bar(); 569 } 570 // CHECK: declare void @_ZN6test221BINS_2A1EE3fooEv() 571 // CHECK-LABEL: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv() 572 // CHECK: declare void @_ZN6test221BINS_2A2EE3fooEv() 573 // CHECK-LABEL: define linkonce_odr void @_ZN6test221BINS_2A2EE3barEv() 574 // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A1EE3fooEv() 575 // CHECK-HIDDEN-LABEL: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv() 576 // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A2EE3fooEv() 577 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test221BINS_2A2EE3barEv() 578 } 579 580 namespace PR10113 { 581 namespace foo DEFAULT { 582 template<typename T> 583 class bar { 584 void zed() {} 585 }; 586 } 587 template class foo::bar<char>; 588 // CHECK-LABEL: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv 589 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv 590 591 struct zed { 592 }; 593 template class foo::bar<zed>; 594 // CHECK-LABEL: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv 595 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN7PR101133foo3barINS_3zedEE3zedEv 596 } 597 598 namespace PR11690 { 599 template<class T> struct Class { 600 void size() const { 601 } 602 }; 603 template class DEFAULT Class<char>; 604 // CHECK-LABEL: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv 605 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv 606 607 template<class T> void Method() {} 608 template DEFAULT void Method<char>(); 609 // CHECK-LABEL: define weak_odr void @_ZN7PR116906MethodIcEEvv 610 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN7PR116906MethodIcEEvv 611 } 612 613 namespace PR11690_2 { 614 namespace foo DEFAULT { 615 class bar; 616 template<typename T1, typename T2 = bar> 617 class zed { 618 void bar() { 619 } 620 }; 621 } 622 struct baz { 623 }; 624 template class foo::zed<baz>; 625 // CHECK-LABEL: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv 626 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv 627 } 628 629 namespace test23 { 630 // Having a template argument that is explicitly visible should not make 631 // the template instantiation visible. 632 template <typename T> 633 struct X { 634 static void f() { 635 } 636 }; 637 638 class DEFAULT A; 639 640 void g() { 641 X<A> y; 642 y.f(); 643 } 644 // CHECK-LABEL: define linkonce_odr void @_ZN6test231XINS_1AEE1fEv 645 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test231XINS_1AEE1fEv 646 } 647 648 namespace PR12001 { 649 template <typename P1> 650 void Bind(const P1& p1) { 651 } 652 653 class DEFAULT Version { }; 654 655 void f() { 656 Bind(Version()); 657 } 658 // CHECK-LABEL: define linkonce_odr void @_ZN7PR120014BindINS_7VersionEEEvRKT_ 659 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN7PR120014BindINS_7VersionEEEvRKT_ 660 } 661 662 namespace test24 { 663 class DEFAULT A { }; 664 665 struct S { 666 template <typename T> 667 void mem() {} 668 }; 669 670 void test() { 671 S s; 672 s.mem<A>(); 673 } 674 // CHECK-LABEL: define linkonce_odr void @_ZN6test241S3memINS_1AEEEvv 675 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test241S3memINS_1AEEEvv 676 } 677 678 namespace test26 { 679 template<typename T> 680 class C { 681 DEFAULT void f(); 682 }; 683 684 template<> 685 void C<int>::f() { } 686 687 // CHECK-LABEL: define void @_ZN6test261CIiE1fEv 688 // CHECK-HIDDEN-LABEL: define void @_ZN6test261CIiE1fEv 689 } 690 691 namespace test31 { 692 struct A { 693 struct HIDDEN B { 694 static void DEFAULT baz(); 695 }; 696 }; 697 void f() { 698 A::B::baz(); 699 } 700 // CHECK: declare void @_ZN6test311A1B3bazEv() 701 // CHECK-HIDDEN: declare void @_ZN6test311A1B3bazEv() 702 } 703 704 namespace test32 { 705 struct HIDDEN A { 706 struct DEFAULT B { 707 void DEFAULT baz(); 708 }; 709 }; 710 void A::B::baz() { 711 } 712 // CHECK-LABEL: define void @_ZN6test321A1B3bazEv 713 // CHECK-HIDDEN-LABEL: define void @_ZN6test321A1B3bazEv 714 } 715 716 namespace test33 { 717 template<typename T> 718 class foo { 719 void bar() {} 720 }; 721 struct HIDDEN zed { 722 }; 723 template class DEFAULT foo<zed>; 724 // CHECK-LABEL: define weak_odr void @_ZN6test333fooINS_3zedEE3barEv 725 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test333fooINS_3zedEE3barEv 726 } 727 728 namespace test34 { 729 struct foo { 730 }; 731 template<class T> 732 void bar() {} 733 template DEFAULT void bar<foo>(); 734 // CHECK-LABEL: define weak_odr void @_ZN6test343barINS_3fooEEEvv 735 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test343barINS_3fooEEEvv 736 } 737 738 namespace test35 { 739 // This is a really ugly testcase. GCC propagates the DEFAULT in zed's 740 // definition. It's not really clear what we can do here, because we 741 // produce the symbols before even seeing the DEFAULT definition of zed. 742 // FIXME: Maybe the best thing to do here is error? It's certainly hard 743 // to argue that this ought to be valid. 744 template<typename T> 745 struct DEFAULT foo { 746 void bar() {} 747 }; 748 class zed; 749 template class foo<zed>; 750 class DEFAULT zed { 751 }; 752 // CHECK-LABEL: define weak_odr void @_ZN6test353fooINS_3zedEE3barEv 753 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test353fooINS_3zedEE3barEv 754 } 755 756 namespace test36 { 757 template<typename T1, typename T2> 758 class foo { 759 void bar() {} 760 }; 761 class DEFAULT S1 {}; 762 struct HIDDEN S2 {}; 763 template class foo<S1, S2>; 764 // CHECK-LABEL: define weak_odr hidden void @_ZN6test363fooINS_2S1ENS_2S2EE3barEv 765 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test363fooINS_2S1ENS_2S2EE3barEv 766 } 767 768 namespace test37 { 769 struct HIDDEN foo { 770 }; 771 template<class T> 772 DEFAULT void bar() {} 773 template DEFAULT void bar<foo>(); 774 // CHECK-LABEL: define weak_odr void @_ZN6test373barINS_3fooEEEvv 775 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test373barINS_3fooEEEvv 776 } 777 778 namespace test38 { 779 template<typename T> 780 class DEFAULT foo { 781 void bar() {} 782 }; 783 struct HIDDEN zed { 784 }; 785 template class foo<zed>; 786 // CHECK-LABEL: define weak_odr hidden void @_ZN6test383fooINS_3zedEE3barEv 787 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test383fooINS_3zedEE3barEv 788 } 789 790 namespace test39 { 791 class DEFAULT default_t; 792 class HIDDEN hidden_t; 793 template <class T> class A { 794 template <class U> class B { 795 HIDDEN void hidden() {} 796 void noattr() {} 797 template <class V> void temp() {} 798 }; 799 }; 800 template class DEFAULT A<hidden_t>; 801 template class DEFAULT A<hidden_t>::B<hidden_t>; 802 template void A<hidden_t>::B<hidden_t>::temp<default_t>(); 803 template void A<hidden_t>::B<hidden_t>::temp<hidden_t>(); 804 805 // CHECK-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E6hiddenEv 806 // CHECK-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E6noattrEv 807 // CHECK-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempINS_9default_tEEEvv 808 809 // GCC produces a default for this one. Why? 810 // CHECK-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempIS1_EEvv 811 812 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E6hiddenEv 813 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E6noattrEv 814 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempINS_9default_tEEEvv 815 816 // GCC produces a default for this one. Why? 817 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test391AINS_8hidden_tEE1BIS1_E4tempIS1_EEvv 818 } 819 820 namespace test42 { 821 struct HIDDEN foo { 822 }; 823 template <class P> 824 struct bar { 825 }; 826 template <> 827 struct HIDDEN bar<foo> { 828 DEFAULT static void zed(); 829 }; 830 void bar<foo>::zed() { 831 } 832 // CHECK-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv 833 // CHECK-HIDDEN-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv 834 } 835 836 namespace test43 { 837 struct HIDDEN foo { 838 }; 839 template <class P> 840 void bar() { 841 } 842 template <> 843 DEFAULT void bar<foo>() { 844 } 845 // CHECK-LABEL: define void @_ZN6test433barINS_3fooEEEvv 846 // CHECK-HIDDEN-LABEL: define void @_ZN6test433barINS_3fooEEEvv 847 } 848 849 namespace test44 { 850 template <typename T> 851 struct foo { 852 foo() {} 853 }; 854 namespace { 855 struct bar; 856 } 857 template struct DEFAULT foo<bar>; 858 foo<bar> x; 859 // CHECK-LABEL: define internal void @_ZN6test443fooINS_12_GLOBAL__N_13barEEC1Ev 860 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test443fooINS_12_GLOBAL__N_13barEEC1Ev 861 } 862 863 namespace test45 { 864 template <typename T> 865 struct foo { 866 template <typename T2> 867 struct bar { 868 bar() {}; 869 }; 870 }; 871 namespace { 872 struct zed; 873 } 874 template struct DEFAULT foo<int>::bar<zed>; 875 foo<int>::bar<zed> x; 876 // CHECK-LABEL: define internal void @_ZN6test453fooIiE3barINS_12_GLOBAL__N_13zedEEC1Ev 877 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test453fooIiE3barINS_12_GLOBAL__N_13zedEEC1Ev 878 } 879 880 namespace test46 { 881 template <typename T> 882 void foo() { 883 } 884 namespace { 885 struct bar; 886 } 887 template DEFAULT void foo<bar>(); 888 void zed() { 889 foo<bar>(); 890 } 891 // CHECK-LABEL: define internal void @_ZN6test463fooINS_12_GLOBAL__N_13barEEEvv 892 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test463fooINS_12_GLOBAL__N_13barEEEvv 893 } 894 895 namespace test47 { 896 struct foo { 897 template <typename T> 898 static void bar() { 899 } 900 }; 901 namespace { 902 struct zed; 903 } 904 template DEFAULT void foo::bar<zed>(); 905 void baz() { 906 foo::bar<zed>(); 907 } 908 // CHECK-LABEL: define internal void @_ZN6test473foo3barINS_12_GLOBAL__N_13zedEEEvv 909 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test473foo3barINS_12_GLOBAL__N_13zedEEEvv 910 } 911 912 namespace test49 { 913 // Test that we use the visibility of struct foo when instantiating the 914 // template. Note that is a case where we disagree with gcc, it produces 915 // a default symbol. 916 917 struct HIDDEN foo { 918 }; 919 920 DEFAULT foo x; 921 922 struct bar { 923 template<foo *z> 924 void zed() { 925 } 926 }; 927 928 template void bar::zed<&x>(); 929 // CHECK-LABEL: define weak_odr hidden void @_ZN6test493bar3zedIXadL_ZNS_1xEEEEEvv 930 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test493bar3zedIXadL_ZNS_1xEEEEEvv 931 } 932 933 namespace test50 { 934 // Test that we use the visibility of struct foo when instantiating the 935 // template. Note that is a case where we disagree with gcc, it produces 936 // a default symbol. 937 938 struct HIDDEN foo { 939 }; 940 DEFAULT foo x; 941 template<foo *z> 942 struct DEFAULT bar { 943 void zed() { 944 } 945 }; 946 template void bar<&x>::zed(); 947 // CHECK-LABEL: define weak_odr hidden void @_ZN6test503barIXadL_ZNS_1xEEEE3zedEv 948 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test503barIXadL_ZNS_1xEEEE3zedEv 949 } 950 951 namespace test51 { 952 // Test that we use the visibility of struct foo when instantiating the 953 // template. Note that is a case where we disagree with gcc, it produces 954 // a default symbol. 955 956 struct HIDDEN foo { 957 }; 958 DEFAULT foo x; 959 template<foo *z> 960 void DEFAULT zed() { 961 } 962 template void zed<&x>(); 963 // CHECK-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_1xEEEEEvv 964 // CHECK-HIDDEN-LABEL: define weak_odr hidden void @_ZN6test513zedIXadL_ZNS_1xEEEEEvv 965 } 966 967 namespace test52 { 968 // Test that we use the linkage of struct foo when instantiating the 969 // template. Note that is a case where we disagree with gcc, it produces 970 // an external symbol. 971 972 namespace { 973 struct foo { 974 }; 975 } 976 template<foo *x> 977 void zed() { 978 } 979 void f() { 980 zed<nullptr>(); 981 } 982 // CHECK-LABEL: define internal void @_ZN6test523zedILPNS_12_GLOBAL__N_13fooE0EEEvv 983 // CHECK-HIDDEN-LABEL: define internal void @_ZN6test523zedILPNS_12_GLOBAL__N_13fooE0EEEvv 984 } 985 986 namespace test53 { 987 template<typename _Tp > struct vector { 988 static void _M_fill_insert(); 989 }; 990 #pragma GCC visibility push(hidden) 991 // GCC doesn't seem to use the visibility of enums at all, we do. 992 enum zed {v1}; 993 994 // GCC fails to mark this specialization hidden, we mark it. 995 template<> 996 struct vector<int> { 997 static void _M_fill_insert(); 998 }; 999 void foo() { 1000 vector<unsigned>::_M_fill_insert(); 1001 vector<int>::_M_fill_insert(); 1002 vector<zed>::_M_fill_insert(); 1003 } 1004 #pragma GCC visibility pop 1005 // CHECK: declare void @_ZN6test536vectorIjE14_M_fill_insertEv 1006 // CHECK-HIDDEN: declare void @_ZN6test536vectorIjE14_M_fill_insertEv 1007 // CHECK: declare hidden void @_ZN6test536vectorIiE14_M_fill_insertEv 1008 // CHECK-HIDDEN: declare hidden void @_ZN6test536vectorIiE14_M_fill_insertEv 1009 // CHECK: declare hidden void @_ZN6test536vectorINS_3zedEE14_M_fill_insertEv 1010 // CHECK-HIDDEN: declare hidden void @_ZN6test536vectorINS_3zedEE14_M_fill_insertEv 1011 } 1012 1013 namespace test54 { 1014 template <class T> 1015 struct foo { 1016 static void bar(); 1017 }; 1018 #pragma GCC visibility push(hidden) 1019 class zed { 1020 zed(const zed &); 1021 }; 1022 void bah() { 1023 foo<zed>::bar(); 1024 } 1025 #pragma GCC visibility pop 1026 // CHECK: declare hidden void @_ZN6test543fooINS_3zedEE3barEv 1027 // CHECK-HIDDEN: declare hidden void @_ZN6test543fooINS_3zedEE3barEv 1028 } 1029 1030 namespace test55 { 1031 template <class T> 1032 struct HIDDEN foo { 1033 static void bar(); 1034 }; 1035 template <class T> struct foo; 1036 void foobar() { 1037 foo<int>::bar(); 1038 } 1039 // CHECK: declare hidden void @_ZN6test553fooIiE3barEv 1040 // CHECK-HIDDEN: declare hidden void @_ZN6test553fooIiE3barEv 1041 } 1042 1043 namespace test56 { 1044 template <class T> struct foo; 1045 template <class T> 1046 struct HIDDEN foo { 1047 static void bar(); 1048 }; 1049 void foobar() { 1050 foo<int>::bar(); 1051 } 1052 // CHECK: declare hidden void @_ZN6test563fooIiE3barEv 1053 // CHECK-HIDDEN: declare hidden void @_ZN6test563fooIiE3barEv 1054 } 1055 1056 namespace test57 { 1057 #pragma GCC visibility push(hidden) 1058 template <class T> 1059 struct foo; 1060 void bar(foo<int>*); 1061 template <class T> 1062 struct foo { 1063 static void zed(); 1064 }; 1065 void bah() { 1066 foo<int>::zed(); 1067 } 1068 #pragma GCC visibility pop 1069 // CHECK: declare hidden void @_ZN6test573fooIiE3zedEv 1070 // CHECK-HIDDEN: declare hidden void @_ZN6test573fooIiE3zedEv 1071 } 1072 1073 namespace test58 { 1074 #pragma GCC visibility push(hidden) 1075 struct foo; 1076 template<typename T> 1077 struct DEFAULT bar { 1078 static void zed() { 1079 } 1080 }; 1081 void bah() { 1082 bar<foo>::zed(); 1083 } 1084 #pragma GCC visibility pop 1085 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test583barINS_3fooEE3zedEv 1086 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test583barINS_3fooEE3zedEv 1087 } 1088 1089 namespace test59 { 1090 DEFAULT int f(); 1091 HIDDEN int g(); 1092 typedef int (*foo)(); 1093 template<foo x, foo y> 1094 void test() {} 1095 void use() { 1096 test<&g, &f>(); 1097 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1gEvEEXadL_ZNS_1fEvEEEEvv 1098 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1gEvEEXadL_ZNS_1fEvEEEEvv 1099 1100 test<&f, &g>(); 1101 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1fEvEEXadL_ZNS_1gEvEEEEvv 1102 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test594testIXadL_ZNS_1fEvEEXadL_ZNS_1gEvEEEEvv 1103 } 1104 } 1105 1106 namespace test60 { 1107 template<int i> 1108 class HIDDEN a {}; 1109 template<int i> 1110 class DEFAULT b {}; 1111 template<template<int> class x, template<int> class y> 1112 void test() {} 1113 void use() { 1114 test<a, b>(); 1115 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1aENS_1bEEEvv 1116 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1aENS_1bEEEvv 1117 1118 test<b, a>(); 1119 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1bENS_1aEEEvv 1120 // CHECK-HIDDEN-LABEL: define linkonce_odr hidden void @_ZN6test604testINS_1bENS_1aEEEvv 1121 } 1122 } 1123 1124 namespace test61 { 1125 template <typename T1> 1126 struct Class1 1127 { 1128 void f1() { f2(); } 1129 inline void f2(); 1130 }; 1131 template<> 1132 inline void Class1<int>::f2() 1133 { 1134 } 1135 void g(Class1<int> *x) { 1136 x->f1(); 1137 } 1138 } 1139 namespace test61 { 1140 // Just test that we don't crash. Currently we apply this attribute. Current 1141 // gcc issues a warning about it being unused since "the type is already 1142 // defined". We should probably do the same. 1143 template class HIDDEN Class1<int>; 1144 } 1145 1146 namespace test62 { 1147 template <typename T1> 1148 struct Class1 1149 { 1150 void f1() { f2(); } 1151 inline void f2() {} 1152 }; 1153 template<> 1154 inline void Class1<int>::f2() 1155 { 1156 } 1157 void g(Class1<int> *x) { 1158 x->f2(); 1159 } 1160 } 1161 namespace test62 { 1162 template class HIDDEN Class1<int>; 1163 // Just test that we don't crash. Currently we apply this attribute. Current 1164 // gcc issues a warning about it being unused since "the type is already 1165 // defined". We should probably do the same. 1166 } 1167 1168 namespace test63 { 1169 enum HIDDEN E { E0 }; 1170 struct A { 1171 template <E> static void foo() {} 1172 1173 template <E> struct B { 1174 static void foo() {} 1175 }; 1176 }; 1177 1178 void test() { 1179 A::foo<E0>(); 1180 A::B<E0>::foo(); 1181 } 1182 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test631A3fooILNS_1EE0EEEvv() 1183 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test631A1BILNS_1EE0EE3fooEv() 1184 } 1185 1186 // Don't ignore the visibility of template arguments just because we 1187 // explicitly instantiated something. 1188 namespace test64 { 1189 struct HIDDEN A {}; 1190 template <class P> struct B { 1191 static DEFAULT void foo() {} 1192 }; 1193 1194 template class B<A>; 1195 // CHECK-LABEL: define weak_odr hidden void @_ZN6test641BINS_1AEE3fooEv() 1196 } 1197 1198 namespace test65 { 1199 class HIDDEN A {}; 1200 template <class T> struct B { 1201 static void func(); 1202 template <class U> static void funcT1(); 1203 template <class U> static void funcT2(); 1204 class Inner {}; 1205 template <class U> class InnerT {}; 1206 }; 1207 template <template <class T> class Temp> struct C { 1208 static void foo() {} 1209 }; 1210 1211 // CHECK-LABEL: define void @_ZN6test651BINS_1AEE4funcEv() 1212 template <> DEFAULT void B<A>::func() {} 1213 1214 // CHECK-LABEL: define void @_ZN6test651BINS_1AEE6funcT2IS1_EEvv() 1215 template <> template <> DEFAULT void B<A>::funcT2<A>() {} 1216 1217 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE6funcT1IiEEvv() 1218 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test651BINS_1AEE6funcT1IS1_EEvv() 1219 template <> template <class T> DEFAULT void B<A>::funcT1() {} 1220 1221 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE5Inner3fooEv() 1222 template <> struct DEFAULT B<A>::Inner { 1223 static void foo() {} 1224 }; 1225 1226 // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE6InnerTIiE3fooEv() 1227 // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test651BINS_1AEE6InnerTIS1_E3fooEv() 1228 template <> template <class U> struct DEFAULT B<A>::InnerT { 1229 static void foo() {} 1230 }; 1231 1232 void test() { 1233 B<A>::funcT1<int>(); 1234 B<A>::funcT1<A>(); 1235 B<A>::Inner::foo(); 1236 B<A>::InnerT<int>::foo(); 1237 B<A>::InnerT<A>::foo(); 1238 } 1239 1240 template class C<B<A>::InnerT>; 1241 } 1242 1243 namespace test66 { 1244 template <typename T> 1245 struct DEFAULT barT { 1246 static void zed() {} 1247 }; 1248 class foo; 1249 class DEFAULT foo; 1250 template struct barT<foo>; 1251 // CHECK-LABEL: define weak_odr void @_ZN6test664barTINS_3fooEE3zedEv 1252 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barTINS_3fooEE3zedEv 1253 1254 template <int* I> 1255 struct DEFAULT barI { 1256 static void zed() {} 1257 }; 1258 extern int I; 1259 extern int I DEFAULT; 1260 template struct barI<&I>; 1261 // CHECK-LABEL: define weak_odr void @_ZN6test664barIIXadL_ZNS_1IEEEE3zedEv 1262 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barIIXadL_ZNS_1IEEEE3zedEv 1263 1264 typedef void (*fType)(void); 1265 template<fType F> 1266 struct DEFAULT barF { 1267 static void zed() {} 1268 }; 1269 void F(); 1270 void F() DEFAULT; 1271 template struct barF<F>; 1272 // CHECK-LABEL: define weak_odr void @_ZN6test664barFIXadL_ZNS_1FEvEEE3zedEv 1273 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test664barFIXadL_ZNS_1FEvEEE3zedEv 1274 } 1275 1276 namespace test67 { 1277 template <typename T> 1278 struct DEFAULT bar { 1279 static void zed() {} 1280 }; 1281 1282 class foo; 1283 class compute { 1284 void f(foo *rootfoo); 1285 }; 1286 class DEFAULT foo; 1287 1288 template struct bar<foo>; 1289 // CHECK-LABEL: define weak_odr void @_ZN6test673barINS_3fooEE3zedEv 1290 // CHECK-HIDDEN-LABEL: define weak_odr void @_ZN6test673barINS_3fooEE3zedEv 1291 } 1292 1293 namespace test68 { 1294 class A { public: ~A(); }; 1295 class f { 1296 public: 1297 f() { 1298 static A test; 1299 } 1300 }; 1301 void g() { 1302 f a; 1303 } 1304 // Check lines at top of file. 1305 } 1306 1307 namespace test69 { 1308 // PR18174 1309 namespace foo { 1310 void f(); 1311 } 1312 namespace foo { 1313 void f() {}; 1314 } 1315 namespace foo __attribute__((visibility("hidden"))) { 1316 } 1317 // CHECK-LABEL: define void @_ZN6test693foo1fEv 1318 // CHECK-HIDDEN-LABEL: define hidden void @_ZN6test693foo1fEv 1319 } 1320
