1#ifndef NULL
2#define NULL ((void *) 0)
3#endif
4
5/* This is part of the shared library ld test.  This file becomes part
6   of a shared library.  */
7
8/* This variable is supplied by the main program.  */
9#ifndef XCOFF_TEST
10extern int mainvar;
11#endif
12
13/* This variable is defined in the shared library, and overridden by
14   the main program.  */
15#ifndef XCOFF_TEST
16#ifdef SHARED
17/* SHARED is defined if we are compiling with -fpic/-fPIC.  */
18int overriddenvar = -1;
19#else
20/* Without -fpic, newer versions of gcc assume that we are not
21   compiling for a shared library, and thus that overriddenvar is
22   local.  */
23extern int overriddenvar;
24#endif
25#endif
26
27/* This variable is defined in the shared library.  */
28int shlibvar1 = 3;
29
30/* This variable is defined by another object in the shared library.  */
31extern int shlibvar2;
32
33/* These functions return the values of the above variables as seen in
34   the shared library.  */
35
36#ifndef XCOFF_TEST
37int
38shlib_mainvar ()
39{
40  return mainvar;
41}
42#endif
43
44#ifndef XCOFF_TEST
45int
46shlib_overriddenvar ()
47{
48  return overriddenvar;
49}
50#endif
51
52int
53shlib_shlibvar1 ()
54{
55  return shlibvar1;
56}
57
58int
59shlib_shlibvar2 ()
60{
61  return shlibvar2;
62}
63
64/* This function calls a function defined by another object in the
65   shared library.  */
66
67extern int shlib_shlibcalled ();
68
69int
70shlib_shlibcall ()
71{
72  return shlib_shlibcalled ();
73}
74
75#ifndef XCOFF_TEST
76/* This function calls a function defined in this object in the shared
77   library.  The main program will override the called function.  */
78
79extern int shlib_overriddencall2 ();
80
81int
82shlib_shlibcall2 ()
83{
84  return shlib_overriddencall2 ();
85}
86
87#ifdef SHARED
88int
89shlib_overriddencall2 ()
90{
91  return 7;
92}
93#endif
94#endif
95
96/* This function calls a function defined by the main program.  */
97
98#ifndef XCOFF_TEST
99extern int main_called ();
100
101int
102shlib_maincall ()
103{
104  return main_called ();
105}
106#endif
107
108/* This function is passed a function pointer to shlib_mainvar.  It
109   confirms that the pointer compares equally.  */
110
111int
112shlib_checkfunptr1 (p)
113     int (*p) ();
114{
115  return p == shlib_shlibvar1;
116}
117
118/* This function is passed a function pointer to main_called.  It
119   confirms that the pointer compares equally.  */
120
121#ifndef XCOFF_TEST
122int
123shlib_checkfunptr2 (p)
124     int (*p) ();
125{
126  return p == main_called;
127}
128#endif
129
130/* This function returns a pointer to shlib_mainvar.  */
131
132int
133(*shlib_getfunptr1 ()) ()
134{
135  return shlib_shlibvar1;
136}
137
138/* This function returns a pointer to main_called.  */
139
140#ifndef XCOFF_TEST
141int
142(*shlib_getfunptr2 ()) ()
143{
144  return main_called;
145}
146#endif
147
148/* This function makes sure that constant data and local functions
149   work.  */
150
151#ifndef __STDC__
152#define const
153#endif
154
155static int i = 6;
156static const char *str = "Hello, world\n";
157
158int
159shlib_check ()
160{
161  const char *s1, *s2;
162
163  if (i != 6)
164    return 0;
165
166  /* To isolate the test, don't rely on any external functions, such
167     as strcmp.  */
168  s1 = "Hello, world\n";
169  s2 = str;
170  while (*s1 != '\0')
171    if (*s1++ != *s2++)
172      return 0;
173  if (*s2 != '\0')
174    return 0;
175
176  if (shlib_shlibvar1 () != 3)
177    return 0;
178
179  return 1;
180}
181
182#ifdef HIDDEN_WEAK_TEST
183#define HIDDEN_UNDEF_TEST
184#define WEAK_TEST
185#endif
186
187#ifdef PROTECTED_WEAK_TEST
188#define PROTECTED_UNDEF_TEST
189#define WEAK_TEST
190#endif
191
192#if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST)
193#ifdef WEAK_TEST
194#pragma weak visibility
195#endif
196extern int visibility ();
197#else
198int
199visibility ()
200{
201  return 2;
202}
203#endif
204
205#ifdef HIDDEN_NORMAL_TEST
206asm (".hidden visibility_normal");
207
208int
209visibility_normal ()
210{
211  return 2;
212}
213#endif
214
215int
216visibility_checkfunptr ()
217{
218#ifdef WEAK_TEST
219  return 1;
220#else
221#ifdef HIDDEN_NORMAL_TEST
222  int (*v) () = visibility_normal;
223#else
224  int (*v) () = visibility;
225#endif
226  return (*v) () == 2;
227#endif
228}
229
230int
231visibility_check ()
232{
233#ifdef WEAK_TEST
234  if (&visibility)
235    return visibility () == 1;
236  else
237    return 1;
238#else
239#ifdef HIDDEN_NORMAL_TEST
240  return visibility_normal () == 2;
241#else
242  return visibility () == 2;
243#endif
244#endif
245}
246
247void *
248visibility_funptr ()
249{
250#ifdef WEAK_TEST
251  if (&visibility == NULL)
252    return NULL;
253  else
254#endif
255    return visibility;
256}
257
258#if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST)
259#ifdef WEAK_TEST
260#pragma weak visibility_var
261#endif
262extern int visibility_var;
263#else
264int visibility_var = 2;
265#endif
266
267#ifdef HIDDEN_NORMAL_TEST
268asm (".hidden visibility_var_normal");
269
270int visibility_var_normal = 2;
271#endif
272
273int
274visibility_checkvarptr ()
275{
276#ifdef WEAK_TEST
277  if (&visibility_var)
278    return visibility_var == 1;
279  else
280    return 1;
281#else
282#ifdef HIDDEN_NORMAL_TEST
283  int *v = &visibility_var_normal;
284#else
285  int *v = &visibility_var;
286#endif
287  return *v == 2;
288#endif
289}
290
291int
292visibility_checkvar ()
293{
294#ifdef WEAK_TEST
295  return 1;
296#else
297#ifdef HIDDEN_NORMAL_TEST
298  return visibility_var_normal == 2;
299#else
300  return visibility_var == 2;
301#endif
302#endif
303}
304
305void *
306visibility_varptr ()
307{
308#ifdef WEAK_TEST
309  if (&visibility_var == NULL)
310    return NULL;
311  else
312#endif
313    return &visibility_var;
314}
315
316int
317visibility_varval ()
318{
319#ifdef WEAK_TEST
320  if (&visibility_var == NULL)
321    return 0;
322  else
323#endif
324    return visibility_var;
325}
326
327#if defined (HIDDEN_TEST) || defined (HIDDEN_UNDEF_TEST)
328asm (".hidden visibility");
329asm (".hidden visibility_var");
330#else
331#if defined (PROTECTED_TEST) || defined (PROTECTED_UNDEF_TEST) || defined (PROTECTED_WEAK_TEST)
332asm (".protected visibility");
333asm (".protected visibility_var");
334#endif
335#endif
336
337#ifdef HIDDEN_NORMAL_TEST
338int shlib_visibility_com;
339asm (".hidden shlib_visibility_com");
340
341int
342shlib_visibility_checkcom ()
343{
344  return shlib_visibility_com == 0;
345}
346
347int
348shlib_visibility_checkweak ()
349{
350  return 1;
351}
352#elif defined (HIDDEN_WEAK_TEST)
353#pragma weak shlib_visibility_undef_var_weak
354extern int shlib_visibility_undef_var_weak;
355asm (".hidden shlib_visibility_undef_var_weak");
356
357#pragma weak shlib_visibility_undef_func_weak
358extern int shlib_visibility_undef_func_weak ();
359asm (".hidden shlib_visibility_undef_func_weak");
360
361#pragma weak shlib_visibility_var_weak
362extern int shlib_visibility_var_weak;
363asm (".hidden shlib_visibility_var_weak");
364
365#pragma weak shlib_visibility_func_weak
366extern int shlib_visibility_func_weak ();
367asm (".hidden shlib_visibility_func_weak");
368
369int
370shlib_visibility_checkcom ()
371{
372  return 1;
373}
374
375int
376shlib_visibility_checkweak ()
377{
378  return &shlib_visibility_undef_var_weak == NULL
379	 && &shlib_visibility_undef_func_weak == NULL
380	 && &shlib_visibility_func_weak == NULL
381	 && &shlib_visibility_var_weak == NULL;
382}
383#else
384int
385shlib_visibility_checkcom ()
386{
387  return 1;
388}
389
390int
391shlib_visibility_checkweak ()
392{
393  return 1;
394}
395#endif
396
397#ifdef PROTECTED_TEST
398#ifdef SHARED
399int shared_data = 100;
400#else
401extern int shared_data;
402#endif
403
404int *
405shared_data_p ()
406{
407  return &shared_data;
408}
409
410int
411shared_func ()
412{
413  return 100;
414}
415
416void *
417shared_func_p ()
418{
419  return shared_func;
420}
421#endif
422