1 // { dg-do run }
2 // { dg-require-weak "" }
3 // On darwin, we use attr-weakref-1-darwin.c.
4 // This test requires support for undefined weak symbols.  This support
5 // is not available on hppa*-*-hpux*.  The test is skipped rather than
6 // xfailed to suppress the warning that would otherwise arise.
7 // { dg-skip-if "" { "hppa*-*-hpux*" } "*" { "" } }
8 // For kernel modules and static RTPs, the loader treats undefined weak
9 // symbols in the same way as undefined strong symbols.  The test
10 // therefore fails to load, so skip it.
11 // { dg-skip-if "" { "*-*-vxworks*" && nonpic } "*" { "-non-static" } }
12 // { dg-options "-O2" }
13 // { dg-additional-options "-Wl,-undefined,dynamic_lookup" { target *-*-darwin* } }
14 // { dg-additional-options "-Wl,-flat_namespace" { target *-*-darwin[89]* } }
15 // { dg-additional-sources "attr-weakref-1a.c" }
16 
17 // Copyright 2005 Free Software Foundation, Inc.
18 // Contributed by Alexandre Oliva <aoliva@redhat.com>
19 
20 // Torture test for weakrefs.  The first letter of an identifier
21 // indicates whether/how it is defined; the second letter indicates
22 // whether it is part of a variable or function test; the number that
23 // follows is a test counter, and a letter that may follow enables
24 // multiple identifiers within the same test (e.g., multiple weakrefs
25 // or pointers to the same identifier).
26 
27 // Identifiers starting with W are weakrefs; those with p are
28 // pointers; those with g are global definitions; those with l are
29 // local definitions; those with w are expected to be weak undefined
30 // in the symbol table; those with u are expected to be marked as
31 // non-weak undefined in the symbol table.
32 
33 #include <stdlib.h>
34 
35 #define USED __attribute__((used))
36 
37 typedef int vtype;
38 
39 extern vtype wv1;
40 static vtype Wv1a __attribute__((weakref ("wv1")));
41 static vtype *pv1a USED = &Wv1a;
42 
43 vtype gv2;
44 static vtype Wv2a __attribute__((weakref ("gv2")));
45 static vtype *pv2a USED = &Wv2a;
46 
47 static vtype lv3;
48 static vtype Wv3a __attribute__((weakref ("lv3")));
49 static vtype *pv3a USED = &Wv3a;
50 
51 extern vtype uv4;
52 static vtype Wv4a __attribute__((weakref ("uv4")));
53 static vtype *pv4a USED = &Wv4a;
54 static vtype *pv4 USED = &uv4;
55 
56 static vtype Wv5a __attribute__((weakref ("uv5")));
57 static vtype *pv5a USED = &Wv5a;
58 extern vtype uv5;
59 static vtype *pv5 USED = &uv5;
60 
61 static vtype Wv6a __attribute__((weakref ("wv6")));
62 static vtype *pv6a USED = &Wv6a;
63 extern vtype wv6;
64 
65 static vtype Wv7a __attribute__((weakref ("uv7")));
fv7(void)66 static vtype* USED fv7 (void) {
67   return &Wv7a;
68 }
69 extern vtype uv7;
fv7a(void)70 static vtype* USED fv7a (void) {
71   return &uv7;
72 }
73 
74 extern vtype uv8;
fv8a(void)75 static vtype* USED fv8a (void) {
76   return &uv8;
77 }
78 static vtype Wv8a __attribute__((weakref ("uv8")));
fv8(void)79 static vtype* USED fv8 (void) {
80   return &Wv8a;
81 }
82 
83 extern vtype wv9 __attribute__((weak));
84 static vtype Wv9a __attribute__((weakref ("wv9")));
85 static vtype *pv9a USED = &Wv9a;
86 
87 static vtype Wv10a __attribute__((weakref ("Wv10b")));
88 static vtype Wv10b __attribute__((weakref ("Wv10c")));
89 static vtype Wv10c __attribute__((weakref ("Wv10d")));
90 static vtype Wv10d __attribute__((weakref ("wv10")));
91 extern vtype wv10;
92 
93 extern vtype wv11;
94 static vtype Wv11d __attribute__((weakref ("wv11")));
95 static vtype Wv11c __attribute__((weakref ("Wv11d")));
96 static vtype Wv11b __attribute__((weakref ("Wv11c")));
97 static vtype Wv11a __attribute__((weakref ("Wv11b")));
98 
99 static vtype Wv12 __attribute__((weakref ("wv12")));
100 extern vtype wv12 __attribute__((weak));
101 
102 static vtype Wv13 __attribute__((weakref ("wv13")));
103 extern vtype wv13 __attribute__((weak));
104 
105 static vtype Wv14a __attribute__((weakref ("wv14")));
106 static vtype Wv14b __attribute__((weakref ("wv14")));
107 extern vtype wv14 __attribute__((weak));
108 
109 typedef void ftype(void);
110 
111 extern ftype wf1;
112 static ftype Wf1a __attribute__((weakref ("wf1")));
113 static ftype *pf1a USED = &Wf1a;
114 static ftype Wf1c __attribute__((weakref));
115 extern ftype Wf1c __attribute__((alias ("wf1")));
116 static ftype *pf1c USED = &Wf1c;
117 
gf2(void)118 void gf2(void) {}
119 static ftype Wf2a __attribute__((weakref ("gf2")));
120 static ftype *pf2a USED = &Wf2a;
121 
lf3(void)122 static void lf3(void) {}
123 static ftype Wf3a __attribute__((weakref ("lf3")));
124 static ftype *pf3a USED = &Wf3a;
125 
126 extern ftype uf4;
127 static ftype Wf4a __attribute__((weakref ("uf4")));
128 static ftype *pf4a USED = &Wf4a;
129 static ftype *pf4 USED = &uf4;
130 
131 static ftype Wf5a __attribute__((weakref ("uf5")));
132 static ftype *pf5a USED = &Wf5a;
133 extern ftype uf5;
134 static ftype *pf5 USED = &uf5;
135 
136 static ftype Wf6a __attribute__((weakref ("wf6")));
137 static ftype *pf6a USED = &Wf6a;
138 extern ftype wf6;
139 
140 static ftype Wf7a __attribute__((weakref ("uf7")));
ff7(void)141 static ftype* USED ff7 (void) {
142   return &Wf7a;
143 }
144 extern ftype uf7;
ff7a(void)145 static ftype* USED ff7a (void) {
146   return &uf7;
147 }
148 
149 extern ftype uf8;
ff8a(void)150 static ftype* USED ff8a (void) {
151   return &uf8;
152 }
153 static ftype Wf8a __attribute__((weakref ("uf8")));
ff8(void)154 static ftype* USED ff8 (void) {
155   return &Wf8a;
156 }
157 
158 extern ftype wf9 __attribute__((weak));
159 static ftype Wf9a __attribute__((weakref ("wf9")));
160 static ftype *pf9a USED = &Wf9a;
161 
162 static ftype Wf10a __attribute__((weakref ("Wf10b")));
163 static ftype Wf10b __attribute__((weakref ("Wf10c")));
164 static ftype Wf10c __attribute__((weakref ("Wf10d")));
165 static ftype Wf10d __attribute__((weakref ("wf10")));
166 extern ftype wf10;
167 
168 extern ftype wf11;
169 static ftype Wf11d __attribute__((weakref ("wf11")));
170 static ftype Wf11c __attribute__((weakref ("Wf11d")));
171 static ftype Wf11b __attribute__((weakref ("Wf11c")));
172 static ftype Wf11a __attribute__((weakref ("Wf11b")));
173 
174 static ftype Wf12 __attribute__((weakref ("wf12")));
175 extern ftype wf12 __attribute__((weak));
176 
177 static ftype Wf13 __attribute__((weakref ("wf13")));
178 extern ftype wf13 __attribute__((weak));
179 
180 static ftype Wf14a __attribute__((weakref ("wf14")));
181 static ftype Wf14b __attribute__((weakref ("wf14")));
182 extern ftype wf14 __attribute__((weak));
183 
184 #ifndef __APPLE__
185 #define chk(p) do { if (!p) abort (); } while (0)
186 #else
187 #define chk(p) /* */
188 #endif
189 
main()190 int main () {
191   chk (!pv1a);
192   chk (pv2a);
193   chk (pv3a);
194   chk (pv4a);
195   chk (pv4);
196   chk (pv5a);
197   chk (pv5);
198   chk (!pv6a);
199   chk (fv7 ());
200   chk (fv7a ());
201   chk (fv8 ());
202   chk (fv8a ());
203   chk (!pv9a);
204   chk (!&Wv10a);
205   chk (!&Wv11a);
206   chk (!&Wv12);
207   chk (!&wv12);
208   chk (!&wv13);
209   chk (!&Wv14a);
210 
211   chk (!pf1a);
212   chk (!pf1c);
213   chk (pf2a);
214   chk (pf3a);
215   chk (pf4a);
216   chk (pf4);
217   chk (pf5a);
218   chk (pf5);
219   chk (!pf6a);
220   chk (ff7 ());
221   chk (ff7a ());
222   chk (ff8 ());
223   chk (ff8a ());
224   chk (!pf9a);
225   chk (!&Wf10a);
226   chk (!&Wf11a);
227   chk (!&Wf12);
228   chk (!&wf12);
229   chk (!&wf13);
230   chk (!&Wf14a);
231 
232   exit (0);
233 }
234