1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
2 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-HIDDEN
3 
4 #define HIDDEN __attribute__((visibility("hidden")))
5 #define PROTECTED __attribute__((visibility("protected")))
6 #define DEFAULT __attribute__((visibility("default")))
7 
8 // CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10
9 // CHECK: @_ZN5Test71aE = hidden global
10 // CHECK: @_ZN5Test71bE = global
11 // CHECK: @test9_var = global
12 // CHECK-HIDDEN: @test9_var = global
13 // CHECK: @_ZN6Test121A6hiddenE = external hidden global
14 // CHECK: @_ZN6Test121A7visibleE = external global
15 // CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global
16 // CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global
17 // CHECK: @_ZN6Test131B1aE = hidden global
18 // CHECK: @_ZN6Test131C1aE = global
19 // CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global
20 // CHECK-HIDDEN: @_ZN6Test131C1aE = global
21 // CHECK: @_ZN6Test143varE = external global
22 // CHECK-HIDDEN: @_ZN6Test143varE = external global
23 // CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
24 // CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
25 // CHECK: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr global
26 // CHECK: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr global i64
27 // CHECK-HIDDEN: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr hidden global
28 // CHECK-HIDDEN: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr hidden global i64
29 // CHECK-HIDDEN: @_ZTVN6Test161AIcEE = external unnamed_addr constant
30 // CHECK-HIDDEN: @_ZTTN6Test161AIcEE = external unnamed_addr constant
31 // CHECK: @_ZTVN5Test63fooE = linkonce_odr hidden unnamed_addr constant
32 
33 namespace Test1 {
34   // CHECK: define hidden void @_ZN5Test11fEv
35   void HIDDEN f() { }
36 
37 }
38 
39 namespace Test2 {
40   struct HIDDEN A {
41     void f();
42   };
43 
44   // A::f is a member function of a hidden class.
45   // CHECK: define hidden void @_ZN5Test21A1fEv
46   void A::f() { }
47 }
48 
49 namespace Test3 {
50   struct HIDDEN A {
51     struct B {
52       void f();
53     };
54   };
55 
56   // B is a nested class where its parent class is hidden.
57   // CHECK: define hidden void @_ZN5Test31A1B1fEv
58   void A::B::f() { }
59 }
60 
61 namespace Test4 HIDDEN {
62   int VariableInHiddenNamespace = 10;
63 
64   // Test4::g is in a hidden namespace.
65   // CHECK: define hidden void @_ZN5Test41gEv
66   void g() { }
67 
68   struct DEFAULT A {
69     void f();
70   };
71 
72   // A has default visibility.
73   // CHECK: define void @_ZN5Test41A1fEv
74   void A::f() { }
75 }
76 
77 namespace Test5 {
78 
79   namespace NS HIDDEN {
80     // f is in NS which is hidden.
81     // CHECK: define hidden void @_ZN5Test52NS1fEv()
82     void f() { }
83   }
84 
85   namespace NS {
86     // g is in NS, but this NS decl is not hidden.
87     // CHECK: define void @_ZN5Test52NS1gEv
88     void g() { }
89   }
90 }
91 
92 // <rdar://problem/8091955>
93 namespace Test6 {
94   struct HIDDEN foo {
95     foo() { }
96     void bonk();
97     virtual void bar() = 0;
98 
99     virtual void zonk() {}
100   };
101 
102   struct barc : public foo {
103     barc();
104     virtual void bar();
105   };
106 
107   barc::barc() {}
108 }
109 
110 namespace Test7 {
111   class HIDDEN A {};
112   A a; // top of file
113 
114   template <A&> struct Aref {
115     static void foo() {}
116   };
117 
118   class B : public A {};
119   B b; // top of file
120 
121   // CHECK: define linkonce_odr hidden void @_ZN5Test74ArefILZNS_1aEEE3fooEv()
122   void test() {
123     Aref<a>::foo();
124   }
125 }
126 
127 namespace Test8 {
128   void foo();
129   void bar() {}
130   // CHECK-HIDDEN: define hidden void @_ZN5Test83barEv()
131   // CHECK-HIDDEN: declare void @_ZN5Test83fooEv()
132 
133   void test() {
134     foo();
135     bar();
136   }
137 }
138 
139 // PR8457
140 namespace Test9 {
141   extern "C" {
142     struct A { int field; };
143     void DEFAULT test9_fun(struct A *a) { }
144     struct A DEFAULT test9_var; // above
145   }
146   // CHECK: define void @test9_fun(
147   // CHECK-HIDDEN: define void @test9_fun(
148 
149   void test() {
150     A a = test9_var;
151     test9_fun(&a);
152   }
153 }
154 
155 // PR8478
156 namespace Test10 {
157   struct A;
158 
159   class DEFAULT B {
160     void foo(A*);
161   };
162 
163   // CHECK: define void @_ZN6Test101B3fooEPNS_1AE(
164   // CHECK-HIDDEN: define void @_ZN6Test101B3fooEPNS_1AE(
165   void B::foo(A*) {}
166 }
167 
168 // PR8492
169 namespace Test11 {
170   struct A {
171     void foo() {}
172     void DEFAULT bar() {}
173   };
174 
175   void test() {
176     A a;
177     a.foo();
178     a.bar();
179   }
180 
181   // CHECK: define linkonce_odr void @_ZN6Test111A3fooEv(
182   // CHECK: define linkonce_odr void @_ZN6Test111A3barEv(
183   // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN6Test111A3fooEv(
184   // CHECK-HIDDEN: define linkonce_odr void @_ZN6Test111A3barEv(
185 }
186 
187 // Tested at top of file.
188 namespace Test12 {
189   struct A {
190     // This is hidden in all cases: the explicit attribute takes
191     // priority over -fvisibility on the parent.
192     static int hidden HIDDEN;
193 
194     // This is default in all cases because it's only a declaration.
195     static int visible;
196   };
197 
198   void test() {
199     A::hidden = 0;
200     A::visible = 0;
201   }
202 }
203 
204 // Tested at top of file.
205 namespace Test13 {
206   struct HIDDEN A {};
207 
208   // Should be hidden in all cases.
209   struct B {
210     static A a;
211   };
212   A B::a;
213 
214   // Should be default in all cases.
215   struct DEFAULT C {
216     static A a;
217   };
218   A C::a;
219 };
220 
221 // Tested at top of file.
222 namespace Test14 {
223   // Neither the visibility of the type nor -fvisibility=hidden should
224   // apply to declarations.
225   extern struct A *var;
226 
227   struct A *test() { return var; }
228 }
229 
230 // rdar://problem/8613093
231 namespace Test15 {
232   struct A {};
233   template <class T> struct Temp {
234     struct Inner {
235       static char buffer[0];
236     };
237   };
238 
239   char *test() {
240     return Temp<A>::Inner::buffer;
241   }
242 }
243 
244 namespace Test16 {
245   struct Base1 { virtual void foo(); };
246   struct Base2 : virtual Base1 { virtual void foo(); };
247   template <class T> struct A : virtual Base1, Base2 {
248     virtual void foo();
249   };
250   extern template struct A<char>;
251 
252   void test() {
253     A<char> a;
254     a.foo();
255   }
256 }
257 
258 namespace Test17 {
259   struct HIDDEN A {
260     static void foo();
261     static void DEFAULT bar();
262     static void HIDDEN baz();
263 
264     struct DEFAULT B {
265       static void foo();
266       static void DEFAULT bar();
267       static void HIDDEN baz();
268     };
269   };
270 
271   void test() {
272     A::foo();
273     A::bar();
274     A::baz();
275     A::B::foo();
276     A::B::bar();
277     A::B::baz();
278   }
279   // CHECK: declare hidden void @_ZN6Test171A3fooEv()
280   // CHECK: declare void @_ZN6Test171A3barEv()
281   // CHECK: declare hidden void @_ZN6Test171A3bazEv()
282   // CHECK: declare void @_ZN6Test171A1B3fooEv()
283   // CHECK: declare void @_ZN6Test171A1B3barEv()
284   // CHECK: declare hidden void @_ZN6Test171A1B3bazEv()
285   // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3fooEv()
286   // CHECK-HIDDEN: declare void @_ZN6Test171A3barEv()
287   // CHECK-HIDDEN: declare hidden void @_ZN6Test171A3bazEv()
288   // CHECK-HIDDEN: declare void @_ZN6Test171A1B3fooEv()
289   // CHECK-HIDDEN: declare void @_ZN6Test171A1B3barEv()
290   // CHECK-HIDDEN: declare hidden void @_ZN6Test171A1B3bazEv()
291 }
292 
293 namespace Test18 {
294   template <class T> struct HIDDEN A {
295     static void foo();
296     static void DEFAULT bar();
297     static void HIDDEN baz();
298 
299     struct DEFAULT B {
300       static void foo();
301       static void DEFAULT bar();
302       static void HIDDEN baz();
303     };
304   };
305   struct HIDDEN H;
306 
307   void test() {
308     A<int>::foo();
309     A<int>::bar();
310     A<int>::baz();
311     A<int>::B::foo();
312     A<int>::B::bar();
313     A<int>::B::baz();
314     A<H>::foo();
315     A<H>::bar();
316     A<H>::baz();
317     A<H>::B::foo();
318     A<H>::B::bar();
319     A<H>::B::baz();
320   }
321   // CHECK: declare hidden void @_ZN6Test181AIiE3fooEv()
322   // CHECK: declare void @_ZN6Test181AIiE3barEv()
323   // CHECK: declare hidden void @_ZN6Test181AIiE3bazEv()
324   // CHECK: declare void @_ZN6Test181AIiE1B3fooEv()
325   // CHECK: declare void @_ZN6Test181AIiE1B3barEv()
326   // CHECK: declare hidden void @_ZN6Test181AIiE1B3bazEv()
327   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3fooEv()
328   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3barEv()
329   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE3bazEv()
330   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv()
331   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv()
332   // CHECK: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv()
333   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3fooEv()
334   // CHECK-HIDDEN: declare void @_ZN6Test181AIiE3barEv()
335   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE3bazEv()
336   // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3fooEv()
337   // CHECK-HIDDEN: declare void @_ZN6Test181AIiE1B3barEv()
338   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AIiE1B3bazEv()
339   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3fooEv()
340   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3barEv()
341   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE3bazEv()
342   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3fooEv()
343   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3barEv()
344   // CHECK-HIDDEN: declare hidden void @_ZN6Test181AINS_1HEE1B3bazEv()
345 }
346 
347 namespace Test19 {
348   struct A { A(); ~A(); };
349 
350   // Tested at top of file.
351   template <class T> void foo() {
352     static A a;
353   }
354 
355   void test() {
356     foo<int>();
357   }
358 }
359 
360 // Various things with class template specializations.
361 namespace Test20 {
362   template <unsigned> struct HIDDEN A {};
363 
364   // An explicit specialization inherits the explicit visibility of
365   // the template.
366   template <> struct A<0> {
367     static void test0();
368     static void test1();
369   };
370 
371   // CHECK: define hidden void @_ZN6Test201AILj0EE5test0Ev()
372   void A<0>::test0() {}
373 
374   // CHECK: declare hidden void @_ZN6Test201AILj0EE5test1Ev()
375   void test1() {
376     A<0>::test1();
377   }
378 
379   // ...unless that's explicitly overridden.
380   template <> struct DEFAULT A<1> {
381     static void test2();
382     static void test3();
383   };
384 
385   // CHECK: define void @_ZN6Test201AILj1EE5test2Ev()
386   void A<1>::test2() {}
387 
388   // CHECK: declare void @_ZN6Test201AILj1EE5test3Ev()
389   void test3() {
390     A<1>::test3();
391   }
392 
393   // <rdar://problem/8778497>
394   // But we should assume that an unknown specialization has the
395   // explicit visibility settings of the template.
396   template <class T> struct B {
397     static void test4() {}
398     static void test5();
399   };
400 
401   // CHECK: define linkonce_odr hidden void @_ZN6Test201BINS_1AILj2EEEE5test4Ev()
402   void test4() {
403     B<A<2> >::test4();
404   }
405 
406   // CHECK: declare hidden void @_ZN6Test201BINS_1AILj2EEEE5test5Ev()
407   void test5() {
408     B<A<2> >::test5();
409   }
410 }
411 
412 // PR9371
413 namespace test21 {
414   enum En { en };
415   template<En> struct A {
416     __attribute__((visibility("default"))) void foo() {}
417   };
418 
419   // CHECK: define weak_odr void @_ZN6test211AILNS_2EnE0EE3fooEv(
420   template void A<en>::foo();
421 }
422 
423 // rdar://problem/9616154
424 // Visibility on explicit specializations should take precedence.
425 namespace test22 {
426   class A1 {};
427   class A2 {};
428 
429   template <class T> struct B {};
430   template <> struct DEFAULT B<A1> {
431     static void foo();
432     static void bar() {}
433   };
434   template <> struct B<A2> {
435     static void foo();
436     static void bar() {}
437   };
438 
439   void test() {
440     B<A1>::foo();
441     B<A1>::bar();
442     B<A2>::foo();
443     B<A2>::bar();
444   }
445   // CHECK: declare void @_ZN6test221BINS_2A1EE3fooEv()
446   // CHECK: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv()
447   // CHECK: declare void @_ZN6test221BINS_2A2EE3fooEv()
448   // CHECK: define linkonce_odr void @_ZN6test221BINS_2A2EE3barEv()
449   // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A1EE3fooEv()
450   // CHECK-HIDDEN: define linkonce_odr void @_ZN6test221BINS_2A1EE3barEv()
451   // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A2EE3fooEv()
452   // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN6test221BINS_2A2EE3barEv()
453 }
454 
455 namespace PR10113 {
456   namespace foo DEFAULT {
457     template<typename T>
458       class bar {
459       void zed() {}
460     };
461   }
462   template class foo::bar<char>;
463   // CHECK: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv
464   // CHECK-HIDDEN: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv
465 
466   struct zed {
467   };
468   template class foo::bar<zed>;
469   // CHECK: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv
470   // CHECK-HIDDEN: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv
471 }
472 
473 namespace PR11690 {
474   template<class T> struct Class {
475     void size() const {
476     }
477   };
478   template class DEFAULT Class<char>;
479   // CHECK: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv
480   // CHECK-HIDDEN: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv
481 
482   template<class T> void Method() {}
483   template  DEFAULT void Method<char>();
484   // CHECK: define weak_odr void @_ZN7PR116906MethodIcEEvv
485   // CHECK-HIDDEN: define weak_odr void @_ZN7PR116906MethodIcEEvv
486 }
487 
488 namespace PR11690_2 {
489   namespace foo DEFAULT {
490     class bar;
491     template<typename T1, typename T2 = bar>
492     class zed {
493       void bar() {
494       }
495     };
496   }
497   struct baz {
498   };
499   template class foo::zed<baz>;
500   // CHECK: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv
501   // CHECK-HIDDEN: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv
502 }
503