(strong_alias): Define special version for HAVE_ASM_GLOBAL_DOT_NAME.
[kopensolaris-gnu/glibc.git] / include / libc-symbols.h
index dd573b3..06d5602 100644 (file)
@@ -1,6 +1,6 @@
 /* Support macros for making weak and strong aliases for symbols,
    and for using symbol sets and linker warnings with GNU ld.
-   Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
 # endif
 #endif
 
-
-/* Define ALIAS as a strong alias for ORIGINAL.  */
-#ifdef HAVE_ASM_SET_DIRECTIVE
-# define strong_alias_asm(original, alias)     \
-  ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias);  \
-  .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original)
-# ifdef __ASSEMBLER__
-#  define strong_alias(original, alias)        strong_alias_asm (original, alias)
-# else
-#  define strong_alias(original, alias)        \
-  asm (__string_1 (ASM_GLOBAL_DIRECTIVE) " " __SYMBOL_PREFIX #alias "\n" \
-       ".set " __SYMBOL_PREFIX #alias "," __SYMBOL_PREFIX #original);
-# endif
-#else
-# define strong_alias_asm(original, alias)     \
-  ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias);  \
-  C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original)
-# ifdef __ASSEMBLER__
-#  define strong_alias(original, alias)        strong_alias_asm (original, alias)
-# else
-#  define strong_alias(original, alias)        \
-  asm (__string_1 (ASM_GLOBAL_DIRECTIVE) " " __SYMBOL_PREFIX #alias "\n" \
-       __SYMBOL_PREFIX #alias " = " __SYMBOL_PREFIX #original);
-# endif
+#ifndef ASM_LINE_SEP
+# define ASM_LINE_SEP ;
 #endif
 
-/* Helper macros used above.  */
-#define __string_1(x) __string_0(x)
-#define __string_0(x) #x
+#ifndef __ASSEMBLER__
+/* GCC understands weak symbols and aliases; use its interface where
+   possible, instead of embedded assembly language.  */
+
+/* Define ALIASNAME as a strong alias for NAME.  */
+# define strong_alias(name, aliasname) _strong_alias(name, aliasname)
+# define _strong_alias(name, aliasname) \
+  extern __typeof (name) aliasname __attribute__ ((alias (#name)));
 
+/* This comes between the return type and function name in
+   a function definition to make that definition weak.  */
+# define weak_function __attribute__ ((weak))
+# define weak_const_function __attribute__ ((weak, __const__))
 
-#ifdef HAVE_WEAK_SYMBOLS
+# ifdef HAVE_WEAK_SYMBOLS
 
-# ifdef __ASSEMBLER__
+/* Define ALIASNAME as a weak alias for NAME.
+   If weak aliases are not available, this defines a strong alias.  */
+#  define weak_alias(name, aliasname) _weak_alias (name, aliasname)
+#  define _weak_alias(name, aliasname) \
+  extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
 
+/* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
+#  define weak_extern(symbol) _weak_extern (symbol)
 #  ifdef HAVE_ASM_WEAKEXT_DIRECTIVE
+#   define _weak_extern(symbol) asm (".weakext " __SYMBOL_PREFIX #symbol);
+#  else
+#   define _weak_extern(symbol)    asm (".weak " __SYMBOL_PREFIX #symbol);
+#  endif
 
-/* Define ALIAS as a weak alias for ORIGINAL.
-   If weak aliases are not available, this defines a strong alias.  */
+# else
+
+#  define weak_alias(name, aliasname) strong_alias(name, aliasname)
+#  define weak_extern(symbol) /* Nothing. */
+
+# endif
+
+#else /* __ASSEMBLER__ */
+
+# ifdef HAVE_ASM_SET_DIRECTIVE
+#  define strong_alias(original, alias)                \
+  ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP      \
+  .set C_SYMBOL_NAME (alias),C_SYMBOL_NAME (original)
+# else
+#  ifdef HAVE_ASM_GLOBAL_DOT_NAME
+#   define strong_alias(original, alias)       \
+  ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP      \
+  C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) ASM_LINE_SEP        \
+  ASM_GLOBAL_DIRECTIVE C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP  \
+  C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original)
+#  else
+#   define strong_alias(original, alias)       \
+  ASM_GLOBAL_DIRECTIVE C_SYMBOL_NAME (alias) ASM_LINE_SEP      \
+  C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original)
+#  endif
+# endif
+
+# ifdef HAVE_WEAK_SYMBOLS
+#  ifdef HAVE_ASM_WEAKEXT_DIRECTIVE
 #   define weak_alias(original, alias) \
   .weakext C_SYMBOL_NAME (alias), C_SYMBOL_NAME (original)
-
-/* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
 #   define weak_extern(symbol) \
   .weakext C_SYMBOL_NAME (symbol)
 
 #  else /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */
 
-/* Define ALIAS as a weak alias for ORIGINAL.
-   If weak aliases are not available, this defines a strong alias.  */
-#   define weak_alias(original, alias) \
-  .weak C_SYMBOL_NAME (alias); \
+#   ifdef HAVE_ASM_GLOBAL_DOT_NAME
+#    define weak_alias(original, alias)        \
+  .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP                     \
+  C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original) ASM_LINE_SEP        \
+  .weak C_SYMBOL_DOT_NAME (alias) ASM_LINE_SEP                 \
+  C_SYMBOL_DOT_NAME (alias) = C_SYMBOL_DOT_NAME (original)
+#   else
+#    define weak_alias(original, alias)        \
+  .weak C_SYMBOL_NAME (alias) ASM_LINE_SEP     \
   C_SYMBOL_NAME (alias) = C_SYMBOL_NAME (original)
+#   endif
 
-
-/* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
 #   define weak_extern(symbol) \
   .weak C_SYMBOL_NAME (symbol)
 
 #  endif /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */
 
-# else /* ! __ASSEMBLER__ */
+# else /* ! HAVE_WEAK_SYMBOLS */
 
-#  ifdef HAVE_ASM_WEAKEXT_DIRECTIVE
-#   define weak_extern_asm(symbol) asm (".weakext " __SYMBOL_PREFIX #symbol);
-#   define weak_alias_asm(original, alias) \
-  asm (".weakext " __SYMBOL_PREFIX #alias ", " __SYMBOL_PREFIX #original);
-#  else /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */
-#   define weak_extern_asm(symbol)     asm (".weak " __SYMBOL_PREFIX #symbol);
-#   define weak_alias_asm(original, alias) \
-  asm (".weak " __SYMBOL_PREFIX #alias "\n" \
-       __SYMBOL_PREFIX #alias " = " __SYMBOL_PREFIX #original);
-#  endif /* ! HAVE_ASM_WEAKEXT_DIRECTIVE */
-
-#  define weak_alias(o, a) weak_alias_asm (o, a)
-#  define weak_extern(symbol) weak_extern_asm (symbol)
+#  define weak_alias(original, alias) strong_alias(original, alias)
+#  define weak_extern(symbol) /* Nothing */
+# endif /* ! HAVE_WEAK_SYMBOLS */
 
-# endif /* ! __ASSEMBLER__ */
-#else
-# define weak_alias(original, alias) strong_alias(original, alias)
-# define weak_extern(symbol)   /* Do nothing; the ref will be strong.  */
-#endif
-
-
-#if (!defined __ASSEMBLER__ && \
-     (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)))
-/* GCC 2.7 and later has special syntax for weak symbols and aliases.
-   Using that is better when possible, because the compiler and assembler
-   are better clued in to what we are doing.  */
-# undef        strong_alias
-# define strong_alias(name, aliasname) \
-  extern __typeof (name) aliasname __attribute__ ((alias (#name)));
-
-# ifdef HAVE_WEAK_SYMBOLS
-#  undef weak_alias
-#  define weak_alias(name, aliasname) \
-  extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
-
-/* This comes between the return type and function name in
-   a function definition to make that definition weak.  */
-#  define weak_function __attribute__ ((weak))
-#  define weak_const_function __attribute__ ((weak, __const__))
-
-# endif        /* HAVE_WEAK_SYMBOLS.  */
-#endif /* Not __ASSEMBLER__, and GCC 2.7 or later.  */
-
-
-#ifndef weak_function
-/* If we do not have the __attribute__ ((weak)) syntax, there is no way we
-   can define functions as weak symbols.  The compiler will emit a `.globl'
-   directive for the function symbol, and a `.weak' directive in addition
-   will produce an error from the assembler.  */
-# define weak_function         /* empty */
-# define weak_const_function   /* empty */
-#endif
+#endif /* __ASSEMBLER__ */
 
 /* On some platforms we can make internal function calls (i.e., calls of
    functions not exported) a bit faster by using a different calling
 # define __builtin_expect(expr, val) (expr)
 #endif
 
+/* Determine the return address.  */
+#define RETURN_ADDRESS(nr) \
+  __builtin_extract_return_addr (__builtin_return_address (nr))
+
 /* When a reference to SYMBOL is encountered, the linker will emit a
    warning message MSG.  */
 #ifdef HAVE_GNU_LD
 /* We want the .gnu.warning.SYMBOL section to be unallocated.  */
 #  ifdef HAVE_ASM_PREVIOUS_DIRECTIVE
 #   define __make_section_unallocated(section_string)  \
-  asm(".section " section_string "; .previous");
-#  elif defined (HAVE_ASM_POPSECTION_DIRECTIVE)
+  asm (".section " section_string "\n\t.previous");
+#  elif defined HAVE_ASM_POPSECTION_DIRECTIVE
 #   define __make_section_unallocated(section_string)  \
-  asm(".pushsection " section_string "; .popsection");
+  asm (".pushsection " section_string "\n\t.popsection");
 #  else
 #   define __make_section_unallocated(section_string)
 #  endif
 
-#  define link_warning(symbol, msg)                    \
-  __make_section_unallocated (".gnu.warning." #symbol) \
+/* Tacking on "\n\t#" to the section name makes gcc put it's bogus
+   section attributes on what looks like a comment to the assembler.  */
+#  ifdef HAVE_SECTION_QUOTES
+#   define link_warning(symbol, msg) \
+  __make_section_unallocated (".gnu.warning." #symbol) \
   static const char __evoke_link_warning_##symbol[]    \
-    __attribute__ ((section (".gnu.warning." #symbol))) = msg;
+    __attribute__ ((section (".gnu.warning." #symbol "\"\n\t#\""))) = msg;
+#  else
+#   define link_warning(symbol, msg) \
+  __make_section_unallocated (".gnu.warning." #symbol) \
+  static const char __evoke_link_warning_##symbol[]    \
+    __attribute__ ((section (".gnu.warning." #symbol "\n\t#"))) = msg;
+#  endif
 # else
 #  define link_warning(symbol, msg)            \
-  asm(".stabs \"" msg "\",30,0,0,0\n"  \
-      ".stabs \"" __SYMBOL_PREFIX #symbol "\",1,0,0,0\n");
+  asm (".stabs \"" msg "\",30,0,0,0\n\t"       \
+       ".stabs \"" __SYMBOL_PREFIX #symbol "\",1,0,0,0\n");
 # endif
 #else
 /* We will never be heard; they will all die horribly.  */
 
 /* These are all done the same way in ELF.
    There is a new section created for each set.  */
-#  ifdef PIC
+#  ifdef SHARED
 /* When building a shared library, make the set section writable,
    because it will need to be relocated at run time anyway.  */
 #   define _elf_set_element(set, symbol) \
 # else /* Not ELF: a.out.  */
 
 #  define text_set_element(set, symbol)        \
-  asm(".stabs \"" __SYMBOL_PREFIX #set "\",23,0,0," __SYMBOL_PREFIX #symbol)
+  asm (".stabs \"" __SYMBOL_PREFIX #set "\",23,0,0," __SYMBOL_PREFIX #symbol)
 #  define data_set_element(set, symbol)        \
-  asm(".stabs \"" __SYMBOL_PREFIX #set "\",25,0,0," __SYMBOL_PREFIX #symbol)
+  asm (".stabs \"" __SYMBOL_PREFIX #set "\",25,0,0," __SYMBOL_PREFIX #symbol)
 #  define bss_set_element(set, symbol) ?error Must use initialized data.
 #  define symbol_set_define(set)       void *const (set)[1];
 #  define symbol_set_declare(set)      extern void *const (set)[1];
 #endif /* Have GNU ld.  */
 
 #if DO_VERSIONING
+# define symbol_version(real, name, version) \
+     _symbol_version(real, name, version)
+# define default_symbol_version(real, name, version) \
+     _default_symbol_version(real, name, version)
 # ifdef __ASSEMBLER__
-#  define symbol_version(real, name, version) \
+#  define _symbol_version(real, name, version) \
      .symver real, name##@##version
-#  define default_symbol_version(real, name, version) \
+#  define _default_symbol_version(real, name, version) \
      .symver real, name##@##@##version
 # else
-#  define symbol_version(real, name, version) \
+#  define _symbol_version(real, name, version) \
      __asm__ (".symver " #real "," #name "@" #version)
-#  define default_symbol_version(real, name, version) \
+#  define _default_symbol_version(real, name, version) \
      __asm__ (".symver " #real "," #name "@@" #version)
 # endif
 #else