From ba79d61b44be92bb81cba28076792a856585c4a0 Mon Sep 17 00:00:00 2001 From: Roland McGrath Date: Mon, 10 Jun 1996 20:19:39 +0000 Subject: * Makerules ($(common-objpfx)libc.so): Depend on $(elfobjdir)/ld.so. * elf/dl-close.c: New file. * elf/link.h: Declare _dl_close. * elf/Makefile (routines): Add dl-close. * elf/dlclose.c (dlclose): Use _dl_close. * elf/Makefile ($(objpfx)librtld.so): Remove libelf from deps. * elf/dl-runtime.c (_dl_global_scope): New variable. (_dl_object_relocation_scope): New function. (fixup): Use it. * elf/rtld.c (dl_main): Use it. * elf/dl-open.c (_dl_open): Use it. If (MODE & RTLD_GLOBAL), set the l_global bit and append the new map to _dl_global_scope. * elf/link.h: Declare _dl_global_scope, _dl_global_scope_alloc, and _dl_object_relocation_scope. * elf/link.h (struct link_map): Add l_loader member. Remove _dl_map_object_from_fd decl. * elf/dl-load.c (_dl_map_object): Pass LOADER to ... (_dl_map_object_from_fd): Take new arg LOADER and set l_loader member. (_dl_map_object): Try DT_RPATH from all loaders up the chain. * elf/dl-object.c (_dl_loaded): Variable removed. (_dl_default_scope): New variable replaces it. * elf/link.h (_dl_loaded): Remove variable decl; instead define as macro for _dl_default_scope[2]. (_dl_default_scope): Declare it. * sysdeps/i386/dl-machine.h (RTLD_START): Use _dl_default_scope[2] instead of _dl_loaded. * sysdeps/m68k/dl-machine.h (RTLD_START): Likewise. * elf/rtld.c (dl_main): Use _dl_default_scope for symbol lookups. * elf/dl-reloc.c (_dl_relocate_object): Remove check for _dl_rtld_map. * elf/rtld.c (dl_main): Pass 0 for LAZY flag when re-relocating self. * elf/link.h (struct link_map.l_type): Remove lt_interpreter. (struct link_map): Add new flag member l_global. * elf/dl-reloc.c (_dl_relocate_object): Check for _dl_rtld_map directly instead of looking for lt_interpreter. * sysdeps/i386/dl-machine.h (elf_machine_rel): Likewise. * elf/rtld.c (_dl_start): Don't bother setting BOOTSTRAP_MAP.l_type. (dl_main): Set _dl_rtld_map.l_type to lt_library. * elf/dl-deps.c (_dl_map_object_deps): Propagate MAP->l_type to dependencies loaded, downgrading lt_executable -> lt_library. * elf/dl-load.c (_dl_map_object_from_fd): Take new arg TYPE and set l_type from that, translating lt_library->lt_executable based on the file's ELF type. (_dl_map_object): Likewise. * elf/link.h: Update prototypes. * elf/dl-open.c: Pass type lt_loaded. * elf/rtld.c: Pass type lt_library. * elf/dl-load.c (_dl_map_object_from_fd): Handle null return from _dl_new_object. (_dl_map_object_from_fd: lose): Unchain and free L if it's not null. Free REALNAME, and just use NAME in error message. * elf/dl-object.c (_dl_new_object): If malloc fails, return null instead of calling _dl_signal_error. * elf/dl-load.c (_dl_map_object_from_fd): Close FD before signalling error for _dl_zerofd setup failure. * elf/dl-object.c (_dl_startup_loaded): Variable removed. * elf/link.h: Remove its decl. * elf/dl-reloc.c (_dl_relocate_object): Take new SCOPE arg and pass it through to _dl_lookup_symbol. * elf/link.h (_dl_relocate_object): Update comment and prototype. * elf/rtld.c (dl_main): Pass scope vector to _dl_relocate_object. * elf/dl-lookup.c (_dl_lookup_symbol): Arg SYMBOL_SCOPE is now a null-terminated vector of pointers, no longer a vector of exactly two. * elf/link.h (_dl_lookup_symbol): Update comment and prototype. * elf/dl-runtime.c (fixup): Set up scope for symbol lookup properly as done in _dl_relocate_object. * elf/dlopen.c: Pass "" to _dl_open when FILE is null. --- elf/dl-reloc.c | 33 +++++++-------------------------- 1 file changed, 7 insertions(+), 26 deletions(-) (limited to 'elf/dl-reloc.c') diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c index 5da8575da5..e6778e7de3 100644 --- a/elf/dl-reloc.c +++ b/elf/dl-reloc.c @@ -26,7 +26,7 @@ Cambridge, MA 02139, USA. */ void -_dl_relocate_object (struct link_map *l, int lazy) +_dl_relocate_object (struct link_map *l, struct link_map *scope[], int lazy) { if (l->l_relocated) return; @@ -52,44 +52,26 @@ _dl_relocate_object (struct link_map *l, int lazy) } { - struct link_map *scope[2]; + /* Do the actual relocation of the object's GOT and other data. */ - const char *strtab + const char *strtab /* String table object symbols. */ = ((void *) l->l_addr + l->l_info[DT_STRTAB]->d_un.d_ptr); - ElfW(Addr) resolve (const ElfW(Sym) **ref, ElfW(Addr) reloc_addr, int noplt) { + /* Look up the referenced symbol in the specified scope. */ return _dl_lookup_symbol (strtab + (*ref)->st_name, ref, scope, l->l_name, reloc_addr, noplt); } - if (l->l_info[DT_SYMBOLIC]) - { - scope[0] = l; - scope[1] = _dl_loaded; - } - else - { - scope[0] = _dl_loaded; - scope[1] = l; - } - - if (l->l_type == lt_interpreter) - /* We cannot be lazy when relocating the dynamic linker itself. It - was previously relocated eagerly (allowing us to be running now), - and needs always to be fully relocated so it can run without the - aid of run-time fixups (because it's the one to do them), so we - must always re-relocate its PLT eagerly. */ - lazy = 0; - ELF_DYNAMIC_RELOCATE (l, lazy, resolve); } - /* Set up the PLT so its unrelocated entries will - jump to _dl_runtime_resolve, which will relocate them. */ + /* Set up the PLT so its unrelocated entries will jump to + _dl_runtime_resolve (dl-runtime.c), which will relocate them. */ elf_machine_runtime_setup (l, lazy); + /* Mark the object so we know ths work has been done. */ l->l_relocated = 1; if (l->l_info[DT_TEXTREL]) @@ -114,5 +96,4 @@ _dl_relocate_object (struct link_map *l, int lazy) "can't restore segment prot after reloc"); } } - } -- cgit v1.2.3