include/libc-internal.h

   1 /* Copyright (C) 1991,92,93,95,96,97,98,99,2000,2001 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, write to the Free
  16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17    02111-1307 USA.  */
  18
  19 #ifndef _LIBC_INTERNAL_H
  20 #define _LIBC_INTERNAL_H 1
  21
  22 #include <features.h>
  23
  24 #ifndef __ASSEMBLER__
  25 /* GCC understands weak symbols and aliases; use its interface where
  26    possible, instead of embedded assembly language.  */
  27
  28 /* Define ALIASNAME as a strong alias for NAME.  */
  29 # define strong_alias(name, aliasname) _strong_alias(name, aliasname)
  30 # define _strong_alias(name, aliasname) \
  31   extern __typeof (name) aliasname __attribute__ ((alias (#name)));
  32
  33 /* This comes between the return type and function name in
  34    a function definition to make that definition weak.  */
  35 # define weak_function __attribute__ ((weak))
  36 # define weak_const_function __attribute__ ((weak, __const__))
  37
  38 /* Define ALIASNAME as a weak alias for NAME.
  39    If weak aliases are not available, this defines a strong alias.  */
  40 # define weak_alias(name, aliasname) _weak_alias (name, aliasname)
  41 # define _weak_alias(name, aliasname) \
  42   extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
  43
  44 /* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
  45 # define weak_extern(symbol) _weak_extern (weak symbol)
  46 # define _weak_extern(expr) _Pragma (#expr)
  47
  48 #else /* __ASSEMBLER__ */
  49
  50 #ifdef __SYMBOL_PREFIX
  51 # define C_SYMBOL_NAME(name) _##name
  52 #else
  53 # define C_SYMBOL_NAME(name) name
  54 #endif
  55
  56 # define strong_alias(name, aliasname)                                  \
  57   .global C_SYMBOL_NAME (aliasname) ;                                   \
  58   .set C_SYMBOL_NAME(aliasname),C_SYMBOL_NAME(name)
  59
  60 # define weak_alias(name, aliasname)                                    \
  61   .weak C_SYMBOL_NAME(aliasname) ;                                      \
  62   C_SYMBOL_NAME(aliasname) = C_SYMBOL_NAME(name)
  63
  64 # define weak_extern(symbol)                                            \
  65   .weak C_SYMBOL_NAME(symbol)
  66
  67 #endif /* __ASSEMBLER__ */
  68
  69 /* When a reference to SYMBOL is encountered, the linker will emit a
  70    warning message MSG.  */
  71 #ifdef __HAVE_ELF__
  72
  73 /* We want the .gnu.warning.SYMBOL section to be unallocated.  */
  74 # define __make_section_unallocated(section_string)     \
  75   asm (".section " section_string "\n\t.previous");
  76
  77 /* Tacking on "\n\t#" to the section name makes gcc put it's bogus
  78    section attributes on what looks like a comment to the assembler.  */
  79 # ifdef __sparc__ //HAVE_SECTION_QUOTES
  80 #  define __sec_comment "\"\n\t#\""
  81 # else
  82 #  define __sec_comment "\n\t#"
  83 # endif
  84 # ifdef __cris__
  85 #  define link_warning(symbol, msg)
  86 # else
  87 #  define link_warning(symbol, msg) \
  88   __make_section_unallocated (".gnu.warning." #symbol) \
  89   static const char __evoke_link_warning_##symbol[]     \
  90     __attribute__ ((used, section (".gnu.warning." #symbol __sec_comment))) \
  91     = msg;
  92 # endif
  93 #else /* __HAVE_ELF__ */
  94 # define link_warning(symbol, msg)              \
  95      asm (".stabs \"" msg "\",30,0,0,0\n\t"     \
  96           ".stabs \"" __C_SYMBOL_PREFIX__ #symbol "\",1,0,0,0\n");
  97 #endif /* __HAVE_ELF__ */
  98
  99 #ifndef weak_function
 100 /* If we do not have the __attribute__ ((weak)) syntax, there is no way we
 101    can define functions as weak symbols.  The compiler will emit a `.globl'
 102    directive for the function symbol, and a `.weak' directive in addition
 103    will produce an error from the assembler.  */
 104 # define weak_function          /* empty */
 105 # define weak_const_function    /* empty */
 106 #endif
 107
 108 /* On some platforms we can make internal function calls (i.e., calls of
 109    functions not exported) a bit faster by using a different calling
 110    convention.  */
 111 #if 0 /*def __i386__*/
 112 # define internal_function __attribute__ ((regparm (3), stdcall))
 113 #endif
 114 #ifndef internal_function
 115 # define internal_function      /* empty */
 116 #endif
 117
 118 #ifndef NOT_IN_libc
 119 # define IS_IN_libc 1
 120 #endif
 121
 122 /* need this to unset defaults in libpthread for files that get added to libc */
 123 #ifdef IS_IN_libc
 124 # undef NOT_IN_libc
 125 #endif
 126
 127 /* Prepare for the case that `__builtin_expect' is not available.  */
 128 #if __GNUC__ == 2 && __GNUC_MINOR__ < 96
 129 # define __builtin_expect(x, expected_value) (x)
 130 #endif
 131 #ifndef likely
 132 # define likely(x)      __builtin_expect((!!(x)),1)
 133 #endif
 134 #ifndef unlikely
 135 # define unlikely(x)    __builtin_expect((!!(x)),0)
 136 #endif
 137 #ifndef __LINUX_COMPILER_H
 138 # define __LINUX_COMPILER_H
 139 #endif
 140 #ifndef __cast__
 141 # define __cast__(_to)
 142 #endif
 143
 144 #define attribute_unused __attribute__ ((unused))
 145
 146 /* The following macros are used for PLT bypassing within libc.so
 147    (and if needed other libraries similarly).
 148    First of all, you need to have the function prototyped somewhere,
 149    say in foo/foo.h:
 150
 151    int foo (int __bar);
 152
 153    If calls to foo within libc.so should always go to foo defined in libc.so,
 154    then in include/foo.h you add:
 155
 156    libc_hidden_proto (foo)
 157
 158    line and after the foo function definition:
 159
 160    int foo (int __bar)
 161    {
 162      return __bar;
 163    }
 164    libc_hidden_def (foo)
 165
 166    or
 167
 168    int foo (int __bar)
 169    {
 170      return __bar;
 171    }
 172    libc_hidden_weak (foo)
 173
 174    Simularly for global data. If references to foo within libc.so should
 175    always go to foo defined in libc.so, then in include/foo.h you add:
 176
 177    libc_hidden_proto (foo)
 178
 179    line and after foo's definition:
 180
 181    int foo = INITIAL_FOO_VALUE;
 182    libc_hidden_data_def (foo)
 183
 184    or
 185
 186    int foo = INITIAL_FOO_VALUE;
 187    libc_hidden_data_weak (foo)
 188
 189    If foo is normally just an alias (strong or weak) of some other function,
 190    you should use the normal strong_alias first, then add libc_hidden_def
 191    or libc_hidden_weak:
 192
 193    int baz (int __bar)
 194    {
 195      return __bar;
 196    }
 197    strong_alias (baz, foo)
 198    libc_hidden_weak (foo)
 199
 200    If the function should be internal to multiple objects, say ld.so and
 201    libc.so, the best way is to use:
 202
 203    #if !defined NOT_IN_libc || defined IS_IN_rtld
 204    hidden_proto (foo)
 205    #endif
 206
 207    in include/foo.h and the normal macros at all function definitions
 208    depending on what DSO they belong to.
 209
 210    If versioned_symbol macro is used to define foo,
 211    libc_hidden_ver macro should be used, as in:
 212
 213    int __real_foo (int __bar)
 214    {
 215      return __bar;
 216    }
 217    versioned_symbol (libc, __real_foo, foo, GLIBC_2_1);
 218    libc_hidden_ver (__real_foo, foo)  */
 219
 220 /* uClibc specific (the above comment was copied from glibc):
 221  * a. when ppc64 will be supported, we need changes to support:
 222  * strong_data_alias (used by asm hidden_data_def) / HAVE_ASM_GLOBAL_DOT_NAME
 223  * b. libc_hidden_proto(foo) should be added after the header having foo's prototype
 224  * or after extern foo... to all source files that should use the internal version
 225  * of foo within libc, even to the file defining foo itself, libc_hidden_def does
 226  * not hide __GI_foo itself, although the name suggests it (hiding is done exclusively
 227  * by libc_hidden_proto). The reasoning to have it after the header w/ foo's prototype is
 228  * to get first the __REDIRECT from original header and then create the __GI_foo alias
 229  * c. no versioning support, hidden[_data]_ver are noop */
 230
 231 /* Arrange to hide uClibc internals */
 232 #if __GNUC_PREREQ (3, 3)
 233 # define attribute_hidden __attribute__ ((visibility ("hidden")))
 234 # define __hidden_proto_hiddenattr(attrs...) __attribute__ ((visibility ("hidden"), ##attrs))
 235 #else
 236 # define attribute_hidden
 237 # define __hidden_proto_hiddenattr(attrs...)
 238 #endif
 239
 240 /* if ppc64 will be supported, this section needs adapting due to HAVE_ASM_GLOBAL_DOT_NAME */
 241 #if 1 /* SHARED */
 242 # ifndef __ASSEMBLER__
 243 #  define hidden_strong_alias(name, aliasname) _hidden_strong_alias(name, aliasname)
 244 #  define _hidden_strong_alias(name, aliasname) \
 245    extern __typeof (name) aliasname __attribute__ ((alias (#name))) attribute_hidden;
 246
 247 #  define hidden_weak_alias(name, aliasname) _hidden_weak_alias (name, aliasname)
 248 #  define _hidden_weak_alias(name, aliasname) \
 249    extern __typeof (name) aliasname __attribute__ ((weak, alias (#name))) attribute_hidden;
 250
 251 #  define hidden_proto(name, attrs...) __hidden_proto (name, __GI_##name, ##attrs)
 252 #  define __hidden_proto(name, internal, attrs...) \
 253    extern __typeof (name) name __asm__ (__hidden_asmname (#internal)) \
 254    __hidden_proto_hiddenattr (attrs);
 255 #  define __hidden_asmname(name) __hidden_asmname1 (__USER_LABEL_PREFIX__, name)
 256 #  define __hidden_asmname1(prefix, name) __hidden_asmname2(prefix, name)
 257 #  define __hidden_asmname2(prefix, name) #prefix name
 258 #  define __hidden_ver1(local, internal, name) \
 259    extern __typeof (name) __EI_##name __asm__(__hidden_asmname (#internal)); \
 260    extern __typeof (name) __EI_##name __attribute__((alias (__hidden_asmname (#local))))
 261 #  define hidden_def(name)              __hidden_ver1(__GI_##name, name, name);
 262 #  define hidden_data_def(name)         hidden_def(name)
 263 #  define hidden_weak(name)             __hidden_ver1(__GI_##name, name, name) __attribute__((weak));
 264 #  define hidden_data_weak(name)        hidden_weak(name)
 265
 266 # else /* __ASSEMBLER__ */
 267 #  define hidden_strong_alias(name, aliasname)                          \
 268    .global C_SYMBOL_NAME (aliasname) ;                                  \
 269    .hidden C_SYMBOL_NAME (aliasname) ;                                  \
 270    .set C_SYMBOL_NAME(aliasname),C_SYMBOL_NAME(name)
 271
 272 #  define hidden_weak_alias(name, aliasname)                            \
 273    .weak C_SYMBOL_NAME(aliasname) ;                                     \
 274    .hidden C_SYMBOL_NAME(aliasname) ;                                   \
 275    C_SYMBOL_NAME(aliasname) = C_SYMBOL_NAME(name)
 276
 277 /* For assembly, we need to do the opposite of what we do in C:
 278    in assembly gcc __REDIRECT stuff is not in place, so functions
 279    are defined by its normal name and we need to create the
 280    __GI_* alias to it, in C __REDIRECT causes the function definition
 281    to use __GI_* name and we need to add alias to the real name.
 282    There is no reason to use hidden_weak over hidden_def in assembly,
 283    but we provide it for consistency with the C usage.
 284    hidden_proto doesn't make sense for assembly but the equivalent
 285    is to call via the HIDDEN_JUMPTARGET macro instead of JUMPTARGET.  */
 286 #  define hidden_def(name)      hidden_strong_alias (name, __GI_##name)
 287 #  define hidden_data_def(name) hidden_strong_alias (name, __GI_##name)
 288 #  define hidden_weak(name)     hidden_def (name)
 289 #  define hidden_data_weak(name)        hidden_data_def (name)
 290 #  define HIDDEN_JUMPTARGET(name) __GI_##name
 291 # endif /* __ASSEMBLER__ */
 292 #else /* SHARED */
 293 # define hidden_strong_alias(name, aliasname)
 294 # define hidden_weak_alias(name, aliasname)
 295
 296 # ifndef __ASSEMBLER__
 297 #  define hidden_proto(name, attrs...)
 298 # else
 299 #  define HIDDEN_JUMPTARGET(name) name
 300 # endif
 301 # define hidden_def(name)
 302 # define hidden_data_def(name)
 303 # define hidden_weak(name)
 304 # define hidden_data_weak(name)
 305 #endif /* SHARED */
 306
 307 /* uClibc does not support versioning yet. */
 308 #define versioned_symbol(lib, local, symbol, version) /* weak_alias(local, symbol) */
 309 #define hidden_ver(local, name) /* strong_alias(local, __GI_##name) */
 310 #define hidden_data_ver(local, name) /* strong_alias(local,__GI_##name) */
 311
 312 #if !defined NOT_IN_libc
 313 # define libc_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 314 # define libc_hidden_def(name) hidden_def (name)
 315 # define libc_hidden_weak(name) hidden_weak (name)
 316 # define libc_hidden_ver(local, name) hidden_ver (local, name)
 317 # define libc_hidden_data_def(name) hidden_data_def (name)
 318 # define libc_hidden_data_weak(name) hidden_data_weak (name)
 319 # define libc_hidden_data_ver(local, name) hidden_data_ver (local, name)
 320 #else
 321 # define libc_hidden_proto(name, attrs...)
 322 # define libc_hidden_def(name)
 323 # define libc_hidden_weak(name)
 324 # define libc_hidden_ver(local, name)
 325 # define libc_hidden_data_def(name)
 326 # define libc_hidden_data_weak(name)
 327 # define libc_hidden_data_ver(local, name)
 328 #endif
 329
 330 #if defined NOT_IN_libc && defined IS_IN_rtld
 331 # define rtld_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 332 # define rtld_hidden_def(name) hidden_def (name)
 333 # define rtld_hidden_weak(name) hidden_weak (name)
 334 # define rtld_hidden_ver(local, name) hidden_ver (local, name)
 335 # define rtld_hidden_data_def(name) hidden_data_def (name)
 336 # define rtld_hidden_data_weak(name) hidden_data_weak (name)
 337 # define rtld_hidden_data_ver(local, name) hidden_data_ver (local, name)
 338 #else
 339 # define rtld_hidden_proto(name, attrs...)
 340 # define rtld_hidden_def(name)
 341 # define rtld_hidden_weak(name)
 342 # define rtld_hidden_ver(local, name)
 343 # define rtld_hidden_data_def(name)
 344 # define rtld_hidden_data_weak(name)
 345 # define rtld_hidden_data_ver(local, name)
 346 #endif
 347
 348 #if defined NOT_IN_libc && defined IS_IN_libm
 349 # define libm_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 350 # define libm_hidden_def(name) hidden_def (name)
 351 # define libm_hidden_weak(name) hidden_weak (name)
 352 # define libm_hidden_ver(local, name) hidden_ver (local, name)
 353 # define libm_hidden_data_def(name) hidden_data_def (name)
 354 # define libm_hidden_data_weak(name) hidden_data_weak (name)
 355 # define libm_hidden_data_ver(local, name) hidden_data_ver (local, name)
 356 #else
 357 # define libm_hidden_proto(name, attrs...)
 358 # define libm_hidden_def(name)
 359 # define libm_hidden_weak(name)
 360 # define libm_hidden_ver(local, name)
 361 # define libm_hidden_data_def(name)
 362 # define libm_hidden_data_weak(name)
 363 # define libm_hidden_data_ver(local, name)
 364 #endif
 365
 366 #if defined NOT_IN_libc && defined IS_IN_libresolv
 367 # define libresolv_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 368 # define libresolv_hidden_def(name) hidden_def (name)
 369 # define libresolv_hidden_weak(name) hidden_weak (name)
 370 # define libresolv_hidden_ver(local, name) hidden_ver (local, name)
 371 # define libresolv_hidden_data_def(name) hidden_data_def (name)
 372 # define libresolv_hidden_data_weak(name) hidden_data_weak (name)
 373 # define libresolv_hidden_data_ver(local, name) hidden_data_ver (local, name)
 374 #else
 375 # define libresolv_hidden_proto(name, attrs...)
 376 # define libresolv_hidden_def(name)
 377 # define libresolv_hidden_weak(name)
 378 # define libresolv_hidden_ver(local, name)
 379 # define libresolv_hidden_data_def(name)
 380 # define libresolv_hidden_data_weak(name)
 381 # define libresolv_hidden_data_ver(local, name)
 382 #endif
 383
 384 #if defined NOT_IN_libc && defined IS_IN_librt
 385 # define librt_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 386 # define librt_hidden_def(name) hidden_def (name)
 387 # define librt_hidden_weak(name) hidden_weak (name)
 388 # define librt_hidden_ver(local, name) hidden_ver (local, name)
 389 # define librt_hidden_data_def(name) hidden_data_def (name)
 390 # define librt_hidden_data_weak(name) hidden_data_weak (name)
 391 # define librt_hidden_data_ver(local, name) hidden_data_ver (local, name)
 392 #else
 393 # define librt_hidden_proto(name, attrs...)
 394 # define librt_hidden_def(name)
 395 # define librt_hidden_weak(name)
 396 # define librt_hidden_ver(local, name)
 397 # define librt_hidden_data_def(name)
 398 # define librt_hidden_data_weak(name)
 399 # define librt_hidden_data_ver(local, name)
 400 #endif
 401
 402 #if defined NOT_IN_libc && defined IS_IN_libdl
 403 # define libdl_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 404 # define libdl_hidden_def(name) hidden_def (name)
 405 # define libdl_hidden_weak(name) hidden_weak (name)
 406 # define libdl_hidden_ver(local, name) hidden_ver (local, name)
 407 # define libdl_hidden_data_def(name) hidden_data_def (name)
 408 # define libdl_hidden_data_weak(name) hidden_data_weak (name)
 409 # define libdl_hidden_data_ver(local, name) hidden_data_ver (local, name)
 410 #else
 411 # define libdl_hidden_proto(name, attrs...)
 412 # define libdl_hidden_def(name)
 413 # define libdl_hidden_weak(name)
 414 # define libdl_hidden_ver(local, name)
 415 # define libdl_hidden_data_def(name)
 416 # define libdl_hidden_data_weak(name)
 417 # define libdl_hidden_data_ver(local, name)
 418 #endif
 419
 420 #if defined NOT_IN_libc && defined IS_IN_libintl
 421 # define libintl_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 422 # define libintl_hidden_def(name) hidden_def (name)
 423 # define libintl_hidden_weak(name) hidden_weak (name)
 424 # define libintl_hidden_ver(local, name) hidden_ver (local, name)
 425 # define libintl_hidden_data_def(name) hidden_data_def (name)
 426 # define libintl_hidden_data_weak(name) hidden_data_weak (name)
 427 # define libintl_hidden_data_ver(local, name) hidden_data_ver(local, name)
 428 #else
 429 # define libintl_hidden_proto(name, attrs...)
 430 # define libintl_hidden_def(name)
 431 # define libintl_hidden_weak(name)
 432 # define libintl_hidden_ver(local, name)
 433 # define libintl_hidden_data_def(name)
 434 # define libintl_hidden_data_weak(name)
 435 # define libintl_hidden_data_ver(local, name)
 436 #endif
 437
 438 #if defined NOT_IN_libc && defined IS_IN_libnsl
 439 # define libnsl_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 440 # define libnsl_hidden_def(name) hidden_def (name)
 441 # define libnsl_hidden_weak(name) hidden_weak (name)
 442 # define libnsl_hidden_ver(local, name) hidden_ver (local, name)
 443 # define libnsl_hidden_data_def(name) hidden_data_def (name)
 444 # define libnsl_hidden_data_weak(name) hidden_data_weak (name)
 445 # define libnsl_hidden_data_ver(local, name) hidden_data_ver (local, name)
 446 #else
 447 # define libnsl_hidden_proto(name, attrs...)
 448 # define libnsl_hidden_def(name)
 449 # define libnsl_hidden_weak(name)
 450 # define libnsl_hidden_ver(local, name)
 451 # define libnsl_hidden_data_def(name)
 452 # define libnsl_hidden_data_weak(name)
 453 # define libnsl_hidden_data_ver(local, name)
 454 #endif
 455
 456 #if defined NOT_IN_libc && defined IS_IN_libutil
 457 # define libutil_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 458 # define libutil_hidden_def(name) hidden_def (name)
 459 # define libutil_hidden_weak(name) hidden_weak (name)
 460 # define libutil_hidden_ver(local, name) hidden_ver (local, name)
 461 # define libutil_hidden_data_def(name) hidden_data_def (name)
 462 # define libutil_hidden_data_weak(name) hidden_data_weak (name)
 463 # define libutil_hidden_data_ver(local, name) hidden_data_ver (local, name)
 464 #else
 465 # define libutil_hidden_proto(name, attrs...)
 466 # define libutil_hidden_def(name)
 467 # define libutil_hidden_weak(name)
 468 # define libutil_hidden_ver(local, name)
 469 # define libutil_hidden_data_def(name)
 470 # define libutil_hidden_data_weak(name)
 471 # define libutil_hidden_data_ver(local, name)
 472 #endif
 473
 474 #if defined NOT_IN_libc && defined IS_IN_libcrypt
 475 # define libcrypt_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 476 # define libcrypt_hidden_def(name) hidden_def (name)
 477 # define libcrypt_hidden_weak(name) hidden_weak (name)
 478 # define libcrypt_hidden_ver(local, name) hidden_ver (local, name)
 479 # define libcrypt_hidden_data_def(name) hidden_data_def (name)
 480 # define libcrypt_hidden_data_weak(name) hidden_data_weak (name)
 481 # define libcrypt_hidden_data_ver(local, name) hidden_data_ver (local, name)
 482 #else
 483 # define libcrypt_hidden_proto(name, attrs...)
 484 # define libcrypt_hidden_def(name)
 485 # define libcrypt_hidden_weak(name)
 486 # define libcrypt_hidden_ver(local, name)
 487 # define libcrypt_hidden_data_def(name)
 488 # define libcrypt_hidden_data_weak(name)
 489 # define libcrypt_hidden_data_ver(local, name)
 490 #endif
 491
 492 #if defined NOT_IN_libc && defined IS_IN_libpthread
 493 # define libpthread_hidden_proto(name, attrs...) hidden_proto (name, ##attrs)
 494 # define libpthread_hidden_def(name) hidden_def (name)
 495 # define libpthread_hidden_weak(name) hidden_weak (name)
 496 # define libpthread_hidden_ver(local, name) hidden_ver (local, name)
 497 # define libpthread_hidden_data_def(name) hidden_data_def (name)
 498 # define libpthread_hidden_data_weak(name) hidden_data_weak (name)
 499 # define libpthread_hidden_data_ver(local, name) hidden_data_ver (local, name)
 500 #else
 501 # define libpthread_hidden_proto(name, attrs...)
 502 # define libpthread_hidden_def(name)
 503 # define libpthread_hidden_weak(name)
 504 # define libpthread_hidden_ver(local, name)
 505 # define libpthread_hidden_data_def(name)
 506 # define libpthread_hidden_data_weak(name)
 507 # define libpthread_hidden_data_ver(local, name)
 508 #endif
 509
 510 #ifdef __UCLIBC_BUILD_RELRO__
 511 # define attribute_relro __attribute__ ((section (".data.rel.ro")))
 512 #else
 513 # define attribute_relro
 514 #endif
 515
 516 #ifdef __GNUC__
 517 # define attribute_noreturn __attribute__ ((__noreturn__))
 518 #else
 519 # define attribute_noreturn
 520 #endif
 521
 522 #ifdef __UCLIBC_HAS_THREADS_NATIVE__
 523 # define attribute_tls_model_ie __attribute__ ((tls_model ("initial-exec")))
 524 #endif
 525
 526 /* Pull in things like __attribute_used__ */
 527 #include <sys/cdefs.h>
 528
 529 /* --- this is added to integrate linuxthreads */
 530 #define __USE_UNIX98            1
 531
 532 #ifndef __ASSEMBLER__
 533 # ifdef IS_IN_libc
 534
 535 #  define __need_size_t
 536 #  include <stddef.h>
 537
 538 /* sources are built w/ _GNU_SOURCE, this gets undefined */
 539 extern int __xpg_strerror_r (int __errnum, char *__buf, size_t __buflen);
 540 //extern char *__glibc_strerror_r (int __errnum, char *__buf, size_t __buflen);
 541
 542 /* #include <pthread.h> */
 543 #  ifndef __UCLIBC_HAS_THREADS__
 544 #   define __pthread_mutex_init(mutex, mutexattr)         ((void)0)
 545 #   define __pthread_mutex_lock(mutex)                    ((void)0)
 546 #   define __pthread_mutex_trylock(mutex)                 ((void)0)
 547 #   define __pthread_mutex_unlock(mutex)                  ((void)0)
 548 #  endif
 549
 550 /* internal access to program name */
 551 extern const char *__uclibc_progname attribute_hidden;
 552
 553 # endif /* IS_IN_libc */
 554
 555 /* #include <alloca.h> */
 556 #include <bits/stackinfo.h>
 557 #if _STACK_GROWS_DOWN
 558 # define extend_alloca(buf, len, newlen) \
 559   (__typeof (buf)) ({ size_t __newlen = (newlen);                             \
 560                       char *__newbuf = alloca (__newlen);                     \
 561                       if (__newbuf + __newlen == (char *) buf)                \
 562                         len += __newlen;                                      \
 563                       else                                                    \
 564                         len = __newlen;                                       \
 565                       __newbuf; })
 566 #elif _STACK_GROWS_UP
 567 # define extend_alloca(buf, len, newlen) \
 568   (__typeof (buf)) ({ size_t __newlen = (newlen);                             \
 569                       char *__newbuf = alloca (__newlen);                     \
 570                       char *__buf = (buf);                                    \
 571                       if (__buf + __newlen == __newbuf)                       \
 572                         {                                                     \
 573                           len += __newlen;                                    \
 574                           __newbuf = __buf;                                   \
 575                         }                                                     \
 576                       else                                                    \
 577                         len = __newlen;                                       \
 578                       __newbuf; })
 579 #else
 580 # warning unknown stack
 581 # define extend_alloca(buf, len, newlen) \
 582   alloca (((len) = (newlen)))
 583 #endif
 584
 585 #endif /* __ASSEMBLER__ */
 586
 587 #endif /* _LIBC_INTERNAL_H */