link_elf.c revision 105147
118334Speter/*- 218334Speter * Copyright (c) 1998-2000 Doug Rabson 390075Sobrien * All rights reserved. 496263Sobrien * 518334Speter * Redistribution and use in source and binary forms, with or without 690075Sobrien * modification, are permitted provided that the following conditions 718334Speter * are met: 890075Sobrien * 1. Redistributions of source code must retain the above copyright 990075Sobrien * notice, this list of conditions and the following disclaimer. 1090075Sobrien * 2. Redistributions in binary form must reproduce the above copyright 1190075Sobrien * notice, this list of conditions and the following disclaimer in the 1218334Speter * documentation and/or other materials provided with the distribution. 1390075Sobrien * 1490075Sobrien * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1590075Sobrien * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1690075Sobrien * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1718334Speter * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1818334Speter * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1990075Sobrien * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2090075Sobrien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2190075Sobrien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2218334Speter * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2390075Sobrien * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2490075Sobrien * SUCH DAMAGE. 2590075Sobrien * 2618334Speter * $FreeBSD: head/sys/kern/link_elf.c 105147 2002-10-15 05:40:07Z marcel $ 2790075Sobrien */ 2818334Speter 2918334Speter#include "opt_ddb.h" 3018334Speter 3190075Sobrien#include <sys/param.h> 3218334Speter#include <sys/systm.h> 3318334Speter#include <sys/kernel.h> 3418334Speter#include <sys/lock.h> 3590075Sobrien#include <sys/malloc.h> 3618334Speter#include <sys/mutex.h> 3718334Speter#include <sys/proc.h> 3818334Speter#include <sys/namei.h> 3990075Sobrien#include <sys/fcntl.h> 4018334Speter#include <sys/vnode.h> 4190075Sobrien#include <sys/linker.h> 4218334Speter 4318334Speter#include <machine/elf.h> 4490075Sobrien#ifdef GPROF 4518334Speter#include <machine/profile.h> 4618334Speter#endif 4790075Sobrien 4818334Speter#include <vm/vm.h> 4918334Speter#include <vm/vm_param.h> 5018334Speter#ifdef SPARSE_MAPPING 5118334Speter#include <vm/vm_object.h> 5290075Sobrien#include <vm/vm_kern.h> 5318334Speter#include <vm/vm_extern.h> 5418334Speter#endif 5518334Speter#include <vm/pmap.h> 5690075Sobrien#include <vm/vm_map.h> 5718334Speter 5818334Speter#include <sys/link_elf.h> 5918334Speter 6018334Speter#include "linker_if.h" 6118334Speter 6218334Spetertypedef struct elf_file { 6390075Sobrien struct linker_file lf; /* Common fields */ 6418334Speter int preloaded; /* Was file pre-loaded */ 6518334Speter caddr_t address; /* Relocation address */ 6618334Speter#ifdef SPARSE_MAPPING 6718334Speter vm_object_t object; /* VM object to hold file pages */ 6890075Sobrien#endif 6918334Speter Elf_Dyn* dynamic; /* Symbol table etc. */ 7018334Speter Elf_Hashelt nbuckets; /* DT_HASH info */ 7190075Sobrien Elf_Hashelt nchains; 7218334Speter const Elf_Hashelt* buckets; 7318334Speter const Elf_Hashelt* chains; 7418334Speter caddr_t hash; 7518334Speter caddr_t strtab; /* DT_STRTAB */ 7690075Sobrien int strsz; /* DT_STRSZ */ 7718334Speter const Elf_Sym* symtab; /* DT_SYMTAB */ 7818334Speter Elf_Addr* got; /* DT_PLTGOT */ 7918334Speter const Elf_Rel* pltrel; /* DT_JMPREL */ 8090075Sobrien int pltrelsize; /* DT_PLTRELSZ */ 8118334Speter const Elf_Rela* pltrela; /* DT_JMPREL */ 8218334Speter int pltrelasize; /* DT_PLTRELSZ */ 8318334Speter const Elf_Rel* rel; /* DT_REL */ 8496263Sobrien int relsize; /* DT_RELSZ */ 8518334Speter const Elf_Rela* rela; /* DT_RELA */ 8618334Speter int relasize; /* DT_RELASZ */ 8718334Speter caddr_t modptr; 8890075Sobrien const Elf_Sym* ddbsymtab; /* The symbol table we are using */ 8918334Speter long ddbsymcnt; /* Number of symbols */ 9050397Sobrien caddr_t ddbstrtab; /* String table */ 9150397Sobrien long ddbstrcnt; /* number of bytes in string table */ 9250397Sobrien caddr_t symbase; /* malloc'ed symbold base */ 9390075Sobrien caddr_t strbase; /* malloc'ed string base */ 9450397Sobrien#ifdef DDB 9552284Sobrien struct link_map gdb; /* hooks for gdb */ 9652284Sobrien#endif 9790075Sobrien} *elf_file_t; 9852284Sobrien 9918334Speterstatic int link_elf_link_preload(linker_class_t cls, 10090075Sobrien const char*, linker_file_t*); 10118334Speterstatic int link_elf_link_preload_finish(linker_file_t); 10218334Speterstatic int link_elf_load_file(linker_class_t, const char*, linker_file_t*); 10318334Speterstatic int link_elf_lookup_symbol(linker_file_t, const char*, 10490075Sobrien c_linker_sym_t*); 10518334Speterstatic int link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*); 10618334Speterstatic int link_elf_search_symbol(linker_file_t, caddr_t value, 10718334Speter c_linker_sym_t* sym, long* diffp); 10818334Speter 10990075Sobrienstatic void link_elf_unload_file(linker_file_t); 11018334Speterstatic void link_elf_unload_preload(linker_file_t); 11118334Speterstatic int link_elf_lookup_set(linker_file_t, const char *, 11218334Speter void ***, void ***, int *); 11390075Sobrienstatic int link_elf_each_function_name(linker_file_t, 11418334Speter int (*)(const char *, void *), 11518334Speter void *); 11618334Speter 11790075Sobrienstatic kobj_method_t link_elf_methods[] = { 11818334Speter KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 11918334Speter KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 12090075Sobrien KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 12118334Speter KOBJMETHOD(linker_unload, link_elf_unload_file), 12290075Sobrien KOBJMETHOD(linker_load_file, link_elf_load_file), 12390075Sobrien KOBJMETHOD(linker_link_preload, link_elf_link_preload), 12490075Sobrien KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 12590075Sobrien KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 12690075Sobrien KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 12718334Speter { 0, 0 } 12818334Speter}; 12990075Sobrien 13018334Speterstatic struct linker_class link_elf_class = { 13118334Speter#if ELF_TARG_CLASS == ELFCLASS32 13218334Speter "elf32", 13390075Sobrien#else 13450397Sobrien "elf64", 13590075Sobrien#endif 13690075Sobrien link_elf_methods, sizeof(struct elf_file) 13790075Sobrien}; 13890075Sobrien 13990075Sobrienstatic int parse_dynamic(elf_file_t ef); 14090075Sobrienstatic int relocate_file(elf_file_t ef); 14190075Sobrienstatic int link_elf_preload_parse_symbols(elf_file_t ef); 14250397Sobrien 14390075Sobrien#ifdef DDB 14490075Sobrienstatic void r_debug_state(struct r_debug *dummy_one, 14590075Sobrien struct link_map *dummy_two); 14690075Sobrien 14790075Sobrien/* 14890075Sobrien * A list of loaded modules for GDB to use for loading symbols. 14918334Speter */ 15018334Speterstruct r_debug r_debug; 15118334Speter 15218334Speter#define GDB_STATE(s) r_debug.r_state = s; r_debug_state(NULL, NULL); 15318334Speter 15490075Sobrien/* 15518334Speter * Function for the debugger to set a breakpoint on to gain control. 15618334Speter */ 15790075Sobrienstatic void 15818334Speterr_debug_state(struct r_debug *dummy_one __unused, 15952284Sobrien struct link_map *dummy_two __unused) 16090075Sobrien{ 16152284Sobrien} 16218334Speter 16318334Speter#endif 16490075Sobrien 16518334Speter#ifdef __ia64__ 16690075SobrienElf_Addr link_elf_get_gp(linker_file_t); 16790075Sobrien#endif 16818334Speter 16990075Sobrien/* 17090075Sobrien * The kernel symbol table starts here. 17150397Sobrien */ 17250397Sobrienextern struct _dynamic _DYNAMIC; 17390075Sobrien 17490075Sobrienstatic void 17590075Sobrienlink_elf_init(void* arg) 17690075Sobrien{ 17790075Sobrien Elf_Dyn *dp; 17890075Sobrien caddr_t modptr, baseptr, sizeptr; 17990075Sobrien elf_file_t ef; 18090075Sobrien char *modname; 18190075Sobrien#ifdef DDB 18290075Sobrien char *newfilename; 18390075Sobrien#endif 18490075Sobrien 18590075Sobrien linker_add_class(&link_elf_class); 18690075Sobrien 18790075Sobrien dp = (Elf_Dyn*) &_DYNAMIC; 18890075Sobrien modname = NULL; 18990075Sobrien modptr = preload_search_by_type("elf kernel"); 19090075Sobrien if (modptr) 19190075Sobrien modname = (char *)preload_search_info(modptr, MODINFO_NAME); 19290075Sobrien if (modname == NULL) 19390075Sobrien modname = "kernel"; 19490075Sobrien linker_kernel_file = linker_make_file(modname, &link_elf_class); 19590075Sobrien if (linker_kernel_file == NULL) 19690075Sobrien panic("link_elf_init: Can't create linker structures for kernel"); 19790075Sobrien 19890075Sobrien ef = (elf_file_t) linker_kernel_file; 19990075Sobrien ef->preloaded = 1; 20090075Sobrien ef->address = 0; 20190075Sobrien#ifdef SPARSE_MAPPING 20290075Sobrien ef->object = 0; 20390075Sobrien#endif 20490075Sobrien ef->dynamic = dp; 20590075Sobrien 20690075Sobrien if (dp) 20790075Sobrien parse_dynamic(ef); 20890075Sobrien linker_kernel_file->address = (caddr_t) KERNBASE; 20990075Sobrien linker_kernel_file->size = -(intptr_t)linker_kernel_file->address; 21090075Sobrien 21190075Sobrien if (modptr) { 21290075Sobrien ef->modptr = modptr; 21318334Speter baseptr = preload_search_info(modptr, MODINFO_ADDR); 21418334Speter if (baseptr) 21518334Speter linker_kernel_file->address = *(caddr_t *)baseptr; 21650397Sobrien sizeptr = preload_search_info(modptr, MODINFO_SIZE); 21750397Sobrien if (sizeptr) 21890075Sobrien linker_kernel_file->size = *(size_t *)sizeptr; 21918334Speter } 22018334Speter (void)link_elf_preload_parse_symbols(ef); 22190075Sobrien 22218334Speter#ifdef DDB 22390075Sobrien ef->gdb.l_addr = linker_kernel_file->address; 22490075Sobrien newfilename = malloc(strlen(modname) + 1, M_LINKER, M_WAITOK); 22590075Sobrien strcpy(newfilename, modname); 22650397Sobrien ef->gdb.l_name = newfilename; 22790075Sobrien ef->gdb.l_ld = dp; 22890075Sobrien ef->gdb.l_prev = 0; 22990075Sobrien ef->gdb.l_next = 0; 23090075Sobrien 23118334Speter r_debug.r_map = &ef->gdb; 23250397Sobrien r_debug.r_brk = r_debug_state; 23390075Sobrien r_debug.r_state = RT_CONSISTENT; 23496263Sobrien 23596263Sobrien r_debug_state(NULL, NULL); /* say hello to gdb! */ 23650397Sobrien#endif 23750397Sobrien} 23850397Sobrien 23990075SobrienSYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 24050397Sobrien 24118334Speterstatic int 24218334Speterlink_elf_preload_parse_symbols(elf_file_t ef) 24318334Speter{ 24418334Speter caddr_t pointer; 24518334Speter caddr_t ssym, esym, base; 24618334Speter caddr_t strtab; 24718334Speter int strcnt; 24890075Sobrien Elf_Sym* symtab; 24918334Speter int symcnt; 25050397Sobrien 25118334Speter if (ef->modptr == NULL) 25218334Speter return 0; 25390075Sobrien pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM); 25418334Speter if (pointer == NULL) 25518334Speter return 0; 25690075Sobrien ssym = *(caddr_t *)pointer; 25718334Speter pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM); 25890075Sobrien if (pointer == NULL) 25950397Sobrien return 0; 26018334Speter esym = *(caddr_t *)pointer; 26118334Speter 26290075Sobrien base = ssym; 26318334Speter 26418334Speter symcnt = *(long *)base; 26518334Speter base += sizeof(long); 26618334Speter symtab = (Elf_Sym *)base; 26718334Speter base += roundup(symcnt, sizeof(long)); 26890075Sobrien 26918334Speter if (base > esym || base < ssym) { 27018334Speter printf("Symbols are corrupt!\n"); 27118334Speter return EINVAL; 27290075Sobrien } 27318334Speter 27418334Speter strcnt = *(long *)base; 27518334Speter base += sizeof(long); 27618334Speter strtab = base; 27718334Speter base += roundup(strcnt, sizeof(long)); 27818334Speter 27918334Speter if (base > esym || base < ssym) { 28018334Speter printf("Symbols are corrupt!\n"); 28118334Speter return EINVAL; 28218334Speter } 28390075Sobrien 28418334Speter ef->ddbsymtab = symtab; 28518334Speter ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 28618334Speter ef->ddbstrtab = strtab; 28718334Speter ef->ddbstrcnt = strcnt; 28890075Sobrien 28950397Sobrien return 0; 29018334Speter} 29190075Sobrien 29290075Sobrienstatic int 29390075Sobrienparse_dynamic(elf_file_t ef) 29490075Sobrien{ 29590075Sobrien Elf_Dyn *dp; 29690075Sobrien int plttype = DT_REL; 29790075Sobrien 29890075Sobrien for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 29990075Sobrien switch (dp->d_tag) { 30090075Sobrien case DT_HASH: 30118334Speter { 30218334Speter /* From src/libexec/rtld-elf/rtld.c */ 30390075Sobrien const Elf_Hashelt *hashtab = (const Elf_Hashelt *) 30418334Speter (ef->address + dp->d_un.d_ptr); 30518334Speter ef->nbuckets = hashtab[0]; 30618334Speter ef->nchains = hashtab[1]; 30790075Sobrien ef->buckets = hashtab + 2; 30818334Speter ef->chains = ef->buckets + ef->nbuckets; 30918334Speter break; 31090075Sobrien } 31190075Sobrien case DT_STRTAB: 31218334Speter ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr); 31318334Speter break; 31418334Speter case DT_STRSZ: 31518334Speter ef->strsz = dp->d_un.d_val; 31618334Speter break; 31718334Speter case DT_SYMTAB: 31890075Sobrien ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr); 31918334Speter break; 32090075Sobrien case DT_SYMENT: 32190075Sobrien if (dp->d_un.d_val != sizeof(Elf_Sym)) 32290075Sobrien return ENOEXEC; 32390075Sobrien break; 32490075Sobrien case DT_PLTGOT: 32590075Sobrien ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr); 32690075Sobrien break; 32790075Sobrien case DT_REL: 32890075Sobrien ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 32918334Speter break; 33090075Sobrien case DT_RELSZ: 33190075Sobrien ef->relsize = dp->d_un.d_val; 33290075Sobrien break; 33318334Speter case DT_RELENT: 33490075Sobrien if (dp->d_un.d_val != sizeof(Elf_Rel)) 33590075Sobrien return ENOEXEC; 33618334Speter break; 33790075Sobrien case DT_JMPREL: 33890075Sobrien ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 33990075Sobrien break; 34090075Sobrien case DT_PLTRELSZ: 34190075Sobrien ef->pltrelsize = dp->d_un.d_val; 34290075Sobrien break; 34390075Sobrien case DT_RELA: 34490075Sobrien ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr); 34590075Sobrien break; 34690075Sobrien case DT_RELASZ: 34790075Sobrien ef->relasize = dp->d_un.d_val; 34890075Sobrien break; 34990075Sobrien case DT_RELAENT: 35018334Speter if (dp->d_un.d_val != sizeof(Elf_Rela)) 35190075Sobrien return ENOEXEC; 35290075Sobrien break; 35390075Sobrien case DT_PLTREL: 35418334Speter plttype = dp->d_un.d_val; 35518334Speter if (plttype != DT_REL && plttype != DT_RELA) 35618334Speter return ENOEXEC; 35718334Speter break; 35818334Speter#ifdef DDB 35918334Speter case DT_DEBUG: 36090075Sobrien dp->d_un.d_ptr = (Elf_Addr) &r_debug; 36118334Speter break; 36218334Speter#endif 36390075Sobrien } 36418334Speter } 36518334Speter 36618334Speter if (plttype == DT_RELA) { 36790075Sobrien ef->pltrela = (const Elf_Rela *) ef->pltrel; 36818334Speter ef->pltrel = NULL; 36918334Speter ef->pltrelasize = ef->pltrelsize; 37090075Sobrien ef->pltrelsize = 0; 37118334Speter } 37290075Sobrien 37390075Sobrien ef->ddbsymtab = ef->symtab; 37490075Sobrien ef->ddbsymcnt = ef->nchains; 37590075Sobrien ef->ddbstrtab = ef->strtab; 37618334Speter ef->ddbstrcnt = ef->strsz; 37718334Speter 37890075Sobrien return 0; 37918334Speter} 38090075Sobrien 38190075Sobrienstatic void 38290075Sobrienlink_elf_error(const char *s) 38390075Sobrien{ 38490075Sobrien printf("kldload: %s\n", s); 38590075Sobrien} 38690075Sobrien 38790075Sobrien#ifdef DDB 38890075Sobrien 38990075Sobrienstatic void 39090075Sobrienlink_elf_add_gdb(struct link_map *l) 39118334Speter{ 39218334Speter struct link_map *prev; 39318334Speter 39418334Speter /* 39518334Speter * Scan to the end of the list. 39690075Sobrien */ 39790075Sobrien for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next) 39890075Sobrien ; 39990075Sobrien 40090075Sobrien /* Link in the new entry. */ 40118334Speter l->l_prev = prev; 40218334Speter l->l_next = prev->l_next; 40318334Speter prev->l_next = l; 40418334Speter} 40518334Speter 40618334Speterstatic void 40718334Speterlink_elf_delete_gdb(struct link_map *l) 40818334Speter{ 40918334Speter if (l->l_prev == NULL) { 41018334Speter if ((r_debug.r_map = l->l_next) != NULL) 41118334Speter l->l_next->l_prev = NULL; 41218334Speter return; 41390075Sobrien } 41490075Sobrien 41518334Speter if ((l->l_prev->l_next = l->l_next) != NULL) 41690075Sobrien l->l_next->l_prev = l->l_prev; 41790075Sobrien} 41890075Sobrien 41918334Speter#endif /* DDB */ 42090075Sobrien 42118334Speterstatic int 42290075Sobrienlink_elf_link_preload(linker_class_t cls, 42390075Sobrien const char* filename, linker_file_t *result) 42490075Sobrien{ 42518334Speter caddr_t modptr, baseptr, sizeptr, dynptr; 42690075Sobrien char *type; 42790075Sobrien elf_file_t ef; 42818334Speter linker_file_t lf; 42990075Sobrien int error; 43090075Sobrien vm_offset_t dp; 43118334Speter 43252284Sobrien /* Look to see if we have the file preloaded */ 43352284Sobrien modptr = preload_search_by_name(filename); 43452284Sobrien if (modptr == NULL) 43590075Sobrien return ENOENT; 43652284Sobrien 43752284Sobrien type = (char *)preload_search_info(modptr, MODINFO_TYPE); 43852284Sobrien baseptr = preload_search_info(modptr, MODINFO_ADDR); 43990075Sobrien sizeptr = preload_search_info(modptr, MODINFO_SIZE); 44090075Sobrien dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC); 44190075Sobrien if (type == NULL || strcmp(type, "elf module") != 0) 44290075Sobrien return (EFTYPE); 44390075Sobrien if (baseptr == NULL || sizeptr == NULL || dynptr == NULL) 44452284Sobrien return (EINVAL); 44552284Sobrien 44690075Sobrien lf = linker_make_file(filename, &link_elf_class); 44752284Sobrien if (lf == NULL) { 44852284Sobrien return ENOMEM; 44952284Sobrien } 45052284Sobrien 45152284Sobrien ef = (elf_file_t) lf; 45252284Sobrien ef->preloaded = 1; 45352284Sobrien ef->modptr = modptr; 45452284Sobrien ef->address = *(caddr_t *)baseptr; 45552284Sobrien#ifdef SPARSE_MAPPING 45652284Sobrien ef->object = 0; 45752284Sobrien#endif 45852284Sobrien dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr; 45952284Sobrien ef->dynamic = (Elf_Dyn *)dp; 46052284Sobrien lf->address = ef->address; 46152284Sobrien lf->size = *(size_t *)sizeptr; 46290075Sobrien 46390075Sobrien error = parse_dynamic(ef); 46490075Sobrien if (error) { 46590075Sobrien linker_file_unload(lf); 46690075Sobrien return error; 46790075Sobrien } 46850397Sobrien *result = lf; 46950397Sobrien return (0); 47050397Sobrien} 47150397Sobrien 47250397Sobrienstatic int 47350397Sobrienlink_elf_link_preload_finish(linker_file_t lf) 47450397Sobrien{ 47550397Sobrien elf_file_t ef; 47650397Sobrien int error; 47750397Sobrien#ifdef DDB 47852284Sobrien char *newfilename; 47952284Sobrien#endif 48052284Sobrien 48152284Sobrien ef = (elf_file_t) lf; 48252284Sobrien#if 0 /* this will be more trouble than it's worth for now */ 48352284Sobrien for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 48452284Sobrien if (dp->d_tag != DT_NEEDED) 48552284Sobrien continue; 48652284Sobrien modname = ef->strtab + dp->d_un.d_val; 48752284Sobrien error = linker_load_module(modname, lf); 48852284Sobrien if (error) 48990075Sobrien goto out; 49090075Sobrien } 49190075Sobrien#endif 49290075Sobrien error = relocate_file(ef); 49390075Sobrien if (error) 49490075Sobrien return error; 49590075Sobrien (void)link_elf_preload_parse_symbols(ef); 49690075Sobrien 49790075Sobrien#ifdef DDB 49890075Sobrien GDB_STATE(RT_ADD); 49990075Sobrien ef->gdb.l_addr = lf->address; 50090075Sobrien newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK); 50190075Sobrien strcpy(newfilename, lf->filename); 50290075Sobrien ef->gdb.l_name = newfilename; 50390075Sobrien ef->gdb.l_ld = ef->dynamic; 50490075Sobrien link_elf_add_gdb(&ef->gdb); 50590075Sobrien GDB_STATE(RT_CONSISTENT); 50690075Sobrien#endif 50790075Sobrien 50890075Sobrien return (0); 50990075Sobrien} 51090075Sobrien 51190075Sobrienstatic int 51290075Sobrienlink_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result) 51390075Sobrien{ 51496263Sobrien struct nameidata nd; 51596263Sobrien struct thread* td = curthread; /* XXX */ 51690075Sobrien Elf_Ehdr *hdr; 51790075Sobrien caddr_t firstpage; 51890075Sobrien int nbytes, i; 51990075Sobrien Elf_Phdr *phdr; 52090075Sobrien Elf_Phdr *phlimit; 52190075Sobrien Elf_Phdr *segs[2]; 52290075Sobrien int nsegs; 52390075Sobrien Elf_Phdr *phdyn; 52490075Sobrien Elf_Phdr *phphdr; 52590075Sobrien caddr_t mapbase; 52690075Sobrien size_t mapsize; 52790075Sobrien Elf_Off base_offset; 52890075Sobrien Elf_Addr base_vaddr; 52990075Sobrien Elf_Addr base_vlimit; 53090075Sobrien int error = 0; 53190075Sobrien int resid, flags; 53290075Sobrien elf_file_t ef; 53390075Sobrien linker_file_t lf; 53490075Sobrien Elf_Shdr *shdr; 53590075Sobrien int symtabindex; 53690075Sobrien int symstrindex; 53790075Sobrien int symcnt; 53890075Sobrien int strcnt; 53990075Sobrien#ifdef DDB 54090075Sobrien char *newfilename; 54190075Sobrien#endif 54290075Sobrien 54390075Sobrien GIANT_REQUIRED; 54490075Sobrien 54590075Sobrien shdr = NULL; 54690075Sobrien lf = NULL; 547 548 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); 549 flags = FREAD; 550 error = vn_open(&nd, &flags, 0); 551 if (error) 552 return error; 553 NDFREE(&nd, NDF_ONLY_PNBUF); 554 555 /* 556 * Read the elf header from the file. 557 */ 558 firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK); 559 if (firstpage == NULL) { 560 error = ENOMEM; 561 goto out; 562 } 563 hdr = (Elf_Ehdr *)firstpage; 564 error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, 565 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 566 &resid, td); 567 nbytes = PAGE_SIZE - resid; 568 if (error) 569 goto out; 570 571 if (!IS_ELF(*hdr)) { 572 error = ENOEXEC; 573 goto out; 574 } 575 576 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 577 || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 578 link_elf_error("Unsupported file layout"); 579 error = ENOEXEC; 580 goto out; 581 } 582 if (hdr->e_ident[EI_VERSION] != EV_CURRENT 583 || hdr->e_version != EV_CURRENT) { 584 link_elf_error("Unsupported file version"); 585 error = ENOEXEC; 586 goto out; 587 } 588 if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) { 589 link_elf_error("Unsupported file type"); 590 error = ENOEXEC; 591 goto out; 592 } 593 if (hdr->e_machine != ELF_TARG_MACH) { 594 link_elf_error("Unsupported machine"); 595 error = ENOEXEC; 596 goto out; 597 } 598 599 /* 600 * We rely on the program header being in the first page. This is 601 * not strictly required by the ABI specification, but it seems to 602 * always true in practice. And, it simplifies things considerably. 603 */ 604 if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) && 605 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) && 606 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes))) 607 link_elf_error("Unreadable program headers"); 608 609 /* 610 * Scan the program header entries, and save key information. 611 * 612 * We rely on there being exactly two load segments, text and data, 613 * in that order. 614 */ 615 phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff); 616 phlimit = phdr + hdr->e_phnum; 617 nsegs = 0; 618 phdyn = NULL; 619 phphdr = NULL; 620 while (phdr < phlimit) { 621 switch (phdr->p_type) { 622 623 case PT_LOAD: 624 if (nsegs == 2) { 625 link_elf_error("Too many sections"); 626 error = ENOEXEC; 627 goto out; 628 } 629 segs[nsegs] = phdr; 630 ++nsegs; 631 break; 632 633 case PT_PHDR: 634 phphdr = phdr; 635 break; 636 637 case PT_DYNAMIC: 638 phdyn = phdr; 639 break; 640 641 case PT_INTERP: 642 link_elf_error("Unsupported file type"); 643 error = ENOEXEC; 644 goto out; 645 } 646 647 ++phdr; 648 } 649 if (phdyn == NULL) { 650 link_elf_error("Object is not dynamically-linked"); 651 error = ENOEXEC; 652 goto out; 653 } 654 655 /* 656 * Allocate the entire address space of the object, to stake out our 657 * contiguous region, and to establish the base address for relocation. 658 */ 659 base_offset = trunc_page(segs[0]->p_offset); 660 base_vaddr = trunc_page(segs[0]->p_vaddr); 661 base_vlimit = round_page(segs[1]->p_vaddr + segs[1]->p_memsz); 662 mapsize = base_vlimit - base_vaddr; 663 664 lf = linker_make_file(filename, &link_elf_class); 665 if (!lf) { 666 error = ENOMEM; 667 goto out; 668 } 669 670 ef = (elf_file_t) lf; 671#ifdef SPARSE_MAPPING 672 ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT); 673 if (ef->object == NULL) { 674 free(ef, M_LINKER); 675 error = ENOMEM; 676 goto out; 677 } 678 vm_object_reference(ef->object); 679 ef->address = (caddr_t) vm_map_min(kernel_map); 680 error = vm_map_find(kernel_map, ef->object, 0, 681 (vm_offset_t *) &ef->address, 682 mapsize, 1, 683 VM_PROT_ALL, VM_PROT_ALL, 0); 684 if (error) { 685 vm_object_deallocate(ef->object); 686 ef->object = 0; 687 goto out; 688 } 689#else 690 ef->address = malloc(mapsize, M_LINKER, M_WAITOK); 691 if (!ef->address) { 692 error = ENOMEM; 693 goto out; 694 } 695#endif 696 mapbase = ef->address; 697 698 /* 699 * Read the text and data sections and zero the bss. 700 */ 701 for (i = 0; i < 2; i++) { 702 caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; 703 error = vn_rdwr(UIO_READ, nd.ni_vp, 704 segbase, segs[i]->p_filesz, segs[i]->p_offset, 705 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 706 &resid, td); 707 if (error) { 708 goto out; 709 } 710 bzero(segbase + segs[i]->p_filesz, 711 segs[i]->p_memsz - segs[i]->p_filesz); 712 713#ifdef SPARSE_MAPPING 714 /* 715 * Wire down the pages 716 */ 717 vm_map_wire(kernel_map, 718 (vm_offset_t) segbase, 719 (vm_offset_t) segbase + segs[i]->p_memsz, 720 FALSE); 721#endif 722 } 723 724#ifdef GPROF 725 /* Update profiling information with the new text segment. */ 726 kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr + 727 segs[0]->p_memsz)); 728#endif 729 730 ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr); 731 732 lf->address = ef->address; 733 lf->size = mapsize; 734 735 error = parse_dynamic(ef); 736 if (error) 737 goto out; 738 error = linker_load_dependencies(lf); 739 if (error) 740 goto out; 741#if 0 /* this will be more trouble than it's worth for now */ 742 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 743 if (dp->d_tag != DT_NEEDED) 744 continue; 745 modname = ef->strtab + dp->d_un.d_val; 746 error = linker_load_module(modname, lf); 747 if (error) 748 goto out; 749 } 750#endif 751 error = relocate_file(ef); 752 if (error) 753 goto out; 754 755 /* Try and load the symbol table if it's present. (you can strip it!) */ 756 nbytes = hdr->e_shnum * hdr->e_shentsize; 757 if (nbytes == 0 || hdr->e_shoff == 0) 758 goto nosyms; 759 shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 760 if (shdr == NULL) { 761 error = ENOMEM; 762 goto out; 763 } 764 error = vn_rdwr(UIO_READ, nd.ni_vp, 765 (caddr_t)shdr, nbytes, hdr->e_shoff, 766 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 767 &resid, td); 768 if (error) 769 goto out; 770 symtabindex = -1; 771 symstrindex = -1; 772 for (i = 0; i < hdr->e_shnum; i++) { 773 if (shdr[i].sh_type == SHT_SYMTAB) { 774 symtabindex = i; 775 symstrindex = shdr[i].sh_link; 776 } 777 } 778 if (symtabindex < 0 || symstrindex < 0) 779 goto nosyms; 780 781 symcnt = shdr[symtabindex].sh_size; 782 ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK); 783 strcnt = shdr[symstrindex].sh_size; 784 ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK); 785 786 if (ef->symbase == NULL || ef->strbase == NULL) { 787 error = ENOMEM; 788 goto out; 789 } 790 error = vn_rdwr(UIO_READ, nd.ni_vp, 791 ef->symbase, symcnt, shdr[symtabindex].sh_offset, 792 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 793 &resid, td); 794 if (error) 795 goto out; 796 error = vn_rdwr(UIO_READ, nd.ni_vp, 797 ef->strbase, strcnt, shdr[symstrindex].sh_offset, 798 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 799 &resid, td); 800 if (error) 801 goto out; 802 803 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 804 ef->ddbsymtab = (const Elf_Sym *)ef->symbase; 805 ef->ddbstrcnt = strcnt; 806 ef->ddbstrtab = ef->strbase; 807 808#ifdef DDB 809 GDB_STATE(RT_ADD); 810 ef->gdb.l_addr = lf->address; 811 newfilename = malloc(strlen(filename) + 1, M_LINKER, M_WAITOK); 812 strcpy(newfilename, filename); 813 ef->gdb.l_name = (const char *)newfilename; 814 ef->gdb.l_ld = ef->dynamic; 815 link_elf_add_gdb(&ef->gdb); 816 GDB_STATE(RT_CONSISTENT); 817#endif 818 819nosyms: 820 821 *result = lf; 822 823out: 824 if (error && lf) 825 linker_file_unload(lf); 826 if (shdr) 827 free(shdr, M_LINKER); 828 if (firstpage) 829 free(firstpage, M_LINKER); 830 VOP_UNLOCK(nd.ni_vp, 0, td); 831 vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 832 833 return error; 834} 835 836static void 837link_elf_unload_file(linker_file_t file) 838{ 839 elf_file_t ef = (elf_file_t) file; 840 841#ifdef DDB 842 if (ef->gdb.l_ld) { 843 GDB_STATE(RT_DELETE); 844 free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER); 845 link_elf_delete_gdb(&ef->gdb); 846 GDB_STATE(RT_CONSISTENT); 847 } 848#endif 849 850 if (ef->preloaded) { 851 link_elf_unload_preload(file); 852 return; 853 } 854#ifdef SPARSE_MAPPING 855 if (ef->object) { 856 vm_map_remove(kernel_map, (vm_offset_t) ef->address, 857 (vm_offset_t) ef->address 858 + (ef->object->size << PAGE_SHIFT)); 859 vm_object_deallocate(ef->object); 860 } 861#else 862 if (ef->address) 863 free(ef->address, M_LINKER); 864#endif 865 if (ef->symbase) 866 free(ef->symbase, M_LINKER); 867 if (ef->strbase) 868 free(ef->strbase, M_LINKER); 869} 870 871static void 872link_elf_unload_preload(linker_file_t file) 873{ 874 if (file->filename) 875 preload_delete_name(file->filename); 876} 877 878static const char * 879symbol_name(elf_file_t ef, Elf_Word r_info) 880{ 881 const Elf_Sym *ref; 882 883 if (ELF_R_SYM(r_info)) { 884 ref = ef->symtab + ELF_R_SYM(r_info); 885 return ef->strtab + ref->st_name; 886 } else 887 return NULL; 888} 889 890static int 891relocate_file(elf_file_t ef) 892{ 893 const Elf_Rel *rellim; 894 const Elf_Rel *rel; 895 const Elf_Rela *relalim; 896 const Elf_Rela *rela; 897 const char *symname; 898 899 /* Perform relocations without addend if there are any: */ 900 rel = ef->rel; 901 if (rel) { 902 rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 903 while (rel < rellim) { 904 if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) { 905 symname = symbol_name(ef, rel->r_info); 906 printf("link_elf: symbol %s undefined\n", symname); 907 return ENOENT; 908 } 909 rel++; 910 } 911 } 912 913 /* Perform relocations with addend if there are any: */ 914 rela = ef->rela; 915 if (rela) { 916 relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize); 917 while (rela < relalim) { 918 if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) { 919 symname = symbol_name(ef, rela->r_info); 920 printf("link_elf: symbol %s undefined\n", symname); 921 return ENOENT; 922 } 923 rela++; 924 } 925 } 926 927 /* Perform PLT relocations without addend if there are any: */ 928 rel = ef->pltrel; 929 if (rel) { 930 rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize); 931 while (rel < rellim) { 932 if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) { 933 symname = symbol_name(ef, rel->r_info); 934 printf("link_elf: symbol %s undefined\n", symname); 935 return ENOENT; 936 } 937 rel++; 938 } 939 } 940 941 /* Perform relocations with addend if there are any: */ 942 rela = ef->pltrela; 943 if (rela) { 944 relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize); 945 while (rela < relalim) { 946 if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) { 947 symname = symbol_name(ef, rela->r_info); 948 printf("link_elf: symbol %s undefined\n", symname); 949 return ENOENT; 950 } 951 rela++; 952 } 953 } 954 955 return 0; 956} 957 958/* 959 * Hash function for symbol table lookup. Don't even think about changing 960 * this. It is specified by the System V ABI. 961 */ 962static unsigned long 963elf_hash(const char *name) 964{ 965 const unsigned char *p = (const unsigned char *) name; 966 unsigned long h = 0; 967 unsigned long g; 968 969 while (*p != '\0') { 970 h = (h << 4) + *p++; 971 if ((g = h & 0xf0000000) != 0) 972 h ^= g >> 24; 973 h &= ~g; 974 } 975 return h; 976} 977 978static int 979link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym) 980{ 981 elf_file_t ef = (elf_file_t) lf; 982 unsigned long symnum; 983 const Elf_Sym* symp; 984 const char *strp; 985 unsigned long hash; 986 int i; 987 988 /* First, search hashed global symbols */ 989 hash = elf_hash(name); 990 symnum = ef->buckets[hash % ef->nbuckets]; 991 992 while (symnum != STN_UNDEF) { 993 if (symnum >= ef->nchains) { 994 printf("link_elf_lookup_symbol: corrupt symbol table\n"); 995 return ENOENT; 996 } 997 998 symp = ef->symtab + symnum; 999 if (symp->st_name == 0) { 1000 printf("link_elf_lookup_symbol: corrupt symbol table\n"); 1001 return ENOENT; 1002 } 1003 1004 strp = ef->strtab + symp->st_name; 1005 1006 if (strcmp(name, strp) == 0) { 1007 if (symp->st_shndx != SHN_UNDEF || 1008 (symp->st_value != 0 && 1009 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1010 *sym = (c_linker_sym_t) symp; 1011 return 0; 1012 } else 1013 return ENOENT; 1014 } 1015 1016 symnum = ef->chains[symnum]; 1017 } 1018 1019 /* If we have not found it, look at the full table (if loaded) */ 1020 if (ef->symtab == ef->ddbsymtab) 1021 return ENOENT; 1022 1023 /* Exhaustive search */ 1024 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1025 strp = ef->ddbstrtab + symp->st_name; 1026 if (strcmp(name, strp) == 0) { 1027 if (symp->st_shndx != SHN_UNDEF || 1028 (symp->st_value != 0 && 1029 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1030 *sym = (c_linker_sym_t) symp; 1031 return 0; 1032 } else 1033 return ENOENT; 1034 } 1035 } 1036 1037 return ENOENT; 1038} 1039 1040static int 1041link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval) 1042{ 1043 elf_file_t ef = (elf_file_t) lf; 1044 const Elf_Sym* es = (const Elf_Sym*) sym; 1045 1046 if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) { 1047 symval->name = ef->strtab + es->st_name; 1048 symval->value = (caddr_t) ef->address + es->st_value; 1049 symval->size = es->st_size; 1050 return 0; 1051 } 1052 if (ef->symtab == ef->ddbsymtab) 1053 return ENOENT; 1054 if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 1055 symval->name = ef->ddbstrtab + es->st_name; 1056 symval->value = (caddr_t) ef->address + es->st_value; 1057 symval->size = es->st_size; 1058 return 0; 1059 } 1060 return ENOENT; 1061} 1062 1063static int 1064link_elf_search_symbol(linker_file_t lf, caddr_t value, 1065 c_linker_sym_t* sym, long* diffp) 1066{ 1067 elf_file_t ef = (elf_file_t) lf; 1068 u_long off = (uintptr_t) (void *) value; 1069 u_long diff = off; 1070 u_long st_value; 1071 const Elf_Sym* es; 1072 const Elf_Sym* best = 0; 1073 int i; 1074 1075 for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1076 if (es->st_name == 0) 1077 continue; 1078 st_value = es->st_value + (uintptr_t) (void *) ef->address; 1079 if (off >= st_value) { 1080 if (off - st_value < diff) { 1081 diff = off - st_value; 1082 best = es; 1083 if (diff == 0) 1084 break; 1085 } else if (off - st_value == diff) { 1086 best = es; 1087 } 1088 } 1089 } 1090 if (best == 0) 1091 *diffp = off; 1092 else 1093 *diffp = diff; 1094 *sym = (c_linker_sym_t) best; 1095 1096 return 0; 1097} 1098 1099/* 1100 * Look up a linker set on an ELF system. 1101 */ 1102static int 1103link_elf_lookup_set(linker_file_t lf, const char *name, 1104 void ***startp, void ***stopp, int *countp) 1105{ 1106 c_linker_sym_t sym; 1107 linker_symval_t symval; 1108 char *setsym; 1109 void **start, **stop; 1110 int len, error = 0, count; 1111 1112 len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */ 1113 setsym = malloc(len, M_LINKER, M_WAITOK); 1114 if (setsym == NULL) 1115 return ENOMEM; 1116 1117 /* get address of first entry */ 1118 snprintf(setsym, len, "%s%s", "__start_set_", name); 1119 error = link_elf_lookup_symbol(lf, setsym, &sym); 1120 if (error) 1121 goto out; 1122 link_elf_symbol_values(lf, sym, &symval); 1123 if (symval.value == 0) { 1124 error = ESRCH; 1125 goto out; 1126 } 1127 start = (void **)symval.value; 1128 1129 /* get address of last entry */ 1130 snprintf(setsym, len, "%s%s", "__stop_set_", name); 1131 error = link_elf_lookup_symbol(lf, setsym, &sym); 1132 if (error) 1133 goto out; 1134 link_elf_symbol_values(lf, sym, &symval); 1135 if (symval.value == 0) { 1136 error = ESRCH; 1137 goto out; 1138 } 1139 stop = (void **)symval.value; 1140 1141 /* and the number of entries */ 1142 count = stop - start; 1143 1144 /* and copy out */ 1145 if (startp) 1146 *startp = start; 1147 if (stopp) 1148 *stopp = stop; 1149 if (countp) 1150 *countp = count; 1151 1152out: 1153 free(setsym, M_LINKER); 1154 return error; 1155} 1156 1157static int 1158link_elf_each_function_name(linker_file_t file, 1159 int (*callback)(const char *, void *), void *opaque) { 1160 elf_file_t ef = (elf_file_t)file; 1161 const Elf_Sym* symp; 1162 int i, error; 1163 1164 /* Exhaustive search */ 1165 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1166 if (symp->st_value != 0 && 1167 ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1168 error = callback(ef->ddbstrtab + symp->st_name, opaque); 1169 if (error) 1170 return (error); 1171 } 1172 } 1173 return (0); 1174} 1175 1176#ifdef __ia64__ 1177/* 1178 * Each KLD has its own GP. The GP value for each load module is given by 1179 * DT_PLTGOT on ia64. We need GP to construct function descriptors, but 1180 * don't have direct access to the ELF file structure. The link_elf_get_gp() 1181 * function returns the GP given a pointer to a generic linker file struct. 1182 */ 1183Elf_Addr 1184link_elf_get_gp(linker_file_t lf) 1185{ 1186 elf_file_t ef = (elf_file_t)lf; 1187 return (Elf_Addr)ef->got; 1188} 1189#endif 1190 1191const Elf_Sym * 1192elf_get_sym(linker_file_t lf, Elf_Word symidx) 1193{ 1194 elf_file_t ef = (elf_file_t)lf; 1195 1196 if (symidx >= ef->nchains) 1197 return (NULL); 1198 return (ef->symtab + symidx); 1199} 1200 1201const char * 1202elf_get_symname(linker_file_t lf, Elf_Word symidx) 1203{ 1204 elf_file_t ef = (elf_file_t)lf; 1205 const Elf_Sym *sym; 1206 1207 if (symidx >= ef->nchains) 1208 return (NULL); 1209 sym = ef->symtab + symidx; 1210 return (ef->strtab + sym->st_name); 1211} 1212 1213/* 1214 * Symbol lookup function that can be used when the symbol index is known (ie 1215 * in relocations). It uses the symbol index instead of doing a fully fledged 1216 * hash table based lookup when such is valid. For example for local symbols. 1217 * This is not only more efficient, it's also more correct. It's not always 1218 * the case that the symbol can be found through the hash table. 1219 */ 1220Elf_Addr 1221elf_lookup(linker_file_t lf, Elf_Word symidx, int deps) 1222{ 1223 elf_file_t ef = (elf_file_t)lf; 1224 const Elf_Sym *sym; 1225 const char *symbol; 1226 1227 /* Don't even try to lookup the symbol if the index is bogus. */ 1228 if (symidx >= ef->nchains) 1229 return (0); 1230 1231 sym = ef->symtab + symidx; 1232 1233 /* 1234 * Don't do a full lookup when the symbol is local. It may even 1235 * fail because it may not be found through the hash table. 1236 */ 1237 if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 1238 /* Force lookup failure when we have an insanity. */ 1239 if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0) 1240 return (0); 1241 return ((Elf_Addr)ef->address + sym->st_value); 1242 } 1243 1244 /* 1245 * XXX we can avoid doing a hash table based lookup for global 1246 * symbols as well. This however is not always valid, so we'll 1247 * just do it the hard way for now. Performance tweaks can 1248 * always be added. 1249 */ 1250 1251 symbol = ef->strtab + sym->st_name; 1252 1253 /* Force a lookup failure if the symbol name is bogus. */ 1254 if (*symbol == 0) 1255 return (0); 1256 1257 return ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1258} 1259