]>
Commit | Line | Data |
---|---|---|
1 | /* Support macros for making weak and strong aliases for symbols, | |
2 | and for using symbol sets and linker warnings with GNU ld. | |
3 | Copyright (C) 1995-1998,2000,2001,2002,2003 Free Software Foundation, Inc. | |
4 | This file is part of the GNU C Library. | |
5 | ||
6 | The GNU C Library is free software; you can redistribute it and/or | |
7 | modify it under the terms of the GNU Lesser General Public | |
8 | License as published by the Free Software Foundation; either | |
9 | version 2.1 of the License, or (at your option) any later version. | |
10 | ||
11 | The GNU C Library is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | Lesser General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU Lesser General Public | |
17 | License along with the GNU C Library; if not, write to the Free | |
18 | Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
19 | 02111-1307 USA. */ | |
20 | ||
21 | #ifndef _LIBC_SYMBOLS_H | |
22 | #define _LIBC_SYMBOLS_H 1 | |
23 | ||
24 | /* This file's macros are included implicitly in the compilation of every | |
25 | file in the C library by -imacros. | |
26 | ||
27 | We include config.h which is generated by configure. | |
28 | It should define for us the following symbols: | |
29 | ||
30 | * HAVE_ASM_SET_DIRECTIVE if we have `.set B, A' instead of `A = B'. | |
31 | * ASM_GLOBAL_DIRECTIVE with `.globl' or `.global'. | |
32 | * ASM_TYPE_DIRECTIVE_PREFIX with `@' or `#' or whatever for .type, | |
33 | or leave it undefined if there is no .type directive. | |
34 | * HAVE_GNU_LD if using GNU ld, with support for weak symbols in a.out, | |
35 | and for symbol set and warning messages extensions in a.out and ELF. | |
36 | * HAVE_ELF if using ELF, which supports weak symbols using `.weak'. | |
37 | * HAVE_ASM_WEAK_DIRECTIVE if we have weak symbols using `.weak'. | |
38 | * HAVE_ASM_WEAKEXT_DIRECTIVE if we have weak symbols using `.weakext'. | |
39 | ||
40 | */ | |
41 | ||
42 | /* This is defined for the compilation of all C library code. features.h | |
43 | tests this to avoid inclusion of stubs.h while compiling the library, | |
44 | before stubs.h has been generated. Some library code that is shared | |
45 | with other packages also tests this symbol to see if it is being | |
46 | compiled as part of the C library. We must define this before including | |
47 | config.h, because it makes some definitions conditional on whether libc | |
48 | itself is being compiled, or just some generator program. */ | |
49 | #define _LIBC 1 | |
50 | ||
51 | /* Enable declarations of GNU extensions, since we are compiling them. */ | |
52 | #define _GNU_SOURCE 1 | |
53 | /* And we also need the data for the reentrant functions. */ | |
54 | #define _REENTRANT 1 | |
55 | ||
56 | #include <config.h> | |
57 | ||
58 | /* The symbols in all the user (non-_) macros are C symbols. | |
59 | HAVE_GNU_LD without HAVE_ELF implies a.out. */ | |
60 | ||
61 | #if defined HAVE_ASM_WEAK_DIRECTIVE || defined HAVE_ASM_WEAKEXT_DIRECTIVE | |
62 | # define HAVE_WEAK_SYMBOLS | |
63 | #endif | |
64 | ||
65 | #ifndef __SYMBOL_PREFIX | |
66 | # ifdef NO_UNDERSCORES | |
67 | # define __SYMBOL_PREFIX | |
68 | # else | |
69 | # define __SYMBOL_PREFIX "_" | |
70 | # endif | |
71 | #endif | |
72 | ||
73 | #ifndef C_SYMBOL_NAME | |
74 | # ifdef NO_UNDERSCORES | |
75 | # define C_SYMBOL_NAME(name) name | |
76 | # else | |
77 | # define C_SYMBOL_NAME(name) _##name | |
78 | # endif | |
79 | #endif | |
80 | ||
81 | #ifndef ASM_LINE_SEP | |
82 | # define ASM_LINE_SEP ; | |
83 | #endif | |
84 | ||
85 | #ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
86 | # ifndef C_SYMBOL_DOT_NAME | |
87 | # if defined __GNUC__ && defined __GNUC_MINOR__ \ | |
88 | && (__GNUC__ << 16) + __GNUC_MINOR__ >= (3 << 16) + 1 | |
89 | # define C_SYMBOL_DOT_NAME(name) .name | |
90 | # else | |
91 | # define C_SYMBOL_DOT_NAME(name) .##name | |
92 | # endif | |
93 | # endif | |
94 | #endif | |
95 | ||
96 | #ifndef __ASSEMBLER__ | |
97 | /* GCC understands weak symbols and aliases; use its interface where | |
98 | possible, instead of embedded assembly language. */ | |
99 | ||
100 | /* Define ALIASNAME as a strong alias for NAME. */ | |
101 | # define strong_alias(name, aliasname) _strong_alias(name, aliasname) | |
102 | # define _strong_alias(name, aliasname) \ | |
103 | extern __typeof (name) aliasname __attribute__ ((alias (#name))); | |
104 | ||
105 | /* This comes between the return type and function name in | |
106 | a function definition to make that definition weak. */ | |
107 | # define weak_function __attribute__ ((weak)) | |
108 | # define weak_const_function __attribute__ ((weak, __const__)) | |
109 | ||
110 | # ifdef HAVE_WEAK_SYMBOLS | |
111 | ||
112 | /* Define ALIASNAME as a weak alias for NAME. | |
113 | If weak aliases are not available, this defines a strong alias. */ | |
114 | # define weak_alias(name, aliasname) _weak_alias (name, aliasname) | |
115 | # define _weak_alias(name, aliasname) \ | |
116 | extern __typeof (name) aliasname __attribute__ ((weak, alias (#name))); | |
117 | ||
118 | /* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined). */ | |
119 | # define weak_extern(symbol) _weak_extern (weak symbol) | |
120 | # define _weak_extern(expr) _Pragma (#expr) | |
121 | ||
122 | # else | |
123 | ||
124 | # define weak_alias(name, aliasname) strong_alias(name, aliasname) | |
125 | # define weak_extern(symbol) /* Nothing. */ | |
126 | ||
127 | # endif | |
128 | ||
129 | #else /* __ASSEMBLER__ */ | |
130 | ||
131 | # ifdef HAVE_ASM_SET_DIRECTIVE | |
132 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
133 | # define strong_alias(original, alias) \ | |
134 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
135 | .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original) ASM_LINE_SEP \ | |
136 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
137 | .set C_SYMBOL_DOT_NAME (alias),C_SYMBOL_DOT_NAME (original) | |
138 | # define strong_data_alias(original, alias) \ | |
139 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
140 | .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original) | |
141 | # else | |
142 | # define strong_alias(original, alias) \ | |
143 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
144 | .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original) | |
145 | # define strong_data_alias(original, alias) strong_alias(original, alias) | |
146 | # endif | |
147 | # else | |
148 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
149 | # define strong_alias(original, alias) \ | |
150 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
151 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) ASM_LINE_SEP \ | |
152 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
153 | C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original) | |
154 | # define strong_data_alias(original, alias) \ | |
155 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
156 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) | |
157 | # else | |
158 | # define strong_alias(original, alias) \ | |
159 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
160 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) | |
161 | # define strong_data_alias(original, alias) strong_alias(original, alias) | |
162 | # endif | |
163 | # endif | |
164 | ||
165 | # ifdef HAVE_WEAK_SYMBOLS | |
166 | # ifdef HAVE_ASM_WEAKEXT_DIRECTIVE | |
167 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
168 | # define weak_alias(original, alias) \ | |
169 | .weakext C_SYMBOL_NAME (alias), C_SYMBOL_NAME (original) ASM_LINE_SEP \ | |
170 | .weakext C_SYMBOL_DOT_NAME (alias), C_SYMBOL_DOT_NAME (original) | |
171 | # else | |
172 | # define weak_alias(original, alias) \ | |
173 | .weakext C_SYMBOL_NAME (alias), C_SYMBOL_NAME (original) | |
174 | # endif | |
175 | # define weak_extern(symbol) \ | |
176 | .weakext C_SYMBOL_NAME (symbol) | |
177 | ||
178 | # else /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */ | |
179 | ||
180 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
181 | # define weak_alias(original, alias) \ | |
182 | .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
183 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) ASM_LINE_SEP \ | |
184 | .weak C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
185 | C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original) | |
186 | # else | |
187 | # define weak_alias(original, alias) \ | |
188 | .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
189 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) | |
190 | # endif | |
191 | ||
192 | # define weak_extern(symbol) \ | |
193 | .weak C_SYMBOL_NAME (symbol) | |
194 | ||
195 | # endif /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */ | |
196 | ||
197 | # else /* ! HAVE_WEAK_SYMBOLS */ | |
198 | ||
199 | # define weak_alias(original, alias) strong_alias(original, alias) | |
200 | # define weak_extern(symbol) /* Nothing */ | |
201 | # endif /* ! HAVE_WEAK_SYMBOLS */ | |
202 | ||
203 | #endif /* __ASSEMBLER__ */ | |
204 | ||
205 | /* On some platforms we can make internal function calls (i.e., calls of | |
206 | functions not exported) a bit faster by using a different calling | |
207 | convention. */ | |
208 | #ifndef internal_function | |
209 | # define internal_function /* empty */ | |
210 | #endif | |
211 | ||
212 | /* Prepare for the case that `__builtin_expect' is not available. */ | |
213 | #ifndef HAVE_BUILTIN_EXPECT | |
214 | # define __builtin_expect(expr, val) (expr) | |
215 | #endif | |
216 | ||
217 | /* Determine the return address. */ | |
218 | #define RETURN_ADDRESS(nr) \ | |
219 | __builtin_extract_return_addr (__builtin_return_address (nr)) | |
220 | ||
221 | /* When a reference to SYMBOL is encountered, the linker will emit a | |
222 | warning message MSG. */ | |
223 | #ifdef HAVE_GNU_LD | |
224 | # ifdef HAVE_ELF | |
225 | ||
226 | /* We want the .gnu.warning.SYMBOL section to be unallocated. */ | |
227 | # ifdef HAVE_ASM_PREVIOUS_DIRECTIVE | |
228 | # define __make_section_unallocated(section_string) \ | |
229 | asm (".section " section_string "\n\t.previous"); | |
230 | # elif defined HAVE_ASM_POPSECTION_DIRECTIVE | |
231 | # define __make_section_unallocated(section_string) \ | |
232 | asm (".pushsection " section_string "\n\t.popsection"); | |
233 | # else | |
234 | # define __make_section_unallocated(section_string) | |
235 | # endif | |
236 | ||
237 | /* Tacking on "\n\t#" to the section name makes gcc put it's bogus | |
238 | section attributes on what looks like a comment to the assembler. */ | |
239 | # ifdef HAVE_SECTION_QUOTES | |
240 | # define __sec_comment "\"\n\t#\"" | |
241 | # else | |
242 | # define __sec_comment "\n\t#" | |
243 | # endif | |
244 | # define link_warning(symbol, msg) \ | |
245 | __make_section_unallocated (".gnu.warning." #symbol) \ | |
246 | static const char __evoke_link_warning_##symbol[] \ | |
247 | __attribute__ ((unused, section (".gnu.warning." #symbol __sec_comment))) \ | |
248 | = msg; | |
249 | # define libc_freeres_ptr(decl) \ | |
250 | __make_section_unallocated ("__libc_freeres_ptrs, \"aw\", %nobits") \ | |
251 | decl __attribute__ ((section ("__libc_freeres_ptrs" __sec_comment))) | |
252 | # define __libc_freeres_fn_section \ | |
253 | __attribute__ ((section ("__libc_freeres_fn"))) | |
254 | # else /* Not ELF: a.out */ | |
255 | # ifdef HAVE_XCOFF | |
256 | /* XCOFF does not support .stabs. | |
257 | The native aix linker will remove the .stab and .stabstr sections | |
258 | The gnu linker will have a fatal error if there is a relocation for | |
259 | symbol in the .stab section. Silently disable this macro. */ | |
260 | # define link_warning(symbol, msg) | |
261 | # else | |
262 | # define link_warning(symbol, msg) \ | |
263 | asm (".stabs \"" msg "\",30,0,0,0\n\t" \ | |
264 | ".stabs \"" __SYMBOL_PREFIX #symbol "\",1,0,0,0\n"); | |
265 | # endif /* XCOFF */ | |
266 | # define libc_freeres_ptr(decl) decl | |
267 | # define __libc_freeres_fn_section | |
268 | # endif | |
269 | #else | |
270 | /* We will never be heard; they will all die horribly. */ | |
271 | # define link_warning(symbol, msg) | |
272 | # define libc_freeres_ptr(decl) decl | |
273 | # define __libc_freeres_fn_section | |
274 | #endif | |
275 | #define libc_freeres_fn(name) \ | |
276 | static void name (void) __attribute_used__ __libc_freeres_fn_section; \ | |
277 | text_set_element (__libc_subfreeres, name); \ | |
278 | static void name (void) | |
279 | ||
280 | /* A canned warning for sysdeps/stub functions. */ | |
281 | #define stub_warning(name) \ | |
282 | link_warning (name, \ | |
283 | "warning: " #name " is not implemented and will always fail") | |
284 | ||
285 | ||
286 | /* Declare SYMBOL to be TYPE (`function' or `object') and of SIZE bytes, | |
287 | when the assembler supports such declarations (such as in ELF). | |
288 | This is only necessary when defining something in assembly, or playing | |
289 | funny alias games where the size should be other than what the compiler | |
290 | thinks it is. */ | |
291 | #define declare_symbol(symbol, type, size) \ | |
292 | declare_symbol_1 (symbol, type, size) | |
293 | #ifdef ASM_TYPE_DIRECTIVE_PREFIX | |
294 | # ifdef __ASSEMBLER__ | |
295 | # define declare_symbol_1(symbol, type, size) \ | |
296 | .type C_SYMBOL_NAME (symbol), \ | |
297 | declare_symbol_1_paste (ASM_TYPE_DIRECTIVE_PREFIX, type), size | |
298 | # define declare_symbol_1_paste(a, b) declare_symbol_1_paste_1 (a,b) | |
299 | # define declare_symbol_1_paste_1(a,b) a##b | |
300 | # else /* Not __ASSEMBLER__. */ | |
301 | # define declare_symbol_1(symbol, type, size) \ | |
302 | asm (".type " __SYMBOL_PREFIX #symbol ", " \ | |
303 | declare_symbol_1_stringify (ASM_TYPE_DIRECTIVE_PREFIX) #type \ | |
304 | "\n\t.size " __SYMBOL_PREFIX #symbol ", " #size); | |
305 | # define declare_symbol_1_stringify(x) declare_symbol_1_stringify_1 (x) | |
306 | # define declare_symbol_1_stringify_1(x) #x | |
307 | # endif /* __ASSEMBLER__ */ | |
308 | #else | |
309 | # define declare_symbol_1(symbol, type, size) /* Nothing. */ | |
310 | #endif | |
311 | ||
312 | ||
313 | /* | |
314 | \f | |
315 | */ | |
316 | ||
317 | #ifdef HAVE_GNU_LD | |
318 | ||
319 | /* Symbol set support macros. */ | |
320 | ||
321 | # ifdef HAVE_ELF | |
322 | ||
323 | /* Make SYMBOL, which is in the text segment, an element of SET. */ | |
324 | # define text_set_element(set, symbol) _elf_set_element(set, symbol) | |
325 | /* Make SYMBOL, which is in the data segment, an element of SET. */ | |
326 | # define data_set_element(set, symbol) _elf_set_element(set, symbol) | |
327 | /* Make SYMBOL, which is in the bss segment, an element of SET. */ | |
328 | # define bss_set_element(set, symbol) _elf_set_element(set, symbol) | |
329 | ||
330 | /* These are all done the same way in ELF. | |
331 | There is a new section created for each set. */ | |
332 | # ifdef SHARED | |
333 | /* When building a shared library, make the set section writable, | |
334 | because it will need to be relocated at run time anyway. */ | |
335 | # define _elf_set_element(set, symbol) \ | |
336 | static const void *__elf_set_##set##_element_##symbol##__ \ | |
337 | __attribute__ ((unused, section (#set))) = &(symbol) | |
338 | # else | |
339 | # define _elf_set_element(set, symbol) \ | |
340 | static const void *const __elf_set_##set##_element_##symbol##__ \ | |
341 | __attribute__ ((unused, section (#set))) = &(symbol) | |
342 | # endif | |
343 | ||
344 | /* Define SET as a symbol set. This may be required (it is in a.out) to | |
345 | be able to use the set's contents. */ | |
346 | # define symbol_set_define(set) symbol_set_declare(set) | |
347 | ||
348 | /* Declare SET for use in this module, if defined in another module. | |
349 | In a shared library, this is always local to that shared object. | |
350 | For static linking, the set might be wholly absent and so we use | |
351 | weak references. */ | |
352 | # define symbol_set_declare(set) \ | |
353 | extern char const __start_##set[] __symbol_set_attribute; \ | |
354 | extern char const __stop_##set[] __symbol_set_attribute; | |
355 | # ifdef SHARED | |
356 | # define __symbol_set_attribute attribute_hidden | |
357 | # else | |
358 | # define __symbol_set_attribute __attribute__ ((weak)) | |
359 | # endif | |
360 | ||
361 | /* Return a pointer (void *const *) to the first element of SET. */ | |
362 | # define symbol_set_first_element(set) ((void *const *) (&__start_##set)) | |
363 | ||
364 | /* Return true iff PTR (a void *const *) has been incremented | |
365 | past the last element in SET. */ | |
366 | # define symbol_set_end_p(set, ptr) ((ptr) >= (void *const *) &__stop_##set) | |
367 | ||
368 | # else /* Not ELF: a.out. */ | |
369 | ||
370 | # ifdef HAVE_XCOFF | |
371 | /* XCOFF does not support .stabs. | |
372 | The native aix linker will remove the .stab and .stabstr sections | |
373 | The gnu linker will have a fatal error if there is a relocation for | |
374 | symbol in the .stab section. Silently disable these macros. */ | |
375 | # define text_set_element(set, symbol) | |
376 | # define data_set_element(set, symbol) | |
377 | # define bss_set_element(set, symbol) | |
378 | # else | |
379 | # define text_set_element(set, symbol) \ | |
380 | asm (".stabs \"" __SYMBOL_PREFIX #set "\",23,0,0," __SYMBOL_PREFIX #symbol) | |
381 | # define data_set_element(set, symbol) \ | |
382 | asm (".stabs \"" __SYMBOL_PREFIX #set "\",25,0,0," __SYMBOL_PREFIX #symbol) | |
383 | # define bss_set_element(set, symbol) ?error Must use initialized data. | |
384 | # endif /* XCOFF */ | |
385 | # define symbol_set_define(set) void *const (set)[1]; | |
386 | # define symbol_set_declare(set) extern void *const (set)[1]; | |
387 | ||
388 | # define symbol_set_first_element(set) &(set)[1] | |
389 | # define symbol_set_end_p(set, ptr) (*(ptr) == 0) | |
390 | ||
391 | # endif /* ELF. */ | |
392 | #else | |
393 | /* We cannot do anything in generial. */ | |
394 | # define text_set_element(set, symbol) asm ("") | |
395 | # define data_set_element(set, symbol) asm ("") | |
396 | # define bss_set_element(set, symbol) asm ("") | |
397 | # define symbol_set_define(set) void *const (set)[1]; | |
398 | # define symbol_set_declare(set) extern void *const (set)[1]; | |
399 | ||
400 | # define symbol_set_first_element(set) &(set)[1] | |
401 | # define symbol_set_end_p(set, ptr) (*(ptr) == 0) | |
402 | #endif /* Have GNU ld. */ | |
403 | ||
404 | #if DO_VERSIONING | |
405 | # define symbol_version(real, name, version) \ | |
406 | _symbol_version(real, name, version) | |
407 | # define default_symbol_version(real, name, version) \ | |
408 | _default_symbol_version(real, name, version) | |
409 | # ifdef __ASSEMBLER__ | |
410 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
411 | # define _symbol_version(real, name, version) \ | |
412 | .symver real, name##@##version ASM_LINE_SEP \ | |
413 | .symver .##real, .##name##@##version | |
414 | # define _default_symbol_version(real, name, version) \ | |
415 | .symver real, name##@##@##version ASM_LINE_SEP \ | |
416 | .symver .##real, .##name##@##@##version | |
417 | # else | |
418 | # define _symbol_version(real, name, version) \ | |
419 | .symver real, name##@##version | |
420 | # define _default_symbol_version(real, name, version) \ | |
421 | .symver real, name##@##@##version | |
422 | # endif | |
423 | # else | |
424 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
425 | # define _symbol_version(real, name, version) \ | |
426 | __asm__ (".symver " #real "," #name "@" #version "\n\t" \ | |
427 | ".symver ." #real ",." #name "@" #version) | |
428 | # define _default_symbol_version(real, name, version) \ | |
429 | __asm__ (".symver " #real "," #name "@@" #version "\n\t" \ | |
430 | ".symver ." #real ",." #name "@@" #version) | |
431 | # else | |
432 | # define _symbol_version(real, name, version) \ | |
433 | __asm__ (".symver " #real "," #name "@" #version) | |
434 | # define _default_symbol_version(real, name, version) \ | |
435 | __asm__ (".symver " #real "," #name "@@" #version) | |
436 | # endif | |
437 | # endif | |
438 | #else | |
439 | # define symbol_version(real, name, version) | |
440 | # define default_symbol_version(real, name, version) \ | |
441 | strong_alias(real, name) | |
442 | #endif | |
443 | ||
444 | #if defined HAVE_VISIBILITY_ATTRIBUTE \ | |
445 | && (defined SHARED || defined LIBC_NONSHARED) | |
446 | # define attribute_hidden __attribute__ ((visibility ("hidden"))) | |
447 | #else | |
448 | # define attribute_hidden | |
449 | #endif | |
450 | ||
451 | #if defined HAVE_TLS_MODEL_ATTRIBUTE | |
452 | # define attribute_tls_model_ie __attribute__ ((tls_model ("initial-exec"))) | |
453 | #else | |
454 | # define attribute_tls_model_ie | |
455 | #endif | |
456 | ||
457 | /* Handling on non-exported internal names. We have to do this only | |
458 | for shared code. */ | |
459 | #ifdef SHARED | |
460 | # define INTUSE(name) name##_internal | |
461 | # define INTDEF(name) strong_alias (name, name##_internal) | |
462 | # define INTVARDEF(name) \ | |
463 | _INTVARDEF (name, name##_internal) | |
464 | # if defined HAVE_VISIBILITY_ATTRIBUTE | |
465 | # define _INTVARDEF(name, aliasname) \ | |
466 | extern __typeof (name) aliasname __attribute__ ((alias (#name), \ | |
467 | visibility ("hidden"))); | |
468 | # else | |
469 | # define _INTVARDEF(name, aliasname) \ | |
470 | extern __typeof (name) aliasname __attribute__ ((alias (#name))); | |
471 | # endif | |
472 | # define INTDEF2(name, newname) strong_alias (name, newname##_internal) | |
473 | # define INTVARDEF2(name, newname) _INTVARDEF (name, newname##_internal) | |
474 | #else | |
475 | # define INTUSE(name) name | |
476 | # define INTDEF(name) | |
477 | # define INTVARDEF(name) | |
478 | # define INTDEF2(name, newname) | |
479 | # define INTVARDEF2(name, newname) | |
480 | #endif | |
481 | ||
482 | /* The following macros are used for PLT bypassing within libc.so | |
483 | (and if needed other libraries similarly). | |
484 | First of all, you need to have the function prototyped somewhere, | |
485 | say in foo/foo.h: | |
486 | ||
487 | int foo (int __bar); | |
488 | ||
489 | If calls to foo within libc.so should always go to foo defined in libc.so, | |
490 | then in include/foo.h you add: | |
491 | ||
492 | libc_hidden_proto (foo) | |
493 | ||
494 | line and after the foo function definition: | |
495 | ||
496 | int foo (int __bar) | |
497 | { | |
498 | return __bar; | |
499 | } | |
500 | libc_hidden_def (foo) | |
501 | ||
502 | or | |
503 | ||
504 | int foo (int __bar) | |
505 | { | |
506 | return __bar; | |
507 | } | |
508 | libc_hidden_weak (foo) | |
509 | ||
510 | Simularly for global data. If references to foo within libc.so should | |
511 | always go to foo defined in libc.so, then in include/foo.h you add: | |
512 | ||
513 | libc_hidden_proto (foo) | |
514 | ||
515 | line and after foo's definition: | |
516 | ||
517 | int foo = INITIAL_FOO_VALUE; | |
518 | libc_hidden_data_def (foo) | |
519 | ||
520 | or | |
521 | ||
522 | int foo = INITIAL_FOO_VALUE; | |
523 | libc_hidden_data_weak (foo) | |
524 | ||
525 | If foo is normally just an alias (strong or weak) of some other function, | |
526 | you should use the normal strong_alias first, then add libc_hidden_def | |
527 | or libc_hidden_weak: | |
528 | ||
529 | int baz (int __bar) | |
530 | { | |
531 | return __bar; | |
532 | } | |
533 | strong_alias (baz, foo) | |
534 | libc_hidden_weak (foo) | |
535 | ||
536 | If the function should be internal to multiple objects, say ld.so and | |
537 | libc.so, the best way is to use: | |
538 | ||
539 | #if !defined NOT_IN_libc || defined IS_IN_rtld | |
540 | hidden_proto (foo) | |
541 | #endif | |
542 | ||
543 | in include/foo.h and the normal macros at all function definitions | |
544 | depending on what DSO they belong to. | |
545 | ||
546 | If versioned_symbol macro is used to define foo, | |
547 | libc_hidden_ver macro should be used, as in: | |
548 | ||
549 | int __real_foo (int __bar) | |
550 | { | |
551 | return __bar; | |
552 | } | |
553 | versioned_symbol (libc, __real_foo, foo, GLIBC_2_1); | |
554 | libc_hidden_ver (__real_foo, foo) */ | |
555 | ||
556 | #if defined SHARED && defined DO_VERSIONING \ | |
557 | && !defined HAVE_BROKEN_ALIAS_ATTRIBUTE && !defined NO_HIDDEN | |
558 | # ifndef __ASSEMBLER__ | |
559 | # if !defined HAVE_VISIBILITY_ATTRIBUTE \ | |
560 | || defined HAVE_BROKEN_VISIBILITY_ATTRIBUTE | |
561 | # define __hidden_proto_hiddenattr(attrs...) | |
562 | # else | |
563 | # define __hidden_proto_hiddenattr(attrs...) \ | |
564 | __attribute__ ((visibility ("hidden"), ##attrs)) | |
565 | # endif | |
566 | # define hidden_proto(name, attrs...) \ | |
567 | __hidden_proto (name, __GI_##name, ##attrs) | |
568 | # define __hidden_proto(name, internal, attrs...) \ | |
569 | extern __typeof (name) internal; \ | |
570 | extern __typeof (name) name __asm__ (__hidden_asmname (#internal)) \ | |
571 | __hidden_proto_hiddenattr (attrs); | |
572 | # define __hidden_asmname(name) \ | |
573 | __hidden_asmname1 (__USER_LABEL_PREFIX__, name) | |
574 | # define __hidden_asmname1(prefix, name) __hidden_asmname2(prefix, name) | |
575 | # define __hidden_asmname2(prefix, name) #prefix name | |
576 | # ifdef HAVE_ASM_SET_DIRECTIVE | |
577 | # define __hidden_def1(original, alias) \ | |
578 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
579 | .set C_SYMBOL_NAME (alias), C_SYMBOL_NAME (original) | |
580 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
581 | # define __hidden_dot_def1(original, alias) ASM_LINE_SEP \ | |
582 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
583 | .set C_SYMBOL_DOT_NAME (alias), C_SYMBOL_DOT_NAME (original) | |
584 | # else | |
585 | # define __hidden_dot_def1(original, alias) | |
586 | # endif | |
587 | # else | |
588 | # define __hidden_def1(original, alias) \ | |
589 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
590 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) | |
591 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
592 | # define __hidden_dot_def1(original, alias) ASM_LINE_SEP \ | |
593 | ASM_GLOBAL_DIRECTIVE C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
594 | C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original) | |
595 | # else | |
596 | # define __hidden_dot_def1(original, alias) | |
597 | # endif | |
598 | # endif | |
599 | # define __hidden_def2(...) #__VA_ARGS__ | |
600 | # define __hidden_def3(...) __hidden_def2 (__VA_ARGS__) | |
601 | # define hidden_def(name) \ | |
602 | __asm__ (__hidden_def3 (__hidden_def1 (__GI_##name, name) \ | |
603 | __hidden_dot_def1 (__GI_##name, name))); | |
604 | # define hidden_data_def(name) \ | |
605 | __asm__ (__hidden_def3 (__hidden_def1 (__GI_##name, name))); | |
606 | # define hidden_ver(local, name) \ | |
607 | __asm__ (__hidden_def3 (__hidden_def1 (local, __GI_##name) \ | |
608 | __hidden_dot_def1 (local, __GI_##name))); | |
609 | # define hidden_data_ver(local, name) \ | |
610 | __asm__ (__hidden_def3 (__hidden_def1 (local, __GI_##name))); | |
611 | # ifdef HAVE_WEAK_SYMBOLS | |
612 | # ifdef HAVE_ASM_WEAKEXT_DIRECTIVE | |
613 | # define __hidden_weak1(original, alias) \ | |
614 | .weakext C_SYMBOL_NAME (alias), C_SYMBOL_NAME (original) | |
615 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
616 | # define __hidden_dot_weak1(original, alias) ASM_LINE_SEP \ | |
617 | .weakext C_SYMBOL_DOT_NAME (alias), C_SYMBOL_DOT_NAME (original) | |
618 | # else | |
619 | # define __hidden_dot_weak1(original, alias) | |
620 | # endif | |
621 | # else /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */ | |
622 | # define __hidden_weak1(original, alias) \ | |
623 | .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP \ | |
624 | C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) | |
625 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
626 | # define __hidden_dot_weak1(original, alias) ASM_LINE_SEP \ | |
627 | .weak C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP \ | |
628 | C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original) | |
629 | # else | |
630 | # define __hidden_dot_weak1(original, alias) | |
631 | # endif | |
632 | # endif | |
633 | # define hidden_weak(name) \ | |
634 | __asm__ (__hidden_def3 (__hidden_weak1 (__GI_##name, name) \ | |
635 | __hidden_dot_weak1 (__GI_##name, name))); | |
636 | # define hidden_data_weak(name) \ | |
637 | __asm__ (__hidden_def3 (__hidden_weak1 (__GI_##name, name))); | |
638 | # else | |
639 | # define hidden_weak(name) hidden_def (name) | |
640 | # endif | |
641 | # else | |
642 | /* For assembly, we need to do the opposite of what we do in C: | |
643 | in assembly gcc __REDIRECT stuff is not in place, so functions | |
644 | are defined by its normal name and we need to create the | |
645 | __GI_* alias to it, in C __REDIRECT causes the function definition | |
646 | to use __GI_* name and we need to add alias to the real name. | |
647 | There is no reason to use hidden_weak over hidden_def in assembly, | |
648 | but we provide it for consistency with the C usage. | |
649 | hidden_proto doesn't make sense for assembly but the equivalent | |
650 | is to call via the HIDDEN_JUMPTARGET macro instead of JUMPTARGET. */ | |
651 | # define hidden_def(name) strong_alias (name, __GI_##name) | |
652 | # define hidden_weak(name) hidden_def (name) | |
653 | # define hidden_ver(local, name) strong_alias (local, __GI_##name) | |
654 | # define hidden_data_def(name) strong_data_alias (name, __GI_##name) | |
655 | # define hidden_data_weak(name) hidden_data_def (name) | |
656 | # define hidden_data_ver(local, name) strong_data_alias (local, __GI_##name) | |
657 | # ifdef HAVE_ASM_GLOBAL_DOT_NAME | |
658 | # define HIDDEN_JUMPTARGET(name) .__GI_##name | |
659 | # else | |
660 | # define HIDDEN_JUMPTARGET(name) __GI_##name | |
661 | # endif | |
662 | # endif | |
663 | #else | |
664 | # ifndef __ASSEMBLER__ | |
665 | # define hidden_proto(name, attrs...) | |
666 | # else | |
667 | # define HIDDEN_JUMPTARGET(name) JUMPTARGET(name) | |
668 | # endif /* Not __ASSEMBLER__ */ | |
669 | # define hidden_weak(name) | |
670 | # define hidden_def(name) | |
671 | # define hidden_ver(local, name) | |
672 | # define hidden_data_weak(name) | |
673 | # define hidden_data_def(name) | |
674 | # define hidden_data_ver(local, name) | |
675 | #endif | |
676 | ||
677 | #if !defined NOT_IN_libc | |
678 | # define libc_hidden_proto(name, attrs...) hidden_proto (name, ##attrs) | |
679 | # define libc_hidden_def(name) hidden_def (name) | |
680 | # define libc_hidden_weak(name) hidden_weak (name) | |
681 | # define libc_hidden_ver(local, name) hidden_ver (local, name) | |
682 | # define libc_hidden_data_def(name) hidden_data_def (name) | |
683 | # define libc_hidden_data_weak(name) hidden_data_weak (name) | |
684 | # define libc_hidden_data_ver(local, name) hidden_data_ver (local, name) | |
685 | #else | |
686 | # define libc_hidden_proto(name, attrs...) | |
687 | # define libc_hidden_def(name) | |
688 | # define libc_hidden_weak(name) | |
689 | # define libc_hidden_ver(local, name) | |
690 | # define libc_hidden_data_def(name) | |
691 | # define libc_hidden_data_weak(name) | |
692 | # define libc_hidden_data_ver(local, name) | |
693 | #endif | |
694 | ||
695 | #if defined NOT_IN_libc && defined IS_IN_rtld | |
696 | # define rtld_hidden_proto(name, attrs...) hidden_proto (name, ##attrs) | |
697 | # define rtld_hidden_def(name) hidden_def (name) | |
698 | # define rtld_hidden_weak(name) hidden_weak (name) | |
699 | # define rtld_hidden_ver(local, name) hidden_ver (local, name) | |
700 | # define rtld_hidden_data_def(name) hidden_data_def (name) | |
701 | # define rtld_hidden_data_weak(name) hidden_data_weak (name) | |
702 | # define rtld_hidden_data_ver(local, name) hidden_data_ver (local, name) | |
703 | #else | |
704 | # define rtld_hidden_proto(name, attrs...) | |
705 | # define rtld_hidden_def(name) | |
706 | # define rtld_hidden_weak(name) | |
707 | # define rtld_hidden_ver(local, name) | |
708 | # define rtld_hidden_data_def(name) | |
709 | # define rtld_hidden_data_weak(name) | |
710 | # define rtld_hidden_data_ver(local, name) | |
711 | #endif | |
712 | ||
713 | #if defined NOT_IN_libc && defined IS_IN_libm | |
714 | # define libm_hidden_proto(name, attrs...) hidden_proto (name, ##attrs) | |
715 | # define libm_hidden_def(name) hidden_def (name) | |
716 | # define libm_hidden_weak(name) hidden_weak (name) | |
717 | # define libm_hidden_ver(local, name) hidden_ver (local, name) | |
718 | # define libm_hidden_data_def(name) hidden_data_def (name) | |
719 | # define libm_hidden_data_weak(name) hidden_data_weak (name) | |
720 | # define libm_hidden_data_ver(local, name) hidden_data_ver (local, name) | |
721 | #else | |
722 | # define libm_hidden_proto(name, attrs...) | |
723 | # define libm_hidden_def(name) | |
724 | # define libm_hidden_weak(name) | |
725 | # define libm_hidden_ver(local, name) | |
726 | # define libm_hidden_data_def(name) | |
727 | # define libm_hidden_data_weak(name) | |
728 | # define libm_hidden_data_ver(local, name) | |
729 | #endif | |
730 | ||
731 | #ifdef HAVE_BUILTIN_REDIRECTION | |
732 | # define libc_hidden_builtin_proto(name, attrs...) libc_hidden_proto (name, ##attrs) | |
733 | # define libc_hidden_builtin_def(name) libc_hidden_def (name) | |
734 | # define libc_hidden_builtin_weak(name) libc_hidden_weak (name) | |
735 | # define libc_hidden_builtin_ver(local, name) libc_hidden_ver (local, name) | |
736 | #else | |
737 | # define libc_hidden_builtin_proto(name, attrs...) | |
738 | # define libc_hidden_builtin_def(name) | |
739 | # define libc_hidden_builtin_weak(name) | |
740 | # define libc_hidden_builtin_ver(local, name) | |
741 | #endif | |
742 | ||
743 | #endif /* libc-symbols.h */ |