include/libc-symbols.h

   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-2023 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, see
  18    <https://www.gnu.org/licenses/>.  */
  19
  20 #ifndef _LIBC_SYMBOLS_H
  21 #define _LIBC_SYMBOLS_H 1
  22
  23 /* This file is included implicitly in the compilation of every source file,
  24    using -include.  It includes config.h.  */
  25
  26 /* Enable declarations of GNU extensions, since we are compiling them.  */
  27 #define _GNU_SOURCE 1
  28
  29 #ifdef MODULE_NAME
  30
  31 /* Use `#if IS_IN (module)` to detect what component is being compiled.  */
  32 #define PASTE_NAME1(a,b) a##b
  33 #define PASTE_NAME(a,b)  PASTE_NAME1 (a,b)
  34 #define IN_MODULE        PASTE_NAME (MODULE_, MODULE_NAME)
  35 #define IS_IN(lib)       (IN_MODULE == MODULE_##lib)
  36
  37 /* True if the current module is a versioned library.  Versioned
  38    library names culled from shlib-versions files are assigned a
  39    MODULE_* value greater than MODULE_LIBS_BEGIN.  */
  40 #define IS_IN_LIB        (IN_MODULE > MODULE_LIBS_BEGIN)
  41
  42 /* The testsuite, and some other ancillary code, should be compiled against
  43    as close an approximation to the installed headers as possible.
  44    Defining this symbol disables most internal-use-only declarations
  45    provided by this header, and all those provided by other internal
  46    wrapper headers.  */
  47 #if IS_IN (testsuite) || defined IS_IN_build || defined __cplusplus
  48 # define _ISOMAC 1
  49 #endif
  50
  51 #else
  52 /* The generation process for a few files created very early in the
  53    build (notably libc-modules.h itself) involves preprocessing this
  54    header without defining MODULE_NAME.  Under these conditions,
  55    internal declarations (especially from config.h) must be visible,
  56    but IS_IN should always evaluate as false.  */
  57 # define IS_IN(lib) 0
  58 # define IS_IN_LIB 0
  59 # define IN_MODULE (-1)
  60 #endif
  61
  62 #ifndef _ISOMAC
  63
  64 /* This is defined for the compilation of all C library code.  features.h
  65    tests this to avoid inclusion of stubs.h while compiling the library,
  66    before stubs.h has been generated.  Some library code that is shared
  67    with other packages also tests this symbol to see if it is being
  68    compiled as part of the C library.  We must define this before including
  69    config.h, because it makes some definitions conditional on whether libc
  70    itself is being compiled, or just some generator program.  */
  71 #define _LIBC   1
  72
  73 /* Some files must be compiled with optimization on.  */
  74 #if !defined __ASSEMBLER__ && !defined __OPTIMIZE__
  75 # error "glibc cannot be compiled without optimization"
  76 #endif
  77
  78 /* -ffast-math cannot be applied to the C library, as it alters the ABI.
  79    Some test components that use -ffast-math are currently not part of
  80    IS_IN (testsuite) for technical reasons, so we have a secondary override.  */
  81 #if defined __FAST_MATH__ && !defined TEST_FAST_MATH
  82 # error "glibc must not be compiled with -ffast-math"
  83 #endif
  84
  85 #include <config.h>
  86
  87 /* Obtain the definition of symbol_version_reference.  */
  88 #include <libc-symver.h>
  89
  90 /* When PIC is defined and SHARED isn't defined, we are building PIE
  91    by default.  */
  92 #if defined PIC && !defined SHARED
  93 # define BUILD_PIE_DEFAULT 1
  94 #else
  95 # define BUILD_PIE_DEFAULT 0
  96 #endif
  97
  98 /* Define this for the benefit of portable GNU code that wants to check it.
  99    Code that checks with #if will not #include <config.h> again, since we've
 100    already done it (and this file is implicitly included in every compile,
 101    via -include).  Code that checks with #ifdef will #include <config.h>,
 102    but that file should always be idempotent (i.e., it's just #define/#undef
 103    and nothing else anywhere should be changing the macro state it touches),
 104    so it's harmless.  */
 105 #define HAVE_CONFIG_H   0
 106
 107 /* Define these macros for the benefit of portable GNU code that wants to check
 108    them.  Of course, STDC_HEADERS is never false when building libc!  */
 109 #define STDC_HEADERS    1
 110 #define HAVE_MBSTATE_T  1
 111 #define HAVE_MBSRTOWCS  1
 112 #define HAVE_LIBINTL_H  1
 113 #define HAVE_WCTYPE_H   1
 114 #define HAVE_ISWCTYPE   1
 115 #define ENABLE_NLS      1
 116
 117 /* The symbols in all the user (non-_) macros are C symbols.  */
 118
 119 #ifndef __SYMBOL_PREFIX
 120 # define __SYMBOL_PREFIX
 121 #endif
 122
 123 #ifndef C_SYMBOL_NAME
 124 # define C_SYMBOL_NAME(name) name
 125 #endif
 126
 127 #ifndef ASM_LINE_SEP
 128 # define ASM_LINE_SEP ;
 129 #endif
 130
 131 #ifndef __attribute_copy__
 132 /* Provide an empty definition when cdefs.h is not included.  */
 133 # define __attribute_copy__(arg)
 134 #endif
 135
 136 #ifndef __ASSEMBLER__
 137 /* GCC understands weak symbols and aliases; use its interface where
 138    possible, instead of embedded assembly language.  */
 139
 140 /* Define ALIASNAME as a strong alias for NAME.  */
 141 # define strong_alias(name, aliasname) _strong_alias(name, aliasname)
 142 # define _strong_alias(name, aliasname) \
 143   extern __typeof (name) aliasname __attribute__ ((alias (#name))) \
 144     __attribute_copy__ (name);
 145
 146 /* This comes between the return type and function name in
 147    a function definition to make that definition weak.  */
 148 # define weak_function __attribute__ ((weak))
 149 # define weak_const_function __attribute__ ((weak, __const__))
 150
 151 /* Define ALIASNAME as a weak alias for NAME.
 152    If weak aliases are not available, this defines a strong alias.  */
 153 # define weak_alias(name, aliasname) _weak_alias (name, aliasname)
 154 # define _weak_alias(name, aliasname) \
 155   extern __typeof (name) aliasname __attribute__ ((weak, alias (#name))) \
 156     __attribute_copy__ (name);
 157
 158 /* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
 159 # define weak_extern(symbol) _weak_extern (weak symbol)
 160 # define _weak_extern(expr) _Pragma (#expr)
 161
 162 /* In shared builds, the expression call_function_static_weak
 163    (FUNCTION-SYMBOL, ARGUMENTS) invokes FUNCTION-SYMBOL (an
 164    identifier) unconditionally, with the (potentially empty) argument
 165    list ARGUMENTS.  In static builds, if FUNCTION-SYMBOL has a
 166    definition, the function is invoked as before; if FUNCTION-SYMBOL
 167    is NULL, no call is performed.  */
 168 # ifdef SHARED
 169 #  define call_function_static_weak(func, ...) func (__VA_ARGS__)
 170 # else  /* !SHARED */
 171 #  define call_function_static_weak(func, ...)          \
 172   ({                                                    \
 173     extern __typeof__ (func) func weak_function;        \
 174     (func != NULL ? func (__VA_ARGS__) : (void)0);      \
 175   })
 176 # endif
 177
 178 #else /* __ASSEMBLER__ */
 179
 180 # ifdef HAVE_ASM_SET_DIRECTIVE
 181 #  define strong_alias(original, alias)                         \
 182   .globl C_SYMBOL_NAME (alias) ASM_LINE_SEP             \
 183   .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original)
 184 #  define strong_data_alias(original, alias) strong_alias(original, alias)
 185 # else
 186 #  define strong_alias(original, alias)                         \
 187   .globl C_SYMBOL_NAME (alias) ASM_LINE_SEP             \
 188   C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original)
 189 #  define strong_data_alias(original, alias) strong_alias(original, alias)
 190 # endif
 191
 192 # define weak_alias(original, alias)                                    \
 193   .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP                              \
 194   C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original)
 195
 196 # define weak_extern(symbol)                                            \
 197   .weak C_SYMBOL_NAME (symbol)
 198
 199 #endif /* __ASSEMBLER__ */
 200
 201 /* Determine the return address.  */
 202 #define RETURN_ADDRESS(nr) \
 203   __builtin_extract_return_addr (__builtin_return_address (nr))
 204
 205 /* When a reference to SYMBOL is encountered, the linker will emit a
 206    warning message MSG.  */
 207 /* We want the .gnu.warning.SYMBOL section to be unallocated.  */
 208 #define __make_section_unallocated(section_string)      \
 209   asm (".section " section_string "\n\t.previous");
 210
 211 /* Tacking on "\n\t#" to the section name makes gcc put it's bogus
 212    section attributes on what looks like a comment to the assembler.  */
 213 #ifdef HAVE_SECTION_QUOTES
 214 # define __sec_comment "\"\n\t#\""
 215 #else
 216 # define __sec_comment "\n\t#"
 217 #endif
 218 #define link_warning(symbol, msg) \
 219   __make_section_unallocated (".gnu.warning." #symbol) \
 220   static const char __evoke_link_warning_##symbol[]     \
 221     __attribute__ ((used, section (".gnu.warning." #symbol __sec_comment))) \
 222     = msg;
 223
 224 /* A canned warning for sysdeps/stub functions.  */
 225 #define stub_warning(name) \
 226   __make_section_unallocated (".gnu.glibc-stub." #name) \
 227   link_warning (name, #name " is not implemented and will always fail")
 228
 229 /* Warning for linking functions calling dlopen into static binaries.  */
 230 #ifdef SHARED
 231 #define static_link_warning(name)
 232 #else
 233 #define static_link_warning(name) static_link_warning1(name)
 234 #define static_link_warning1(name) \
 235   link_warning(name, "Using '" #name "' in statically linked applications \
 236 requires at runtime the shared libraries from the glibc version used \
 237 for linking")
 238 #endif
 239
 240 /* Declare SYMBOL to be TYPE (`function' or `object') of SIZE bytes
 241    alias to ORIGINAL, when the assembler supports such declarations
 242    (such as in ELF).
 243    This is only necessary when defining something in assembly, or playing
 244    funny alias games where the size should be other than what the compiler
 245    thinks it is.  */
 246 #define declare_object_symbol_alias(symbol, original, size) \
 247   declare_object_symbol_alias_1 (symbol, original, size)
 248 #ifdef __ASSEMBLER__
 249 # define declare_object_symbol_alias_1(symbol, original, s_size) \
 250    strong_alias (original, symbol) ASM_LINE_SEP \
 251    .type C_SYMBOL_NAME (symbol), %object ASM_LINE_SEP \
 252    .size C_SYMBOL_NAME (symbol), s_size ASM_LINE_SEP
 253 #else /* Not __ASSEMBLER__.  */
 254 # ifdef HAVE_ASM_SET_DIRECTIVE
 255 #  define declare_object_symbol_alias_1(symbol, original, size) \
 256      asm (".global " __SYMBOL_PREFIX # symbol "\n" \
 257           ".type " __SYMBOL_PREFIX # symbol ", %object\n" \
 258           ".set " __SYMBOL_PREFIX #symbol ", " __SYMBOL_PREFIX original "\n" \
 259           ".size " __SYMBOL_PREFIX #symbol ", " #size "\n");
 260 # else
 261 #  define declare_object_symbol_alias_1(symbol, original, size) \
 262      asm (".global " __SYMBOL_PREFIX # symbol "\n" \
 263           ".type " __SYMBOL_PREFIX # symbol ", %object\n" \
 264           __SYMBOL_PREFIX #symbol " = " __SYMBOL_PREFIX original "\n" \
 265           ".size " __SYMBOL_PREFIX #symbol ", " #size "\n");
 266 # endif /* HAVE_ASM_SET_DIRECTIVE */
 267 #endif /* __ASSEMBLER__ */
 268
 269
 270 /*
 271 \f
 272 */
 273
 274 #ifdef HAVE_GNU_RETAIN
 275 # define attribute_used_retain __attribute__ ((__used__, __retain__))
 276 #else
 277 # define attribute_used_retain __attribute__ ((__used__))
 278 #endif
 279
 280 /* Symbol set support macros.  */
 281
 282 /* Make SYMBOL, which is in the text segment, an element of SET.  */
 283 #define text_set_element(set, symbol)   _elf_set_element(set, symbol)
 284 /* Make SYMBOL, which is in the data segment, an element of SET.  */
 285 #define data_set_element(set, symbol)   _elf_set_element(set, symbol)
 286 /* Make SYMBOL, which is in the bss segment, an element of SET.  */
 287 #define bss_set_element(set, symbol)    _elf_set_element(set, symbol)
 288
 289 /* These are all done the same way in ELF.
 290    There is a new section created for each set.  */
 291 #ifdef SHARED
 292 /* When building a shared library, make the set section writable,
 293    because it will need to be relocated at run time anyway.  */
 294 # define _elf_set_element(set, symbol) \
 295     static const void *__elf_set_##set##_element_##symbol##__ \
 296       attribute_used_retain __attribute__ ((section (#set))) = &(symbol)
 297 #else
 298 # define _elf_set_element(set, symbol) \
 299     static const void *const __elf_set_##set##_element_##symbol##__ \
 300       attribute_used_retain __attribute__ ((section (#set))) = &(symbol)
 301 #endif
 302
 303 /* Define SET as a symbol set.  This may be required (it is in a.out) to
 304    be able to use the set's contents.  */
 305 #define symbol_set_define(set)  symbol_set_declare(set)
 306
 307 /* Declare SET for use in this module, if defined in another module.
 308    In a shared library, this is always local to that shared object.
 309    For static linking, the set might be wholly absent and so we use
 310    weak references.  */
 311 #define symbol_set_declare(set) \
 312   extern char const __start_##set[] __symbol_set_attribute; \
 313   extern char const __stop_##set[] __symbol_set_attribute;
 314 #ifdef SHARED
 315 # define __symbol_set_attribute attribute_hidden
 316 #else
 317 # define __symbol_set_attribute __attribute__ ((weak))
 318 #endif
 319
 320 /* Return a pointer (void *const *) to the first element of SET.  */
 321 #define symbol_set_first_element(set)   ((void *const *) (&__start_##set))
 322
 323 /* Return true iff PTR (a void *const *) has been incremented
 324    past the last element in SET.  */
 325 #define symbol_set_end_p(set, ptr) ((ptr) >= (void *const *) &__stop_##set)
 326
 327 #ifdef SHARED
 328 # define symbol_version(real, name, version) \
 329   symbol_version_reference(real, name, version)
 330 # define default_symbol_version(real, name, version) \
 331      _default_symbol_version(real, name, version)
 332 /* See <libc-symver.h>.  */
 333 # ifdef __ASSEMBLER__
 334 #  define _default_symbol_version(real, name, version) \
 335   _set_symbol_version (real, name@@version)
 336 # else
 337 #  define _default_symbol_version(real, name, version) \
 338   _set_symbol_version (real, #name "@@" #version)
 339 # endif
 340
 341 /* Evaluates to a string literal for VERSION in LIB.  */
 342 # define symbol_version_string(lib, version) \
 343   _symbol_version_stringify_1 (VERSION_##lib##_##version)
 344 # define _symbol_version_stringify_1(arg) _symbol_version_stringify_2 (arg)
 345 # define _symbol_version_stringify_2(arg) #arg
 346
 347 #else /* !SHARED */
 348 # define symbol_version(real, name, version)
 349 # define default_symbol_version(real, name, version) \
 350   strong_alias(real, name)
 351 #endif
 352
 353 #if defined SHARED || defined LIBC_NONSHARED \
 354   || (BUILD_PIE_DEFAULT && IS_IN (libc))
 355 # define attribute_hidden __attribute__ ((visibility ("hidden")))
 356 #else
 357 # define attribute_hidden
 358 #endif
 359
 360 #define attribute_tls_model_ie __attribute__ ((tls_model ("initial-exec")))
 361
 362 #define attribute_relro __attribute__ ((section (".data.rel.ro")))
 363
 364
 365 /* Used to disable stack protection in sensitive places, like ifunc
 366    resolvers and early static TLS init.  */
 367 #ifdef HAVE_CC_NO_STACK_PROTECTOR
 368 # define inhibit_stack_protector \
 369     __attribute__ ((__optimize__ ("-fno-stack-protector")))
 370 #else
 371 # define inhibit_stack_protector
 372 #endif
 373
 374 /* The following macros are used for PLT bypassing within libc.so
 375    (and if needed other libraries similarly).
 376    First of all, you need to have the function prototyped somewhere,
 377    say in foo/foo.h:
 378
 379    int foo (int __bar);
 380
 381    If calls to foo within libc.so should always go to foo defined in libc.so,
 382    then in include/foo.h you add:
 383
 384    libc_hidden_proto (foo)
 385
 386    line and after the foo function definition:
 387
 388    int foo (int __bar)
 389    {
 390      return __bar;
 391    }
 392    libc_hidden_def (foo)
 393
 394    or
 395
 396    int foo (int __bar)
 397    {
 398      return __bar;
 399    }
 400    libc_hidden_weak (foo)
 401
 402    Similarly for global data.  If references to foo within libc.so should
 403    always go to foo defined in libc.so, then in include/foo.h you add:
 404
 405    libc_hidden_proto (foo)
 406
 407    line and after foo's definition:
 408
 409    int foo = INITIAL_FOO_VALUE;
 410    libc_hidden_data_def (foo)
 411
 412    or
 413
 414    int foo = INITIAL_FOO_VALUE;
 415    libc_hidden_data_weak (foo)
 416
 417    If foo is normally just an alias (strong or weak) to some other function,
 418    you should use the normal strong_alias first, then add libc_hidden_def
 419    or libc_hidden_weak:
 420
 421    int baz (int __bar)
 422    {
 423      return __bar;
 424    }
 425    strong_alias (baz, foo)
 426    libc_hidden_weak (foo)
 427
 428    If the function should be internal to multiple objects, say ld.so and
 429    libc.so, the best way is to use:
 430
 431    #if IS_IN (libc) || IS_IN (rtld)
 432    hidden_proto (foo)
 433    #endif
 434
 435    in include/foo.h and the normal macros at all function definitions
 436    depending on what DSO they belong to.
 437
 438    If versioned_symbol macro is used to define foo,
 439    libc_hidden_ver macro should be used, as in:
 440
 441    int __real_foo (int __bar)
 442    {
 443      return __bar;
 444    }
 445    versioned_symbol (libc, __real_foo, foo, GLIBC_2_1);
 446    libc_hidden_ver (__real_foo, foo)  */
 447
 448 #if defined SHARED && !defined NO_HIDDEN
 449 # ifndef __ASSEMBLER__
 450 #  define __hidden_proto_hiddenattr(attrs...) \
 451   __attribute__ ((visibility ("hidden"), ##attrs))
 452 #  define hidden_proto(name, attrs...) \
 453   __hidden_proto (name, , __GI_##name, ##attrs)
 454 #  define hidden_proto_alias(name, alias, attrs...) \
 455   __hidden_proto_alias (name, , alias, ##attrs)
 456 #  define hidden_tls_proto(name, attrs...) \
 457   __hidden_proto (name, __thread, __GI_##name, ##attrs)
 458 #  define __hidden_proto(name, thread, internal, attrs...)           \
 459   extern thread __typeof (name) name __asm__ (__hidden_asmname (#internal)) \
 460   __hidden_proto_hiddenattr (attrs);
 461 #  define __hidden_proto_alias(name, thread, internal, attrs...)             \
 462   extern thread __typeof (name) internal __hidden_proto_hiddenattr (attrs);
 463 #  define __hidden_asmname(name) \
 464   __hidden_asmname1 (__USER_LABEL_PREFIX__, name)
 465 #  define __hidden_asmname1(prefix, name) __hidden_asmname2(prefix, name)
 466 #  define __hidden_asmname2(prefix, name) #prefix name
 467 #  define __hidden_ver1(local, internal, name) \
 468   __hidden_ver2 (, local, internal, name)
 469 #  define __hidden_ver2(thread, local, internal, name)                  \
 470   extern thread __typeof (name) __EI_##name \
 471     __asm__(__hidden_asmname (#internal));  \
 472   extern thread __typeof (name) __EI_##name \
 473     __attribute__((alias (__hidden_asmname (#local))))  \
 474     __attribute_copy__ (name)
 475 #  define hidden_ver(local, name)       __hidden_ver1(local, __GI_##name, name);
 476 #  define hidden_def(name)              __hidden_ver1(__GI_##name, name, name);
 477 #  define hidden_def_alias(name, internal) \
 478   strong_alias (name, internal)
 479 #  define hidden_data_def(name)         hidden_def(name)
 480 #  define hidden_data_def_alias(name, alias) hidden_def_alias(name, alias)
 481 #  define hidden_tls_def(name)                          \
 482   __hidden_ver2 (__thread, __GI_##name, name, name);
 483 #  define hidden_weak(name) \
 484         __hidden_ver1(__GI_##name, name, name) __attribute__((weak));
 485 #  define hidden_data_weak(name)        hidden_weak(name)
 486 #  define hidden_nolink(name, lib, version) \
 487   __hidden_nolink1 (__GI_##name, __EI_##name, name, VERSION_##lib##_##version)
 488 #  define __hidden_nolink1(local, internal, name, version) \
 489   __hidden_nolink2 (local, internal, name, version)
 490 #  define __hidden_nolink2(local, internal, name, version) \
 491   extern __typeof (name) internal __attribute__ ((alias (#local)))      \
 492     __attribute_copy__ (name);                                          \
 493   __hidden_nolink3 (local, internal, #name "@" #version)
 494 #  define __hidden_nolink3(local, internal, vername) \
 495   __asm__ (".symver " #internal ", " vername);
 496 # else
 497 /* For assembly, we need to do the opposite of what we do in C:
 498    in assembly gcc __REDIRECT stuff is not in place, so functions
 499    are defined by its normal name and we need to create the
 500    __GI_* alias to it, in C __REDIRECT causes the function definition
 501    to use __GI_* name and we need to add alias to the real name.
 502    There is no reason to use hidden_weak over hidden_def in assembly,
 503    but we provide it for consistency with the C usage.
 504    hidden_proto doesn't make sense for assembly but the equivalent
 505    is to call via the HIDDEN_JUMPTARGET macro instead of JUMPTARGET.  */
 506 #  define hidden_def(name)      strong_alias (name, __GI_##name)
 507 #  define hidden_def_alias(name, alias) strong_alias (name, alias)
 508 #  define hidden_weak(name)     hidden_def (name)
 509 #  define hidden_ver(local, name) strong_alias (local, __GI_##name)
 510 #  define hidden_data_def(name) strong_data_alias (name, __GI_##name)
 511 #  define hidden_data_def_alias(name, alias) strong_data_alias (name, alias)
 512 #  define hidden_tls_def(name)  hidden_data_def (name)
 513 #  define hidden_data_weak(name)        hidden_data_def (name)
 514 #  define HIDDEN_JUMPTARGET(name) __GI_##name
 515 # endif
 516 #else
 517 # ifndef __ASSEMBLER__
 518 #  if !defined SHARED && IS_IN (libc) && !defined LIBC_NONSHARED \
 519       && (!defined PIC || !defined NO_HIDDEN_EXTERN_FUNC_IN_PIE) \
 520       && !defined NO_HIDDEN
 521 #   define __hidden_proto_hiddenattr(attrs...) \
 522   __attribute__ ((visibility ("hidden"), ##attrs))
 523 #   define hidden_proto(name, attrs...) \
 524   __hidden_proto (name, , name, ##attrs)
 525 #  define hidden_proto_alias(name, alias, attrs...) \
 526   __hidden_proto_alias (name, , alias, ##attrs)
 527 #   define hidden_tls_proto(name, attrs...) \
 528   __hidden_proto (name, __thread, name, ##attrs)
 529 #  define __hidden_proto(name, thread, internal, attrs...)           \
 530   extern thread __typeof (name) name __hidden_proto_hiddenattr (attrs);
 531 #  define __hidden_proto_alias(name, thread, internal, attrs...)     \
 532   extern thread __typeof (name) internal __hidden_proto_hiddenattr (attrs);
 533 # else
 534 #   define hidden_proto(name, attrs...)
 535 #   define hidden_proto_alias(name, alias, attrs...)
 536 #   define hidden_tls_proto(name, attrs...)
 537 # endif
 538 # else
 539 #  define HIDDEN_JUMPTARGET(name) JUMPTARGET(name)
 540 # endif /* Not  __ASSEMBLER__ */
 541 # define hidden_weak(name)
 542 # define hidden_def(name)
 543 # define hidden_def_alias(name, alias)
 544 # define hidden_ver(local, name)
 545 # define hidden_data_weak(name)
 546 # define hidden_data_def(name)
 547 # define hidden_data_def_alias(name, alias)
 548 # define hidden_tls_def(name)
 549 # define hidden_nolink(name, lib, version)
 550 #endif
 551
 552 #if IS_IN (libc)
 553 # define libc_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 554 # define libc_hidden_proto_alias(name, alias, attrs...) \
 555    hidden_proto_alias (name, alias, ##attrs)
 556 # define libc_hidden_tls_proto(name, attrs...) hidden_tls_proto (name, ##attrs)
 557 # define libc_hidden_def(name) hidden_def (name)
 558 # define libc_hidden_weak(name) hidden_weak (name)
 559 # define libc_hidden_nolink_sunrpc(name, version) hidden_nolink (name, libc, version)
 560 # define libc_hidden_ver(local, name) hidden_ver (local, name)
 561 # define libc_hidden_data_def(name) hidden_data_def (name)
 562 # define libc_hidden_data_def_alias(name, alias) hidden_data_def_alias (name, alias)
 563 # define libc_hidden_tls_def(name) hidden_tls_def (name)
 564 # define libc_hidden_data_weak(name) hidden_data_weak (name)
 565 #else
 566 # define libc_hidden_proto(name, attrs...)
 567 # define libc_hidden_proto_alias(name, alias, attrs...)
 568 # define libc_hidden_tls_proto(name, attrs...)
 569 # define libc_hidden_def(name)
 570 # define libc_hidden_weak(name)
 571 # define libc_hidden_ver(local, name)
 572 # define libc_hidden_data_def(name)
 573 # define libc_hidden_data_def_alias(name, alias)
 574 # define libc_hidden_tls_def(name)
 575 # define libc_hidden_data_weak(name)
 576 #endif
 577
 578 #if IS_IN (rtld)
 579 # define rtld_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 580 # define rtld_hidden_def(name) hidden_def (name)
 581 # define rtld_hidden_weak(name) hidden_weak (name)
 582 # define rtld_hidden_data_def(name) hidden_data_def (name)
 583 #else
 584 # define rtld_hidden_proto(name, attrs...)
 585 # define rtld_hidden_def(name)
 586 # define rtld_hidden_weak(name)
 587 # define rtld_hidden_data_def(name)
 588 #endif
 589
 590 #if IS_IN (libm)
 591 # define libm_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 592 # define libm_hidden_def(name) hidden_def (name)
 593 # define libm_hidden_weak(name) hidden_weak (name)
 594 # define libm_hidden_ver(local, name) hidden_ver (local, name)
 595 #else
 596 # define libm_hidden_proto(name, attrs...)
 597 # define libm_hidden_def(name)
 598 # define libm_hidden_weak(name)
 599 # define libm_hidden_ver(local, name)
 600 #endif
 601
 602 #if IS_IN (libmvec)
 603 # define libmvec_hidden_def(name) hidden_def (name)
 604 #else
 605 # define libmvec_hidden_def(name)
 606 #endif
 607
 608 #if IS_IN (libresolv)
 609 # define libresolv_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 610 # define libresolv_hidden_def(name) hidden_def (name)
 611 # define libresolv_hidden_data_def(name) hidden_data_def (name)
 612 #else
 613 # define libresolv_hidden_proto(name, attrs...)
 614 # define libresolv_hidden_def(name)
 615 # define libresolv_hidden_data_def(name)
 616 #endif
 617
 618 #if IS_IN (libpthread)
 619 # define libpthread_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 620 # define libpthread_hidden_def(name) hidden_def (name)
 621 #else
 622 # define libpthread_hidden_proto(name, attrs...)
 623 # define libpthread_hidden_def(name)
 624 #endif
 625
 626 #if IS_IN (librt)
 627 # define librt_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 628 # define librt_hidden_ver(local, name) hidden_ver (local, name)
 629 #else
 630 # define librt_hidden_proto(name, attrs...)
 631 # define librt_hidden_ver(local, name)
 632 #endif
 633
 634 #if IS_IN (libnsl)
 635 # define libnsl_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 636 # define libnsl_hidden_nolink_def(name, version) hidden_nolink (name, libnsl, version)
 637 #else
 638 # define libnsl_hidden_proto(name, attrs...)
 639 #endif
 640
 641 #define libc_hidden_builtin_proto(name, attrs...) libc_hidden_proto (name, ##attrs)
 642 #define libc_hidden_builtin_def(name) libc_hidden_def (name)
 643
 644 #define libc_hidden_ldbl_proto(name, attrs...) libc_hidden_proto (name, ##attrs)
 645 #ifdef __ASSEMBLER__
 646 # define HIDDEN_BUILTIN_JUMPTARGET(name) HIDDEN_JUMPTARGET(name)
 647 #endif
 648
 649 #if IS_IN (libanl)
 650 # define libanl_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 651 #else
 652 # define libanl_hidden_proto(name, attrs...)
 653 #endif
 654
 655 /* Get some dirty hacks.  */
 656 #include <symbol-hacks.h>
 657
 658 /* Move compatibility symbols out of the way by placing them all in a
 659    special section.  */
 660 #ifndef __ASSEMBLER__
 661 # define attribute_compat_text_section \
 662     __attribute__ ((section (".text.compat")))
 663 #else
 664 # define compat_text_section .section ".text.compat", "ax";
 665 #endif
 666
 667 /* Helper / base  macros for indirect function symbols.  */
 668 #define __ifunc_resolver(type_name, name, expr, arg, init, classifier)  \
 669   classifier inhibit_stack_protector                                    \
 670   __typeof (type_name) *name##_ifunc (arg)                              \
 671   {                                                                     \
 672     init ();                                                            \
 673     __typeof (type_name) *res = expr;                                   \
 674     return res;                                                         \
 675   }
 676
 677 #ifdef HAVE_GCC_IFUNC
 678 # define __ifunc(type_name, name, expr, arg, init)                      \
 679   extern __typeof (type_name) name __attribute__                        \
 680                               ((ifunc (#name "_ifunc")));               \
 681   __ifunc_resolver (type_name, name, expr, arg, init, static)
 682
 683 # define __ifunc_hidden(type_name, name, expr, arg, init)       \
 684   __ifunc (type_name, name, expr, arg, init)
 685 #else
 686 /* Gcc does not support __attribute__ ((ifunc (...))).  Use the old behaviour
 687    as fallback.  But keep in mind that the debug information for the ifunc
 688    resolver functions is not correct.  It contains the ifunc'ed function as
 689    DW_AT_linkage_name.  E.g. lldb uses this field and an inferior function
 690    call of the ifunc'ed function will fail due to "no matching function for
 691    call to ..." because the ifunc'ed function and the resolver function have
 692    different signatures.  (Gcc support is disabled at least on a ppc64le
 693    Ubuntu 14.04 system.)  */
 694
 695 # define __ifunc(type_name, name, expr, arg, init)                      \
 696   extern __typeof (type_name) name;                                     \
 697   __typeof (type_name) *name##_ifunc (arg) __asm__ (#name);             \
 698   __ifunc_resolver (type_name, name, expr, arg, init,)                  \
 699  __asm__ (".type " #name ", %gnu_indirect_function");
 700
 701 # define __ifunc_hidden(type_name, name, expr, arg, init)               \
 702   extern __typeof (type_name) __libc_##name;                            \
 703   __ifunc (type_name, __libc_##name, expr, arg, init)                   \
 704   strong_alias (__libc_##name, name);
 705 #endif /* !HAVE_GCC_IFUNC  */
 706
 707 /* The following macros are used for indirect function symbols in libc.so.
 708    First of all, you need to have the function prototyped somewhere,
 709    say in foo.h:
 710
 711    int foo (int __bar);
 712
 713    If you have an implementation for foo which e.g. uses a special hardware
 714    feature which isn't available on all machines where this libc.so will be
 715    used but decidable if available at runtime e.g. via hwcaps, you can provide
 716    two or multiple implementations of foo:
 717
 718    int __foo_default (int __bar)
 719    {
 720      return __bar;
 721    }
 722
 723    int __foo_special (int __bar)
 724    {
 725      return __bar;
 726    }
 727
 728    If your function foo has no libc_hidden_proto (foo) defined for PLT
 729    bypassing, you can use:
 730
 731    #define INIT_ARCH() unsigned long int hwcap = __GLRO(dl_hwcap);
 732
 733    libc_ifunc (foo, (hwcap & HWCAP_SPECIAL) ? __foo_special : __foo_default);
 734
 735    This will define a resolver function for foo which returns __foo_special or
 736    __foo_default depending on your specified expression.  Please note that you
 737    have to define a macro function INIT_ARCH before using libc_ifunc macro as
 738    it is called by the resolver function before evaluating the specified
 739    expression.  In this example it is used to prepare the hwcap variable.
 740    The resolver function is assigned to an ifunc'ed symbol foo.  Calls to foo
 741    from inside or outside of libc.so will be indirected by a PLT call.
 742
 743    If your function foo has a libc_hidden_proto (foo) defined for PLT bypassing
 744    and calls to foo within libc.so should always go to one specific
 745    implementation of foo e.g. __foo_default then you have to add:
 746
 747    __hidden_ver1 (__foo_default, __GI_foo, __foo_default);
 748
 749    or a tweaked definition of libc_hidden_def macro after the __foo_default
 750    function definition.  Calls to foo within libc.so will always go directly to
 751    __foo_default.  Calls to foo from outside libc.so will be indirected by a
 752    PLT call to ifunc'ed symbol foo which you have to define in a separate
 753    compile unit:
 754
 755    #define foo __redirect_foo
 756    #include <foo.h>
 757    #undef foo
 758
 759    extern __typeof (__redirect_foo) __foo_default attribute_hidden;
 760    extern __typeof (__redirect_foo) __foo_special attribute_hidden;
 761
 762    libc_ifunc_redirected (__redirect_foo, foo,
 763                           (hwcap & HWCAP_SPECIAL)
 764                           ? __foo_special
 765                           : __foo_default);
 766
 767    This will define the ifunc'ed symbol foo like above.  The redirection of foo
 768    in header file is needed to omit an additional definition of __GI_foo which
 769    would end in a linker error while linking libc.so.  You have to specify
 770    __redirect_foo as first parameter which is used within libc_ifunc_redirected
 771    macro in conjunction with typeof to define the ifunc'ed symbol foo.
 772
 773    If your function foo has a libc_hidden_proto (foo) defined and calls to foo
 774    within or from outside libc.so should go via ifunc'ed symbol, then you have
 775    to use:
 776
 777    libc_ifunc_hidden (foo, foo,
 778                       (hwcap & HWCAP_SPECIAL)
 779                       ? __foo_special
 780                       : __foo_default);
 781    libc_hidden_def (foo)
 782
 783    The first parameter foo of libc_ifunc_hidden macro is used in the same way
 784    as for libc_ifunc_redirected macro.  */
 785
 786 #define libc_ifunc(name, expr) __ifunc (name, name, expr, void, INIT_ARCH)
 787
 788 #define libc_ifunc_redirected(redirected_name, name, expr)      \
 789   __ifunc (redirected_name, name, expr, void, INIT_ARCH)
 790
 791 #define libc_ifunc_hidden(redirected_name, name, expr)                  \
 792   __ifunc_hidden (redirected_name, name, expr, void, INIT_ARCH)
 793
 794 /* The body of the function is supposed to use __get_cpu_features
 795    which will, if necessary, initialize the data first.  */
 796 #define libm_ifunc_init()
 797 #define libm_ifunc(name, expr)                          \
 798   __ifunc (name, name, expr, void, libm_ifunc_init)
 799
 800 /* Add the compiler optimization to inhibit loop transformation to library
 801    calls.  This is used to avoid recursive calls in memset and memmove
 802    default implementations.  */
 803 #ifdef HAVE_CC_INHIBIT_LOOP_TO_LIBCALL
 804 # define inhibit_loop_to_libcall \
 805     __attribute__ ((__optimize__ ("-fno-tree-loop-distribute-patterns")))
 806 #else
 807 # define inhibit_loop_to_libcall
 808 #endif
 809 \f
 810 /* These macros facilitate sharing source files with gnulib.
 811
 812    They are here instead of sys/cdefs.h because they should not be
 813    used in public header files.
 814
 815    Their definitions should be kept consistent with the definitions in
 816    gnulib-common.m4, but it is not necessary to cater to old non-GCC
 817    compilers, since they will only be used while building glibc itself.
 818    (Note that _GNUC_PREREQ cannot be used in this file.)  */
 819
 820 /* Define as a marker that can be attached to declarations that might not
 821     be used.  This helps to reduce warnings, such as from
 822     GCC -Wunused-parameter.  */
 823 #if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
 824 # define _GL_UNUSED __attribute__ ((__unused__))
 825 #else
 826 # define _GL_UNUSED
 827 #endif
 828
 829 /* gcc supports the "unused" attribute on possibly unused labels, and
 830    g++ has since version 4.5.  Note to support C++ as well as C,
 831    _GL_UNUSED_LABEL should be used with a trailing ;  */
 832 #if !defined __cplusplus || __GNUC__ > 4 \
 833     || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
 834 # define _GL_UNUSED_LABEL _GL_UNUSED
 835 #else
 836 # define _GL_UNUSED_LABEL
 837 #endif
 838
 839 /* The __pure__ attribute was added in gcc 2.96.  */
 840 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
 841 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
 842 #else
 843 # define _GL_ATTRIBUTE_PURE /* empty */
 844 #endif
 845
 846 /* The __const__ attribute was added in gcc 2.95.  */
 847 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
 848 # define _GL_ATTRIBUTE_CONST __attribute__ ((__const__))
 849 #else
 850 # define _GL_ATTRIBUTE_CONST /* empty */
 851 #endif
 852
 853 #endif /* !_ISOMAC */
 854 #endif /* libc-symbols.h */