* elf/Versions: Remove functions which are not exported anymore.
* dlfcn/dlerror.c: Call ld.so functions through GLSO.
* dlfcn/dlinfo.c: Likewise.
* elf/dl-close.c: Likewise.
* elf/dl-libc.c: Likewise.
* elf/dl-open.c: Likewise.
* elf/dl-sym.c: Likewise.
* sysdeps/generic/libc-start.c: Likewise.
* elf/dl-debug.c: Remove *_internal definition. Don't use INTUSE for
functions which are not exported anymore.
* elf/dl-deps.c: Likewise.
* elf/dl-dst.h: Likewise.
* elf/dl-error.c: Likewise.
* elf/dl-fini.c: Likewise.
* elf/dl-init.c: Likewise.
* elf/dl-load.c: Likewise.
* elf/dl-lookup.c: Likewise.
* elf/dl-misc.c: Likewise.
* elf/dl-profile.c: Likewise.
* elf/dl-profstub.c: Likewise.
* elf/dl-reloc.c: Likewise.
* elf/dl-runtime.c: Likewise.
* elf/dl-version.c: Likewise.
* elf/do-lookup.h: Likewise.
* include/dlfcn.h: Likewise.
* sysdeps/generic/dl-cache.c: Likewise.
* sysdeps/generic/dl-fptr.c: Likewise.
* sysdeps/generic/dl-origin.c: Likewise.
* sysdeps/generic/dl-sysdep.c: Likewise.
* sysdeps/generic/dl-tls.c: Likewise.
* sysdeps/generic/ldsodefs.h: Likewise.
* sysdeps/i386/dl-tls.h: Likewise.
* sysdeps/unix/sysv/linux/dl-origin.c: Likewise.
* elf/rtld.c: Likewise. Export function though _rtld_global_ro.
* generic/dl-fptr.c: Likewise.
* mach/hurd/dl-sysdep.c: Likewise.
* unix/sysv/linux/ia64/dl-static.c: Likewise.
* unix/sysv/linux/ia64/getpagesize.c: Likewise.
* unix/sysv/linux/m68k/getpagesize.c: Likewise.
* unix/sysv/linux/sparc/sparc32/getpagesize.c: Likewise.
2004-03-05 Ulrich Drepper <drepper@redhat.com>
+ * elf/Versions: Remove functions which are not exported anymore.
+ * dlfcn/dlerror.c: Call ld.so functions through GLSO.
+ * dlfcn/dlinfo.c: Likewise.
+ * elf/dl-close.c: Likewise.
+ * elf/dl-libc.c: Likewise.
+ * elf/dl-open.c: Likewise.
+ * elf/dl-sym.c: Likewise.
+ * sysdeps/generic/libc-start.c: Likewise.
+ * elf/dl-debug.c: Remove *_internal definition. Don't use INTUSE for
+ functions which are not exported anymore.
+ * elf/dl-deps.c: Likewise.
+ * elf/dl-dst.h: Likewise.
+ * elf/dl-error.c: Likewise.
+ * elf/dl-fini.c: Likewise.
+ * elf/dl-init.c: Likewise.
+ * elf/dl-load.c: Likewise.
+ * elf/dl-lookup.c: Likewise.
+ * elf/dl-misc.c: Likewise.
+ * elf/dl-profile.c: Likewise.
+ * elf/dl-profstub.c: Likewise.
+ * elf/dl-reloc.c: Likewise.
+ * elf/dl-runtime.c: Likewise.
+ * elf/dl-version.c: Likewise.
+ * elf/do-lookup.h: Likewise.
+ * include/dlfcn.h: Likewise.
+ * sysdeps/generic/dl-cache.c: Likewise.
+ * sysdeps/generic/dl-fptr.c: Likewise.
+ * sysdeps/generic/dl-origin.c: Likewise.
+ * sysdeps/generic/dl-sysdep.c: Likewise.
+ * sysdeps/generic/dl-tls.c: Likewise.
+ * sysdeps/generic/ldsodefs.h: Likewise.
+ * sysdeps/i386/dl-tls.h: Likewise.
+ * sysdeps/unix/sysv/linux/dl-origin.c: Likewise.
+ * elf/rtld.c: Likewise. Export function though _rtld_global_ro.
+
* sysdeps/generic/ldsodefs.h (struct rtld_global): Move
dl_debug_fd to rtld_global_ro.
* elf/rtld.c: Use GLRO instead of GL for dl_debug_fd.
* sysdeps/ia64/dl-machine.h: Likewise.
* sysdeps/arm/dl-machine.h: Likewise.
* sysdeps/alpha/dl-machine.h: Likewise.
+ * generic/dl-fptr.c: Likewise.
+ * mach/hurd/dl-sysdep.c: Likewise.
+ * unix/sysv/linux/ia64/dl-static.c: Likewise.
+ * unix/sysv/linux/ia64/getpagesize.c: Likewise.
+ * unix/sysv/linux/m68k/getpagesize.c: Likewise.
+ * unix/sysv/linux/sparc/sparc32/getpagesize.c: Likewise.
2004-03-04 Ulrich Drepper <drepper@redhat.com>
/* Return error detail for failing <dlfcn.h> functions.
- Copyright (C) 1995,1996,1997,1998,1999,2000,2002,2003
- Free Software Foundation, Inc.
+ Copyright (C) 1995-2000,2002,2003,2004 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
#include <stdlib.h>
#include <string.h>
#include <bits/libc-lock.h>
+#include <ldsodefs.h>
/* Type for storing results of dynamic loading actions. */
struct dl_action_result
result->errstring = NULL;
}
- result->errcode = _dl_catch_error (&result->objname, &result->errstring,
- operate, args);
+ result->errcode = GLRO(dl_catch_error) (&result->objname, &result->errstring,
+ operate, args);
/* If no error we mark that no error string is available. */
result->returned = result->errstring == NULL;
/* dlinfo -- Get information from the dynamic linker.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004 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
break;
if (l == NULL)
- _dl_signal_error (0, NULL, NULL, N_("\
+ GLRO(dl_signal_error) (0, NULL, NULL, N_("\
RTLD_SELF used in code not dynamically loaded"));
}
#endif
case RTLD_DI_LMID:
case RTLD_DI_CONFIGADDR:
default:
- _dl_signal_error (0, NULL, NULL, N_("unsupported dlinfo request"));
+ GLRO(dl_signal_error) (0, NULL, NULL, N_("unsupported dlinfo request"));
break;
case RTLD_DI_LINKMAP:
GLIBC_PRIVATE {
# Those are in the dynamic linker, but used by libc.so.
__libc_enable_secure;
- _dl_argv; _dl_catch_error; _dl_check_map_versions;
- _dl_debug_printf; _dl_debug_state; _dl_dst_count;
- _dl_dst_substitute; _dl_init; _dl_lookup_symbol; _dl_lookup_symbol_skip;
- _dl_lookup_versioned_symbol; _dl_lookup_versioned_symbol_skip;
- _dl_map_object; _dl_map_object_deps; _dl_out_of_memory;
- _dl_relocate_object; _dl_signal_error; _dl_start_profile; _dl_starting_up;
- _dl_unload_cache;
+ _dl_argv;
+ _dl_out_of_memory;
+ _dl_starting_up;
_rtld_global; _rtld_global_ro;
- _dl_tls_symaddr; _dl_allocate_tls; _dl_deallocate_tls;
+ _dl_allocate_tls; _dl_deallocate_tls;
_dl_get_tls_static_info; _dl_allocate_tls_init;
- _dl_get_origin; _dl_tls_setup; _dl_rtld_di_serinfo;
+ _dl_tls_setup; _dl_rtld_di_serinfo;
_dl_make_stack_executable;
}
}
return;
if (__builtin_expect (map->l_opencount, 1) == 0)
- _dl_signal_error (0, map->l_name, NULL, N_("shared object not open"));
+ GLRO(dl_signal_error) (0, map->l_name, NULL, N_("shared object not open"));
/* Acquire the lock. */
__rtld_lock_lock_recursive (GL(dl_load_lock));
{
/* There are still references to this object. Do nothing more. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- _dl_debug_printf ("\nclosing file=%s; opencount == %u\n",
- map->l_name, map->l_opencount);
+ GLRO(dl_debug_printf) ("\nclosing file=%s; opencount == %u\n",
+ map->l_name, map->l_opencount);
/* Decrement the object's reference counter, not the dependencies'. */
--map->l_opencount;
{
/* When debugging print a message first. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- _dl_debug_printf ("\ncalling fini: %s\n\n", imap->l_name);
+ GLRO(dl_debug_printf) ("\ncalling fini: %s\n\n", imap->l_name);
/* Call its termination function. Do not do it for
half-cooked objects. */
/* Notify the debugger we are about to remove some loaded objects. */
_r_debug.r_state = RT_DELETE;
- _dl_debug_state ();
+ GLRO(dl_debug_state) ();
#ifdef USE_TLS
size_t tls_free_start;
/* Notify the debugger those objects are finalized and gone. */
_r_debug.r_state = RT_CONSISTENT;
- _dl_debug_state ();
+ GLRO(dl_debug_state) ();
/* Now we can perhaps also remove the modules for which we had
dependencies because of symbol lookup. */
/* Communicate dynamic linker state to the debugger at runtime.
- Copyright (C) 1996, 1998, 2000, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 2000, 2002, 2004 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
_r_debug.r_version = 1 /* R_DEBUG_VERSION XXX */;
_r_debug.r_ldbase = ldbase;
_r_debug.r_map = GL(dl_loaded);
- _r_debug.r_brk = (ElfW(Addr)) &INTUSE(_dl_debug_state);
+ _r_debug.r_brk = (ElfW(Addr)) &_dl_debug_state;
}
return &_r_debug;
_dl_debug_state (void)
{
}
-INTDEF (_dl_debug_state)
{
struct openaux_args *args = (struct openaux_args *) a;
- args->aux = INTUSE(_dl_map_object) (args->map, args->name, 0,
- (args->map->l_type == lt_executable
- ? lt_library : args->map->l_type),
- args->trace_mode, args->open_mode);
+ args->aux = _dl_map_object (args->map, args->name, 0,
+ (args->map->l_type == lt_executable
+ ? lt_library : args->map->l_type),
+ args->trace_mode, args->open_mode);
}
static ptrdiff_t
\
/* DST must not appear in SUID/SGID programs. */ \
if (INTUSE(__libc_enable_secure)) \
- INTUSE(_dl_signal_error) (0, __str, NULL, N_("\
+ _dl_signal_error (0, __str, NULL, N_("\
DST not allowed in SUID/SGID programs")); \
\
__newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str), \
__cnt)); \
\
- __result = INTUSE(_dl_dst_substitute) (l, __str, __newp, 0); \
+ __result = _dl_dst_substitute (l, __str, __newp, 0); \
\
if (*__result == '\0') \
{ \
/* The replacement for the DST is not known. We can't \
processed. */ \
if (fatal) \
- INTUSE(_dl_signal_error) (0, __str, NULL, N_("\
+ _dl_signal_error (0, __str, NULL, N_("\
empty dynamics string token substitution")); \
else \
{ \
/* This is for DT_AUXILIARY. */ \
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))\
- INTUSE(_dl_debug_printf) (N_("\
+ _dl_debug_printf (N_("\
cannot load auxiliary `%s' because of empty dynamic string token " \
"substitution\n"), __str); \
continue; \
/* Store the tag in the argument structure. */
args.name = name;
- err = INTUSE(_dl_catch_error) (&objname, &errstring, openaux,
- &args);
+ err = _dl_catch_error (&objname, &errstring, openaux, &args);
if (__builtin_expect (errstring != NULL, 0))
{
if (err)
/* Say that we are about to load an auxiliary library. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS,
0))
- INTUSE(_dl_debug_printf) ("load auxiliary object=%s"
- " requested by file=%s\n",
- name,
- l->l_name[0]
- ? l->l_name : rtld_progname);
+ _dl_debug_printf ("load auxiliary object=%s"
+ " requested by file=%s\n",
+ name,
+ l->l_name[0]
+ ? l->l_name : rtld_progname);
/* We must be prepared that the addressed shared
object is not available. */
- err = INTUSE(_dl_catch_error) (&objname, &errstring,
- openaux, &args);
+ err = _dl_catch_error (&objname, &errstring, openaux,
+ &args);
if (__builtin_expect (errstring != NULL, 0))
{
/* We are not interested in the error message. */
/* Say that we are about to load an auxiliary library. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS,
0))
- INTUSE(_dl_debug_printf) ("load filtered object=%s"
- " requested by file=%s\n",
- name,
- l->l_name[0]
- ? l->l_name : rtld_progname);
+ _dl_debug_printf ("load filtered object=%s"
+ " requested by file=%s\n",
+ name,
+ l->l_name[0]
+ ? l->l_name : rtld_progname);
/* For filter objects the dependency must be available. */
- err = INTUSE(_dl_catch_error) (&objname, &errstring,
- openaux, &args);
+ err = _dl_catch_error (&objname, &errstring, openaux,
+ &args);
if (__builtin_expect (errstring != NULL, 0))
{
if (err)
l->l_initfini = (struct link_map **)
malloc ((2 * nneeded + 1) * sizeof needed[0]);
if (l->l_initfini == NULL)
- INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL,
- N_("cannot allocate dependency list"));
+ _dl_signal_error (ENOMEM, map->l_name, NULL,
+ N_("cannot allocate dependency list"));
l->l_initfini[0] = l;
memcpy (&l->l_initfini[1], needed, nneeded * sizeof needed[0]);
memcpy (&l->l_initfini[nneeded + 1], l->l_initfini,
(struct link_map **) malloc ((2 * nlist + 1)
* sizeof (struct link_map *));
if (map->l_initfini == NULL)
- INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL,
- N_("cannot allocate symbol search list"));
+ _dl_signal_error (ENOMEM, map->l_name, NULL,
+ N_("cannot allocate symbol search list"));
map->l_searchlist.r_list = &map->l_initfini[nlist + 1];
/* As current DT_AUXILIARY/DT_FILTER implementation needs to be
rewritten, no need to bother with prelinking the old
implementation. */
- INTUSE(_dl_signal_error) (EINVAL, l->l_name, NULL, N_("\
+ _dl_signal_error (EINVAL, l->l_name, NULL, N_("\
Filters not supported with LD_TRACE_PRELINKING"));
}
+ (cnt
* sizeof (struct link_map *)));
if (l->l_local_scope[0] == NULL)
- INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL,
- N_("cannot allocate symbol search list"));
+ _dl_signal_error (ENOMEM, map->l_name, NULL,
+ N_("cannot allocate symbol search list"));
l->l_local_scope[0]->r_nlist = cnt;
l->l_local_scope[0]->r_list =
(struct link_map **) (l->l_local_scope[0] + 1);
map->l_initfini[nlist] = NULL;
if (errno_reason)
- INTUSE(_dl_signal_error) (errno_reason == -1 ? 0 : errno_reason, objname,
- NULL, errstring);
+ _dl_signal_error (errno_reason == -1 ? 0 : errno_reason, objname,
+ NULL, errstring);
}
-INTDEF (_dl_map_object_deps)
const char *__sf = strchr (name, '$'); \
\
if (__builtin_expect (__sf != NULL, 0)) \
- __cnt = INTUSE(_dl_dst_count) (__sf, is_path); \
+ __cnt = _dl_dst_count (__sf, is_path); \
\
__cnt; })
-
-/* Prototype for used function. */
-extern size_t _dl_dst_count (const char *name, int is_path);
-extern size_t _dl_dst_count_internal (const char *name, int is_path);
+#ifndef IS_IN_rtld
+# define _dl_dst_count GLRO(dl_dst_count)
+#endif
/* Guess from the number of DSTs the length of the result string. */
\
__len; })
-/* Find origin of the executable. */
-extern const char *_dl_get_origin (void);
-extern const char *_dl_get_origin_internal (void);
-
-#ifdef IS_IN_rtld
-# define _dl_get_origin INTUSE(_dl_get_origin)
+#ifndef IS_IN_rtld
+# define _dl_get_origin GLRO(dl_get_origin)
+# define _dl_dst_substitute GLRO(dl_dst_substitute)
#endif
-
-/* Prototype for used function. */
-extern char *_dl_dst_substitute (struct link_map *l, const char *name,
- char *result, int is_path);
-extern char *_dl_dst_substitute_internal (struct link_map *l, const char *name,
- char *result, int is_path);
: ""));
}
}
-INTDEF (_dl_signal_error)
void
{
if (__builtin_expect (GLRO(dl_debug_mask)
& ~(DL_DEBUG_STATISTICS|DL_DEBUG_PRELINK), 0))
- INTUSE(_dl_debug_printf) ("%s: error: %s: %s (%s)\n", objname, occation,
- errstring, receiver ? "continued" : "fatal");
+ _dl_debug_printf ("%s: error: %s: %s (%s)\n", objname, occation,
+ errstring, receiver ? "continued" : "fatal");
if (receiver)
{
(*receiver) (errcode, objname, errstring);
}
else
- INTUSE(_dl_signal_error) (errcode, objname, occation, errstring);
+ _dl_signal_error (errcode, objname, occation, errstring);
}
*errstring = c.errstring;
return errcode == -1 ? 0 : errcode;
}
-INTDEF (_dl_catch_error)
void
/* When debugging print a message first. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- INTUSE(_dl_debug_printf) ("\ncalling fini: %s\n\n",
- l->l_name[0]
- ? l->l_name : rtld_progname);
+ _dl_debug_printf ("\ncalling fini: %s\n\n",
+ l->l_name[0] ? l->l_name : rtld_progname);
/* First see whether an array is given. */
if (l->l_info[DT_FINI_ARRAY] != NULL)
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
{
- INTUSE(_dl_debug_printf) ("\nruntime linker statistics:\n");
- INTUSE(_dl_debug_printf) ("\
+ _dl_debug_printf ("\nruntime linker statistics:\n");
+ _dl_debug_printf ("\
final number of relocations: %lu\n",
- GL(dl_num_relocations));
- INTUSE(_dl_debug_printf) ("\
+ GL(dl_num_relocations));
+ _dl_debug_printf ("\
final number of relocations from cache: %lu\n",
- GL(dl_num_cache_relocations));
+ GL(dl_num_cache_relocations));
}
}
/* Print a debug message if wanted. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- INTUSE(_dl_debug_printf) ("\ncalling init: %s\n\n",
- l->l_name[0] ? l->l_name : rtld_progname);
+ _dl_debug_printf ("\ncalling init: %s\n\n",
+ l->l_name[0] ? l->l_name : rtld_progname);
/* Now run the local constructors. There are two forms of them:
- the one named by DT_INIT
unsigned int cnt;
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- INTUSE(_dl_debug_printf) ("\ncalling preinit: %s\n\n",
- main_map->l_name[0]
- ? main_map->l_name : rtld_progname);
+ _dl_debug_printf ("\ncalling preinit: %s\n\n",
+ main_map->l_name[0]
+ ? main_map->l_name : rtld_progname);
addrs = (ElfW(Addr) *) (preinit_array->d_un.d_ptr + main_map->l_addr);
for (cnt = 0; cnt < i; ++cnt)
not been used before. */
r = _dl_debug_initialize (0);
r->r_state = RT_ADD;
- INTUSE(_dl_debug_state) ();
+ _dl_debug_state ();
/* Stupid users forced the ELF specification to be changed. It now
says that the dynamic loader is responsible for determining the
/* Notify the debugger all new objects are now ready to go. */
r->r_state = RT_CONSISTENT;
- INTUSE(_dl_debug_state) ();
+ _dl_debug_state ();
/* Finished starting up. */
INTUSE(_dl_starting_up) = 0;
/* Handle loading and unloading shared objects for internal libc purposes.
- Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Zack Weinberg <zack@rabi.columbia.edu>, 1999.
const char *last_errstring = NULL;
int result;
- (void) _dl_catch_error (&objname, &last_errstring, operate, args);
+ (void) GLRO(dl_catch_error) (&objname, &last_errstring, operate, args);
result = last_errstring != NULL;
if (result && last_errstring != _dl_out_of_memory)
{
struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
args->ref = NULL;
- args->loadbase = _dl_lookup_symbol (args->name, args->map, &args->ref,
- args->map->l_local_scope, 0,
- DL_LOOKUP_RETURN_NEWEST);
+ args->loadbase = GLRO(dl_lookup_symbol) (args->name, args->map, &args->ref,
+ args->map->l_local_scope, 0,
+ DL_LOOKUP_RETURN_NEWEST);
}
static void
struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
args->ref = NULL;
- l = _dl_lookup_versioned_symbol (args->name, args->map,
- &args->ref, args->map->l_scope,
- &vers, 0, 0);
+ l = GLRO(dl_lookup_versioned_symbol) (args->name, args->map,
+ &args->ref, args->map->l_scope,
+ &vers, 0, 0);
args->loadbase = l;
}
return cnt;
}
-INTDEF (_dl_dst_count)
char *
return result;
}
-INTDEF (_dl_dst_substitute)
/* Return copy of argument with all recognized dynamic string tokens
if (result == NULL)
return NULL;
- return INTUSE(_dl_dst_substitute) (l, s, result, 1);
+ return _dl_dst_substitute (l, s, result, 1);
}
if (newname == NULL)
{
/* No more memory. */
- INTUSE(_dl_signal_error) (ENOMEM, name, NULL,
- N_("cannot allocate name record"));
+ _dl_signal_error (ENOMEM, name, NULL, N_("cannot allocate name record"));
return;
}
/* The object should have a libname set from _dl_new_object. */
malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status)
+ where_len + len + 1);
if (dirp == NULL)
- INTUSE(_dl_signal_error) (ENOMEM, NULL, NULL,
- N_("cannot create cache for search path"));
+ _dl_signal_error (ENOMEM, NULL, NULL,
+ N_("cannot create cache for search path"));
dirp->dirname = ((char *) dirp + sizeof (*dirp)
+ ncapstr * sizeof (enum r_dir_status));
signal_error_cache:
errstring = N_("cannot create cache for search path");
signal_error:
- INTUSE(_dl_signal_error) (ENOMEM, NULL, NULL, errstring);
+ _dl_signal_error (ENOMEM, NULL, NULL, errstring);
}
sps->dirs = result;
{
errstring = N_("cannot create search path array");
signal_error:
- INTUSE(_dl_signal_error) (ENOMEM, NULL, NULL, errstring);
+ _dl_signal_error (ENOMEM, NULL, NULL, errstring);
}
round_size = ((2 * sizeof (struct r_search_path_elem) - 1
free (l);
}
free (realname);
- INTUSE(_dl_signal_error) (code, name, NULL, msg);
+ _dl_signal_error (code, name, NULL, msg);
}
/* Print debugging message. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- INTUSE(_dl_debug_printf) ("file=%s; generating link map\n", name);
+ _dl_debug_printf ("file=%s; generating link map\n", name);
/* This is the ELF header. We read it in `open_verify'. */
header = (void *) fbp->buf;
if (_dl_zerofd == -1)
{
__close (fd);
- INTUSE(_dl_signal_error) (errno, NULL, NULL,
- N_("cannot open zero fill device"));
+ _dl_signal_error (errno, NULL, NULL,
+ N_("cannot open zero fill device"));
}
}
#endif
l->l_entry += l->l_addr;
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- INTUSE(_dl_debug_printf) ("\
+ _dl_debug_printf ("\
dynamic: 0x%0*lx base: 0x%0*lx size: 0x%0*Zx\n\
entry: 0x%0*lx phdr: 0x%0*lx phnum: %*u\n\n",
(int) sizeof (void *) * 2,
char buf[max_dirnamelen + max_capstrlen];
int first = 1;
- INTUSE(_dl_debug_printf) (" search path=");
+ _dl_debug_printf (" search path=");
while (*list != NULL && (*list)->what == what) /* Yes, ==. */
{
/* Print name we try if this is wanted. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
- INTUSE(_dl_debug_printf) (" trying file=%s\n", buf);
+ _dl_debug_printf (" trying file=%s\n", buf);
fd = open_verify (buf, fbp);
if (this_dir->status[cnt] == unknown)
/* Display information if we are debugging. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0)
&& loader != NULL)
- INTUSE(_dl_debug_printf) ("\nfile=%s; needed by %s\n", name,
+ _dl_debug_printf ("\nfile=%s; needed by %s\n", name,
loader->l_name[0]
? loader->l_name : rtld_progname);
size_t namelen = strlen (name) + 1;
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
- INTUSE(_dl_debug_printf) ("find library=%s; searching\n", name);
+ _dl_debug_printf ("find library=%s; searching\n", name);
fd = -1;
/* Add another newline when we are tracing the library loading. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
- INTUSE(_dl_debug_printf) ("\n");
+ _dl_debug_printf ("\n");
}
else
{
/* Enter the new object in the list of loaded objects. */
if ((name_copy = local_strdup (name)) == NULL
|| (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
- INTUSE(_dl_signal_error) (ENOMEM, name, NULL, N_("\
-cannot create shared object descriptor"));
+ _dl_signal_error (ENOMEM, name, NULL,
+ N_("cannot create shared object descriptor"));
/* Signal that this is a faked entry. */
l->l_faked = 1;
/* Since the descriptor is initialized with zero we do not
return l;
}
else
- INTUSE(_dl_signal_error) (errno, name, NULL,
- N_("cannot open shared object file"));
+ _dl_signal_error (errno, name, NULL,
+ N_("cannot open shared object file"));
}
void *stack_end = __libc_stack_end;
return _dl_map_object_from_fd (name, fd, &fb, realname, loader, type, mode,
&stack_end);
}
-INTDEF (_dl_map_object)
+
void
internal_function
/* Display information if we are debugging. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- INTUSE(_dl_debug_printf) ("\
+ _dl_debug_printf ("\
\nfile=%s; needed by %s (relocation dependency)\n\n",
- map->l_name[0] ? map->l_name : rtld_progname,
- undef_map->l_name[0]
- ? undef_map->l_name : rtld_progname);
+ map->l_name[0] ? map->l_name : rtld_progname,
+ undef_map->l_name[0]
+ ? undef_map->l_name : rtld_progname);
}
else
/* Whoa, that was bad luck. We have to search again. */
&& add_dependency (undef_map, current_value.m) < 0)
/* Something went wrong. Perhaps the object we tried to reference
was just removed. Try finding another definition. */
- return INTUSE(_dl_lookup_symbol) (undef_name, undef_map, ref,
- symbol_scope, type_class, flags);
+ return _dl_lookup_symbol (undef_name, undef_map, ref, symbol_scope,
+ type_class, flags);
if (__builtin_expect (GLRO(dl_debug_mask)
& (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK), 0))
*ref = current_value.s;
return LOOKUP_VALUE (current_value.m);
}
-INTDEF (_dl_lookup_symbol)
/* This function is nearly the same as `_dl_lookup_symbol' but it
/* This function works like _dl_lookup_symbol but it takes an
- additional arguement with the version number of the requested
- symbol.
+ additional argument with the version number of the requested symbol.
XXX We'll see whether we need this separate function. */
lookup_t
&& add_dependency (undef_map, current_value.m) < 0)
/* Something went wrong. Perhaps the object we tried to reference
was just removed. Try finding another definition. */
- return INTUSE(_dl_lookup_versioned_symbol) (undef_name, undef_map,
- ref, symbol_scope,
- version, type_class, flags);
+ return _dl_lookup_versioned_symbol (undef_name, undef_map, ref,
+ symbol_scope, version, type_class,
+ flags);
if (__builtin_expect (GLRO(dl_debug_mask)
& (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK), 0))
*ref = current_value.s;
return LOOKUP_VALUE (current_value.m);
}
-INTDEF (_dl_lookup_versioned_symbol)
/* Similar to _dl_lookup_symbol_skip but takes an additional argument
if (GLRO(dl_debug_mask) & DL_DEBUG_BINDINGS)
{
- INTUSE(_dl_debug_printf) ("binding file %s to %s: %s symbol `%s'",
- (reference_name[0]
- ? reference_name
- : (rtld_progname ?: "<main program>")),
- value->m->l_name[0]
- ? value->m->l_name : rtld_progname,
- protected ? "protected" : "normal",
- undef_name);
+ _dl_debug_printf ("binding file %s to %s: %s symbol `%s'",
+ (reference_name[0]
+ ? reference_name
+ : (rtld_progname ?: "<main program>")),
+ value->m->l_name[0] ? value->m->l_name : rtld_progname,
+ protected ? "protected" : "normal", undef_name);
if (version)
_dl_debug_printf_c (" [%s]\n", version->name);
else
_dl_debug_vdprintf (GLRO(dl_debug_fd), 1, fmt, arg);
va_end (arg);
}
-INTDEF(_dl_debug_printf)
/* Write to debug file but don't start with a tag. */
{
GL(dl_global_scope_alloc) = 0;
nomem:
- _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
- N_("cannot extend global scope"));
+ GLRO(dl_signal_error) (ENOMEM, new->l_libname->name, NULL,
+ N_("cannot extend global scope"));
return 1;
}
#ifdef SHARED
/* Check whether _dl_open() has been called from a valid DSO. */
if (check_libc_caller (args->caller_dl_open) != 0)
- _dl_signal_error (0, "dlopen", NULL, N_("invalid caller"));
+ GLRO(dl_signal_error) (0, "dlopen", NULL, N_("invalid caller"));
#endif
/* Maybe we have to expand a DST. */
/* DSTs must not appear in SUID/SGID programs. */
if (__libc_enable_secure)
/* This is an error. */
- _dl_signal_error (0, "dlopen", NULL,
- N_("DST not allowed in SUID/SGID programs"));
+ GLRO(dl_signal_error) (0, "dlopen", NULL,
+ N_("DST not allowed in SUID/SGID programs"));
/* We have to find out from which object the caller is calling. */
call_map = NULL;
/* If the substitution failed don't try to load. */
if (*new_file == '\0')
- _dl_signal_error (0, "dlopen", NULL,
- N_("empty dynamic string token substitution"));
+ GLRO(dl_signal_error) (0, "dlopen", NULL,
+ N_("empty dynamic string token substitution"));
/* Now we have a new file name. */
file = new_file;
}
/* Load the named object. */
- args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0, mode);
+ args->map = new = GLRO(dl_map_object) (NULL, file, 0, lt_loaded, 0, mode);
/* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
set and the object is not already loaded. */
{
/* Let the user know about the opencount. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- _dl_debug_printf ("opening file=%s; opencount == %u\n\n",
- new->l_name, new->l_opencount);
+ GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
+ new->l_name, new->l_opencount);
/* If the user requested the object to be in the global namespace
but it is not so far, add it now. */
}
/* Load that object's dependencies. */
- _dl_map_object_deps (new, NULL, 0, 0, mode & __RTLD_DLOPEN);
+ GLRO(dl_map_object_deps) (new, NULL, 0, 0, mode & __RTLD_DLOPEN);
/* So far, so good. Now check the versions. */
for (i = 0; i < new->l_searchlist.r_nlist; ++i)
if (new->l_searchlist.r_list[i]->l_versions == NULL)
- (void) _dl_check_map_versions (new->l_searchlist.r_list[i], 0, 0);
+ (void) GLRO(dl_check_map_versions) (new->l_searchlist.r_list[i], 0, 0);
#ifdef SCOPE_DEBUG
show_scope (new);
start the profiling. */
struct link_map *old_profile_map = GL(dl_profile_map);
- _dl_relocate_object (l, l->l_scope, 1, 1);
+ GLRO(dl_relocate_object) (l, l->l_scope, 1, 1);
if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
/* We must prepare the profiling. */
- _dl_start_profile (GL(dl_profile_map),
- GLRO(dl_profile_output));
+ GLRO(dl_start_profile) (GL(dl_profile_map),
+ GLRO(dl_profile_output));
}
else
#endif
- _dl_relocate_object (l, l->l_scope, lazy, 0);
+ GLRO(dl_relocate_object) (l, l->l_scope, lazy, 0);
}
if (l == new)
newp = (struct r_scope_elem **)
malloc (new_size * sizeof (struct r_scope_elem *));
if (newp == NULL)
- _dl_signal_error (ENOMEM, "dlopen", NULL,
- N_("cannot create scope list"));
+ GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
+ N_("cannot create scope list"));
imap->l_scope = memcpy (newp, imap->l_scope,
cnt * sizeof (imap->l_scope[0]));
}
realloc (imap->l_scope,
new_size * sizeof (struct r_scope_elem *));
if (newp == NULL)
- _dl_signal_error (ENOMEM, "dlopen", NULL,
- N_("cannot create scope list"));
+ GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
+ N_("cannot create scope list"));
imap->l_scope = newp;
}
generation. */
++GL(dl_tls_generation);
- _dl_signal_error (ENOMEM, "dlopen", NULL,
- N_("cannot create TLS data structures"));
+ GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL, N_("\
+cannot create TLS data structures"));
}
listp->len = TLS_SLOTINFO_SURPLUS;
#endif
/* Run the initializer functions of new objects. */
- _dl_init (new, __libc_argc, __libc_argv, __environ);
+ GLRO(dl_init) (new, __libc_argc, __libc_argv, __environ);
/* Now we can make the new map available in the global scope. */
if (mode & RTLD_GLOBAL)
/* Let the user know about the opencount. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
- _dl_debug_printf ("opening file=%s; opencount == %u\n\n",
- new->l_name, new->l_opencount);
+ GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
+ new->l_name, new->l_opencount);
}
if ((mode & RTLD_BINDING_MASK) == 0)
/* One of the flags must be set. */
- _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
+ GLRO(dl_signal_error) (EINVAL, file, NULL,
+ N_("invalid mode for dlopen()"));
/* Make sure we are alone. */
__rtld_lock_lock_recursive (GL(dl_load_lock));
args.caller_dlopen = caller_dlopen;
args.caller_dl_open = RETURN_ADDRESS (0);
args.map = NULL;
- errcode = _dl_catch_error (&objname, &errstring, dl_open_worker, &args);
+ errcode = GLRO(dl_catch_error) (&objname, &errstring, dl_open_worker, &args);
#ifndef MAP_COPY
/* We must munmap() the cache file. */
- _dl_unload_cache ();
+ GLRO(dl_unload_cache) ();
#endif
/* Release the lock. */
free ((char *) errstring);
/* Reraise the error. */
- _dl_signal_error (errcode, objname, NULL, local_errstring);
+ GLRO(dl_signal_error) (errcode, objname, NULL, local_errstring);
}
#ifndef SHARED
/* Turn on profiling. */
running = 1;
}
-INTDEF (_dl_start_profile)
void
/* Helper definitions for profiling of shared libraries.
- Copyright (C) 1998, 2000, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1998, 2000, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
/* This is the map for the shared object we profile. It is defined here
only because we test for this value being NULL or not. */
-//Xextern struct link_map *_dl_profile_map;
void
_dl_mcount_wrapper (void *selfpc)
{
- _dl_mcount ((ElfW(Addr)) RETURN_ADDRESS (0), (ElfW(Addr)) selfpc);
+ GLRO(dl_mcount) ((ElfW(Addr)) RETURN_ADDRESS (0), (ElfW(Addr)) selfpc);
}
_dl_mcount_wrapper_check (void *selfpc)
{
if (GL(dl_profile_map) != NULL)
- _dl_mcount ((ElfW(Addr)) RETURN_ADDRESS (0), (ElfW(Addr)) selfpc);
+ GLRO(dl_mcount) ((ElfW(Addr)) RETURN_ADDRESS (0), (ElfW(Addr)) selfpc);
}
libc_hidden_def (_dl_mcount_wrapper_check)
if (map->l_tls_align > GL(dl_tls_static_align))
{
fail:
- INTUSE(_dl_signal_error) (0, map->l_name, NULL, N_("\
+ _dl_signal_error (0, map->l_name, NULL, N_("\
cannot allocate memory in static TLS block"));
}
lazy = 0;
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
- INTUSE(_dl_debug_printf) ("\nrelocation processing: %s%s\n",
- l->l_name[0] ? l->l_name : rtld_progname,
- lazy ? " (lazy)" : "");
+ _dl_debug_printf ("\nrelocation processing: %s%s\n",
+ l->l_name[0] ? l->l_name : rtld_progname,
+ lazy ? " (lazy)" : "");
/* DT_TEXTREL is now in level 2 and might phase out at some time.
But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make
{
errstring = N_("cannot make segment writable for relocation");
call_error:
- INTUSE(_dl_signal_error) (errno, l->l_name, NULL, errstring);
+ _dl_signal_error (errno, l->l_name, NULL, errstring);
}
#if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
l->l_lookup_cache.type_class = _tc; \
l->l_lookup_cache.sym = (*ref); \
_lr = ((version) != NULL && (version)->hash != 0 \
- ? INTUSE(_dl_lookup_versioned_symbol) (strtab \
- + (*ref)->st_name, \
- l, (ref), scope, \
- (version), _tc, 0) \
- : INTUSE(_dl_lookup_symbol) (strtab + (*ref)->st_name, l, \
- (ref), scope, _tc, \
- DL_LOOKUP_ADD_DEPENDENCY)); \
+ ? _dl_lookup_versioned_symbol (strtab + (*ref)->st_name, \
+ l, (ref), scope, (version),\
+ _tc, 0) \
+ : _dl_lookup_symbol (strtab + (*ref)->st_name, l, (ref), \
+ scope, _tc, \
+ DL_LOOKUP_ADD_DEPENDENCY)); \
l->l_lookup_cache.ret = (*ref); \
l->l_lookup_cache.value = _lr; })) \
: l)
l->l_lookup_cache.type_class = _tc; \
l->l_lookup_cache.sym = (*ref); \
_lr = ((version) != NULL && (version)->hash != 0 \
- ? INTUSE(_dl_lookup_versioned_symbol) (strtab \
- + (*ref)->st_name, \
- l, (ref), scope, \
- (version), _tc, 0) \
- : INTUSE(_dl_lookup_symbol) (strtab + (*ref)->st_name, l, \
- (ref), scope, _tc, \
- DL_LOOKUP_ADD_DEPENDENCY)); \
+ ? _dl_lookup_versioned_symbol (strtab + (*ref)->st_name, \
+ l, (ref), scope, \
+ (version), _tc, 0) \
+ : _dl_lookup_symbol (strtab + (*ref)->st_name, l, (ref), \
+ scope, _tc, \
+ DL_LOOKUP_ADD_DEPENDENCY)); \
l->l_lookup_cache.ret = (*ref); \
l->l_lookup_cache.value = _lr; })) \
: l->l_addr)
if (l->l_relro_size != 0)
_dl_protect_relro (l);
}
-INTDEF (_dl_relocate_object)
+
void internal_function
_dl_protect_relro (struct link_map *l)
if (start != end
&& __mprotect ((void *) start, end - start, PROT_READ) < 0)
{
- const char *errstring = N_("\
+ static const char errstring[] = N_("\
cannot apply additional memory protection after relocation");
- INTUSE(_dl_signal_error) (errno, l->l_name, NULL, errstring);
+ _dl_signal_error (errno, l->l_name, NULL, errstring);
}
}
*cp++ = DIGIT (type);
*cp = '\0';
- INTUSE(_dl_signal_error) (0, map->l_name, NULL, msgbuf);
+ _dl_signal_error (0, map->l_name, NULL, msgbuf);
}
if (version->hash != 0)
{
- result = INTUSE(_dl_lookup_versioned_symbol) (strtab
- + sym->st_name,
- l, &sym, l->l_scope,
- version,
- ELF_RTYPE_CLASS_PLT,
- 0);
+ result = _dl_lookup_versioned_symbol (strtab + sym->st_name,
+ l, &sym, l->l_scope,
+ version,
+ ELF_RTYPE_CLASS_PLT, 0);
break;
}
}
case 0:
- result = INTUSE(_dl_lookup_symbol) (strtab + sym->st_name, l, &sym,
- l->l_scope, ELF_RTYPE_CLASS_PLT,
- DL_LOOKUP_ADD_DEPENDENCY);
+ result = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
+ l->l_scope, ELF_RTYPE_CLASS_PLT,
+ DL_LOOKUP_ADD_DEPENDENCY);
}
/* Currently result contains the base load address (or link map)
if (version->hash != 0)
{
- result = INTUSE(_dl_lookup_versioned_symbol) (strtab
- + sym->st_name,
- l, &sym,
- l->l_scope,
- version,
- ELF_RTYPE_CLASS_PLT,
- 0);
+ result = _dl_lookup_versioned_symbol (strtab
+ + sym->st_name,
+ l, &sym, l->l_scope,
+ version,
+ ELF_RTYPE_CLASS_PLT,
+ 0);
break;
}
}
case 0:
- result = INTUSE(_dl_lookup_symbol) (strtab + sym->st_name, l,
- &sym, l->l_scope,
- ELF_RTYPE_CLASS_PLT,
- DL_LOOKUP_ADD_DEPENDENCY);
+ result = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
+ l->l_scope, ELF_RTYPE_CLASS_PLT,
+ DL_LOOKUP_ADD_DEPENDENCY);
}
/* Currently result contains the base load address (or link map)
#include <dlfcn.h>
#include <ldsodefs.h>
#include <dl-hash.h>
+#include <dl-tls.h>
+
+
+#if defined USE_TLS && defined SHARED
+/* Systems which do not have tls_index also probably have to define
+ DONT_USE_TLS_INDEX. */
+
+# ifndef __TLS_GET_ADDR
+# define __TLS_GET_ADDR __tls_get_addr
+# endif
+
+/* Return the symbol address given the map of the module it is in and
+ the symbol record. This is used in dl-sym.c. */
+static void *
+internal_function
+_dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
+{
+# ifndef DONT_USE_TLS_INDEX
+ tls_index tmp =
+ {
+ .ti_module = map->l_tls_modid,
+ .ti_offset = ref->st_value
+ };
+
+ return __TLS_GET_ADDR (&tmp);
+# else
+ return __TLS_GET_ADDR (map->l_tls_modid, ref->st_value);
+# endif
+}
+#endif
+
void *
internal_function
if (handle == RTLD_DEFAULT)
/* Search the global scope as seen in the caller object. */
- result = _dl_lookup_symbol (name, match, &ref, match->l_scope, 0,
- DL_LOOKUP_RETURN_NEWEST
- | DL_LOOKUP_ADD_DEPENDENCY);
+ result = GLRO(dl_lookup_symbol) (name, match, &ref, match->l_scope, 0,
+ DL_LOOKUP_RETURN_NEWEST
+ | DL_LOOKUP_ADD_DEPENDENCY);
else
{
if (handle != RTLD_NEXT)
/* Search the scope of the given object. */
struct link_map *map = handle;
- result = _dl_lookup_symbol (name, match, &ref, map->l_local_scope,
- 0, DL_LOOKUP_RETURN_NEWEST);
+ result = GLRO(dl_lookup_symbol) (name, match, &ref,
+ map->l_local_scope, 0,
+ DL_LOOKUP_RETURN_NEWEST);
}
else
{
if (! GL(dl_loaded)
|| caller < GL(dl_loaded)->l_map_start
|| caller >= GL(dl_loaded)->l_map_end)
- _dl_signal_error (0, NULL, NULL, N_("\
+ GLRO(dl_signal_error) (0, NULL, NULL, N_("\
RTLD_NEXT used in code not dynamically loaded"));
}
while (l->l_loader != NULL)
l = l->l_loader;
- result = _dl_lookup_symbol_skip (name, l, &ref, l->l_local_scope,
- match);
+ result = GLRO(dl_lookup_symbol_skip) (name, l, &ref,
+ l->l_local_scope, match);
}
}
if (handle == RTLD_DEFAULT)
/* Search the global scope. */
- result = _dl_lookup_versioned_symbol (name, match, &ref, match->l_scope,
- &vers, 0, DL_LOOKUP_ADD_DEPENDENCY);
+ result = GLRO(dl_lookup_versioned_symbol) (name, match, &ref,
+ match->l_scope, &vers, 0,
+ DL_LOOKUP_ADD_DEPENDENCY);
else if (handle == RTLD_NEXT)
{
if (__builtin_expect (match == GL(dl_loaded), 0))
if (! GL(dl_loaded)
|| caller < GL(dl_loaded)->l_map_start
|| caller >= GL(dl_loaded)->l_map_end)
- _dl_signal_error (0, NULL, NULL, N_("\
+ GLRO(dl_signal_error) (0, NULL, NULL, N_("\
RTLD_NEXT used in code not dynamically loaded"));
}
while (l->l_loader != NULL)
l = l->l_loader;
- result = _dl_lookup_versioned_symbol_skip (name, l, &ref,
- l->l_local_scope,
- &vers, match);
+ result = GLRO(dl_lookup_versioned_symbol_skip) (name, l, &ref,
+ l->l_local_scope,
+ &vers, match);
}
else
{
/* Search the scope of the given object. */
struct link_map *map = handle;
- result = _dl_lookup_versioned_symbol (name, map, &ref,
- map->l_local_scope, &vers, 0, 0);
+ result = GLRO(dl_lookup_versioned_symbol) (name, map, &ref,
+ map->l_local_scope, &vers,
+ 0, 0);
}
if (ref != NULL)
/* Display information about what we are doing while debugging. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_VERSIONS, 0))
- INTUSE(_dl_debug_printf) ("\
+ _dl_debug_printf ("\
checking for version `%s' in file %s required by file %s\n",
- string, map->l_name[0]
- ? map->l_name : rtld_progname, name);
+ string, map->l_name[0] ? map->l_name : rtld_progname,
+ name);
if (__builtin_expect (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL, 0))
{
&buf[sizeof (buf) - 1], 10, 0),
" of Verneed record\n");
call_error:
- INTUSE(_dl_signal_error) (errval, (*map->l_name
- ? map->l_name : rtld_progname),
- NULL, errstring);
+ _dl_signal_error (errval, *map->l_name ? map->l_name : rtld_progname,
+ NULL, errstring);
}
while (1)
return result;
}
-INTDEF (_dl_check_map_versions)
int
for (l = map; l != NULL; l = l->l_next)
result |= (! l->l_faked
- && INTUSE(_dl_check_map_versions) (l, verbose, trace_mode));
+ && _dl_check_map_versions (l, verbose, trace_mode));
return result;
}
/* Print some debugging info if wanted. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
- INTUSE(_dl_debug_printf) ("symbol=%s; lookup in file=%s\n",
- undef_name, (map->l_name[0]
- ? map->l_name : rtld_progname));
+ _dl_debug_printf ("symbol=%s; lookup in file=%s\n",
+ undef_name,
+ map->l_name[0] ? map->l_name : rtld_progname);
symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
02111-1307 USA. */
#include <errno.h>
+#include <dlfcn.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdlib.h>
._dl_hwcap_mask = HWCAP_IMPORTANT,
._dl_lazy = 1,
._dl_fpu_control = _FPU_DEFAULT,
+
+ /* Function pointers. */
+ ._dl_get_origin = _dl_get_origin,
+ ._dl_dst_count = _dl_dst_count,
+ ._dl_dst_substitute = _dl_dst_substitute,
+ ._dl_map_object = _dl_map_object,
+ ._dl_map_object_deps = _dl_map_object_deps,
+ ._dl_relocate_object = _dl_relocate_object,
+ ._dl_check_map_versions = _dl_check_map_versions,
+ ._dl_init = _dl_init,
+ ._dl_debug_state = _dl_debug_state,
+ ._dl_unload_cache = _dl_unload_cache,
+ ._dl_debug_printf = _dl_debug_printf,
+ ._dl_catch_error = _dl_catch_error,
+ ._dl_signal_error = _dl_signal_error,
+ ._dl_start_profile = _dl_start_profile,
+ ._dl_mcount = _dl_mcount_internal,
+ ._dl_lookup_symbol = _dl_lookup_symbol,
+ ._dl_lookup_versioned_symbol = _dl_lookup_versioned_symbol,
+ ._dl_lookup_symbol_skip = _dl_lookup_symbol_skip,
+ ._dl_lookup_versioned_symbol_skip = _dl_lookup_versioned_symbol_skip,
};
/* If we would use strong_alias here the compiler would see a
non-hidden definition. This would undo the effect of the previous
{
struct relocate_args *args = (struct relocate_args *) a;
- INTUSE(_dl_relocate_object) (args->l, args->l->l_scope, args->lazy, 0);
+ _dl_relocate_object (args->l, args->l->l_scope, args->lazy, 0);
}
static void
map_doit (void *a)
{
struct map_args *args = (struct map_args *) a;
- args->map = INTUSE(_dl_map_object) (args->loader, args->str,
- args->is_preloaded, lt_library, 0,
- args->mode);
+ args->map = _dl_map_object (args->loader, args->str,
+ args->is_preloaded, lt_library, 0, args->mode);
}
static void
args.loader = NULL;
args.is_preloaded = 0;
args.mode = __RTLD_OPENEXEC;
- (void) INTUSE(_dl_catch_error) (&objname, &err_str, map_doit, &args);
+ (void) _dl_catch_error (&objname, &err_str, map_doit, &args);
if (__builtin_expect (err_str != NULL, 0))
/* We don't free the returned string, the programs stops
anyway. */
else
{
HP_TIMING_NOW (start);
- INTUSE(_dl_map_object) (NULL, rtld_progname, 0, lt_library, 0,
- __RTLD_OPENEXEC);
+ _dl_map_object (NULL, rtld_progname, 0, lt_library, 0,
+ __RTLD_OPENEXEC);
HP_TIMING_NOW (stop);
HP_TIMING_DIFF (load_time, start, stop);
&& (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
|| strchr (p, '/') == NULL))
{
- struct link_map *new_map = INTUSE(_dl_map_object) (GL(dl_loaded),
- p, 1,
- lt_library,
- 0, 0);
+ struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
+ lt_library, 0, 0);
if (++new_map->l_opencount == 1)
/* It is no duplicate. */
++npreloads;
args.is_preloaded = 1;
args.mode = 0;
- (void) INTUSE(_dl_catch_error) (&objname, &err_str, map_doit,
- &args);
+ (void) _dl_catch_error (&objname, &err_str, map_doit, &args);
if (__builtin_expect (err_str != NULL, 0))
{
_dl_error_printf ("\
if (problem != NULL)
{
char *p = strndupa (problem, file_size - (problem - file));
- struct link_map *new_map = INTUSE(_dl_map_object) (GL(dl_loaded), p,
- 1, lt_library,
- 0, 0);
+ struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
+ lt_library, 0, 0);
if (++new_map->l_opencount == 1)
/* It is no duplicate. */
++npreloads;
specified some libraries to load, these are inserted before the actual
dependencies in the executable's searchlist for symbol resolution. */
HP_TIMING_NOW (start);
- INTUSE(_dl_map_object_deps) (GL(dl_loaded), preloads, npreloads,
- mode == trace, 0);
+ _dl_map_object_deps (GL(dl_loaded), preloads, npreloads, mode == trace, 0);
HP_TIMING_NOW (stop);
HP_TIMING_DIFF (diff, start, stop);
HP_TIMING_ACCUM_NT (load_time, diff);
ElfW(Addr) loadbase;
lookup_t result;
- result = INTUSE(_dl_lookup_symbol) (INTUSE(_dl_argv)[i],
- GL(dl_loaded),
- &ref, GL(dl_loaded)->l_scope,
- ELF_RTYPE_CLASS_PLT, 1);
+ result = _dl_lookup_symbol (INTUSE(_dl_argv)[i], GL(dl_loaded),
+ &ref, GL(dl_loaded)->l_scope,
+ ELF_RTYPE_CLASS_PLT, 1);
loadbase = LOOKUP_VALUE_ADDRESS (result);
if ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
&& GL(dl_rtld_map).l_opencount > 1)
- INTUSE(_dl_relocate_object) (&GL(dl_rtld_map),
- GL(dl_loaded)->l_scope, 0, 0);
+ _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope,
+ 0, 0);
}
#define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
}
if (l != &GL(dl_rtld_map))
- INTUSE(_dl_relocate_object) (l, l->l_scope, GLRO(dl_lazy),
- consider_profiling);
+ _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy),
+ consider_profiling);
l = l->l_prev;
}
needs to have _dl_profile_map set up by the relocator. */
if (__builtin_expect (GL(dl_profile_map) != NULL, 0))
/* We must prepare the profiling. */
- INTUSE(_dl_start_profile) (GL(dl_profile_map),
- GLRO(dl_profile_output));
+ _dl_start_profile (GL(dl_profile_map), GLRO(dl_profile_output));
if (GL(dl_rtld_map).l_opencount > 1)
{
/* There was an explicit ref to the dynamic linker as a shared lib.
Re-relocate ourselves with user-controlled symbol definitions. */
HP_TIMING_NOW (start);
- INTUSE(_dl_relocate_object) (&GL(dl_rtld_map), GL(dl_loaded)->l_scope,
- 0, 0);
+ _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope, 0, 0);
HP_TIMING_NOW (stop);
HP_TIMING_DIFF (add, start, stop);
HP_TIMING_ACCUM_NT (relocate_time, add);
/* Notify the debugger that all objects are now mapped in. */
r->r_state = RT_ADD;
- INTUSE(_dl_debug_state) ();
+ _dl_debug_state ();
#ifndef MAP_COPY
/* We must munmap() the cache file. */
- INTUSE(_dl_unload_cache) ();
+ _dl_unload_cache ();
#endif
/* Once we return, _dl_sysdep_start will invoke
if (HP_TIMING_AVAIL)
{
HP_TIMING_PRINT (buf, sizeof (buf), *rtld_total_timep);
- INTUSE(_dl_debug_printf) ("\nruntime linker statistics:\n"
- " total startup time in dynamic loader: %s\n",
- buf);
+ _dl_debug_printf ("\nruntime linker statistics:\n"
+ " total startup time in dynamic loader: %s\n", buf);
/* Print relocation statistics. */
char pbuf[30];
*wp++ = *cp++;
}
*wp = '\0';
- INTUSE(_dl_debug_printf) ("\
- time needed for relocation: %s (%s%%)\n",
- buf, pbuf);
+ _dl_debug_printf ("\
+ time needed for relocation: %s (%s%%)\n", buf, pbuf);
}
#endif
num_relative_relocations += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
}
- INTUSE(_dl_debug_printf) (" number of relocations: %lu\n",
- GL(dl_num_relocations));
- INTUSE(_dl_debug_printf) (" number of relocations from cache: %lu\n",
- GL(dl_num_cache_relocations));
- INTUSE(_dl_debug_printf) (" number of relative relocations: %lu\n",
- num_relative_relocations);
+ _dl_debug_printf (" number of relocations: %lu\n",
+ GL(dl_num_relocations));
+ _dl_debug_printf (" number of relocations from cache: %lu\n",
+ GL(dl_num_cache_relocations));
+ _dl_debug_printf (" number of relative relocations: %lu\n",
+ num_relative_relocations);
#ifndef HP_TIMING_NONAVAIL
/* Time spend while loading the object and the dependencies. */
*wp++ = *cp++;
}
*wp = '\0';
- INTUSE(_dl_debug_printf) ("\
+ _dl_debug_printf ("\
time needed to load objects: %s (%s%%)\n",
buf, pbuf);
}
void (*operate) (void *),
void *args)
internal_function;
-extern int _dl_catch_error_internal (const char **objname,
- const char **errstring,
- void (*operate) (void *), void *args)
- internal_function;
/* Helper function for <dlfcn.h> functions. Runs the OPERATE function via
_dl_catch_error. Returns zero for success, nonzero for failure; and
/* Print a message if the loading of libs is traced. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
- INTUSE(_dl_debug_printf) (" search cache=%s\n", LD_SO_CACHE);
+ _dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
if (cache == NULL)
{
/* Print our result if wanted. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0)
&& best != NULL)
- INTUSE(_dl_debug_printf) (" trying file=%s\n", best);
+ _dl_debug_printf (" trying file=%s\n", best);
return best;
}
cache = NULL;
}
}
-INTDEF (_dl_unload_cache)
#endif
/* Manage function descriptors. Generic version.
- Copyright (C) 1999,2000,2001,2002,2003 Free Software Foundation, Inc.
+ Copyright (C) 1999,2000,2001,2002,2003,2004 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
if (! COMPARE_AND_SWAP (&l->npages, old_npages, new_npages))
return (struct fdesc_table *) NULL;
- *size = old_npages * GL(dl_pagesize);
+ *size = old_npages * GLRO(dl_pagesize);
new_table = __mmap (NULL, *size,
PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
if (new_table == MAP_FAILED)
- INTUSE(_dl_signal_error) (errno, NULL, NULL,
- N_("cannot map pages for fdesc table"));
+ _dl_signal_error (errno, NULL, NULL,
+ N_("cannot map pages for fdesc table"));
new_table->len
= (*size - sizeof (*new_table)) / sizeof (struct fdesc);
afterwards... */
len = ((strtab - (char *) symtab)
/ map->l_info[DT_SYMENT]->d_un.d_val);
- size = ((len * sizeof (fptr_table[0]) + GL(dl_pagesize) - 1)
- & -GL(dl_pagesize));
+ size = ((len * sizeof (fptr_table[0]) + GLRO(dl_pagesize) - 1)
+ & -GLRO(dl_pagesize));
/* XXX We don't support here in the moment systems without MAP_ANON.
There probably are none for IA-64. In case this is proven wrong
we will have to open /dev/null here and use the file descriptor
PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
-1, 0);
if (fptr_table == MAP_FAILED)
- INTUSE(_dl_signal_error) (errno, NULL, NULL,
- N_("cannot map pages for fptr table"));
+ _dl_signal_error (errno, NULL, NULL,
+ N_("cannot map pages for fptr table"));
if (COMPARE_AND_SWAP ((ElfW(Addr) *) &map->l_mach.fptr_table,
(ElfW(Addr)) NULL, (ElfW(Addr)) fptr_table))
symidx = sym - symtab;
if (symidx >= map->l_mach.fptr_table_len)
- INTUSE(_dl_signal_error) (0, NULL, NULL, N_("\
-internal error: symidx out of range of fptr table"));
+ _dl_signal_error (0, NULL, NULL,
+ N_("internal error: symidx out of range of fptr table"));
while (ftab[symidx] == 0)
{
#include <dl-dst.h>
-#undef _dl_get_origin
const char *
_dl_get_origin (void)
{
return result;
}
-INTDEF(_dl_get_origin)
#ifndef USE_TLS
no_memory:
#endif
- INTUSE(_dl_signal_error) (ENOMEM, NULL, NULL,
- N_("cannot create capability list"));
+ _dl_signal_error (ENOMEM, NULL, NULL,
+ N_("cannot create capability list"));
}
if (cnt == 1)
/* Thread-local storage handling in the ELF dynamic linker. Generic version.
- Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004 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
# ifndef GET_ADDR_OFFSET
# define GET_ADDR_OFFSET ti->ti_offset
# endif
-/* Systems which do not have tls_index also probably have to define
- DONT_USE_TLS_INDEX. */
-
-# ifndef __TLS_GET_ADDR
-# define __TLS_GET_ADDR __tls_get_addr
-# endif
-
-
-/* Return the symbol address given the map of the module it is in and
- the symbol record. This is used in dl-sym.c. */
-void *
-internal_function
-_dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
-{
-# ifndef DONT_USE_TLS_INDEX
- tls_index tmp =
- {
- .ti_module = map->l_tls_modid,
- .ti_offset = ref->st_value
- };
-
- return __TLS_GET_ADDR (&tmp);
-# else
- return __TLS_GET_ADDR (map->l_tls_modid, ref->st_value);
-# endif
-}
static void *
#endif
#ifdef SHARED
+ /* We add a function table to _rtld_global which is then used to
+ call the function instead of going through the PLT. The result
+ is that we can avoid exporting the functions and we do not jump
+ PLT relocations in libc.so. */
+ const char *(*_dl_get_origin) (void);
+ size_t (*_dl_dst_count) (const char *, int);
+ char *(*_dl_dst_substitute) (struct link_map *, const char *, char *, int);
+ struct link_map *(internal_function *_dl_map_object) (struct link_map *,
+ const char *, int,
+ int, int, int);
+ void (internal_function *_dl_map_object_deps) (struct link_map *,
+ struct link_map **,
+ unsigned int, int, int);
+ void (*_dl_relocate_object) (struct link_map *, struct r_scope_elem *[],
+ int, int);
+ int (internal_function *_dl_check_map_versions) (struct link_map *, int,
+ int);
+ void (internal_function *_dl_init) (struct link_map *, int, char **,
+ char **);
+ void (*_dl_debug_state) (void);
+#ifndef MAP_COPY
+ void (*_dl_unload_cache) (void);
+#endif
+ void (*_dl_debug_printf) (const char *, ...)
+ __attribute__ ((__format__ (__printf__, 1, 2)));
+ int (internal_function *_dl_catch_error) (const char **, const char **,
+ void (*) (void *), void *);
+ void (internal_function *_dl_signal_error) (int, const char *, const char *,
+ const char *);
+ void (internal_function *_dl_start_profile) (struct link_map *,
+ const char *);
+ void (*_dl_mcount) (ElfW(Addr) frompc, ElfW(Addr) selfpc);
+ lookup_t (internal_function *_dl_lookup_symbol) (const char *,
+ struct link_map *,
+ const ElfW(Sym) **,
+ struct r_scope_elem *[],
+ int, int);
+ lookup_t (internal_function *_dl_lookup_versioned_symbol) (const char *,
+ struct link_map *,
+ const ElfW(Sym) **,
+ struct r_scope_elem *[],
+ const struct r_found_version *,
+ int, int);
+ lookup_t (internal_function *_dl_lookup_symbol_skip) (const char *,
+ struct link_map *,
+ const ElfW(Sym) **,
+ struct r_scope_elem *[],
+ struct link_map *);
+ lookup_t (internal_function *_dl_lookup_versioned_symbol_skip) (const char *,
+ struct link_map *,
+ const ElfW(Sym) **,
+ struct r_scope_elem *[],
+ const struct r_found_version *,
+ struct link_map *);
+
};
# define __rtld_global_attribute__
# ifdef IS_IN_rtld
extern struct rtld_global_ro _rtld_local_ro
attribute_relro __rtld_local_attribute__;
-# endif
extern struct rtld_global_ro _rtld_global_ro
attribute_relro __rtld_global_attribute__;
+# else
+/* We cheat a bit here. We declare the variable as as const even
+ though it is at startup. */
+extern const struct rtld_global_ro _rtld_global_ro
+ attribute_relro __rtld_global_attribute__;
+# endif
#endif
#undef EXTERN
interpreted as for a `printf' call. All the lines start with a
tag showing the PID. */
extern void _dl_debug_printf (const char *fmt, ...)
- __attribute__ ((__format__ (__printf__, 1, 2)));
-extern void _dl_debug_printf_internal (const char *fmt, ...)
- __attribute__ ((__format__ (__printf__, 1, 2)))
- attribute_hidden;
+ __attribute__ ((__format__ (__printf__, 1, 2))) attribute_hidden;
/* Write message on the debug file descriptor. The parameters are
interpreted as for a `printf' call. All the lines buf the first
problem. */
extern void _dl_signal_error (int errcode, const char *object,
const char *occurred, const char *errstring)
- internal_function
- __attribute__ ((__noreturn__));
-extern void _dl_signal_error_internal (int errcode, const char *object,
- const char *occurred,
- const char *errstring)
internal_function __attribute__ ((__noreturn__)) attribute_hidden;
/* Like _dl_signal_error, but may return when called in the context of
extern struct link_map *_dl_map_object (struct link_map *loader,
const char *name, int preloaded,
int type, int trace_mode, int mode)
- internal_function;
-extern struct link_map *_dl_map_object_internal (struct link_map *loader,
- const char *name,
- int preloaded,
- int type, int trace_mode,
- int mode)
internal_function attribute_hidden;
/* Call _dl_map_object on the dependencies of MAP, and set up
struct link_map **preloads,
unsigned int npreloads, int trace_mode,
int open_mode)
- internal_function;
-extern void _dl_map_object_deps_internal (struct link_map *map,
- struct link_map **preloads,
- unsigned int npreloads,
- int trace_mode, int open_mode)
internal_function attribute_hidden;
/* Cache the locations of MAP's hash table. */
const ElfW(Sym) **sym,
struct r_scope_elem *symbol_scope[],
int type_class, int flags)
- internal_function;
-extern lookup_t _dl_lookup_symbol_internal (const char *undef,
- struct link_map *undef_map,
- const ElfW(Sym) **sym,
- struct r_scope_elem *symbolscope[],
- int type_class, int flags)
internal_function attribute_hidden;
enum
struct r_scope_elem *symbol_scope[],
const struct r_found_version *version,
int type_class, int explicit)
- internal_function;
-extern lookup_t _dl_lookup_versioned_symbol_internal (const char *undef,
- struct link_map *undef_map,
- const ElfW(Sym) **sym,
- struct r_scope_elem *symbol_scope[],
- const struct r_found_version *version,
- int type_class,
- int explicit)
internal_function attribute_hidden;
/* For handling RTLD_NEXT we must be able to skip shared objects. */
If LAZY is nonzero, don't relocate its PLT. */
extern void _dl_relocate_object (struct link_map *map,
struct r_scope_elem *scope[],
- int lazy, int consider_profiling);
-extern void _dl_relocate_object_internal (struct link_map *map,
- struct r_scope_elem *scope[],
- int lazy, int consider_profiling)
+ int lazy, int consider_profiling)
attribute_hidden;
/* Protect PT_GNU_RELRO area. */
/* Initialize the object in SCOPE by calling the constructors with
ARGC, ARGV, and ENV as the parameters. */
extern void _dl_init (struct link_map *main_map, int argc, char **argv,
- char **env) internal_function;
+ char **env) internal_function attribute_hidden;
/* Call the finalizer functions of all shared objects whose
initializer functions have completed. */
any shared object mappings. The `r_state' member of `struct r_debug'
says what change is taking place. This function's address is
the value of the `r_brk' member. */
-extern void _dl_debug_state (void);
-extern void _dl_debug_state_internal (void) attribute_hidden;
+extern void _dl_debug_state (void) attribute_hidden;
/* Initialize `struct r_debug' if it has not already been done. The
argument is the run-time load address of the dynamic linker, to be put
/* Gather the information needed to install the profiling tables and start
the timers. */
extern void _dl_start_profile (struct link_map *map, const char *output_dir)
- internal_function;
-extern void _dl_start_profile_internal (struct link_map *map,
- const char *output_dir)
internal_function attribute_hidden;
/* The actual functions used to keep book on the calls. */
all the time since this would create problems when the file is replaced.
Therefore we provide this function to close the file and open it again
once needed. */
-extern void _dl_unload_cache (void);
-extern void _dl_unload_cache_internal (void) attribute_hidden;
+extern void _dl_unload_cache (void) attribute_hidden;
/* System-dependent function to read a file's whole contents in the
most convenient manner available. *SIZEP gets the size of the
extern void _dl_deallocate_tls (void *tcb, bool dealloc_tcb) internal_function;
rtld_hidden_proto (_dl_deallocate_tls)
-/* Return the symbol address given the map of the module it is in and
- the symbol record. */
-extern void *_dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
- internal_function;
-
#if defined USE_TLS
extern void _dl_nothread_init_static_tls (struct link_map *) attribute_hidden;
#endif
+/* Find origin of the executable. */
+extern const char *_dl_get_origin (void) attribute_hidden;
+
+/* Count DSTs. */
+extern size_t _dl_dst_count (const char *name, int is_path) attribute_hidden;
+
+/* Substitute DST values. */
+extern char *_dl_dst_substitute (struct link_map *l, const char *name,
+ char *result, int is_path) attribute_hidden;
+
__END_DECLS
#endif /* ldsodefs.h */
/* Call the initializer of the program, if any. */
#ifdef SHARED
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- _dl_debug_printf ("\ninitialize program: %s\n\n", argv[0]);
+ GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
#endif
if (init)
(*init) (
#ifdef SHARED
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
- _dl_debug_printf ("\ntransferring control: %s\n\n", argv[0]);
+ GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
#endif
#ifdef HAVE_CLEANUP_JMP_BUF
/* Thread-local storage handling in the ELF dynamic linker. i386 version.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004 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
extern void *___tls_get_addr_internal (tls_index *ti)
__attribute__ ((__regparm__ (1))) attribute_hidden;
+# ifdef IS_IN_rtld
/* The special thing about the x86 TLS ABI is that we have two
variants of the __tls_get_addr function with different calling
conventions. The GNU version, which we are mostly concerned here,
version of this file. */
# define __tls_get_addr __attribute__ ((__regparm__ (1))) ___tls_get_addr
strong_alias (___tls_get_addr, ___tls_get_addr_internal)
-# define __TLS_GET_ADDR ___tls_get_addr_internal
+#else
+
+/* Users should get the better interface. */
+# define __tls_get_addr ___tls_get_addr
+
+# endif
#endif
/* Operating system support for run-time dynamic linker. Hurd version.
- Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
+ Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Free Software Foundation, Inc.
This file is part of the GNU C Library.
__mach_init ();
/* Initialize frequently used global variable. */
- GL(dl_pagesize) = __getpagesize ();
+ GLRO(dl_pagesize) = __getpagesize ();
#if HP_TIMING_AVAIL
HP_TIMING_NOW (_dl_cpuclock_offset);
the path of the application from the /proc/self/exe symlink. Try this
first and fall back on the generic method if necessary. */
-#undef _dl_get_origin
const char *
_dl_get_origin (void)
{
return result;
}
-INTDEF(_dl_get_origin)
/* Variable initialization. IA-64 version.
- Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004 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
DL_CLKTCK
};
- GL(dl_pagesize) = *((size_t *) array[DL_PAGESIZE]);
- GL(dl_clktck) = *((int *) array[DL_CLKTCK]);
+ GLRO(dl_pagesize) = *((size_t *) array[DL_PAGESIZE]);
+ GLRO(dl_clktck) = *((int *) array[DL_CLKTCK]);
}
#else
static void *variables[] =
{
- &GL(dl_pagesize),
- &GL(dl_clktck)
+ &GLRO(dl_pagesize),
+ &GLRO(dl_clktck)
};
void
-/* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2000, 2001, 2002, 2004 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
int
__getpagesize ()
{
- assert (GL(dl_pagesize) != 0);
- return GL(dl_pagesize);
+ assert (GLRO(dl_pagesize) != 0);
+ return GLRO(dl_pagesize);
}
libc_hidden_def (__getpagesize)
weak_alias (__getpagesize, getpagesize)
-/* Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Andreas Schwab <schwab@suse.de>.
int result;
#endif
- if (GL(dl_pagesize) != 0)
- return GL(dl_pagesize);
+ if (GLRO(dl_pagesize) != 0)
+ return GLRO(dl_pagesize);
#ifdef __NR_getpagesize
INTERNAL_SYSCALL_DECL (err);
-/* Copyright (C) 1997, 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 2002, 2003, 2004 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
int
__getpagesize ()
{
- if (GL(dl_pagesize) == 0)
+ if (GLRO(dl_pagesize) == 0)
{
INTERNAL_SYSCALL_DECL (err);
- GL(dl_pagesize) = INTERNAL_SYSCALL (getpagesize, err, 0);
+ GLRO(dl_pagesize) = INTERNAL_SYSCALL (getpagesize, err, 0);
}
- return GL(dl_pagesize);
+ return GLRO(dl_pagesize);
}
libc_hidden_def (__getpagesize)
weak_alias (__getpagesize, getpagesize)
git.samba.org / jlayton / glibc.git / commitdiff