xref: /freebsd/sys/kern/link_elf.c (revision 00a5db46de56179184c0f000eaacad695e2b0859)
1a4f67738SDoug Rabson /*-
2326e27d8SDoug Rabson  * Copyright (c) 1998-2000 Doug Rabson
3a4f67738SDoug Rabson  * All rights reserved.
4a4f67738SDoug Rabson  *
5a4f67738SDoug Rabson  * Redistribution and use in source and binary forms, with or without
6a4f67738SDoug Rabson  * modification, are permitted provided that the following conditions
7a4f67738SDoug Rabson  * are met:
8a4f67738SDoug Rabson  * 1. Redistributions of source code must retain the above copyright
9a4f67738SDoug Rabson  *    notice, this list of conditions and the following disclaimer.
10a4f67738SDoug Rabson  * 2. Redistributions in binary form must reproduce the above copyright
11a4f67738SDoug Rabson  *    notice, this list of conditions and the following disclaimer in the
12a4f67738SDoug Rabson  *    documentation and/or other materials provided with the distribution.
13a4f67738SDoug Rabson  *
14a4f67738SDoug Rabson  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15a4f67738SDoug Rabson  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16a4f67738SDoug Rabson  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17a4f67738SDoug Rabson  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18a4f67738SDoug Rabson  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19a4f67738SDoug Rabson  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20a4f67738SDoug Rabson  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21a4f67738SDoug Rabson  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22a4f67738SDoug Rabson  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23a4f67738SDoug Rabson  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24a4f67738SDoug Rabson  * SUCH DAMAGE.
25a4f67738SDoug Rabson  */
26a4f67738SDoug Rabson 
27677b542eSDavid E. O'Brien #include <sys/cdefs.h>
28677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
29677b542eSDavid E. O'Brien 
30a2024a3eSJohn Birrell #include "opt_ddb.h"
31ecb01c64SMarcel Moolenaar #include "opt_gdb.h"
32a3df768bSRobert Watson #include "opt_mac.h"
33326e27d8SDoug Rabson 
34a4f67738SDoug Rabson #include <sys/param.h>
35a4f67738SDoug Rabson #include <sys/systm.h>
365ad6c3b1SBruce Evans #ifdef GPROF
375ad6c3b1SBruce Evans #include <sys/gmon.h>
385ad6c3b1SBruce Evans #endif
39fb919e4dSMark Murray #include <sys/kernel.h>
40fb919e4dSMark Murray #include <sys/lock.h>
41a4f67738SDoug Rabson #include <sys/malloc.h>
42c0b824f9SDima Dorfman #include <sys/mutex.h>
4362d615d5SJohn Baldwin #include <sys/mount.h>
44a4f67738SDoug Rabson #include <sys/proc.h>
45a4f67738SDoug Rabson #include <sys/namei.h>
46a4f67738SDoug Rabson #include <sys/fcntl.h>
47a4f67738SDoug Rabson #include <sys/vnode.h>
48a4f67738SDoug Rabson #include <sys/linker.h>
49fb919e4dSMark Murray 
50a4f67738SDoug Rabson #include <machine/elf.h>
51a4f67738SDoug Rabson 
52aed55708SRobert Watson #include <security/mac/mac_framework.h>
53aed55708SRobert Watson 
54fe3db7c7SDoug Rabson #include <vm/vm.h>
55fe3db7c7SDoug Rabson #include <vm/vm_param.h>
56d1f088daSPeter Wemm #ifdef SPARSE_MAPPING
57fe3db7c7SDoug Rabson #include <vm/vm_object.h>
58fe3db7c7SDoug Rabson #include <vm/vm_kern.h>
59fe3db7c7SDoug Rabson #include <vm/vm_extern.h>
60d1f088daSPeter Wemm #endif
61fe3db7c7SDoug Rabson #include <vm/pmap.h>
62fe3db7c7SDoug Rabson #include <vm/vm_map.h>
63fb919e4dSMark Murray 
64f9980387SPeter Wemm #include <sys/link_elf.h>
65fe3db7c7SDoug Rabson 
66a2024a3eSJohn Birrell #ifdef DDB_CTF
67a2024a3eSJohn Birrell #include <net/zlib.h>
68a2024a3eSJohn Birrell #endif
69a2024a3eSJohn Birrell 
70326e27d8SDoug Rabson #include "linker_if.h"
71a4f67738SDoug Rabson 
721a330eb0SPeter Wemm #define MAXSEGS 4
731a330eb0SPeter Wemm 
744f2945f8SDavid E. O'Brien typedef struct elf_file {
754f2945f8SDavid E. O'Brien     struct linker_file	lf;		/* Common fields */
764f2945f8SDavid E. O'Brien     int			preloaded;	/* Was file pre-loaded */
774f2945f8SDavid E. O'Brien     caddr_t		address;	/* Relocation address */
784f2945f8SDavid E. O'Brien #ifdef SPARSE_MAPPING
794f2945f8SDavid E. O'Brien     vm_object_t		object;		/* VM object to hold file pages */
804f2945f8SDavid E. O'Brien #endif
814f2945f8SDavid E. O'Brien     Elf_Dyn*		dynamic;	/* Symbol table etc. */
824f2945f8SDavid E. O'Brien     Elf_Hashelt		nbuckets;	/* DT_HASH info */
834f2945f8SDavid E. O'Brien     Elf_Hashelt		nchains;
844f2945f8SDavid E. O'Brien     const Elf_Hashelt*	buckets;
854f2945f8SDavid E. O'Brien     const Elf_Hashelt*	chains;
864f2945f8SDavid E. O'Brien     caddr_t		hash;
874f2945f8SDavid E. O'Brien     caddr_t		strtab;		/* DT_STRTAB */
884f2945f8SDavid E. O'Brien     int			strsz;		/* DT_STRSZ */
894f2945f8SDavid E. O'Brien     const Elf_Sym*	symtab;		/* DT_SYMTAB */
904f2945f8SDavid E. O'Brien     Elf_Addr*		got;		/* DT_PLTGOT */
914f2945f8SDavid E. O'Brien     const Elf_Rel*	pltrel;		/* DT_JMPREL */
924f2945f8SDavid E. O'Brien     int			pltrelsize;	/* DT_PLTRELSZ */
934f2945f8SDavid E. O'Brien     const Elf_Rela*	pltrela;	/* DT_JMPREL */
944f2945f8SDavid E. O'Brien     int			pltrelasize;	/* DT_PLTRELSZ */
954f2945f8SDavid E. O'Brien     const Elf_Rel*	rel;		/* DT_REL */
964f2945f8SDavid E. O'Brien     int			relsize;	/* DT_RELSZ */
974f2945f8SDavid E. O'Brien     const Elf_Rela*	rela;		/* DT_RELA */
984f2945f8SDavid E. O'Brien     int			relasize;	/* DT_RELASZ */
994f2945f8SDavid E. O'Brien     caddr_t		modptr;
1004f2945f8SDavid E. O'Brien     const Elf_Sym*	ddbsymtab;	/* The symbol table we are using */
1014f2945f8SDavid E. O'Brien     long		ddbsymcnt;	/* Number of symbols */
1024f2945f8SDavid E. O'Brien     caddr_t		ddbstrtab;	/* String table */
1034f2945f8SDavid E. O'Brien     long		ddbstrcnt;	/* number of bytes in string table */
1044f2945f8SDavid E. O'Brien     caddr_t		symbase;	/* malloc'ed symbold base */
1054f2945f8SDavid E. O'Brien     caddr_t		strbase;	/* malloc'ed string base */
1064f2945f8SDavid E. O'Brien     caddr_t		ctftab;		/* CTF table */
1074f2945f8SDavid E. O'Brien     long		ctfcnt;		/* number of bytes in CTF table */
1084f2945f8SDavid E. O'Brien     caddr_t		ctfoff;		/* CTF offset table */
1094f2945f8SDavid E. O'Brien     caddr_t		typoff;		/* Type offset table */
1104f2945f8SDavid E. O'Brien     long		typlen;		/* Number of type entries. */
1114f2945f8SDavid E. O'Brien #ifdef GDB
1124f2945f8SDavid E. O'Brien     struct link_map	gdb;		/* hooks for gdb */
1134f2945f8SDavid E. O'Brien #endif
1144f2945f8SDavid E. O'Brien } *elf_file_t;
1154f2945f8SDavid E. O'Brien 
116a2024a3eSJohn Birrell #include <kern/kern_ctf.c>
117a2024a3eSJohn Birrell 
118c143d6c2SMarcel Moolenaar static int	link_elf_link_common_finish(linker_file_t);
11954823af2SPeter Wemm static int	link_elf_link_preload(linker_class_t cls,
120326e27d8SDoug Rabson 				      const char*, linker_file_t*);
12154823af2SPeter Wemm static int	link_elf_link_preload_finish(linker_file_t);
12254823af2SPeter Wemm static int	link_elf_load_file(linker_class_t, const char*, linker_file_t*);
123326e27d8SDoug Rabson static int	link_elf_lookup_symbol(linker_file_t, const char*,
124326e27d8SDoug Rabson 				       c_linker_sym_t*);
125326e27d8SDoug Rabson static int	link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*);
126326e27d8SDoug Rabson static int	link_elf_search_symbol(linker_file_t, caddr_t value,
127326e27d8SDoug Rabson 				       c_linker_sym_t* sym, long* diffp);
128326e27d8SDoug Rabson 
129326e27d8SDoug Rabson static void	link_elf_unload_file(linker_file_t);
13054823af2SPeter Wemm static void	link_elf_unload_preload(linker_file_t);
131f41325dbSPeter Wemm static int	link_elf_lookup_set(linker_file_t, const char *,
132f41325dbSPeter Wemm 				    void ***, void ***, int *);
133bb9fe9ddSBrian Feldman static int	link_elf_each_function_name(linker_file_t,
134bb9fe9ddSBrian Feldman 				int (*)(const char *, void *),
135bb9fe9ddSBrian Feldman 				void *);
136a2024a3eSJohn Birrell static int	link_elf_each_function_nameval(linker_file_t,
137a2024a3eSJohn Birrell 				linker_function_nameval_callback_t,
138a2024a3eSJohn Birrell 				void *);
1397251b4bfSJake Burkholder static void	link_elf_reloc_local(linker_file_t);
14000a5db46SStacey Son static long	link_elf_symtab_get(linker_file_t, const Elf_Sym **);
14100a5db46SStacey Son static long	link_elf_strtab_get(linker_file_t, caddr_t *);
142757686b1SMarcel Moolenaar static Elf_Addr	elf_lookup(linker_file_t lf, Elf_Size symidx, int deps);
143326e27d8SDoug Rabson 
144326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = {
145326e27d8SDoug Rabson     KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
146326e27d8SDoug Rabson     KOBJMETHOD(linker_symbol_values,	link_elf_symbol_values),
147326e27d8SDoug Rabson     KOBJMETHOD(linker_search_symbol,	link_elf_search_symbol),
148326e27d8SDoug Rabson     KOBJMETHOD(linker_unload,		link_elf_unload_file),
14954823af2SPeter Wemm     KOBJMETHOD(linker_load_file,	link_elf_load_file),
15054823af2SPeter Wemm     KOBJMETHOD(linker_link_preload,	link_elf_link_preload),
15154823af2SPeter Wemm     KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish),
152f41325dbSPeter Wemm     KOBJMETHOD(linker_lookup_set,	link_elf_lookup_set),
153bb9fe9ddSBrian Feldman     KOBJMETHOD(linker_each_function_name, link_elf_each_function_name),
154a2024a3eSJohn Birrell     KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval),
155a2024a3eSJohn Birrell     KOBJMETHOD(linker_ctf_get,          link_elf_ctf_get),
15600a5db46SStacey Son     KOBJMETHOD(linker_symtab_get, 	link_elf_symtab_get),
15700a5db46SStacey Son     KOBJMETHOD(linker_strtab_get, 	link_elf_strtab_get),
158326e27d8SDoug Rabson     { 0, 0 }
159326e27d8SDoug Rabson };
160326e27d8SDoug Rabson 
161326e27d8SDoug Rabson static struct linker_class link_elf_class = {
162326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32
163326e27d8SDoug Rabson     "elf32",
164326e27d8SDoug Rabson #else
165326e27d8SDoug Rabson     "elf64",
166326e27d8SDoug Rabson #endif
167326e27d8SDoug Rabson     link_elf_methods, sizeof(struct elf_file)
168326e27d8SDoug Rabson };
169326e27d8SDoug Rabson 
170326e27d8SDoug Rabson static int		parse_dynamic(elf_file_t ef);
171326e27d8SDoug Rabson static int		relocate_file(elf_file_t ef);
17254823af2SPeter Wemm static int		link_elf_preload_parse_symbols(elf_file_t ef);
173326e27d8SDoug Rabson 
174ecb01c64SMarcel Moolenaar #ifdef GDB
175ca29467eSJohn Baldwin static void		r_debug_state(struct r_debug *dummy_one,
176ca29467eSJohn Baldwin 				      struct link_map *dummy_two);
177326e27d8SDoug Rabson 
178326e27d8SDoug Rabson /*
179326e27d8SDoug Rabson  * A list of loaded modules for GDB to use for loading symbols.
180326e27d8SDoug Rabson  */
181326e27d8SDoug Rabson struct r_debug r_debug;
182326e27d8SDoug Rabson 
183ca29467eSJohn Baldwin #define GDB_STATE(s)	r_debug.r_state = s; r_debug_state(NULL, NULL);
184326e27d8SDoug Rabson 
185326e27d8SDoug Rabson /*
186326e27d8SDoug Rabson  * Function for the debugger to set a breakpoint on to gain control.
187326e27d8SDoug Rabson  */
18837c84183SPoul-Henning Kamp static void
189ca29467eSJohn Baldwin r_debug_state(struct r_debug *dummy_one __unused,
190ca29467eSJohn Baldwin 	      struct link_map *dummy_two __unused)
191326e27d8SDoug Rabson {
192326e27d8SDoug Rabson }
193326e27d8SDoug Rabson 
1941720979bSMarcel Moolenaar static void
1951720979bSMarcel Moolenaar link_elf_add_gdb(struct link_map *l)
1961720979bSMarcel Moolenaar {
1971720979bSMarcel Moolenaar     struct link_map *prev;
1981720979bSMarcel Moolenaar 
199c143d6c2SMarcel Moolenaar     l->l_next = NULL;
200c143d6c2SMarcel Moolenaar 
201c143d6c2SMarcel Moolenaar     if (r_debug.r_map == NULL) {
202c143d6c2SMarcel Moolenaar 	/* Add first. */
203c143d6c2SMarcel Moolenaar 	l->l_prev = NULL;
204c143d6c2SMarcel Moolenaar 	r_debug.r_map = l;
205c143d6c2SMarcel Moolenaar     } else {
206c143d6c2SMarcel Moolenaar 	/* Append to list. */
2071720979bSMarcel Moolenaar 	for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next)
2081720979bSMarcel Moolenaar 	    ;
2091720979bSMarcel Moolenaar 	l->l_prev = prev;
2101720979bSMarcel Moolenaar 	prev->l_next = l;
2111720979bSMarcel Moolenaar     }
212c143d6c2SMarcel Moolenaar }
2131720979bSMarcel Moolenaar 
2141720979bSMarcel Moolenaar static void
2151720979bSMarcel Moolenaar link_elf_delete_gdb(struct link_map *l)
2161720979bSMarcel Moolenaar {
2171720979bSMarcel Moolenaar     if (l->l_prev == NULL) {
218c143d6c2SMarcel Moolenaar 	/* Remove first. */
2191720979bSMarcel Moolenaar 	if ((r_debug.r_map = l->l_next) != NULL)
2201720979bSMarcel Moolenaar 	    l->l_next->l_prev = NULL;
221c143d6c2SMarcel Moolenaar     } else {
222c143d6c2SMarcel Moolenaar 	/* Remove any but first. */
2231720979bSMarcel Moolenaar 	if ((l->l_prev->l_next = l->l_next) != NULL)
2241720979bSMarcel Moolenaar 	    l->l_next->l_prev = l->l_prev;
2251720979bSMarcel Moolenaar     }
226c143d6c2SMarcel Moolenaar }
227ecb01c64SMarcel Moolenaar #endif /* GDB */
228a4f67738SDoug Rabson 
22984201059SMarcel Moolenaar #ifdef __ia64__
23084201059SMarcel Moolenaar Elf_Addr link_elf_get_gp(linker_file_t);
23184201059SMarcel Moolenaar #endif
23284201059SMarcel Moolenaar 
2334f2945f8SDavid E. O'Brien /*
2344f2945f8SDavid E. O'Brien  * The kernel symbol table starts here.
2354f2945f8SDavid E. O'Brien  */
2364f2945f8SDavid E. O'Brien extern struct _dynamic _DYNAMIC;
2374f2945f8SDavid E. O'Brien 
238a4f67738SDoug Rabson static void
239552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s)
2401720979bSMarcel Moolenaar {
241552f9f63SEdwin Groothuis 	if (filename == NULL)
2421720979bSMarcel Moolenaar 		printf("kldload: %s\n", s);
243552f9f63SEdwin Groothuis 	else
244552f9f63SEdwin Groothuis 		printf("kldload: %s: %s\n", filename, s);
2451720979bSMarcel Moolenaar }
2461720979bSMarcel Moolenaar 
247c143d6c2SMarcel Moolenaar /*
248c143d6c2SMarcel Moolenaar  * Actions performed after linking/loading both the preloaded kernel and any
249c143d6c2SMarcel Moolenaar  * modules; whether preloaded or dynamicly loaded.
250c143d6c2SMarcel Moolenaar  */
251c143d6c2SMarcel Moolenaar static int
252c143d6c2SMarcel Moolenaar link_elf_link_common_finish(linker_file_t lf)
253c143d6c2SMarcel Moolenaar {
254ecb01c64SMarcel Moolenaar #ifdef GDB
255c143d6c2SMarcel Moolenaar     elf_file_t ef = (elf_file_t)lf;
256c143d6c2SMarcel Moolenaar     char *newfilename;
257c143d6c2SMarcel Moolenaar #endif
2581aeb23cdSMarcel Moolenaar     int error;
2591aeb23cdSMarcel Moolenaar 
2601aeb23cdSMarcel Moolenaar     /* Notify MD code that a module is being loaded. */
2611aeb23cdSMarcel Moolenaar     error = elf_cpu_load_file(lf);
2621aeb23cdSMarcel Moolenaar     if (error)
2631aeb23cdSMarcel Moolenaar 	return (error);
264c143d6c2SMarcel Moolenaar 
265ecb01c64SMarcel Moolenaar #ifdef GDB
266c143d6c2SMarcel Moolenaar     GDB_STATE(RT_ADD);
267c143d6c2SMarcel Moolenaar     ef->gdb.l_addr = lf->address;
268a163d034SWarner Losh     newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK);
269c143d6c2SMarcel Moolenaar     strcpy(newfilename, lf->filename);
270c143d6c2SMarcel Moolenaar     ef->gdb.l_name = newfilename;
271c143d6c2SMarcel Moolenaar     ef->gdb.l_ld = ef->dynamic;
272c143d6c2SMarcel Moolenaar     link_elf_add_gdb(&ef->gdb);
273c143d6c2SMarcel Moolenaar     GDB_STATE(RT_CONSISTENT);
274c143d6c2SMarcel Moolenaar #endif
275c143d6c2SMarcel Moolenaar 
276c143d6c2SMarcel Moolenaar     return (0);
277c143d6c2SMarcel Moolenaar }
278c143d6c2SMarcel Moolenaar 
2791720979bSMarcel Moolenaar static void
280a4f67738SDoug Rabson link_elf_init(void* arg)
281a4f67738SDoug Rabson {
282de78ca7eSPeter Wemm     Elf_Dyn	*dp;
283de78ca7eSPeter Wemm     caddr_t	modptr, baseptr, sizeptr;
284de78ca7eSPeter Wemm     elf_file_t	ef;
285de78ca7eSPeter Wemm     char	*modname;
286a4f67738SDoug Rabson 
287326e27d8SDoug Rabson     linker_add_class(&link_elf_class);
288a4f67738SDoug Rabson 
289de78ca7eSPeter Wemm     dp = (Elf_Dyn*) &_DYNAMIC;
290de78ca7eSPeter Wemm     modname = NULL;
29167db8b23SPeter Wemm     modptr = preload_search_by_type("elf" __XSTRING(__ELF_WORD_SIZE) " kernel");
29267db8b23SPeter Wemm     if (modptr == NULL)
293de78ca7eSPeter Wemm 	modptr = preload_search_by_type("elf kernel");
294de78ca7eSPeter Wemm     if (modptr)
295de78ca7eSPeter Wemm 	modname = (char *)preload_search_info(modptr, MODINFO_NAME);
296de78ca7eSPeter Wemm     if (modname == NULL)
297de78ca7eSPeter Wemm 	modname = "kernel";
298326e27d8SDoug Rabson     linker_kernel_file = linker_make_file(modname, &link_elf_class);
299a4f67738SDoug Rabson     if (linker_kernel_file == NULL)
300a4f67738SDoug Rabson 	panic("link_elf_init: Can't create linker structures for kernel");
301326e27d8SDoug Rabson 
302326e27d8SDoug Rabson     ef = (elf_file_t) linker_kernel_file;
30354823af2SPeter Wemm     ef->preloaded = 1;
304326e27d8SDoug Rabson     ef->address = 0;
305326e27d8SDoug Rabson #ifdef SPARSE_MAPPING
306326e27d8SDoug Rabson     ef->object = 0;
307326e27d8SDoug Rabson #endif
308326e27d8SDoug Rabson     ef->dynamic = dp;
309326e27d8SDoug Rabson 
31000dda5e8SPeter Wemm     if (dp)
311326e27d8SDoug Rabson 	parse_dynamic(ef);
3124173e420SPeter Wemm     linker_kernel_file->address = (caddr_t) KERNBASE;
313d009ccfaSBruce Evans     linker_kernel_file->size = -(intptr_t)linker_kernel_file->address;
314de78ca7eSPeter Wemm 
315de78ca7eSPeter Wemm     if (modptr) {
3162d636ab0SPeter Wemm 	ef->modptr = modptr;
317de78ca7eSPeter Wemm 	baseptr = preload_search_info(modptr, MODINFO_ADDR);
318de78ca7eSPeter Wemm 	if (baseptr)
319de78ca7eSPeter Wemm 	    linker_kernel_file->address = *(caddr_t *)baseptr;
320de78ca7eSPeter Wemm 	sizeptr = preload_search_info(modptr, MODINFO_SIZE);
321de78ca7eSPeter Wemm 	if (sizeptr)
322de78ca7eSPeter Wemm 	    linker_kernel_file->size = *(size_t *)sizeptr;
323de78ca7eSPeter Wemm     }
32454823af2SPeter Wemm     (void)link_elf_preload_parse_symbols(ef);
325326e27d8SDoug Rabson 
326ecb01c64SMarcel Moolenaar #ifdef GDB
327c143d6c2SMarcel Moolenaar     r_debug.r_map = NULL;
328326e27d8SDoug Rabson     r_debug.r_brk = r_debug_state;
329326e27d8SDoug Rabson     r_debug.r_state = RT_CONSISTENT;
330326e27d8SDoug Rabson #endif
331c143d6c2SMarcel Moolenaar 
332c143d6c2SMarcel Moolenaar     (void)link_elf_link_common_finish(linker_kernel_file);
33359800afcSJohn Baldwin     linker_kernel_file->flags |= LINKER_FILE_LINKED;
334a4f67738SDoug Rabson }
335a4f67738SDoug Rabson 
3368120ddb4SJung-uk Kim SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_THIRD, link_elf_init, 0);
337a4f67738SDoug Rabson 
338a4f67738SDoug Rabson static int
33954823af2SPeter Wemm link_elf_preload_parse_symbols(elf_file_t ef)
3402d636ab0SPeter Wemm {
3412d636ab0SPeter Wemm     caddr_t	pointer;
3422d636ab0SPeter Wemm     caddr_t	ssym, esym, base;
3432d636ab0SPeter Wemm     caddr_t	strtab;
3442d636ab0SPeter Wemm     int		strcnt;
3452d636ab0SPeter Wemm     Elf_Sym*	symtab;
3462d636ab0SPeter Wemm     int		symcnt;
3472d636ab0SPeter Wemm 
348ca65d5c7SPeter Wemm     if (ef->modptr == NULL)
349ca65d5c7SPeter Wemm 	return 0;
3502d636ab0SPeter Wemm     pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM);
3512d636ab0SPeter Wemm     if (pointer == NULL)
3522d636ab0SPeter Wemm 	return 0;
3532d636ab0SPeter Wemm     ssym = *(caddr_t *)pointer;
3542d636ab0SPeter Wemm     pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM);
3552d636ab0SPeter Wemm     if (pointer == NULL)
3562d636ab0SPeter Wemm 	return 0;
3572d636ab0SPeter Wemm     esym = *(caddr_t *)pointer;
3582d636ab0SPeter Wemm 
3592d636ab0SPeter Wemm     base = ssym;
3602d636ab0SPeter Wemm 
3612d636ab0SPeter Wemm     symcnt = *(long *)base;
3622d636ab0SPeter Wemm     base += sizeof(long);
3632d636ab0SPeter Wemm     symtab = (Elf_Sym *)base;
3642d636ab0SPeter Wemm     base += roundup(symcnt, sizeof(long));
3652d636ab0SPeter Wemm 
3662d636ab0SPeter Wemm     if (base > esym || base < ssym) {
3672d636ab0SPeter Wemm 	printf("Symbols are corrupt!\n");
3682d636ab0SPeter Wemm 	return EINVAL;
3692d636ab0SPeter Wemm     }
3702d636ab0SPeter Wemm 
3712d636ab0SPeter Wemm     strcnt = *(long *)base;
3722d636ab0SPeter Wemm     base += sizeof(long);
3732d636ab0SPeter Wemm     strtab = base;
3742d636ab0SPeter Wemm     base += roundup(strcnt, sizeof(long));
3752d636ab0SPeter Wemm 
3762d636ab0SPeter Wemm     if (base > esym || base < ssym) {
3772d636ab0SPeter Wemm 	printf("Symbols are corrupt!\n");
3782d636ab0SPeter Wemm 	return EINVAL;
3792d636ab0SPeter Wemm     }
3802d636ab0SPeter Wemm 
3812d636ab0SPeter Wemm     ef->ddbsymtab = symtab;
3822d636ab0SPeter Wemm     ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
3832d636ab0SPeter Wemm     ef->ddbstrtab = strtab;
3842d636ab0SPeter Wemm     ef->ddbstrcnt = strcnt;
3852d636ab0SPeter Wemm 
3862d636ab0SPeter Wemm     return 0;
3872d636ab0SPeter Wemm }
3882d636ab0SPeter Wemm 
3892d636ab0SPeter Wemm static int
390326e27d8SDoug Rabson parse_dynamic(elf_file_t ef)
391a4f67738SDoug Rabson {
392326e27d8SDoug Rabson     Elf_Dyn *dp;
393fe3db7c7SDoug Rabson     int plttype = DT_REL;
394a4f67738SDoug Rabson 
395a4f67738SDoug Rabson     for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
396a4f67738SDoug Rabson 	switch (dp->d_tag) {
397a4f67738SDoug Rabson 	case DT_HASH:
398a4f67738SDoug Rabson 	{
399a4f67738SDoug Rabson 	    /* From src/libexec/rtld-elf/rtld.c */
4007e510298SJake Burkholder 	    const Elf_Hashelt *hashtab = (const Elf_Hashelt *)
401a4f67738SDoug Rabson 		(ef->address + dp->d_un.d_ptr);
402a4f67738SDoug Rabson 	    ef->nbuckets = hashtab[0];
403a4f67738SDoug Rabson 	    ef->nchains = hashtab[1];
404a4f67738SDoug Rabson 	    ef->buckets = hashtab + 2;
405a4f67738SDoug Rabson 	    ef->chains = ef->buckets + ef->nbuckets;
406a4f67738SDoug Rabson 	    break;
407a4f67738SDoug Rabson 	}
408a4f67738SDoug Rabson 	case DT_STRTAB:
409fe3db7c7SDoug Rabson 	    ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr);
410a4f67738SDoug Rabson 	    break;
4112d636ab0SPeter Wemm 	case DT_STRSZ:
4122d636ab0SPeter Wemm 	    ef->strsz = dp->d_un.d_val;
4132d636ab0SPeter Wemm 	    break;
414a4f67738SDoug Rabson 	case DT_SYMTAB:
415fe3db7c7SDoug Rabson 	    ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr);
416a4f67738SDoug Rabson 	    break;
417a4f67738SDoug Rabson 	case DT_SYMENT:
418a4f67738SDoug Rabson 	    if (dp->d_un.d_val != sizeof(Elf_Sym))
419a4f67738SDoug Rabson 		return ENOEXEC;
420fe3db7c7SDoug Rabson 	    break;
421fe3db7c7SDoug Rabson 	case DT_PLTGOT:
422fe3db7c7SDoug Rabson 	    ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr);
423fe3db7c7SDoug Rabson 	    break;
424fe3db7c7SDoug Rabson 	case DT_REL:
425fe3db7c7SDoug Rabson 	    ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
426fe3db7c7SDoug Rabson 	    break;
427fe3db7c7SDoug Rabson 	case DT_RELSZ:
428fe3db7c7SDoug Rabson 	    ef->relsize = dp->d_un.d_val;
429fe3db7c7SDoug Rabson 	    break;
430fe3db7c7SDoug Rabson 	case DT_RELENT:
431fe3db7c7SDoug Rabson 	    if (dp->d_un.d_val != sizeof(Elf_Rel))
432fe3db7c7SDoug Rabson 		return ENOEXEC;
433fe3db7c7SDoug Rabson 	    break;
434fe3db7c7SDoug Rabson 	case DT_JMPREL:
435fe3db7c7SDoug Rabson 	    ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
436fe3db7c7SDoug Rabson 	    break;
437fe3db7c7SDoug Rabson 	case DT_PLTRELSZ:
438fe3db7c7SDoug Rabson 	    ef->pltrelsize = dp->d_un.d_val;
439fe3db7c7SDoug Rabson 	    break;
440fe3db7c7SDoug Rabson 	case DT_RELA:
441fe3db7c7SDoug Rabson 	    ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr);
442fe3db7c7SDoug Rabson 	    break;
443fe3db7c7SDoug Rabson 	case DT_RELASZ:
444fe3db7c7SDoug Rabson 	    ef->relasize = dp->d_un.d_val;
445fe3db7c7SDoug Rabson 	    break;
446fe3db7c7SDoug Rabson 	case DT_RELAENT:
447fe3db7c7SDoug Rabson 	    if (dp->d_un.d_val != sizeof(Elf_Rela))
448fe3db7c7SDoug Rabson 		return ENOEXEC;
449fe3db7c7SDoug Rabson 	    break;
450fe3db7c7SDoug Rabson 	case DT_PLTREL:
451fe3db7c7SDoug Rabson 	    plttype = dp->d_un.d_val;
452fe3db7c7SDoug Rabson 	    if (plttype != DT_REL && plttype != DT_RELA)
453fe3db7c7SDoug Rabson 		return ENOEXEC;
454fe3db7c7SDoug Rabson 	    break;
455ecb01c64SMarcel Moolenaar #ifdef GDB
456326e27d8SDoug Rabson 	case DT_DEBUG:
457326e27d8SDoug Rabson 	    dp->d_un.d_ptr = (Elf_Addr) &r_debug;
458326e27d8SDoug Rabson 	    break;
459326e27d8SDoug Rabson #endif
460a4f67738SDoug Rabson 	}
461a4f67738SDoug Rabson     }
462fe3db7c7SDoug Rabson 
463fe3db7c7SDoug Rabson     if (plttype == DT_RELA) {
464fe3db7c7SDoug Rabson 	ef->pltrela = (const Elf_Rela *) ef->pltrel;
465fe3db7c7SDoug Rabson 	ef->pltrel = NULL;
466fe3db7c7SDoug Rabson 	ef->pltrelasize = ef->pltrelsize;
467fe3db7c7SDoug Rabson 	ef->pltrelsize = 0;
468fe3db7c7SDoug Rabson     }
469fe3db7c7SDoug Rabson 
4702d636ab0SPeter Wemm     ef->ddbsymtab = ef->symtab;
4712d636ab0SPeter Wemm     ef->ddbsymcnt = ef->nchains;
4722d636ab0SPeter Wemm     ef->ddbstrtab = ef->strtab;
4732d636ab0SPeter Wemm     ef->ddbstrcnt = ef->strsz;
4742d636ab0SPeter Wemm 
475a4f67738SDoug Rabson     return 0;
476a4f67738SDoug Rabson }
477a4f67738SDoug Rabson 
478a4f67738SDoug Rabson static int
47954823af2SPeter Wemm link_elf_link_preload(linker_class_t cls,
480326e27d8SDoug Rabson 		      const char* filename, linker_file_t *result)
481de78ca7eSPeter Wemm {
482de78ca7eSPeter Wemm     caddr_t		modptr, baseptr, sizeptr, dynptr;
483de78ca7eSPeter Wemm     char		*type;
484de78ca7eSPeter Wemm     elf_file_t		ef;
485de78ca7eSPeter Wemm     linker_file_t	lf;
486de78ca7eSPeter Wemm     int			error;
487de78ca7eSPeter Wemm     vm_offset_t		dp;
488de78ca7eSPeter Wemm 
48954823af2SPeter Wemm     /* Look to see if we have the file preloaded */
490de78ca7eSPeter Wemm     modptr = preload_search_by_name(filename);
491de78ca7eSPeter Wemm     if (modptr == NULL)
49254823af2SPeter Wemm 	return ENOENT;
493de78ca7eSPeter Wemm 
494de78ca7eSPeter Wemm     type = (char *)preload_search_info(modptr, MODINFO_TYPE);
495de78ca7eSPeter Wemm     baseptr = preload_search_info(modptr, MODINFO_ADDR);
496de78ca7eSPeter Wemm     sizeptr = preload_search_info(modptr, MODINFO_SIZE);
497de78ca7eSPeter Wemm     dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
49867db8b23SPeter Wemm     if (type == NULL ||
49967db8b23SPeter Wemm 	(strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) " module") != 0 &&
50067db8b23SPeter Wemm 	 strcmp(type, "elf module") != 0))
501de78ca7eSPeter Wemm 	return (EFTYPE);
502de78ca7eSPeter Wemm     if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
503de78ca7eSPeter Wemm 	return (EINVAL);
504de78ca7eSPeter Wemm 
505326e27d8SDoug Rabson     lf = linker_make_file(filename, &link_elf_class);
506326e27d8SDoug Rabson     if (lf == NULL) {
507326e27d8SDoug Rabson 	return ENOMEM;
508326e27d8SDoug Rabson     }
509326e27d8SDoug Rabson 
510326e27d8SDoug Rabson     ef = (elf_file_t) lf;
511326e27d8SDoug Rabson     ef->preloaded = 1;
512ca65d5c7SPeter Wemm     ef->modptr = modptr;
513de78ca7eSPeter Wemm     ef->address = *(caddr_t *)baseptr;
514de78ca7eSPeter Wemm #ifdef SPARSE_MAPPING
515de78ca7eSPeter Wemm     ef->object = 0;
516de78ca7eSPeter Wemm #endif
517de78ca7eSPeter Wemm     dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
518de78ca7eSPeter Wemm     ef->dynamic = (Elf_Dyn *)dp;
519de78ca7eSPeter Wemm     lf->address = ef->address;
520de78ca7eSPeter Wemm     lf->size = *(size_t *)sizeptr;
521de78ca7eSPeter Wemm 
522326e27d8SDoug Rabson     error = parse_dynamic(ef);
523de78ca7eSPeter Wemm     if (error) {
52465a311fcSPoul-Henning Kamp 	linker_file_unload(lf, LINKER_UNLOAD_FORCE);
525de78ca7eSPeter Wemm 	return error;
526de78ca7eSPeter Wemm     }
5277251b4bfSJake Burkholder     link_elf_reloc_local(lf);
528de78ca7eSPeter Wemm     *result = lf;
529de78ca7eSPeter Wemm     return (0);
530de78ca7eSPeter Wemm }
531de78ca7eSPeter Wemm 
532de78ca7eSPeter Wemm static int
53354823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf)
53454823af2SPeter Wemm {
53554823af2SPeter Wemm     elf_file_t		ef;
53654823af2SPeter Wemm     int error;
53754823af2SPeter Wemm 
53854823af2SPeter Wemm     ef = (elf_file_t) lf;
53954823af2SPeter Wemm #if 0	/* this will be more trouble than it's worth for now */
54054823af2SPeter Wemm     for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
54154823af2SPeter Wemm 	if (dp->d_tag != DT_NEEDED)
54254823af2SPeter Wemm 	    continue;
54354823af2SPeter Wemm 	modname = ef->strtab + dp->d_un.d_val;
54454823af2SPeter Wemm 	error = linker_load_module(modname, lf);
54554823af2SPeter Wemm 	if (error)
54654823af2SPeter Wemm 	    goto out;
54754823af2SPeter Wemm     }
54854823af2SPeter Wemm #endif
54954823af2SPeter Wemm     error = relocate_file(ef);
55054823af2SPeter Wemm     if (error)
55154823af2SPeter Wemm 	return error;
55254823af2SPeter Wemm     (void)link_elf_preload_parse_symbols(ef);
55354823af2SPeter Wemm 
554c143d6c2SMarcel Moolenaar     return (link_elf_link_common_finish(lf));
55554823af2SPeter Wemm }
55654823af2SPeter Wemm 
55754823af2SPeter Wemm static int
558c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char* filename,
559c143d6c2SMarcel Moolenaar 	linker_file_t* result)
560a4f67738SDoug Rabson {
561a4f67738SDoug Rabson     struct nameidata nd;
562b40ce416SJulian Elischer     struct thread* td = curthread;	/* XXX */
563caab6e90SPeter Wemm     Elf_Ehdr *hdr;
564caab6e90SPeter Wemm     caddr_t firstpage;
565fe3db7c7SDoug Rabson     int nbytes, i;
566fe3db7c7SDoug Rabson     Elf_Phdr *phdr;
567fe3db7c7SDoug Rabson     Elf_Phdr *phlimit;
5681a330eb0SPeter Wemm     Elf_Phdr *segs[MAXSEGS];
569fe3db7c7SDoug Rabson     int nsegs;
570fe3db7c7SDoug Rabson     Elf_Phdr *phdyn;
571fe3db7c7SDoug Rabson     Elf_Phdr *phphdr;
572fe3db7c7SDoug Rabson     caddr_t mapbase;
573fe3db7c7SDoug Rabson     size_t mapsize;
574fe3db7c7SDoug Rabson     Elf_Off base_offset;
575fe3db7c7SDoug Rabson     Elf_Addr base_vaddr;
576fe3db7c7SDoug Rabson     Elf_Addr base_vlimit;
577a4f67738SDoug Rabson     int error = 0;
578e6796b67SKirk McKusick     int resid, flags;
579a4f67738SDoug Rabson     elf_file_t ef;
580a4f67738SDoug Rabson     linker_file_t lf;
581ca65d5c7SPeter Wemm     Elf_Shdr *shdr;
582ca65d5c7SPeter Wemm     int symtabindex;
583ca65d5c7SPeter Wemm     int symstrindex;
584ca65d5c7SPeter Wemm     int symcnt;
585ca65d5c7SPeter Wemm     int strcnt;
58662d615d5SJohn Baldwin     int vfslocked;
587ca65d5c7SPeter Wemm 
588ca65d5c7SPeter Wemm     shdr = NULL;
589ca65d5c7SPeter Wemm     lf = NULL;
590a4f67738SDoug Rabson 
59162d615d5SJohn Baldwin     NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td);
592e6796b67SKirk McKusick     flags = FREAD;
5939e223287SKonstantin Belousov     error = vn_open(&nd, &flags, 0, NULL);
594a4f67738SDoug Rabson     if (error)
595a4f67738SDoug Rabson 	return error;
59662d615d5SJohn Baldwin     vfslocked = NDHASGIANT(&nd);
597762e6b85SEivind Eklund     NDFREE(&nd, NDF_ONLY_PNBUF);
5981f49b573SRuslan Ermilov     if (nd.ni_vp->v_type != VREG) {
5991f49b573SRuslan Ermilov 	error = ENOEXEC;
6001f49b573SRuslan Ermilov 	firstpage = NULL;
6011f49b573SRuslan Ermilov 	goto out;
6021f49b573SRuslan Ermilov     }
603a3df768bSRobert Watson #ifdef MAC
60430d239bcSRobert Watson     error = mac_kld_check_load(curthread->td_ucred, nd.ni_vp);
605a3df768bSRobert Watson     if (error) {
606a3df768bSRobert Watson 	firstpage = NULL;
607a3df768bSRobert Watson 	goto out;
608a3df768bSRobert Watson     }
609a3df768bSRobert Watson #endif
610a4f67738SDoug Rabson 
611a4f67738SDoug Rabson     /*
612fe3db7c7SDoug Rabson      * Read the elf header from the file.
613a4f67738SDoug Rabson      */
614a163d034SWarner Losh     firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
615caab6e90SPeter Wemm     if (firstpage == NULL) {
616caab6e90SPeter Wemm 	error = ENOMEM;
617caab6e90SPeter Wemm 	goto out;
618caab6e90SPeter Wemm     }
619caab6e90SPeter Wemm     hdr = (Elf_Ehdr *)firstpage;
620caab6e90SPeter Wemm     error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,
6219ca43589SRobert Watson 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
6229ca43589SRobert Watson 		    &resid, td);
623caab6e90SPeter Wemm     nbytes = PAGE_SIZE - resid;
624a4f67738SDoug Rabson     if (error)
625a4f67738SDoug Rabson 	goto out;
626a4f67738SDoug Rabson 
627caab6e90SPeter Wemm     if (!IS_ELF(*hdr)) {
628fe3db7c7SDoug Rabson 	error = ENOEXEC;
629a4f67738SDoug Rabson 	goto out;
630fe3db7c7SDoug Rabson     }
631fe3db7c7SDoug Rabson 
632caab6e90SPeter Wemm     if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
633caab6e90SPeter Wemm       || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
634552f9f63SEdwin Groothuis 	link_elf_error(filename, "Unsupported file layout");
635fe3db7c7SDoug Rabson 	error = ENOEXEC;
636fe3db7c7SDoug Rabson 	goto out;
637fe3db7c7SDoug Rabson     }
638caab6e90SPeter Wemm     if (hdr->e_ident[EI_VERSION] != EV_CURRENT
639caab6e90SPeter Wemm       || hdr->e_version != EV_CURRENT) {
640552f9f63SEdwin Groothuis 	link_elf_error(filename, "Unsupported file version");
641fe3db7c7SDoug Rabson 	error = ENOEXEC;
642fe3db7c7SDoug Rabson 	goto out;
643fe3db7c7SDoug Rabson     }
644caab6e90SPeter Wemm     if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) {
645a1d7ce03SAttilio Rao 	error = ENOSYS;
646fe3db7c7SDoug Rabson 	goto out;
647fe3db7c7SDoug Rabson     }
648caab6e90SPeter Wemm     if (hdr->e_machine != ELF_TARG_MACH) {
649552f9f63SEdwin Groothuis 	link_elf_error(filename, "Unsupported machine");
650fe3db7c7SDoug Rabson 	error = ENOEXEC;
651fe3db7c7SDoug Rabson 	goto out;
652fe3db7c7SDoug Rabson     }
653a4f67738SDoug Rabson 
654a4f67738SDoug Rabson     /*
655fe3db7c7SDoug Rabson      * We rely on the program header being in the first page.  This is
656fe3db7c7SDoug Rabson      * not strictly required by the ABI specification, but it seems to
657fe3db7c7SDoug Rabson      * always true in practice.  And, it simplifies things considerably.
658a4f67738SDoug Rabson      */
659caab6e90SPeter Wemm     if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) &&
660caab6e90SPeter Wemm 	  (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&
661caab6e90SPeter Wemm 	  (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes)))
662552f9f63SEdwin Groothuis 	link_elf_error(filename, "Unreadable program headers");
663fe3db7c7SDoug Rabson 
664fe3db7c7SDoug Rabson     /*
665fe3db7c7SDoug Rabson      * Scan the program header entries, and save key information.
666fe3db7c7SDoug Rabson      *
667fe3db7c7SDoug Rabson      * We rely on there being exactly two load segments, text and data,
668fe3db7c7SDoug Rabson      * in that order.
669fe3db7c7SDoug Rabson      */
670caab6e90SPeter Wemm     phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff);
671caab6e90SPeter Wemm     phlimit = phdr + hdr->e_phnum;
672fe3db7c7SDoug Rabson     nsegs = 0;
673fe3db7c7SDoug Rabson     phdyn = NULL;
674fe3db7c7SDoug Rabson     phphdr = NULL;
675fe3db7c7SDoug Rabson     while (phdr < phlimit) {
676fe3db7c7SDoug Rabson 	switch (phdr->p_type) {
677fe3db7c7SDoug Rabson 
678fe3db7c7SDoug Rabson 	case PT_LOAD:
6791a330eb0SPeter Wemm 	    if (nsegs == MAXSEGS) {
680552f9f63SEdwin Groothuis 		link_elf_error(filename, "Too many sections");
681fe3db7c7SDoug Rabson 		error = ENOEXEC;
682fe3db7c7SDoug Rabson 		goto out;
683fe3db7c7SDoug Rabson 	    }
68487b1831fSPoul-Henning Kamp 	    /*
68587b1831fSPoul-Henning Kamp 	     * XXX: We just trust they come in right order ??
68687b1831fSPoul-Henning Kamp 	     */
687fe3db7c7SDoug Rabson 	    segs[nsegs] = phdr;
688fe3db7c7SDoug Rabson 	    ++nsegs;
689fe3db7c7SDoug Rabson 	    break;
690fe3db7c7SDoug Rabson 
691fe3db7c7SDoug Rabson 	case PT_PHDR:
692fe3db7c7SDoug Rabson 	    phphdr = phdr;
693fe3db7c7SDoug Rabson 	    break;
694fe3db7c7SDoug Rabson 
695fe3db7c7SDoug Rabson 	case PT_DYNAMIC:
696fe3db7c7SDoug Rabson 	    phdyn = phdr;
697fe3db7c7SDoug Rabson 	    break;
6989548091bSBoris Popov 
6999548091bSBoris Popov 	case PT_INTERP:
700a1d7ce03SAttilio Rao 	    error = ENOSYS;
7019548091bSBoris Popov 	    goto out;
702fe3db7c7SDoug Rabson 	}
703fe3db7c7SDoug Rabson 
704fe3db7c7SDoug Rabson 	++phdr;
705fe3db7c7SDoug Rabson     }
706fe3db7c7SDoug Rabson     if (phdyn == NULL) {
707552f9f63SEdwin Groothuis 	link_elf_error(filename, "Object is not dynamically-linked");
708fe3db7c7SDoug Rabson 	error = ENOEXEC;
709fe3db7c7SDoug Rabson 	goto out;
710fe3db7c7SDoug Rabson     }
7111a330eb0SPeter Wemm     if (nsegs == 0) {
712552f9f63SEdwin Groothuis 	link_elf_error(filename, "No sections");
71387b1831fSPoul-Henning Kamp 	error = ENOEXEC;
71487b1831fSPoul-Henning Kamp 	goto out;
71587b1831fSPoul-Henning Kamp     }
716fe3db7c7SDoug Rabson 
717fe3db7c7SDoug Rabson     /*
718fe3db7c7SDoug Rabson      * Allocate the entire address space of the object, to stake out our
719fe3db7c7SDoug Rabson      * contiguous region, and to establish the base address for relocation.
720fe3db7c7SDoug Rabson      */
721fe3db7c7SDoug Rabson     base_offset = trunc_page(segs[0]->p_offset);
722fe3db7c7SDoug Rabson     base_vaddr = trunc_page(segs[0]->p_vaddr);
7231a330eb0SPeter Wemm     base_vlimit = round_page(segs[nsegs - 1]->p_vaddr +
7241a330eb0SPeter Wemm 	segs[nsegs - 1]->p_memsz);
725fe3db7c7SDoug Rabson     mapsize = base_vlimit - base_vaddr;
726fe3db7c7SDoug Rabson 
727326e27d8SDoug Rabson     lf = linker_make_file(filename, &link_elf_class);
728326e27d8SDoug Rabson     if (!lf) {
729326e27d8SDoug Rabson 	error = ENOMEM;
730326e27d8SDoug Rabson 	goto out;
731326e27d8SDoug Rabson     }
732326e27d8SDoug Rabson 
733326e27d8SDoug Rabson     ef = (elf_file_t) lf;
734fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING
735fe3db7c7SDoug Rabson     ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT);
736fe3db7c7SDoug Rabson     if (ef->object == NULL) {
737fe3db7c7SDoug Rabson 	error = ENOMEM;
738fe3db7c7SDoug Rabson 	goto out;
739fe3db7c7SDoug Rabson     }
740fe3db7c7SDoug Rabson     ef->address = (caddr_t) vm_map_min(kernel_map);
741fe3db7c7SDoug Rabson     error = vm_map_find(kernel_map, ef->object, 0,
742fe3db7c7SDoug Rabson 			(vm_offset_t *) &ef->address,
743fe3db7c7SDoug Rabson 			mapsize, 1,
744fe3db7c7SDoug Rabson 			VM_PROT_ALL, VM_PROT_ALL, 0);
745fe3db7c7SDoug Rabson     if (error) {
746fe3db7c7SDoug Rabson 	vm_object_deallocate(ef->object);
747326e27d8SDoug Rabson 	ef->object = 0;
748fe3db7c7SDoug Rabson 	goto out;
749fe3db7c7SDoug Rabson     }
750fe3db7c7SDoug Rabson #else
751a163d034SWarner Losh     ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
752326e27d8SDoug Rabson     if (!ef->address) {
753326e27d8SDoug Rabson 	error = ENOMEM;
754326e27d8SDoug Rabson 	goto out;
755326e27d8SDoug Rabson     }
756fe3db7c7SDoug Rabson #endif
757fe3db7c7SDoug Rabson     mapbase = ef->address;
758a4f67738SDoug Rabson 
759a4f67738SDoug Rabson     /*
760a4f67738SDoug Rabson      * Read the text and data sections and zero the bss.
761a4f67738SDoug Rabson      */
7621a330eb0SPeter Wemm     for (i = 0; i < nsegs; i++) {
763fe3db7c7SDoug Rabson 	caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr;
764fe3db7c7SDoug Rabson 	error = vn_rdwr(UIO_READ, nd.ni_vp,
765fe3db7c7SDoug Rabson 			segbase, segs[i]->p_filesz, segs[i]->p_offset,
7669ca43589SRobert Watson 			UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
7679ca43589SRobert Watson 			&resid, td);
768fe3db7c7SDoug Rabson 	if (error) {
769a4f67738SDoug Rabson 	    goto out;
770a4f67738SDoug Rabson 	}
771fe3db7c7SDoug Rabson 	bzero(segbase + segs[i]->p_filesz,
772fe3db7c7SDoug Rabson 	      segs[i]->p_memsz - segs[i]->p_filesz);
77341673965SAlan Cox 
77441673965SAlan Cox #ifdef SPARSE_MAPPING
77541673965SAlan Cox 	/*
77641673965SAlan Cox 	 * Wire down the pages
77741673965SAlan Cox 	 */
7785d3043ceSAlan Cox 	error = vm_map_wire(kernel_map,
77941673965SAlan Cox 		    (vm_offset_t) segbase,
78041673965SAlan Cox 		    (vm_offset_t) segbase + segs[i]->p_memsz,
78141673965SAlan Cox 		    VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);
7825d3043ceSAlan Cox 	if (error != KERN_SUCCESS) {
7835d3043ceSAlan Cox 	    error = ENOMEM;
7845d3043ceSAlan Cox 	    goto out;
7855d3043ceSAlan Cox 	}
78641673965SAlan Cox #endif
787fe3db7c7SDoug Rabson     }
788fe3db7c7SDoug Rabson 
789f99502a4SBrian Feldman #ifdef GPROF
790f99502a4SBrian Feldman     /* Update profiling information with the new text segment. */
79170f37788SJohn Baldwin     mtx_lock(&Giant);
792f99502a4SBrian Feldman     kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr +
793f99502a4SBrian Feldman 	segs[0]->p_memsz));
79470f37788SJohn Baldwin     mtx_unlock(&Giant);
795f99502a4SBrian Feldman #endif
796f99502a4SBrian Feldman 
797326e27d8SDoug Rabson     ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
798a4f67738SDoug Rabson 
799a4f67738SDoug Rabson     lf->address = ef->address;
800fe3db7c7SDoug Rabson     lf->size = mapsize;
801a4f67738SDoug Rabson 
802326e27d8SDoug Rabson     error = parse_dynamic(ef);
803ca65d5c7SPeter Wemm     if (error)
804de78ca7eSPeter Wemm 	goto out;
8057251b4bfSJake Burkholder     link_elf_reloc_local(lf);
8067251b4bfSJake Burkholder 
8074f7afc20SKonstantin Belousov     VOP_UNLOCK(nd.ni_vp, 0);
8087b9716baSIan Dowse     error = linker_load_dependencies(lf);
8094f7afc20SKonstantin Belousov     vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
810ca65d5c7SPeter Wemm     if (error)
811de78ca7eSPeter Wemm 	goto out;
81254823af2SPeter Wemm #if 0	/* this will be more trouble than it's worth for now */
81354823af2SPeter Wemm     for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
81454823af2SPeter Wemm 	if (dp->d_tag != DT_NEEDED)
81554823af2SPeter Wemm 	    continue;
81654823af2SPeter Wemm 	modname = ef->strtab + dp->d_un.d_val;
81754823af2SPeter Wemm 	error = linker_load_module(modname, lf);
81854823af2SPeter Wemm 	if (error)
81954823af2SPeter Wemm 	    goto out;
82054823af2SPeter Wemm     }
82154823af2SPeter Wemm #endif
822326e27d8SDoug Rabson     error = relocate_file(ef);
823ca65d5c7SPeter Wemm     if (error)
824ca65d5c7SPeter Wemm 	goto out;
825ca65d5c7SPeter Wemm 
826ca65d5c7SPeter Wemm     /* Try and load the symbol table if it's present.  (you can strip it!) */
827caab6e90SPeter Wemm     nbytes = hdr->e_shnum * hdr->e_shentsize;
828caab6e90SPeter Wemm     if (nbytes == 0 || hdr->e_shoff == 0)
829ca65d5c7SPeter Wemm 	goto nosyms;
830a163d034SWarner Losh     shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO);
831ca65d5c7SPeter Wemm     if (shdr == NULL) {
832ca65d5c7SPeter Wemm 	error = ENOMEM;
833a4f67738SDoug Rabson 	goto out;
834a4f67738SDoug Rabson     }
835ca65d5c7SPeter Wemm     error = vn_rdwr(UIO_READ, nd.ni_vp,
836caab6e90SPeter Wemm 		    (caddr_t)shdr, nbytes, hdr->e_shoff,
8379ca43589SRobert Watson 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
8389ca43589SRobert Watson 		    &resid, td);
839ca65d5c7SPeter Wemm     if (error)
840ca65d5c7SPeter Wemm 	goto out;
841ca65d5c7SPeter Wemm     symtabindex = -1;
842ca65d5c7SPeter Wemm     symstrindex = -1;
843caab6e90SPeter Wemm     for (i = 0; i < hdr->e_shnum; i++) {
844ca65d5c7SPeter Wemm 	if (shdr[i].sh_type == SHT_SYMTAB) {
845ca65d5c7SPeter Wemm 	    symtabindex = i;
846ca65d5c7SPeter Wemm 	    symstrindex = shdr[i].sh_link;
847ca65d5c7SPeter Wemm 	}
848ca65d5c7SPeter Wemm     }
849ca65d5c7SPeter Wemm     if (symtabindex < 0 || symstrindex < 0)
850ca65d5c7SPeter Wemm 	goto nosyms;
851ca65d5c7SPeter Wemm 
852ca65d5c7SPeter Wemm     symcnt = shdr[symtabindex].sh_size;
853a163d034SWarner Losh     ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
854ca65d5c7SPeter Wemm     strcnt = shdr[symstrindex].sh_size;
855a163d034SWarner Losh     ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
856ca65d5c7SPeter Wemm 
857ca65d5c7SPeter Wemm     if (ef->symbase == NULL || ef->strbase == NULL) {
858ca65d5c7SPeter Wemm 	error = ENOMEM;
859ca65d5c7SPeter Wemm 	goto out;
860ca65d5c7SPeter Wemm     }
861ca65d5c7SPeter Wemm     error = vn_rdwr(UIO_READ, nd.ni_vp,
862ca65d5c7SPeter Wemm 		    ef->symbase, symcnt, shdr[symtabindex].sh_offset,
8639ca43589SRobert Watson 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
8649ca43589SRobert Watson 		    &resid, td);
865ca65d5c7SPeter Wemm     if (error)
866ca65d5c7SPeter Wemm 	goto out;
867ca65d5c7SPeter Wemm     error = vn_rdwr(UIO_READ, nd.ni_vp,
868ca65d5c7SPeter Wemm 		    ef->strbase, strcnt, shdr[symstrindex].sh_offset,
8699ca43589SRobert Watson 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
8709ca43589SRobert Watson 		    &resid, td);
871ca65d5c7SPeter Wemm     if (error)
872ca65d5c7SPeter Wemm 	goto out;
873ca65d5c7SPeter Wemm 
874ca65d5c7SPeter Wemm     ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
875ca65d5c7SPeter Wemm     ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
876ca65d5c7SPeter Wemm     ef->ddbstrcnt = strcnt;
877ca65d5c7SPeter Wemm     ef->ddbstrtab = ef->strbase;
878ca65d5c7SPeter Wemm 
879c143d6c2SMarcel Moolenaar     error = link_elf_link_common_finish(lf);
880c143d6c2SMarcel Moolenaar     if (error)
881c143d6c2SMarcel Moolenaar 	goto out;
882326e27d8SDoug Rabson 
883ca65d5c7SPeter Wemm nosyms:
884a4f67738SDoug Rabson 
885a4f67738SDoug Rabson     *result = lf;
886a4f67738SDoug Rabson 
887a4f67738SDoug Rabson out:
888ca65d5c7SPeter Wemm     if (error && lf)
88965a311fcSPoul-Henning Kamp 	linker_file_unload(lf, LINKER_UNLOAD_FORCE);
890ca65d5c7SPeter Wemm     if (shdr)
891ca65d5c7SPeter Wemm 	free(shdr, M_LINKER);
892caab6e90SPeter Wemm     if (firstpage)
893caab6e90SPeter Wemm 	free(firstpage, M_LINKER);
89422db15c0SAttilio Rao     VOP_UNLOCK(nd.ni_vp, 0);
895a854ed98SJohn Baldwin     vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
89662d615d5SJohn Baldwin     VFS_UNLOCK_GIANT(vfslocked);
897a4f67738SDoug Rabson 
898a4f67738SDoug Rabson     return error;
899a4f67738SDoug Rabson }
900a4f67738SDoug Rabson 
901a4f67738SDoug Rabson static void
902de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file)
903a4f67738SDoug Rabson {
904326e27d8SDoug Rabson     elf_file_t ef = (elf_file_t) file;
905a4f67738SDoug Rabson 
906ecb01c64SMarcel Moolenaar #ifdef GDB
907326e27d8SDoug Rabson     if (ef->gdb.l_ld) {
908326e27d8SDoug Rabson 	GDB_STATE(RT_DELETE);
909ed6c3888SPeter Wemm 	free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER);
910326e27d8SDoug Rabson 	link_elf_delete_gdb(&ef->gdb);
911326e27d8SDoug Rabson 	GDB_STATE(RT_CONSISTENT);
912326e27d8SDoug Rabson     }
913326e27d8SDoug Rabson #endif
914326e27d8SDoug Rabson 
9151aeb23cdSMarcel Moolenaar     /* Notify MD code that a module is being unloaded. */
9161aeb23cdSMarcel Moolenaar     elf_cpu_unload_file(file);
9171aeb23cdSMarcel Moolenaar 
918326e27d8SDoug Rabson     if (ef->preloaded) {
91954823af2SPeter Wemm 	link_elf_unload_preload(file);
920326e27d8SDoug Rabson 	return;
921326e27d8SDoug Rabson     }
922c143d6c2SMarcel Moolenaar 
923fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING
924fe3db7c7SDoug Rabson     if (ef->object) {
925fe3db7c7SDoug Rabson 	vm_map_remove(kernel_map, (vm_offset_t) ef->address,
926fe3db7c7SDoug Rabson 		      (vm_offset_t) ef->address
927fe3db7c7SDoug Rabson 		      + (ef->object->size << PAGE_SHIFT));
928fe3db7c7SDoug Rabson     }
929fe3db7c7SDoug Rabson #else
930ca65d5c7SPeter Wemm     if (ef->address)
931a4f67738SDoug Rabson 	free(ef->address, M_LINKER);
932fe3db7c7SDoug Rabson #endif
933ca65d5c7SPeter Wemm     if (ef->symbase)
934ca65d5c7SPeter Wemm 	free(ef->symbase, M_LINKER);
935ca65d5c7SPeter Wemm     if (ef->strbase)
936ca65d5c7SPeter Wemm 	free(ef->strbase, M_LINKER);
937a2024a3eSJohn Birrell     if (ef->ctftab)
938a2024a3eSJohn Birrell 	free(ef->ctftab, M_LINKER);
939a2024a3eSJohn Birrell     if (ef->ctfoff)
940a2024a3eSJohn Birrell 	free(ef->ctfoff, M_LINKER);
941a2024a3eSJohn Birrell     if (ef->typoff)
942a2024a3eSJohn Birrell 	free(ef->typoff, M_LINKER);
943a4f67738SDoug Rabson }
944a4f67738SDoug Rabson 
945de78ca7eSPeter Wemm static void
94654823af2SPeter Wemm link_elf_unload_preload(linker_file_t file)
947de78ca7eSPeter Wemm {
948de78ca7eSPeter Wemm     if (file->filename)
949de78ca7eSPeter Wemm 	preload_delete_name(file->filename);
950de78ca7eSPeter Wemm }
951de78ca7eSPeter Wemm 
952fe3db7c7SDoug Rabson static const char *
953757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info)
954a4f67738SDoug Rabson {
955fe3db7c7SDoug Rabson     const Elf_Sym *ref;
956a4f67738SDoug Rabson 
957aa855a59SPeter Wemm     if (ELF_R_SYM(r_info)) {
958aa855a59SPeter Wemm 	ref = ef->symtab + ELF_R_SYM(r_info);
959434bf653SPeter Wemm 	return ef->strtab + ref->st_name;
960fe3db7c7SDoug Rabson     } else
961fe3db7c7SDoug Rabson 	return NULL;
962a4f67738SDoug Rabson }
963a4f67738SDoug Rabson 
964a4f67738SDoug Rabson static int
965326e27d8SDoug Rabson relocate_file(elf_file_t ef)
966a4f67738SDoug Rabson {
967fe3db7c7SDoug Rabson     const Elf_Rel *rellim;
968fe3db7c7SDoug Rabson     const Elf_Rel *rel;
969fe3db7c7SDoug Rabson     const Elf_Rela *relalim;
970fe3db7c7SDoug Rabson     const Elf_Rela *rela;
971aa855a59SPeter Wemm     const char *symname;
972a4f67738SDoug Rabson 
973fe3db7c7SDoug Rabson     /* Perform relocations without addend if there are any: */
974aa855a59SPeter Wemm     rel = ef->rel;
975aa855a59SPeter Wemm     if (rel) {
976cacd1f6aSBruce Evans 	rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
977aa855a59SPeter Wemm 	while (rel < rellim) {
978e8855d4fSPeter Wemm 	    if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL,
979e8855d4fSPeter Wemm 			  elf_lookup)) {
980aa855a59SPeter Wemm 		symname = symbol_name(ef, rel->r_info);
981ef83592dSPeter Wemm 		printf("link_elf: symbol %s undefined\n", symname);
982a4f67738SDoug Rabson 		return ENOENT;
983a13ddfb6SPeter Wemm 	    }
984aa855a59SPeter Wemm 	    rel++;
985aa855a59SPeter Wemm 	}
986a4f67738SDoug Rabson     }
987a4f67738SDoug Rabson 
988fe3db7c7SDoug Rabson     /* Perform relocations with addend if there are any: */
989aa855a59SPeter Wemm     rela = ef->rela;
990aa855a59SPeter Wemm     if (rela) {
991cacd1f6aSBruce Evans 	relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
992aa855a59SPeter Wemm 	while (rela < relalim) {
993e8855d4fSPeter Wemm 	    if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA,
994e8855d4fSPeter Wemm 			  elf_lookup)) {
995aa855a59SPeter Wemm 		symname = symbol_name(ef, rela->r_info);
996ef83592dSPeter Wemm 		printf("link_elf: symbol %s undefined\n", symname);
997fe3db7c7SDoug Rabson 		return ENOENT;
998a13ddfb6SPeter Wemm 	    }
999aa855a59SPeter Wemm 	    rela++;
1000aa855a59SPeter Wemm 	}
1001a4f67738SDoug Rabson     }
1002a4f67738SDoug Rabson 
1003fe3db7c7SDoug Rabson     /* Perform PLT relocations without addend if there are any: */
1004aa855a59SPeter Wemm     rel = ef->pltrel;
1005aa855a59SPeter Wemm     if (rel) {
1006cacd1f6aSBruce Evans 	rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize);
1007aa855a59SPeter Wemm 	while (rel < rellim) {
1008e8855d4fSPeter Wemm 	    if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL,
1009e8855d4fSPeter Wemm 			  elf_lookup)) {
1010aa855a59SPeter Wemm 		symname = symbol_name(ef, rel->r_info);
1011ef83592dSPeter Wemm 		printf("link_elf: symbol %s undefined\n", symname);
1012fe3db7c7SDoug Rabson 		return ENOENT;
1013a13ddfb6SPeter Wemm 	    }
1014aa855a59SPeter Wemm 	    rel++;
1015aa855a59SPeter Wemm 	}
1016a4f67738SDoug Rabson     }
1017a4f67738SDoug Rabson 
1018fe3db7c7SDoug Rabson     /* Perform relocations with addend if there are any: */
1019aa855a59SPeter Wemm     rela = ef->pltrela;
1020aa855a59SPeter Wemm     if (rela) {
1021cacd1f6aSBruce Evans 	relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize);
1022aa855a59SPeter Wemm 	while (rela < relalim) {
1023e8855d4fSPeter Wemm 	    if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA,
1024e8855d4fSPeter Wemm 			  elf_lookup)) {
1025aa855a59SPeter Wemm 		symname = symbol_name(ef, rela->r_info);
1026ef83592dSPeter Wemm 		printf("link_elf: symbol %s undefined\n", symname);
1027fe3db7c7SDoug Rabson 		return ENOENT;
1028a13ddfb6SPeter Wemm 	    }
1029aa855a59SPeter Wemm 	    rela++;
1030aa855a59SPeter Wemm 	}
1031a4f67738SDoug Rabson     }
1032a4f67738SDoug Rabson 
1033a4f67738SDoug Rabson     return 0;
1034a4f67738SDoug Rabson }
1035a4f67738SDoug Rabson 
1036fe3db7c7SDoug Rabson /*
1037fe3db7c7SDoug Rabson  * Hash function for symbol table lookup.  Don't even think about changing
1038fe3db7c7SDoug Rabson  * this.  It is specified by the System V ABI.
1039fe3db7c7SDoug Rabson  */
1040fe3db7c7SDoug Rabson static unsigned long
1041fe3db7c7SDoug Rabson elf_hash(const char *name)
1042a4f67738SDoug Rabson {
1043fe3db7c7SDoug Rabson     const unsigned char *p = (const unsigned char *) name;
1044fe3db7c7SDoug Rabson     unsigned long h = 0;
1045fe3db7c7SDoug Rabson     unsigned long g;
1046a4f67738SDoug Rabson 
1047fe3db7c7SDoug Rabson     while (*p != '\0') {
1048fe3db7c7SDoug Rabson 	h = (h << 4) + *p++;
1049fe3db7c7SDoug Rabson 	if ((g = h & 0xf0000000) != 0)
1050fe3db7c7SDoug Rabson 	    h ^= g >> 24;
1051fe3db7c7SDoug Rabson 	h &= ~g;
1052a4f67738SDoug Rabson     }
1053fe3db7c7SDoug Rabson     return h;
1054fe3db7c7SDoug Rabson }
1055a4f67738SDoug Rabson 
105637c84183SPoul-Henning Kamp static int
1057d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym)
1058a4f67738SDoug Rabson {
1059326e27d8SDoug Rabson     elf_file_t ef = (elf_file_t) lf;
1060fe3db7c7SDoug Rabson     unsigned long symnum;
10612d636ab0SPeter Wemm     const Elf_Sym* symp;
10622d636ab0SPeter Wemm     const char *strp;
1063fe3db7c7SDoug Rabson     unsigned long hash;
1064a4f67738SDoug Rabson     int i;
1065a4f67738SDoug Rabson 
1066f6494f2eSJohn Baldwin     /* If we don't have a hash, bail. */
1067f6494f2eSJohn Baldwin     if (ef->buckets == NULL || ef->nbuckets == 0) {
1068f6494f2eSJohn Baldwin 	printf("link_elf_lookup_symbol: missing symbol hash table\n");
1069f6494f2eSJohn Baldwin 	return ENOENT;
1070f6494f2eSJohn Baldwin     }
1071f6494f2eSJohn Baldwin 
10722d636ab0SPeter Wemm     /* First, search hashed global symbols */
1073fe3db7c7SDoug Rabson     hash = elf_hash(name);
1074fe3db7c7SDoug Rabson     symnum = ef->buckets[hash % ef->nbuckets];
1075fe3db7c7SDoug Rabson 
1076fe3db7c7SDoug Rabson     while (symnum != STN_UNDEF) {
1077fe3db7c7SDoug Rabson 	if (symnum >= ef->nchains) {
1078fe3db7c7SDoug Rabson 	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
1079fe3db7c7SDoug Rabson 	    return ENOENT;
1080a4f67738SDoug Rabson 	}
1081fe3db7c7SDoug Rabson 
1082fe3db7c7SDoug Rabson 	symp = ef->symtab + symnum;
1083fe3db7c7SDoug Rabson 	if (symp->st_name == 0) {
1084fe3db7c7SDoug Rabson 	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
1085fe3db7c7SDoug Rabson 	    return ENOENT;
1086fe3db7c7SDoug Rabson 	}
1087fe3db7c7SDoug Rabson 
1088fe3db7c7SDoug Rabson 	strp = ef->strtab + symp->st_name;
1089fe3db7c7SDoug Rabson 
1090fe3db7c7SDoug Rabson 	if (strcmp(name, strp) == 0) {
1091fe3db7c7SDoug Rabson 	    if (symp->st_shndx != SHN_UNDEF ||
1092fe3db7c7SDoug Rabson 		(symp->st_value != 0 &&
1093fe3db7c7SDoug Rabson 		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1094d254af07SMatthew Dillon 		*sym = (c_linker_sym_t) symp;
1095fe3db7c7SDoug Rabson 		return 0;
1096fe3db7c7SDoug Rabson 	    } else
1097fe3db7c7SDoug Rabson 		return ENOENT;
1098fe3db7c7SDoug Rabson 	}
1099fe3db7c7SDoug Rabson 
1100fe3db7c7SDoug Rabson 	symnum = ef->chains[symnum];
1101a4f67738SDoug Rabson     }
1102a4f67738SDoug Rabson 
11032d636ab0SPeter Wemm     /* If we have not found it, look at the full table (if loaded) */
11042d636ab0SPeter Wemm     if (ef->symtab == ef->ddbsymtab)
11052d636ab0SPeter Wemm 	return ENOENT;
11062d636ab0SPeter Wemm 
11072d636ab0SPeter Wemm     /* Exhaustive search */
11082d636ab0SPeter Wemm     for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
11092d636ab0SPeter Wemm 	strp = ef->ddbstrtab + symp->st_name;
11102d636ab0SPeter Wemm 	if (strcmp(name, strp) == 0) {
11112d636ab0SPeter Wemm 	    if (symp->st_shndx != SHN_UNDEF ||
11122d636ab0SPeter Wemm 		(symp->st_value != 0 &&
11132d636ab0SPeter Wemm 		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1114d254af07SMatthew Dillon 		*sym = (c_linker_sym_t) symp;
11152d636ab0SPeter Wemm 		return 0;
11162d636ab0SPeter Wemm 	    } else
11172d636ab0SPeter Wemm 		return ENOENT;
11182d636ab0SPeter Wemm 	}
11192d636ab0SPeter Wemm     }
11202d636ab0SPeter Wemm 
1121a4f67738SDoug Rabson     return ENOENT;
1122a4f67738SDoug Rabson }
1123a4f67738SDoug Rabson 
1124de78ca7eSPeter Wemm static int
1125fe08c21aSMatthew Dillon link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval)
1126a4f67738SDoug Rabson {
1127326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
11288aef1712SMatthew Dillon 	const Elf_Sym* es = (const Elf_Sym*) sym;
1129a4f67738SDoug Rabson 
11305cf87418SMarcel Moolenaar 	if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) {
1131a4f67738SDoug Rabson 	    symval->name = ef->strtab + es->st_name;
1132fe3db7c7SDoug Rabson 	    symval->value = (caddr_t) ef->address + es->st_value;
1133a4f67738SDoug Rabson 	    symval->size = es->st_size;
1134de78ca7eSPeter Wemm 	    return 0;
1135a4f67738SDoug Rabson 	}
11362d636ab0SPeter Wemm 	if (ef->symtab == ef->ddbsymtab)
11372d636ab0SPeter Wemm 	    return ENOENT;
11385cf87418SMarcel Moolenaar 	if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) {
11392d636ab0SPeter Wemm 	    symval->name = ef->ddbstrtab + es->st_name;
11402d636ab0SPeter Wemm 	    symval->value = (caddr_t) ef->address + es->st_value;
11412d636ab0SPeter Wemm 	    symval->size = es->st_size;
11422d636ab0SPeter Wemm 	    return 0;
11432d636ab0SPeter Wemm 	}
11442d636ab0SPeter Wemm 	return ENOENT;
11452d636ab0SPeter Wemm }
1146a4f67738SDoug Rabson 
1147a4f67738SDoug Rabson static int
1148a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value,
1149d254af07SMatthew Dillon 		       c_linker_sym_t* sym, long* diffp)
1150a4f67738SDoug Rabson {
1151326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
1152586453feSBruce Evans 	u_long off = (uintptr_t) (void *) value;
1153a4f67738SDoug Rabson 	u_long diff = off;
1154586453feSBruce Evans 	u_long st_value;
1155fe3db7c7SDoug Rabson 	const Elf_Sym* es;
1156fe3db7c7SDoug Rabson 	const Elf_Sym* best = 0;
1157a4f67738SDoug Rabson 	int i;
1158a4f67738SDoug Rabson 
11592d636ab0SPeter Wemm 	for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1160a4f67738SDoug Rabson 		if (es->st_name == 0)
1161a4f67738SDoug Rabson 			continue;
1162586453feSBruce Evans 		st_value = es->st_value + (uintptr_t) (void *) ef->address;
1163b5abfb70SPeter Wemm 		if (off >= st_value) {
1164b5abfb70SPeter Wemm 			if (off - st_value < diff) {
1165b5abfb70SPeter Wemm 				diff = off - st_value;
1166a4f67738SDoug Rabson 				best = es;
1167a4f67738SDoug Rabson 				if (diff == 0)
1168a4f67738SDoug Rabson 					break;
1169b5abfb70SPeter Wemm 			} else if (off - st_value == diff) {
1170a4f67738SDoug Rabson 				best = es;
1171a4f67738SDoug Rabson 			}
1172a4f67738SDoug Rabson 		}
1173a4f67738SDoug Rabson 	}
1174a4f67738SDoug Rabson 	if (best == 0)
1175a4f67738SDoug Rabson 		*diffp = off;
1176a4f67738SDoug Rabson 	else
1177a4f67738SDoug Rabson 		*diffp = diff;
1178d254af07SMatthew Dillon 	*sym = (c_linker_sym_t) best;
1179a4f67738SDoug Rabson 
1180a4f67738SDoug Rabson 	return 0;
1181a4f67738SDoug Rabson }
1182f41325dbSPeter Wemm 
1183f41325dbSPeter Wemm /*
1184f41325dbSPeter Wemm  * Look up a linker set on an ELF system.
1185f41325dbSPeter Wemm  */
1186f41325dbSPeter Wemm static int
1187f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name,
1188f41325dbSPeter Wemm 		    void ***startp, void ***stopp, int *countp)
1189f41325dbSPeter Wemm {
1190f41325dbSPeter Wemm 	c_linker_sym_t sym;
1191f41325dbSPeter Wemm 	linker_symval_t symval;
1192f41325dbSPeter Wemm 	char *setsym;
1193f41325dbSPeter Wemm 	void **start, **stop;
1194f41325dbSPeter Wemm 	int len, error = 0, count;
1195f41325dbSPeter Wemm 
1196f41325dbSPeter Wemm 	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
1197a163d034SWarner Losh 	setsym = malloc(len, M_LINKER, M_WAITOK);
1198f41325dbSPeter Wemm 	if (setsym == NULL)
1199f41325dbSPeter Wemm 		return ENOMEM;
1200f41325dbSPeter Wemm 
1201f41325dbSPeter Wemm 	/* get address of first entry */
1202f41325dbSPeter Wemm 	snprintf(setsym, len, "%s%s", "__start_set_", name);
1203f41325dbSPeter Wemm 	error = link_elf_lookup_symbol(lf, setsym, &sym);
1204f41325dbSPeter Wemm 	if (error)
1205f41325dbSPeter Wemm 		goto out;
1206f41325dbSPeter Wemm 	link_elf_symbol_values(lf, sym, &symval);
1207f41325dbSPeter Wemm 	if (symval.value == 0) {
1208f41325dbSPeter Wemm 		error = ESRCH;
1209f41325dbSPeter Wemm 		goto out;
1210f41325dbSPeter Wemm 	}
1211f41325dbSPeter Wemm 	start = (void **)symval.value;
1212f41325dbSPeter Wemm 
1213f41325dbSPeter Wemm 	/* get address of last entry */
1214f41325dbSPeter Wemm 	snprintf(setsym, len, "%s%s", "__stop_set_", name);
1215f41325dbSPeter Wemm 	error = link_elf_lookup_symbol(lf, setsym, &sym);
1216f41325dbSPeter Wemm 	if (error)
1217f41325dbSPeter Wemm 		goto out;
1218f41325dbSPeter Wemm 	link_elf_symbol_values(lf, sym, &symval);
1219f41325dbSPeter Wemm 	if (symval.value == 0) {
1220f41325dbSPeter Wemm 		error = ESRCH;
1221f41325dbSPeter Wemm 		goto out;
1222f41325dbSPeter Wemm 	}
1223f41325dbSPeter Wemm 	stop = (void **)symval.value;
1224f41325dbSPeter Wemm 
1225f41325dbSPeter Wemm 	/* and the number of entries */
1226f41325dbSPeter Wemm 	count = stop - start;
1227f41325dbSPeter Wemm 
1228f41325dbSPeter Wemm 	/* and copy out */
1229f41325dbSPeter Wemm 	if (startp)
1230f41325dbSPeter Wemm 		*startp = start;
1231f41325dbSPeter Wemm 	if (stopp)
1232f41325dbSPeter Wemm 		*stopp = stop;
1233f41325dbSPeter Wemm 	if (countp)
1234f41325dbSPeter Wemm 		*countp = count;
1235f41325dbSPeter Wemm 
1236f41325dbSPeter Wemm out:
1237f41325dbSPeter Wemm 	free(setsym, M_LINKER);
1238f41325dbSPeter Wemm 	return error;
1239f41325dbSPeter Wemm }
1240bb9fe9ddSBrian Feldman 
1241bb9fe9ddSBrian Feldman static int
1242bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file,
1243bb9fe9ddSBrian Feldman   int (*callback)(const char *, void *), void *opaque) {
1244bb9fe9ddSBrian Feldman     elf_file_t ef = (elf_file_t)file;
1245bb9fe9ddSBrian Feldman     const Elf_Sym* symp;
1246bb9fe9ddSBrian Feldman     int i, error;
1247bb9fe9ddSBrian Feldman 
1248bb9fe9ddSBrian Feldman     /* Exhaustive search */
1249bb9fe9ddSBrian Feldman     for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1250bb9fe9ddSBrian Feldman 	if (symp->st_value != 0 &&
1251bb9fe9ddSBrian Feldman 	    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1252bb9fe9ddSBrian Feldman 		error = callback(ef->ddbstrtab + symp->st_name, opaque);
1253bb9fe9ddSBrian Feldman 		if (error)
1254bb9fe9ddSBrian Feldman 		    return (error);
1255bb9fe9ddSBrian Feldman 	}
1256bb9fe9ddSBrian Feldman     }
1257bb9fe9ddSBrian Feldman     return (0);
1258bb9fe9ddSBrian Feldman }
125984201059SMarcel Moolenaar 
1260a2024a3eSJohn Birrell static int
1261a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file,
1262a2024a3eSJohn Birrell     linker_function_nameval_callback_t callback, void *opaque)
1263a2024a3eSJohn Birrell {
1264a2024a3eSJohn Birrell 	linker_symval_t symval;
1265a2024a3eSJohn Birrell 	elf_file_t ef = (elf_file_t)file;
1266a2024a3eSJohn Birrell 	const Elf_Sym* symp;
1267a2024a3eSJohn Birrell 	int i, error;
1268a2024a3eSJohn Birrell 
1269a2024a3eSJohn Birrell 	/* Exhaustive search */
1270a2024a3eSJohn Birrell 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1271a2024a3eSJohn Birrell 		if (symp->st_value != 0 &&
1272a2024a3eSJohn Birrell 		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1273a2024a3eSJohn Birrell 			error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval);
1274a2024a3eSJohn Birrell 			if (error)
1275a2024a3eSJohn Birrell 				return (error);
1276a2024a3eSJohn Birrell 			error = callback(file, i, &symval, opaque);
1277a2024a3eSJohn Birrell 			if (error)
1278a2024a3eSJohn Birrell 				return (error);
1279a2024a3eSJohn Birrell 		}
1280a2024a3eSJohn Birrell 	}
1281a2024a3eSJohn Birrell 	return (0);
1282a2024a3eSJohn Birrell }
1283a2024a3eSJohn Birrell 
128484201059SMarcel Moolenaar #ifdef __ia64__
128584201059SMarcel Moolenaar /*
128684201059SMarcel Moolenaar  * Each KLD has its own GP. The GP value for each load module is given by
128784201059SMarcel Moolenaar  * DT_PLTGOT on ia64. We need GP to construct function descriptors, but
128884201059SMarcel Moolenaar  * don't have direct access to the ELF file structure. The link_elf_get_gp()
128984201059SMarcel Moolenaar  * function returns the GP given a pointer to a generic linker file struct.
129084201059SMarcel Moolenaar  */
129184201059SMarcel Moolenaar Elf_Addr
129284201059SMarcel Moolenaar link_elf_get_gp(linker_file_t lf)
129384201059SMarcel Moolenaar {
129484201059SMarcel Moolenaar 	elf_file_t ef = (elf_file_t)lf;
129584201059SMarcel Moolenaar 	return (Elf_Addr)ef->got;
129684201059SMarcel Moolenaar }
129784201059SMarcel Moolenaar #endif
1298d297ad16SMarcel Moolenaar 
1299169d513cSJake Burkholder const Elf_Sym *
1300757686b1SMarcel Moolenaar elf_get_sym(linker_file_t lf, Elf_Size symidx)
1301169d513cSJake Burkholder {
1302169d513cSJake Burkholder 	elf_file_t ef = (elf_file_t)lf;
1303169d513cSJake Burkholder 
1304169d513cSJake Burkholder 	if (symidx >= ef->nchains)
1305169d513cSJake Burkholder 		return (NULL);
1306169d513cSJake Burkholder 	return (ef->symtab + symidx);
1307169d513cSJake Burkholder }
1308169d513cSJake Burkholder 
130947f75012SMarcel Moolenaar const char *
1310757686b1SMarcel Moolenaar elf_get_symname(linker_file_t lf, Elf_Size symidx)
131147f75012SMarcel Moolenaar {
131247f75012SMarcel Moolenaar 	elf_file_t ef = (elf_file_t)lf;
131347f75012SMarcel Moolenaar 	const Elf_Sym *sym;
131447f75012SMarcel Moolenaar 
131547f75012SMarcel Moolenaar 	if (symidx >= ef->nchains)
131647f75012SMarcel Moolenaar 		return (NULL);
131747f75012SMarcel Moolenaar 	sym = ef->symtab + symidx;
131847f75012SMarcel Moolenaar 	return (ef->strtab + sym->st_name);
131947f75012SMarcel Moolenaar }
132047f75012SMarcel Moolenaar 
1321d297ad16SMarcel Moolenaar /*
1322d297ad16SMarcel Moolenaar  * Symbol lookup function that can be used when the symbol index is known (ie
1323d297ad16SMarcel Moolenaar  * in relocations). It uses the symbol index instead of doing a fully fledged
1324d297ad16SMarcel Moolenaar  * hash table based lookup when such is valid. For example for local symbols.
1325d297ad16SMarcel Moolenaar  * This is not only more efficient, it's also more correct. It's not always
1326d297ad16SMarcel Moolenaar  * the case that the symbol can be found through the hash table.
1327d297ad16SMarcel Moolenaar  */
1328e8855d4fSPeter Wemm static Elf_Addr
1329757686b1SMarcel Moolenaar elf_lookup(linker_file_t lf, Elf_Size symidx, int deps)
1330d297ad16SMarcel Moolenaar {
1331d297ad16SMarcel Moolenaar 	elf_file_t ef = (elf_file_t)lf;
1332d297ad16SMarcel Moolenaar 	const Elf_Sym *sym;
1333d297ad16SMarcel Moolenaar 	const char *symbol;
1334d297ad16SMarcel Moolenaar 
1335d297ad16SMarcel Moolenaar 	/* Don't even try to lookup the symbol if the index is bogus. */
1336d297ad16SMarcel Moolenaar 	if (symidx >= ef->nchains)
1337d297ad16SMarcel Moolenaar 		return (0);
1338d297ad16SMarcel Moolenaar 
1339d297ad16SMarcel Moolenaar 	sym = ef->symtab + symidx;
1340d297ad16SMarcel Moolenaar 
1341d297ad16SMarcel Moolenaar 	/*
1342d297ad16SMarcel Moolenaar 	 * Don't do a full lookup when the symbol is local. It may even
1343d297ad16SMarcel Moolenaar 	 * fail because it may not be found through the hash table.
1344d297ad16SMarcel Moolenaar 	 */
1345d297ad16SMarcel Moolenaar 	if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
1346d297ad16SMarcel Moolenaar 		/* Force lookup failure when we have an insanity. */
1347d297ad16SMarcel Moolenaar 		if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0)
1348d297ad16SMarcel Moolenaar 			return (0);
1349d297ad16SMarcel Moolenaar 		return ((Elf_Addr)ef->address + sym->st_value);
1350d297ad16SMarcel Moolenaar 	}
1351d297ad16SMarcel Moolenaar 
1352d297ad16SMarcel Moolenaar 	/*
1353d297ad16SMarcel Moolenaar 	 * XXX we can avoid doing a hash table based lookup for global
1354d297ad16SMarcel Moolenaar 	 * symbols as well. This however is not always valid, so we'll
1355d297ad16SMarcel Moolenaar 	 * just do it the hard way for now. Performance tweaks can
1356d297ad16SMarcel Moolenaar 	 * always be added.
1357d297ad16SMarcel Moolenaar 	 */
1358d297ad16SMarcel Moolenaar 
1359d297ad16SMarcel Moolenaar 	symbol = ef->strtab + sym->st_name;
1360d297ad16SMarcel Moolenaar 
1361d297ad16SMarcel Moolenaar 	/* Force a lookup failure if the symbol name is bogus. */
1362d297ad16SMarcel Moolenaar 	if (*symbol == 0)
1363d297ad16SMarcel Moolenaar 		return (0);
1364d297ad16SMarcel Moolenaar 
1365d297ad16SMarcel Moolenaar 	return ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps));
1366d297ad16SMarcel Moolenaar }
13677251b4bfSJake Burkholder 
13687251b4bfSJake Burkholder static void
13697251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf)
13707251b4bfSJake Burkholder {
13717251b4bfSJake Burkholder     const Elf_Rel *rellim;
13727251b4bfSJake Burkholder     const Elf_Rel *rel;
13737251b4bfSJake Burkholder     const Elf_Rela *relalim;
13747251b4bfSJake Burkholder     const Elf_Rela *rela;
13757251b4bfSJake Burkholder     elf_file_t ef = (elf_file_t)lf;
13767251b4bfSJake Burkholder 
13777251b4bfSJake Burkholder     /* Perform relocations without addend if there are any: */
13787251b4bfSJake Burkholder     if ((rel = ef->rel) != NULL) {
13797251b4bfSJake Burkholder 	rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
13807251b4bfSJake Burkholder 	while (rel < rellim) {
1381e8855d4fSPeter Wemm 	    elf_reloc_local(lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL,
1382e8855d4fSPeter Wemm 			    elf_lookup);
13837251b4bfSJake Burkholder 	    rel++;
13847251b4bfSJake Burkholder 	}
13857251b4bfSJake Burkholder     }
13867251b4bfSJake Burkholder 
13877251b4bfSJake Burkholder     /* Perform relocations with addend if there are any: */
13887251b4bfSJake Burkholder     if ((rela = ef->rela) != NULL) {
13897251b4bfSJake Burkholder 	relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
13907251b4bfSJake Burkholder 	while (rela < relalim) {
1391e8855d4fSPeter Wemm 	    elf_reloc_local(lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA,
1392e8855d4fSPeter Wemm 			    elf_lookup);
13937251b4bfSJake Burkholder 	    rela++;
13947251b4bfSJake Burkholder 	}
13957251b4bfSJake Burkholder     }
13967251b4bfSJake Burkholder }
139700a5db46SStacey Son 
139800a5db46SStacey Son static long
139900a5db46SStacey Son link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab)
140000a5db46SStacey Son {
140100a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
140200a5db46SStacey Son 
140300a5db46SStacey Son     *symtab = ef->ddbsymtab;
140400a5db46SStacey Son 
140500a5db46SStacey Son     if (*symtab == NULL)
140600a5db46SStacey Son         return (0);
140700a5db46SStacey Son 
140800a5db46SStacey Son     return (ef->ddbsymcnt);
140900a5db46SStacey Son }
141000a5db46SStacey Son 
141100a5db46SStacey Son static long
141200a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab)
141300a5db46SStacey Son {
141400a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
141500a5db46SStacey Son 
141600a5db46SStacey Son     *strtab = ef->ddbstrtab;
141700a5db46SStacey Son 
141800a5db46SStacey Son     if (*strtab == NULL)
141900a5db46SStacey Son         return (0);
142000a5db46SStacey Son 
142100a5db46SStacey Son     return (ef->ddbstrcnt);
142200a5db46SStacey Son }
1423