AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 10:50:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
2001-06-07  David Mosberger  <davidm@hpl.hp.com>

	* sysdeps/ia64/dl-symaddr.c (_dl_symbol_address): Update call to
	__ia64_make_fptr() for new interface.
	(_dl_function_address): Remove.

	* sysdeps/ia64/dl-machine.h (IA64_BOOT_FPTR_TABLE_LEN): Rename
	from IA64_BOOT_FPTR_SIZE and reduce its value from 256 to 200.
	(struct ia64_fdesc): Rename from struct ia64_fptr and drop "next"
	pointer.  Rename member "func" to "ip".
	(struct ia64_fdesc_table): New type.
	(__ia64_make_fptr): Change prototype.
	(__ia64_init_bootstrap_fdesc_table): New function.
	(ELF_MACHINE_BEFORE_RTLD_RELOC): New macro.
	(__boot_ldso_fptr): Removed.
	(__fptr_next): Removed.
	(__fptr_root): Removed.
	(__fptr_count): Removed.
	(TRAMPOLINE_TEMPLATE): Fix typo in comment.  Don't use multi-line
	strings to avoid warning from gcc3.
	(RTLD_START): Don't use multi-line strings.
	(ELF_MACHINE_START_ADDRESS): Use DL_STATIC_FUNCTION_ADDRESS.
	(elf_machine_fixup_plt): Update the code entry point in the
	function descriptor through a "volatile" pointer to ensure proper
	write ordering.
	(elf_machine_rela): Simplify handling of FPTR relocs: always call
	__ia64_make_fptr().

	* sysdeps/ia64/dl-lookupcfg.h (DL_AUTO_FUNCTION_ADDRESS): New macro.
	(DL_STATIC_FUNCTION_ADDRESS): Likewise.
	(DL_DT_INIT_ADDRESS): Use DL_AUTO_FUNCTION_ADDRESS.
	(DL_DT_FINI_ADDRESS): Likewise.

	* sysdeps/ia64/dl-fptr.c: Rewrite for better scalability and to
	avoid deadlocks.

	* include/link.h: Add member machine specific "l_mach" member to
	link_map.

	* sysdeps/generic/bits/link.h: New file.
	* sysdeps/ia64/bits/link.h: Likewise.

	* elf/rtld.c (_dl_start): Fix typo in comment.
	(_dl_start_final): Copy new "l_mach" member from temporary to
	final bootstrap map.
This commit is contained in:
Ulrich Drepper 2001-07-26 00:27:15 +00:00
parent ca13ce66be
commit 370f00c3a7
10 changed files with 599 additions and 463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
ChangeLog
View File

@ -1,3 +1,49 @@
2001-06-07 David Mosberger <davidm@hpl.hp.com>
* sysdeps/ia64/dl-symaddr.c (_dl_symbol_address): Update call to
__ia64_make_fptr() for new interface.
(_dl_function_address): Remove.
* sysdeps/ia64/dl-machine.h (IA64_BOOT_FPTR_TABLE_LEN): Rename
from IA64_BOOT_FPTR_SIZE and reduce its value from 256 to 200.
(struct ia64_fdesc): Rename from struct ia64_fptr and drop "next"
pointer. Rename member "func" to "ip".
(struct ia64_fdesc_table): New type.
(__ia64_make_fptr): Change prototype.
(__ia64_init_bootstrap_fdesc_table): New function.
(ELF_MACHINE_BEFORE_RTLD_RELOC): New macro.
(__boot_ldso_fptr): Removed.
(__fptr_next): Removed.
(__fptr_root): Removed.
(__fptr_count): Removed.
(TRAMPOLINE_TEMPLATE): Fix typo in comment. Don't use multi-line
strings to avoid warning from gcc3.
(RTLD_START): Don't use multi-line strings.
(ELF_MACHINE_START_ADDRESS): Use DL_STATIC_FUNCTION_ADDRESS.
(elf_machine_fixup_plt): Update the code entry point in the
function descriptor through a "volatile" pointer to ensure proper
write ordering.
(elf_machine_rela): Simplify handling of FPTR relocs: always call
__ia64_make_fptr().
* sysdeps/ia64/dl-lookupcfg.h (DL_AUTO_FUNCTION_ADDRESS): New macro.
(DL_STATIC_FUNCTION_ADDRESS): Likewise.
(DL_DT_INIT_ADDRESS): Use DL_AUTO_FUNCTION_ADDRESS.
(DL_DT_FINI_ADDRESS): Likewise.
* sysdeps/ia64/dl-fptr.c: Rewrite for better scalability and to
avoid deadlocks.
* include/link.h: Add member machine specific "l_mach" member to
link_map.
* sysdeps/generic/bits/link.h: New file.
* sysdeps/ia64/bits/link.h: Likewise.
* elf/rtld.c (_dl_start): Fix typo in comment.
(_dl_start_final): Copy new "l_mach" member from temporary to
final bootstrap map.
2001-07-25 Ulrich Drepper <drepper@redhat.com>
* csu/gmon-start.c: Use ENTRY_POINT_DECL is defined instead of a

4
bits/link.h Normal file
View File

@ -0,0 +1,4 @@
struct link_map_machine
{
/* empty by default */
};

3
elf/rtld.c
View File

@ -157,7 +157,7 @@ _dl_start (void *arg)
HP_TIMING_NOW (start_time);
/* Partly clean the `bootstrap_map' structure up. Don't use `memset'
since it might nor be built in or inlined and we cannot make function
since it might not be built in or inlined and we cannot make function
calls at this point. */
for (cnt = 0;
cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
@ -228,6 +228,7 @@ _dl_start_final (void *arg, struct link_map *bootstrap_map_p,
memcpy (_dl_rtld_map.l_info, bootstrap_map_p->l_info,
sizeof _dl_rtld_map.l_info);
_dl_setup_hash (&_dl_rtld_map);
_dl_rtld_map.l_mach = bootstrap_map_p->l_mach;
/* Don't bother trying to work out how ld.so is mapped in memory. */
_dl_rtld_map.l_map_start = ~0;

3
include/link.h
View File

@ -33,6 +33,7 @@
#define _ElfW_1(e,w,t) e##w##t
#include <bits/elfclass.h> /* Defines __ELF_NATIVE_CLASS. */
#include <bits/link.h>
/* Rendezvous structure used by the run-time dynamic linker to communicate
details of shared object loading to the debugger. If the executable's
@ -228,6 +229,8 @@ struct link_map
/* Temporarily used in `dl_close'. */
unsigned int l_idx;
struct link_map_machine l_mach;
};
struct dl_phdr_info

4
sysdeps/generic/bits/link.h Normal file
View File

@ -0,0 +1,4 @@
struct link_map_machine
{
/* empty by default */
};

5
sysdeps/ia64/bits/link.h Normal file
View File

@ -0,0 +1,5 @@
struct link_map_machine
{
size_t fptr_table_len;
Elf64_Addr *fptr_table;
};

361
sysdeps/ia64/dl-fptr.c
View File

@ -1,5 +1,5 @@
/* Unmap a loaded object. IA-64 version.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
/* Manage function descriptors. IA-64 version.
Copyright (C) 1999, 2000, 2001 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
@ -17,6 +17,7 @@
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <ia64intrin.h>
#include <unistd.h>
#include <string.h>
#include <sys/param.h>
@ -27,186 +28,260 @@
#include <dl-machine.h>
#ifdef _LIBC_REENTRANT
# include <pt-machine.h>
static int __ia64_fptr_lock = 0;
# include <signal.h>
# include <time.h>
#endif
/* Because ld.so is now versioned, these functions can be in their own
file; no relocations need to be done to call them. Of course, if
ld.so is not versioned... */
#if 0
#ifndef DO_VERSIONING
# error "This will not work with versioning turned off, sorry."
#endif
#endif
Elf64_Addr __ia64_boot_fptr_table[IA64_BOOT_FPTR_TABLE_LEN];
#ifdef MAP_ANON
/* The fd is not examined when using MAP_ANON. */
#define ANONFD -1
#else
extern int _dl_zerofd;
#define ANONFD _dl_zerofd
#endif
/* ld.so currently has 14 FPTR relocs, we take 256 and use them for
the relocs for the dynamic app itself. */
struct ia64_fptr __boot_ldso_fptr[IA64_BOOT_FPTR_SIZE];
struct ia64_fptr *__fptr_root = NULL;
struct ia64_fptr *__fptr_next = __boot_ldso_fptr;
static struct ia64_fptr *__fptr_free = NULL;
int __fptr_count = IA64_BOOT_FPTR_SIZE;
Elf64_Addr
__ia64_make_fptr (const struct link_map *sym_map, Elf64_Addr value,
struct ia64_fptr **root, struct ia64_fptr *mem)
{
struct ia64_fptr **loc;
struct ia64_fptr *f;
#ifdef _LIBC_REENTRANT
/* Make sure we are alone. We don't need a lock during bootstrap. */
if (mem == NULL)
while (testandset (&__ia64_fptr_lock));
#endif
/* Search the sorted linked list for an existing entry for this
symbol. */
loc = root;
f = *loc;
while (f != NULL && f->func <= value)
static struct local
{
if (f->func == value)
goto found;
loc = &f->next;
f = *loc;
struct ia64_fdesc_table *root;
struct ia64_fdesc *free_list;
unsigned int npages; /* # of pages to allocate */
#ifdef _LIBC_REENTRANT
volatile int lock;
sigset_t full_sigset;
#endif
/* the next to members MUST be consecutive! */
struct ia64_fdesc_table boot_table;
struct ia64_fdesc boot_fdescs[1024];
}
local =
{
root: &local.boot_table,
npages: 2,
boot_table:
{
len: sizeof (local.boot_fdescs) / sizeof (local.boot_fdescs[0]),
first_unused: 0
}
};
/* Locking is tricky: we may get a signal while holding the lock and
the signal handler may end up calling into the dynamic loader
again. Also, if a real-time process spins on the lock, a
non-realtime process may never get the chance to release it's lock,
unless the realtime process relinquishes the CPU from time to time.
Hence we (a) block signals before acquiring the lock and (b) do a
nanosleep() when we detect prolongued contention. */
#ifdef _LIBC_REENTRANT
# define lock(l) \
{ \
sigset_t _saved_set; \
int i = 10000; \
if (!__sigismember (&(l)->full_sigset, SIGINT)) \
__sigfillset (&(l)->full_sigset); \
\
while (testandset ((int *) &(l)->lock)) \
{ \
struct timespec ts; \
if (i > 0) \
{ \
--i; \
continue; \
} \
ts.tv_sec = 0; \
ts.tv_nsec = 1*1000*1000; \
__nanosleep (&ts, NULL); \
} \
__sigprocmask (SIG_BLOCK, &(l)->full_sigset, &_saved_set);
# define unlock(l) \
__sigprocmask (SIG_SETMASK, &_saved_set, NULL); \
(l)->lock = 0; \
}
#else
# define lock(l)
# define unlock(l)
#endif
/* Create a new fdesc table and return a pointer to the first fdesc
entry. The fdesc lock must have been acquired already. */
static struct ia64_fdesc *
new_fdesc_table (struct local *l)
{
size_t size = l->npages * _dl_pagesize;
struct ia64_fdesc_table *new_table;
struct ia64_fdesc *fdesc;
l->npages += l->npages;
new_table = __mmap (0, size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
if (new_table == MAP_FAILED)
_dl_signal_error (errno, NULL, "cannot map pages for fdesc table");
new_table->len = (size - sizeof (*new_table)) / sizeof (struct ia64_fdesc);
fdesc = &new_table->fdesc[0];
new_table->first_unused = 1;
new_table->next = l->root;
l->root = new_table;
return fdesc;
}
static Elf64_Addr
make_fdesc (Elf64_Addr ip, Elf64_Addr gp)
{
struct ia64_fdesc *fdesc = NULL;
struct ia64_fdesc_table *t;
unsigned int old;
struct local *l;
asm ("addl %0 = @gprel (local), gp" : "=r" (l));
t = l->root;
while (1)
{
old = t->first_unused;
if (old >= t->len)
break;
else if (__sync_bool_compare_and_swap (&t->first_unused, old, old + 1))
{
fdesc = &t->fdesc[old];
goto install;
}
}
/* Not found. Create a new one. */
if (mem != NULL)
f = mem;
else if (__fptr_free != NULL)
lock (l);
{
f = __fptr_free;
__fptr_free = f->next;
if (l->free_list)
{
fdesc = l->free_list; /* get it from free-list */
l->free_list = (struct ia64_fdesc *) fdesc->ip;
}
else
{
if (__fptr_count == 0)
{
#ifndef MAP_ANON
# define MAP_ANON 0
if (_dl_zerofd == -1)
{
_dl_zerofd = _dl_sysdep_open_zero_fill ();
if (_dl_zerofd == -1)
{
__close (fd);
_dl_signal_error (errno, NULL,
"cannot open zero fill device");
fdesc = new_fdesc_table (l); /* create new fdesc table */
}
unlock (l);
install:
fdesc->ip = ip;
fdesc->gp = gp;
return (Elf64_Addr) fdesc;
}
static inline Elf64_Addr *
make_fptr_table (struct link_map *map)
{
const Elf64_Sym *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
Elf64_Addr *fptr_table;
size_t size;
size_t len;
/* XXX Apparently the only way to find out the size of the dynamic
symbol section is to assume that the string table follows right
afterwards... */
len = ((strtab - (char *) symtab) / map->l_info[DT_SYMENT]->d_un.d_val);
size = ((len * sizeof (fptr_table[0]) + _dl_pagesize - 1) & -_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
instead of the hard-coded -1. */
fptr_table = __mmap (NULL, size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
if (fptr_table == MAP_FAILED)
_dl_signal_error (errno, NULL, "cannot map pages for fptr table");
map->l_mach.fptr_table_len = len;
map->l_mach.fptr_table = fptr_table;
return fptr_table;
}
Elf64_Addr
__ia64_make_fptr (struct link_map *map, const Elf64_Sym *sym, Elf64_Addr ip)
{
Elf64_Addr *ftab = map->l_mach.fptr_table;
const Elf64_Sym *symtab;
Elf_Symndx symidx;
if (__builtin_expect (!map->l_mach.fptr_table, 0))
ftab = make_fptr_table (map);
symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
symidx = sym - symtab;
if (symidx >= map->l_mach.fptr_table_len)
_dl_signal_error (0, NULL,
"internal error: symidx out of range of fptr table");
if (!ftab[symidx])
{
/* GOT has already been relocated in elf_get_dynamic_info -
don't try to relocate it again. */
ftab[symidx] = make_fdesc (ip, map->l_info[DT_PLTGOT]->d_un.d_ptr);
#if 0
{
const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
struct local *l;
asm ("addl %0 = @gprel (local), gp" : "=r" (l));
if (l->root != &l->boot_table || l->boot_table.first_unused > 20)
_dl_debug_printf ("created fdesc symbol `%s' at %lx\n",
strtab + sym->st_name, ftab[symidx]);
}
#endif
__fptr_next = __mmap (0, _dl_pagesize, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, ANONFD, 0);
if (__fptr_next == MAP_FAILED)
_dl_signal_error(errno, NULL, "cannot map page for fptr");
__fptr_count = _dl_pagesize / sizeof (struct ia64_fptr);
}
f = __fptr_next++;
__fptr_count--;
}
f->func = value;
/* GOT has already been relocated in elf_get_dynamic_info - don't
try to relocate it again. */
f->gp = sym_map->l_info[DT_PLTGOT]->d_un.d_ptr;
f->next = *loc;
*loc = f;
found:
#ifdef _LIBC_REENTRANT
/* Release the lock. */
if (mem == NULL)
__ia64_fptr_lock = 0;
#endif
return (Elf64_Addr) f;
return ftab[symidx];
}
void
_dl_unmap (struct link_map *map)
{
struct ia64_fptr **floc;
struct ia64_fptr *f;
struct ia64_fptr **lloc;
struct ia64_fptr *l;
Elf64_Addr *ftab = map->l_mach.fptr_table;
struct ia64_fdesc *head = NULL, *tail = NULL;
size_t i;
__munmap ((void *) map->l_map_start, map->l_map_end - map->l_map_start);
#ifdef _LIBC_REENTRANT
/* Make sure we are alone. */
while (testandset (&__ia64_fptr_lock));
#endif
if (!ftab)
return;
/* Search the sorted linked list for the first entry for this object. */
floc = &__fptr_root;
f = *floc;
while (f != NULL && f->func < map->l_map_start)
/* String together the fdesc structures that are being freed. */
for (i = 0; i < map->l_mach.fptr_table_len; ++i)
{
floc = &f->next;
f = *floc;
if (ftab[i])
{
*(struct ia64_fdesc **) ftab[i] = head;
head = (struct ia64_fdesc *) ftab[i];
if (!tail)
tail = head;
}
}
/* We found one. */
if (f != NULL && f->func < map->l_map_end)
/* Prepend the new list to the free_list: */
if (tail)
{
/* Get the last entry. */
lloc = floc;
l = f;
while (l && l->func < map->l_map_end)
lock (&local);
{
lloc = &l->next;
l = *lloc;
*(struct ia64_fdesc **) tail = local.free_list;
local.free_list = head;
}
unlock (&local);
}
/* Updated FPTR. */
*floc = l;
/* Prepend them to the free list. */
*lloc = __fptr_free;
__fptr_free = f;
}
#ifdef _LIBC_REENTRANT
/* Release the lock. */
__ia64_fptr_lock = 0;
#endif
__munmap (ftab,
map->l_mach.fptr_table_len * sizeof (map->l_mach.fptr_table[0]));
map->l_mach.fptr_table = NULL;
}
Elf64_Addr
_dl_lookup_address (const void *address)
{
Elf64_Addr addr = (Elf64_Addr) address;
struct ia64_fptr *f;
struct ia64_fdesc_table *t;
unsigned long int i;
#ifdef _LIBC_REENTRANT
/* Make sure we are alone. */
while (testandset (&__ia64_fptr_lock));
#endif
for (f = __fptr_root; f != NULL; f = f->next)
if (f == address)
for (t = local.root; t != NULL; t = t->next)
{
addr = f->func;
i = (struct ia64_fdesc *) addr - &t->fdesc[0];
if (i < t->first_unused && addr == (Elf64_Addr) &t->fdesc[i])
{
addr = t->fdesc[i].ip;
break;
}
#ifdef _LIBC_REENTRANT
/* Release the lock. */
__ia64_fptr_lock = 0;
#endif
}
return addr;
}

22
sysdeps/ia64/dl-lookupcfg.h
View File

@ -36,9 +36,21 @@ extern void _dl_unmap (struct link_map *map);
#define DL_UNMAP(map) _dl_unmap (map)
extern Elf64_Addr _dl_function_address (const struct link_map *map,
Elf64_Addr start);
#define DL_AUTO_FUNCTION_ADDRESS(map, addr) \
({ \
unsigned long fptr[2]; \
fptr[0] = (addr); \
fptr[1] = (map)->l_info[DT_PLTGOT]->d_un.d_ptr; \
(Elf64_Addr) fptr; \
})
#define DL_FUNCTION_ADDRESS(map, addr) _dl_function_address (map, addr)
#define DL_DT_INIT_ADDRESS(map, addr) DL_FUNCTION_ADDRESS (map, addr)
#define DL_DT_FINI_ADDRESS(map, addr) DL_FUNCTION_ADDRESS (map, addr)
#define DL_STATIC_FUNCTION_ADDRESS(map, addr) \
({ \
static unsigned long fptr[2]; \
fptr[0] = (addr); \
fptr[1] = (map)->l_info[DT_PLTGOT]->d_un.d_ptr; \
(Elf64_Addr) fptr; \
})
#define DL_DT_INIT_ADDRESS(map, addr) DL_AUTO_FUNCTION_ADDRESS (map, addr)
#define DL_DT_FINI_ADDRESS(map, addr) DL_AUTO_FUNCTION_ADDRESS (map, addr)

590
sysdeps/ia64/dl-machine.h
View File

@ -1,5 +1,5 @@
/* Machine-dependent ELF dynamic relocation inline functions. IA-64 version.
Copyright (C) 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
Copyright (C) 1995, 1996, 1997, 2000, 2001 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
@ -32,26 +32,43 @@
in l_info array. */
#define DT_IA_64(x) (DT_IA_64_##x - DT_LOPROC + DT_NUM)
/* There are currently 123 dynamic symbols in ld.so.
IA64_BOOT_FPTR_TABLE_LEN needs to be at least that big. */
#define IA64_BOOT_FPTR_TABLE_LEN 200
/* An FPTR is a function descriptor. Properly they consist of just
FUNC and GP. But we want to traverse a binary tree too. */
/* An FDESC is a function descriptor. */
#define IA64_BOOT_FPTR_SIZE 256
struct ia64_fdesc
{
Elf64_Addr ip; /* code entry point */
Elf64_Addr gp; /* global pointer */
};
struct ia64_fptr
struct ia64_fdesc_table
{
struct ia64_fdesc_table *next;
unsigned int len; /* # of entries in fdesc table */
volatile unsigned int first_unused; /* index of first available entry */
struct ia64_fdesc fdesc[0];
};
extern Elf64_Addr __ia64_make_fptr (struct link_map *, const Elf64_Sym *,
Elf64_Addr);
static inline void
__ia64_init_bootstrap_fdesc_table (struct link_map *map)
{
Elf64_Addr func;
Elf64_Addr gp;
struct ia64_fptr *next;
};
Elf64_Addr *boot_table;
extern struct ia64_fptr __boot_ldso_fptr[];
extern struct ia64_fptr *__fptr_next;
extern struct ia64_fptr *__fptr_root;
extern int __fptr_count;
/* careful: this will be called before got has been relocated... */
asm ("addl %0 = @gprel (__ia64_boot_fptr_table), gp" : "=r"(boot_table));
extern Elf64_Addr __ia64_make_fptr (const struct link_map *, Elf64_Addr,
struct ia64_fptr **, struct ia64_fptr *);
map->l_mach.fptr_table_len = IA64_BOOT_FPTR_TABLE_LEN;
map->l_mach.fptr_table = boot_table;
}
#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) \
__ia64_init_bootstrap_fdesc_table (&bootstrap_map);
/* Return nonzero iff ELF header is compatible with the running host. */
static inline int
@ -67,7 +84,7 @@ elf_machine_dynamic (void)
{
Elf64_Addr *p;
__asm__(
__asm__ (
".section .sdata\n"
" .type __dynamic_ltv#, @object\n"
" .size __dynamic_ltv#, 8\n"
@ -75,7 +92,7 @@ elf_machine_dynamic (void)
" data8 @ltv(_DYNAMIC#)\n"
".previous\n"
" addl %0 = @gprel(__dynamic_ltv#), gp ;;"
: "=r"(p));
: "=r" (p));
return *p;
}
@ -88,19 +105,18 @@ elf_machine_load_address (void)
Elf64_Addr ip;
int *p;
__asm__(
__asm__ (
"1: mov %0 = ip\n"
".section .sdata\n"
"2: data4 @ltv(1b)\n"
" .align 8\n"
".previous\n"
" addl %1 = @gprel(2b), gp ;;"
: "=r"(ip), "=r"(p));
: "=r" (ip), "=r" (p));
return ip - (Elf64_Addr)*p;
return ip - (Elf64_Addr) *p;
}
/* Set up the loaded object described by L so its unrelocated PLT
entries will jump to the on-demand fixup code in dl-runtime.c. */
@ -112,21 +128,21 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
if (lazy)
{
register Elf64_Addr gp __asm__("gp");
register Elf64_Addr gp __asm__ ("gp");
Elf64_Addr *reserve, doit;
/*
* Careful with the typecast here or it will try to add l-l_addr
* pointer elements
*/
reserve = (Elf64_Addr *)
(l->l_info[DT_IA_64(PLT_RESERVE)]->d_un.d_ptr + l->l_addr);
reserve = ((Elf64_Addr *)
(l->l_info[DT_IA_64 (PLT_RESERVE)]->d_un.d_ptr + l->l_addr));
/* Identify this shared object. */
reserve[0] = (Elf64_Addr) l;
/* This function will be called to perform the relocation. */
if (!profile)
doit = (Elf64_Addr) ((struct ia64_fptr *)&_dl_runtime_resolve)->func;
doit = (Elf64_Addr) ((struct ia64_fdesc *) &_dl_runtime_resolve)->ip;
else
{
if (_dl_name_match_p (_dl_profile, l))
@ -135,7 +151,7 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
want profiling and the timers are started. */
_dl_profile_map = l;
}
doit = (Elf64_Addr) ((struct ia64_fptr *)&_dl_runtime_profile)->func;
doit = (Elf64_Addr) ((struct ia64_fdesc *) &_dl_runtime_profile)->ip;
}
reserve[1] = doit;
@ -149,7 +165,7 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
/*
This code is used in dl-runtime.c to call the `fixup' function
and then redirect to the address it returns. `fixup()' takes two
arguments, however fixup_profile() takes three.
arguments, however profile_fixup() takes three.
The ABI specifies that we will never see more than 8 input
registers to a function call, thus it is safe to simply allocate
@ -158,102 +174,102 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
*/
#define TRAMPOLINE_TEMPLATE(tramp_name, fixup_name) \
extern void tramp_name (void); \
asm ( "\
.global " #tramp_name "#
.proc " #tramp_name "#
" #tramp_name ":
{ .mmi
alloc loc0 = ar.pfs, 8, 6, 3, 0
adds r2 = -144, r12
adds r3 = -128, r12
}
{ .mii
adds r12 = -160, r12
mov loc1 = b0
mov out2 = b0 /* needed by fixup_profile */
;;
}
{ .mfb
mov loc2 = r8 /* preserve struct value register */
nop.f 0
nop.b 0
}
{ .mii
mov loc3 = r9 /* preserve language specific register */
mov loc4 = r10 /* preserve language specific register */
mov loc5 = r11 /* preserve language specific register */
}
{ .mmi
stf.spill [r2] = f8, 32
stf.spill [r3] = f9, 32
mov out0 = r16
;;
}
{ .mmi
stf.spill [r2] = f10, 32
stf.spill [r3] = f11, 32
shl out1 = r15, 4
;;
}
{ .mmi
stf.spill [r2] = f12, 32
stf.spill [r3] = f13, 32
shladd out1 = r15, 3, out1
;;
}
{ .mmb
stf.spill [r2] = f14
stf.spill [r3] = f15
br.call.sptk.many b0 = " #fixup_name "#
}
{ .mii
ld8 r9 = [ret0], 8
adds r2 = 16, r12
adds r3 = 32, r12
;;
}
{ .mmi
ldf.fill f8 = [r2], 32
ldf.fill f9 = [r3], 32
mov b0 = loc1
;;
}
{ .mmi
ldf.fill f10 = [r2], 32
ldf.fill f11 = [r3], 32
mov b6 = r9
;;
}
{ .mmi
ldf.fill f12 = [r2], 32
ldf.fill f13 = [r3], 32
mov ar.pfs = loc0
;;
}
{ .mmi
ldf.fill f14 = [r2], 32
ldf.fill f15 = [r3], 32
adds r12 = 160, r12
;;
}
{ .mii
mov r9 = loc3 /* restore language specific register */
mov r10 = loc4 /* restore language specific register */
mov r11 = loc5 /* restore language specific register */
}
{ .mii
ld8 gp = [ret0]
mov r8 = loc2 /* restore struct value register */
;;
}
/* An alloc is needed for the break system call to work.
We don't care about the old value of the pfs register. */
{ .mmb
alloc r2 = ar.pfs, 0, 0, 8, 0
br.sptk.many b6
;;
}
.endp " #tramp_name "#")
asm ( \
" .global " #tramp_name "#\n" \
" .proc " #tramp_name "#\n" \
#tramp_name ":\n" \
" { .mmi\n" \
" alloc loc0 = ar.pfs, 8, 6, 3, 0\n" \
" adds r2 = -144, r12\n" \
" adds r3 = -128, r12\n" \
" }\n" \
" { .mii\n" \
" adds r12 = -160, r12\n" \
" mov loc1 = b0\n" \
" mov out2 = b0 /* needed by fixup_profile */\n" \
" ;;\n" \
" }\n" \
" { .mfb\n" \
" mov loc2 = r8 /* preserve struct value register */\n" \
" nop.f 0\n" \
" nop.b 0\n" \
" }\n" \
" { .mii\n" \
" mov loc3 = r9 /* preserve language specific register */\n" \
" mov loc4 = r10 /* preserve language specific register */\n" \
" mov loc5 = r11 /* preserve language specific register */\n" \
" }\n" \
" { .mmi\n" \
" stf.spill [r2] = f8, 32\n" \
" stf.spill [r3] = f9, 32\n" \
" mov out0 = r16\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" stf.spill [r2] = f10, 32\n" \
" stf.spill [r3] = f11, 32\n" \
" shl out1 = r15, 4\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" stf.spill [r2] = f12, 32\n" \
" stf.spill [r3] = f13, 32\n" \
" shladd out1 = r15, 3, out1\n" \
" ;;\n" \
" }\n" \
" { .mmb\n" \
" stf.spill [r2] = f14\n" \
" stf.spill [r3] = f15\n" \
" br.call.sptk.many b0 = " #fixup_name "#\n" \
" }\n" \
" { .mii\n" \
" ld8 r9 = [ret0], 8\n" \
" adds r2 = 16, r12\n" \
" adds r3 = 32, r12\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ldf.fill f8 = [r2], 32\n" \
" ldf.fill f9 = [r3], 32\n" \
" mov b0 = loc1\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ldf.fill f10 = [r2], 32\n" \
" ldf.fill f11 = [r3], 32\n" \
" mov b6 = r9\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ldf.fill f12 = [r2], 32\n" \
" ldf.fill f13 = [r3], 32\n" \
" mov ar.pfs = loc0\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ldf.fill f14 = [r2], 32\n" \
" ldf.fill f15 = [r3], 32\n" \
" adds r12 = 160, r12\n" \
" ;;\n" \
" }\n" \
" { .mii\n" \
" mov r9 = loc3 /* restore language specific register */\n" \
" mov r10 = loc4 /* restore language specific register */\n" \
" mov r11 = loc5 /* restore language specific register */\n" \
" }\n" \
" { .mii\n" \
" ld8 gp = [ret0]\n" \
" mov r8 = loc2 /* restore struct value register */\n" \
" ;;\n" \
" }\n" \
" /* An alloc is needed for the break system call to work.\n" \
" We don't care about the old value of the pfs register. */\n" \
" { .mmb\n" \
" alloc r2 = ar.pfs, 0, 0, 8, 0\n" \
" br.sptk.many b6\n" \
" ;;\n" \
" }\n" \
" .endp " #tramp_name "#\n");
#ifndef PROF
#define ELF_MACHINE_RUNTIME_TRAMPOLINE \
@ -270,148 +286,148 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
The C function `_dl_start' is the real entry point;
its return value is the user program's entry point. */
#define RTLD_START asm ("\
.text
.global _start#
.proc _start#
_start:
0: { .mii
alloc loc0 = ar.pfs, 0, 3, 4, 0
mov r2 = ip
addl r3 = @gprel(0b), r0
;;
}
{ .mlx
/* Calculate the GP, and save a copy in loc1. */
sub gp = r2, r3
movl r8 = 0x9804c0270033f
;;
}
{ .mii
mov ar.fpsr = r8
sub loc1 = r2, r3
/* _dl_start wants a pointer to the pointer to the arg block
and the arg block starts with an integer, thus the magic 16. */
adds out0 = 16, sp
}
{ .bbb
br.call.sptk.many b0 = _dl_start#
;;
}
.endp _start#
/* FALLTHRU */
.global _dl_start_user#
.proc _dl_start_user#
_dl_start_user:
{ .mii
/* Save the pointer to the user entry point fptr in loc2. */
mov loc2 = ret0
/* Store the highest stack address. */
addl r2 = @ltoff(__libc_stack_end#), gp
addl r3 = @gprel(_dl_skip_args), gp
;;
}
{ .mmi
ld8 r2 = [r2]
ld4 r3 = [r3]
adds r11 = 24, sp /* Load the address of argv. */
;;
}
{ .mii
st8 [r2] = sp
adds r10 = 16, sp /* Load the address of argc. */
mov out2 = r11
;;
/* See if we were run as a command with the executable file
name as an extra leading argument. If so, adjust the argv
pointer to skip _dl_skip_args words.
Note that _dl_skip_args is an integer, not a long - Jes
The stack pointer has to be 16 byte aligned. We cannot simply
addjust the stack pointer. We have to move the whole argv and
envp and adjust _dl_argv by _dl_skip_args. H.J. */
}
{ .mib
ld8 out1 = [r10] /* is argc actually stored as a long
or as an int? */
addl r2 = @ltoff(_dl_argv), gp
;;
}
{ .mmi
ld8 r2 = [r2] /* Get the address of _dl_argv. */
sub out1 = out1, r3 /* Get the new argc. */
shladd r3 = r3, 3, r0
;;
}
{
.mib
ld8 r17 = [r2] /* Get _dl_argv. */
add r15 = r11, r3 /* The address of the argv we move */
;;
}
/* ??? Could probably merge these two loops into 3 bundles.
using predication to control which set of copies we're on. */
1: /* Copy argv. */
{ .mfi
ld8 r16 = [r15], 8 /* Load the value in the old argv. */
;;
}
{ .mib
st8 [r11] = r16, 8 /* Store it in the new argv. */
cmp.ne p6, p7 = 0, r16
(p6) br.cond.dptk.few 1b
;;
}
{ .mmi
mov out3 = r11
sub r17 = r17, r3 /* Substract _dl_skip_args. */
addl out0 = @ltoff(_dl_loaded), gp
}
1: /* Copy env. */
{ .mfi
ld8 r16 = [r15], 8 /* Load the value in the old env. */
;;
}
{ .mib
st8 [r11] = r16, 8 /* Store it in the new env. */
cmp.ne p6, p7 = 0, r16
(p6) br.cond.dptk.few 1b
;;
}
{ .mmb
st8 [r10] = out1 /* Record the new argc. */
ld8 out0 = [out0]
;;
}
{ .mmb
ld8 out0 = [out0] /* get the linkmap */
st8 [r2] = r17 /* Load the new _dl_argv. */
br.call.sptk.many b0 = _dl_init#
;;
}
/* Pass our finializer function to the user,
and jump to the user's entry point. */
{ .mmi
ld8 r3 = [loc2], 8
mov b0 = r0
}
{ .mmi
addl ret0 = @ltoff(@fptr(_dl_fini#)), gp
;;
mov b6 = r3
}
{ .mmi
ld8 ret0 = [ret0]
ld8 gp = [loc2]
mov ar.pfs = loc0
;;
}
{ .mfb
br.sptk.many b6
;;
}
.endp _dl_start_user#
.previous");
#define RTLD_START asm ( \
".text\n" \
" .global _start#\n" \
" .proc _start#\n" \
"_start:\n" \
"0: { .mii\n" \
" alloc loc0 = ar.pfs, 0, 3, 4, 0\n" \
" mov r2 = ip\n" \
" addl r3 = @gprel(0b), r0\n" \
" ;;\n" \
" }\n" \
" { .mlx\n" \
" /* Calculate the GP, and save a copy in loc1. */\n" \
" sub gp = r2, r3\n" \
" movl r8 = 0x9804c0270033f\n" \
" ;;\n" \
" }\n" \
" { .mii\n" \
" mov ar.fpsr = r8\n" \
" sub loc1 = r2, r3\n" \
" /* _dl_start wants a pointer to the pointer to the arg block and\n" \
" the arg block starts with an integer, thus the magic 16. */\n" \
" adds out0 = 16, sp\n" \
" }\n" \
" { .bbb\n" \
" br.call.sptk.many b0 = _dl_start#\n" \
" ;;\n" \
" }\n" \
" .endp _start#\n" \
" /* FALLTHRU */\n" \
" .global _dl_start_user#\n" \
" .proc _dl_start_user#\n" \
"_dl_start_user:\n" \
" { .mii\n" \
" /* Save the pointer to the user entry point fptr in loc2. */\n" \
" mov loc2 = ret0\n" \
" /* Store the highest stack address. */\n" \
" addl r2 = @ltoff(__libc_stack_end#), gp\n" \
" addl r3 = @gprel(_dl_skip_args), gp\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ld8 r2 = [r2]\n" \
" ld4 r3 = [r3]\n" \
" adds r11 = 24, sp /* Load the address of argv. */\n" \
" ;;\n" \
" }\n" \
" { .mii\n" \
" st8 [r2] = sp\n" \
" adds r10 = 16, sp /* Load the address of argc. */\n" \
" mov out2 = r11\n" \
" ;;\n" \
" /* See if we were run as a command with the executable file\n" \
" name as an extra leading argument. If so, adjust the argv\n" \
" pointer to skip _dl_skip_args words.\n" \
" Note that _dl_skip_args is an integer, not a long - Jes\n" \
"\n" \
" The stack pointer has to be 16 byte aligned. We cannot simply\n" \
" addjust the stack pointer. We have to move the whole argv and\n" \
" envp and adjust _dl_argv by _dl_skip_args. H.J. */\n" \
" }\n" \
" { .mib\n" \
" ld8 out1 = [r10] /* is argc actually stored as a long\n" \
" or as an int? */\n" \
" addl r2 = @ltoff(_dl_argv), gp\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" ld8 r2 = [r2] /* Get the address of _dl_argv. */\n" \
" sub out1 = out1, r3 /* Get the new argc. */\n" \
" shladd r3 = r3, 3, r0\n" \
" ;;\n" \
" }\n" \
" {\n" \
" .mib\n" \
" ld8 r17 = [r2] /* Get _dl_argv. */\n" \
" add r15 = r11, r3 /* The address of the argv we move */\n" \
" ;;\n" \
" }\n" \
" /* ??? Could probably merge these two loops into 3 bundles.\n" \
" using predication to control which set of copies we're on. */\n" \
"1: /* Copy argv. */\n" \
" { .mfi\n" \
" ld8 r16 = [r15], 8 /* Load the value in the old argv. */\n" \
" ;;\n" \
" }\n" \
" { .mib\n" \
" st8 [r11] = r16, 8 /* Store it in the new argv. */\n" \
" cmp.ne p6, p7 = 0, r16\n" \
"(p6) br.cond.dptk.few 1b\n" \
" ;;\n" \
" }\n" \
" { .mmi\n" \
" mov out3 = r11\n" \
" sub r17 = r17, r3 /* Substract _dl_skip_args. */\n" \
" addl out0 = @ltoff(_dl_loaded), gp\n" \
" }\n" \
"1: /* Copy env. */\n" \
" { .mfi\n" \
" ld8 r16 = [r15], 8 /* Load the value in the old env. */\n" \
" ;;\n" \
" }\n" \
" { .mib\n" \
" st8 [r11] = r16, 8 /* Store it in the new env. */\n" \
" cmp.ne p6, p7 = 0, r16\n" \
"(p6) br.cond.dptk.few 1b\n" \
" ;;\n" \
" }\n" \
" { .mmb\n" \
" st8 [r10] = out1 /* Record the new argc. */\n" \
" ld8 out0 = [out0]\n" \
" ;;\n" \
" }\n" \
" { .mmb\n" \
" ld8 out0 = [out0] /* get the linkmap */\n" \
" st8 [r2] = r17 /* Load the new _dl_argv. */\n" \
" br.call.sptk.many b0 = _dl_init#\n" \
" ;;\n" \
" }\n" \
" /* Pass our finializer function to the user,\n" \
" and jump to the user's entry point. */\n" \
" { .mmi\n" \
" ld8 r3 = [loc2], 8\n" \
" mov b0 = r0\n" \
" }\n" \
" { .mmi\n" \
" addl ret0 = @ltoff(@fptr(_dl_fini#)), gp\n" \
" ;;\n" \
" mov b6 = r3\n" \
" }\n" \
" { .mmi\n" \
" ld8 ret0 = [ret0]\n" \
" ld8 gp = [loc2]\n" \
" mov ar.pfs = loc0\n" \
" ;;\n" \
" }\n" \
" { .mfb\n" \
" br.sptk.many b6\n" \
" ;;\n" \
" }\n" \
" .endp _dl_start_user#\n" \
".previous\n");
#ifndef RTLD_START_SPECIAL_INIT
@ -435,7 +451,7 @@ _dl_start_user:
/* Return the address of the entry point. */
#define ELF_MACHINE_START_ADDRESS(map, start) \
DL_FUNCTION_ADDRESS (map, start)
DL_STATIC_FUNCTION_ADDRESS (map, start)
#define elf_machine_profile_fixup_plt(l, reloc, rel_addr, value) \
elf_machine_fixup_plt (l, reloc, rel_addr, value)
@ -452,7 +468,9 @@ elf_machine_fixup_plt (struct link_map *l, lookup_t t,
* being called */
/* got has already been relocated in elf_get_dynamic_info() */
reloc_addr[1] = t->l_info[DT_PLTGOT]->d_un.d_ptr;
reloc_addr[0] = value;
/* we need a "release" here to ensure that the gp is visible before
the code entry point is updated: */
((volatile Elf64_Addr *) reloc_addr)[0] = value;
return (Elf64_Addr) reloc_addr;
}
@ -487,7 +505,7 @@ elf_machine_rela (struct link_map *map,
const struct r_found_version *version,
Elf64_Addr *const reloc_addr)
{
unsigned long const r_type = ELF64_R_TYPE (reloc->r_info);
const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
Elf64_Addr value;
#ifndef RTLD_BOOTSTRAP
@ -533,35 +551,9 @@ elf_machine_rela (struct link_map *map,
return;
}
else if (R_IA64_TYPE (r_type) == R_IA64_TYPE (R_IA64_FPTR64LSB))
#ifndef RTLD_BOOTSTRAP
value = __ia64_make_fptr (sym_map, value, &__fptr_root, NULL);
#else
{
struct ia64_fptr *p_boot_ldso_fptr;
struct ia64_fptr **p_fptr_root;
int *p_fptr_count;
/* Special care must be taken to address these variables
during bootstrap. Further, since we don't know exactly
when __fptr_next will be relocated, we index directly
off __boot_ldso_fptr. */
asm ("addl %0 = @gprel(__boot_ldso_fptr#), gp\n\t"
"addl %1 = @gprel(__fptr_root#), gp\n\t"
"addl %2 = @gprel(__fptr_count#), gp"
: "=r"(p_boot_ldso_fptr),
"=r"(p_fptr_root),
"=r"(p_fptr_count));
/*
* Go from the top - __ia64_make_fptr goes from the bottom,
* this way we will never clash.
*/
value = __ia64_make_fptr (sym_map, value, p_fptr_root,
&p_boot_ldso_fptr[--*p_fptr_count]);
}
#endif
value = __ia64_make_fptr (sym_map, sym, value);
else if (R_IA64_TYPE (r_type) == R_IA64_TYPE (R_IA64_PCREL64LSB))
value -= (Elf64_Addr)reloc_addr & -16;
value -= (Elf64_Addr) reloc_addr & -16;
else
assert (! "unexpected dynamic reloc type");
}
@ -573,7 +565,7 @@ elf_machine_rela (struct link_map *map,
if (R_IA64_FORMAT (r_type) == R_IA64_FORMAT_64LSB)
*reloc_addr = value;
else if (R_IA64_FORMAT (r_type) == R_IA64_FORMAT_32LSB)
*(int *)reloc_addr = value;
*(int *) reloc_addr = value;
else if (r_type == R_IA64_IPLTLSB)
{
reloc_addr[0] = 0;
@ -589,8 +581,8 @@ static inline void
elf_machine_lazy_rel (struct link_map *map,
Elf64_Addr l_addr, const Elf64_Rela *reloc)
{
Elf64_Addr * const reloc_addr = (void *)(l_addr + reloc->r_offset);
unsigned long const r_type = ELF64_R_TYPE (reloc->r_info);
Elf64_Addr *const reloc_addr = (void *) (l_addr + reloc->r_offset);
const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
if (r_type == R_IA64_IPLTLSB)
{

10
sysdeps/ia64/dl-symaddr.c
View File

@ -1,5 +1,5 @@
/* Get the symbol address. IA-64 version.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
Copyright (C) 1999, 2000, 2001 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
@ -27,13 +27,7 @@ _dl_symbol_address (const struct link_map *map, const Elf64_Sym *ref)
/* On ia64, we have to return the pointer to function descriptor. */
if (ELFW(ST_TYPE) (ref->st_info) == STT_FUNC)
return (void *) __ia64_make_fptr (map, value, &__fptr_root, NULL);
return (void *) __ia64_make_fptr (map, ref, value);
else
return (void *) value;
}
Elf64_Addr
_dl_function_address (const struct link_map *map, Elf64_Addr start)
{
return __ia64_make_fptr (map, start, &__fptr_root, NULL);
}