OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [ld/] [testsuite/] [ld-elfvsb/] [sh1.c] - Blame information for rev 859

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius 
#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
10 
extern 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.  */
18 
int 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.  */
23 
extern int overriddenvar;
24 
#endif
25 
#endif
26 
 
27 
/* This variable is defined in the shared library.  */
28 
int shlibvar1 = 3;
29 
 
30 
/* This variable is defined by another object in the shared library.  */
31 
extern 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
37 
int
38 
shlib_mainvar ()
39 
{
40 
  return mainvar;
41 
}
42 
#endif
43 
 
44 
#ifndef XCOFF_TEST
45 
int
46 
shlib_overriddenvar ()
47 
{
48 
  return overriddenvar;
49 
}
50 
#endif
51 
 
52 
int
53 
shlib_shlibvar1 ()
54 
{
55 
  return shlibvar1;
56 
}
57 
 
58 
int
59 
shlib_shlibvar2 ()
60 
{
61 
  return shlibvar2;
62 
}
63 
 
64 
/* This function calls a function defined by another object in the
65 
   shared library.  */
66 
 
67 
extern int shlib_shlibcalled ();
68 
 
69 
int
70 
shlib_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 
 
79 
extern int shlib_overriddencall2 ();
80 
 
81 
int
82 
shlib_shlibcall2 ()
83 
{
84 
  return shlib_overriddencall2 ();
85 
}
86 
 
87 
#ifdef SHARED
88 
int
89 
shlib_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
99 
extern int main_called ();
100 
 
101 
int
102 
shlib_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 
 
111 
int
112 
shlib_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
122 
int
123 
shlib_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 
 
132 
int
133 
(*shlib_getfunptr1 ()) ()
134 
{
135 
  return shlib_shlibvar1;
136 
}
137 
 
138 
/* This function returns a pointer to main_called.  */
139 
 
140 
#ifndef XCOFF_TEST
141 
int
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 
 
155 
static int i = 6;
156 
static const char *str = "Hello, world\n";
157 
 
158 
int
159 
shlib_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
196 
extern int visibility ();
197 
#else
198 
int
199 
visibility ()
200 
{
201 
  return 2;
202 
}
203 
#endif
204 
 
205 
#ifdef HIDDEN_NORMAL_TEST
206 
asm (".hidden visibility_normal");
207 
 
208 
int
209 
visibility_normal ()
210 
{
211 
  return 2;
212 
}
213 
#endif
214 
 
215 
int
216 
visibility_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 
 
230 
int
231 
visibility_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 
 
247 
void *
248 
visibility_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
262 
extern int visibility_var;
263 
#else
264 
int visibility_var = 2;
265 
#endif
266 
 
267 
#ifdef HIDDEN_NORMAL_TEST
268 
asm (".hidden visibility_var_normal");
269 
 
270 
int visibility_var_normal = 2;
271 
#endif
272 
 
273 
int
274 
visibility_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 
 
291 
int
292 
visibility_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 
 
305 
void *
306 
visibility_varptr ()
307 
{
308 
#ifdef WEAK_TEST
309 
  if (&visibility_var == NULL)
310 
    return NULL;
311 
  else
312 
#endif
313 
    return &visibility_var;
314 
}
315 
 
316 
int
317 
visibility_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)
328 
asm (".hidden visibility");
329 
asm (".hidden visibility_var");
330 
#else
331 
#if defined (PROTECTED_TEST) || defined (PROTECTED_UNDEF_TEST) || defined (PROTECTED_WEAK_TEST)
332 
asm (".protected visibility");
333 
asm (".protected visibility_var");
334 
#endif
335 
#endif
336 
 
337 
#ifdef HIDDEN_NORMAL_TEST
338 
int shlib_visibility_com;
339 
asm (".hidden shlib_visibility_com");
340 
 
341 
int
342 
shlib_visibility_checkcom ()
343 
{
344 
  return shlib_visibility_com == 0;
345 
}
346 
 
347 
int
348 
shlib_visibility_checkweak ()
349 
{
350 
  return 1;
351 
}
352 
#elif defined (HIDDEN_WEAK_TEST)
353 
#pragma weak shlib_visibility_undef_var_weak
354 
extern int shlib_visibility_undef_var_weak;
355 
asm (".hidden shlib_visibility_undef_var_weak");
356 
 
357 
#pragma weak shlib_visibility_undef_func_weak
358 
extern int shlib_visibility_undef_func_weak ();
359 
asm (".hidden shlib_visibility_undef_func_weak");
360 
 
361 
#pragma weak shlib_visibility_var_weak
362 
extern int shlib_visibility_var_weak;
363 
asm (".hidden shlib_visibility_var_weak");
364 
 
365 
#pragma weak shlib_visibility_func_weak
366 
extern int shlib_visibility_func_weak ();
367 
asm (".hidden shlib_visibility_func_weak");
368 
 
369 
int
370 
shlib_visibility_checkcom ()
371 
{
372 
  return 1;
373 
}
374 
 
375 
int
376 
shlib_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
384 
int
385 
shlib_visibility_checkcom ()
386 
{
387 
  return 1;
388 
}
389 
 
390 
int
391 
shlib_visibility_checkweak ()
392 
{
393 
  return 1;
394 
}
395 
#endif
396 
 
397 
#ifdef PROTECTED_TEST
398 
#ifdef SHARED
399 
int shared_data = 100;
400 
#else
401 
extern int shared_data;
402 
#endif
403 
 
404 
int *
405 
shared_data_p ()
406 
{
407 
  return &shared_data;
408 
}
409 
 
410 
int
411 
shared_func ()
412 
{
413 
  return 100;
414 
}
415 
 
416 
void *
417 
shared_func_p ()
418 
{
419 
  return shared_func;
420 
}
421 
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.