xref: /titanic_44/usr/src/lib/libproc/common/Psymtab_machelf32.c (revision 503ad85c168c7992ccc310af845a581cff3c72b5)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <assert.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <stddef.h>
31 #include <string.h>
32 #include <memory.h>
33 #include <sys/sysmacros.h>
34 #include <sys/machelf.h>
35 
36 #include "Pcontrol.h"
37 #include "Psymtab_machelf.h"
38 
39 
40 /*
41  * This file contains code for use by Psymtab.c that is compiled once
42  * for each supported ELFCLASS.
43  *
44  * When processing ELF files, it is common to encounter a situation where
45  * a program with one ELFCLASS (32 or 64-bit) is required to examine a
46  * file with a different ELFCLASS. For example, the 32-bit linker (ld) may
47  * be used to link a 64-bit program. The simplest solution to this problem
48  * is to duplicate each such piece of code, modifying only the data types,
49  * and to use if statements to select the code to run. The problem with
50  * doing it that way is that the resulting code is difficult to maintain.
51  * It is inevitable that the copies will not always get modified identically,
52  * and will drift apart. The only robust solution is to generate the
53  * multiple instances of code automatically from a single piece of code.
54  *
55  * The solution used within the Solaris linker is to write the code once,
56  * using the data types defined in sys/machelf.h, and then to compile that
57  * code twice, once with _ELF64 defined (to generate ELFCLASS64 code) and
58  * once without (to generate ELFCLASS32). We use the same approach here.
59  *
60  * Note that the _ELF64 definition does not refer to the ELFCLASS of
61  * the resulting code, but rather, to the ELFCLASS of the data it
62  * examines. By repeating the above double-compilation for both 32-bit
63  * and 64-bit builds, we end up with 4 instances, which collectively
64  * can handle any combination of program and ELF data class:
65  *
66  *		    \  Compilation class
67  *		     \	  32	64
68  *		      \------------------
69  *		       |
70  *		    32 |   X	 X
71  *   ELF Data Class    |
72  *		    64 |   X	 X
73  */
74 
75 
76 
77 /*
78  * Read data from the specified process and construct an in memory
79  * image of an ELF file that will let us use libelf for most of the
80  * work we need to later (e.g. symbol table lookups). This is used
81  * in cases where no usable on-disk image for the process is available.
82  * We need sections for the dynsym, dynstr, and plt, and we need
83  * the program headers from the text section. The former is used in
84  * Pbuild_file_symtab(); the latter is used in several functions in
85  * Pcore.c to reconstruct the origin of each mapping from the load
86  * object that spawned it.
87  *
88  * Here are some useful pieces of elf trivia that will help
89  * to elucidate this code.
90  *
91  * All the information we need about the dynstr can be found in these
92  * two entries in the dynamic section:
93  *
94  *	DT_STRTAB	base of dynstr
95  *	DT_STRSZ	size of dynstr
96  *
97  * So deciphering the dynstr is pretty straightforward.
98  *
99  * The dynsym is a little trickier.
100  *
101  *	DT_SYMTAB	base of dynsym
102  *	DT_SYMENT	size of a dynstr entry (Elf{32,64}_Sym)
103  *	DT_HASH		base of hash table for dynamic lookups
104  *
105  * The DT_SYMTAB entry gives us any easy way of getting to the base
106  * of the dynsym, but getting the size involves rooting around in the
107  * dynamic lookup hash table. Here's the layout of the hash table:
108  *
109  *		+-------------------+
110  *		|	nbucket	    |	All values are 32-bit
111  *		+-------------------+	(Elf32_Word or Elf64_Word)
112  *		|	nchain	    |
113  *		+-------------------+
114  *		|	bucket[0]   |
115  *		|	. . .	    |
116  *		| bucket[nbucket-1] |
117  *		+-------------------+
118  *		|	chain[0]    |
119  *		|	. . .	    |
120  *		|  chain[nchain-1]  |
121  *		+-------------------+
122  *	(figure 5-12 from the SYS V Generic ABI)
123  *
124  * Symbols names are hashed into a particular bucket which contains
125  * an index into the symbol table. Each entry in the symbol table
126  * has a corresponding entry in the chain table which tells the
127  * consumer where the next entry in the hash chain is. We can use
128  * the nchain field to find out the size of the dynsym.
129  *
130  * If there is a dynsym present, there may also be an optional
131  * section called the SUNW_ldynsym that augments the dynsym by
132  * providing local function symbols. When the Solaris linker lays
133  * out a file that has both of these sections, it makes sure that
134  * the data for the two sections is adjacent with the SUNW_ldynsym
135  * in front. This allows the runtime linker to treat these two
136  * symbol tables as being a single larger table. There are two
137  * items in the dynamic section for this:
138  *
139  *	DT_SUNW_SYMTAB	base of the SUNW_ldynsym
140  *	DT_SUNW_SYMSZ	total size of SUNW_ldynsym and dynsym
141  *			added together. We can figure out the
142  *			size of the SUNW_ldynsym section by
143  *			subtracting the size of the dynsym
144  *			(described above) from this value.
145  *
146  * We can figure out the size of the .plt section, but it takes some
147  * doing. We need to use the following information:
148  *
149  *	DT_PLTGOT	GOT PLT entry offset (on x86) or PLT offset (on sparc)
150  *	DT_JMPREL	base of the PLT's relocation section
151  *	DT_PLTRELSZ	size of the PLT's relocation section
152  *	DT_PLTREL	type of the PLT's relocation section
153  *
154  * We can use the number of relocation entries to calculate the size of
155  * the PLT.  We get the address of the PLT by looking up the
156  * _PROCEDURE_LINKAGE_TABLE_ symbol.
157  *
158  * For more information, check out the System V Generic ABI.
159  */
160 
161 
162 /*
163  * The fake_elfXX() function generated by this file uses the following
164  * string as the string table for the section names. Since it is critical
165  * to count correctly, and to improve readability, the SHSTR_NDX_ macros
166  * supply the proper offset for each name within the string.
167  */
168 static char shstr[] =
169 	".shstrtab\0.dynsym\0.dynstr\0.dynamic\0.plt\0.SUNW_ldynsym";
170 
171 /* Offsets within shstr for each name */
172 #define	SHSTR_NDX_shstrtab	0
173 #define	SHSTR_NDX_dynsym	10
174 #define	SHSTR_NDX_dynstr	18
175 #define	SHSTR_NDX_dynamic	26
176 #define	SHSTR_NDX_plt		35
177 #define	SHSTR_NDX_SUNW_ldynsym	40
178 
179 
180 /*
181  * Section header alignment for 32 and 64-bit ELF files differs
182  */
183 #ifdef _ELF64
184 #define	SH_ADDRALIGN	8
185 #else
186 #define	SH_ADDRALIGN	4
187 #endif
188 
189 /*
190  * This is the smallest number of PLT relocation entries allowed in a proper
191  * .plt section.
192  */
193 #ifdef	__sparc
194 #define	PLTREL_MIN_ENTRIES	4	/* SPARC psABI 3.0 and SCD 2.4 */
195 #else
196 #ifdef	__lint
197 /*
198  * On x86, lint would complain about unsigned comparison with
199  * PLTREL_MIN_ENTRIES. This define fakes up the value of PLTREL_MIN_ENTRIES
200  * and silences lint. On SPARC, there is no such issue.
201  */
202 #define	PLTREL_MIN_ENTRIES	1
203 #else
204 #define	PLTREL_MIN_ENTRIES	0
205 #endif
206 #endif
207 
208 #ifdef _ELF64
209 Elf *
210 fake_elf64(struct ps_prochandle *P, file_info_t *fptr, uintptr_t addr,
211     Ehdr *ehdr, uint_t phnum, Phdr *phdr)
212 #else
213 Elf *
214 fake_elf32(struct ps_prochandle *P, file_info_t *fptr, uintptr_t addr,
215     Ehdr *ehdr, uint_t phnum, Phdr *phdr)
216 #endif
217 {
218 	enum {
219 		DI_PLTGOT,
220 		DI_JMPREL,
221 		DI_PLTRELSZ,
222 		DI_PLTREL,
223 		DI_SYMTAB,
224 		DI_HASH,
225 		DI_SYMENT,
226 		DI_STRTAB,
227 		DI_STRSZ,
228 		DI_SUNW_SYMTAB,
229 		DI_SUNW_SYMSZ,
230 		DI_NENT
231 	};
232 	/*
233 	 * Mask of dynamic options that must be present in a well
234 	 * formed dynamic section. We need all of these in order to
235 	 * put together a complete set of elf sections. They are
236 	 * mandatory in both executables and shared objects so if one
237 	 * of them is missing, we're in some trouble and should abort.
238 	 * The PLT items are expected, but we will let them slide if
239 	 * need be. The DI_SUNW_SYM* items are completely optional, so
240 	 * we use them if they are present and ignore them otherwise.
241 	 */
242 	const int di_req_mask = (1 << DI_SYMTAB) | (1 << DI_HASH) |
243 		(1 << DI_SYMENT) | (1 << DI_STRTAB) | (1 << DI_STRSZ);
244 	int di_mask = 0;
245 	size_t size = 0;
246 	caddr_t elfdata = NULL;
247 	Elf *elf;
248 	size_t dynsym_size = 0, ldynsym_size;
249 	int dynstr_shndx;
250 	Ehdr *ep;
251 	Shdr *sp;
252 	Dyn *dp;
253 	Dyn *d[DI_NENT] = { 0 };
254 	uint_t i;
255 	Off off;
256 	size_t pltsz = 0, pltentries = 0;
257 	uintptr_t hptr = NULL;
258 	Word hnchains, hnbuckets;
259 
260 	if (ehdr->e_type == ET_DYN)
261 		phdr->p_vaddr += addr;
262 
263 	if (P->rap != NULL) {
264 		if (rd_get_dyns(P->rap, addr, (void **)&dp, NULL) != RD_OK)
265 			goto bad;
266 	} else {
267 		if ((dp = malloc(phdr->p_filesz)) == NULL)
268 			goto bad;
269 		if (Pread(P, dp, phdr->p_filesz, phdr->p_vaddr) !=
270 		    phdr->p_filesz)
271 			goto bad;
272 	}
273 
274 	/*
275 	 * Iterate over the items in the dynamic section, grabbing
276 	 * the address of items we want and saving them in dp[].
277 	 */
278 	for (i = 0; i < phdr->p_filesz / sizeof (Dyn); i++) {
279 		switch (dp[i].d_tag) {
280 		/* For the .plt section */
281 		case DT_PLTGOT:
282 			d[DI_PLTGOT] = &dp[i];
283 			break;
284 		case DT_JMPREL:
285 			d[DI_JMPREL] = &dp[i];
286 			break;
287 		case DT_PLTRELSZ:
288 			d[DI_PLTRELSZ] = &dp[i];
289 			break;
290 		case DT_PLTREL:
291 			d[DI_PLTREL] = &dp[i];
292 			break;
293 
294 		/* For the .dynsym section */
295 		case DT_SYMTAB:
296 			d[DI_SYMTAB] = &dp[i];
297 			di_mask |= (1 << DI_SYMTAB);
298 			break;
299 		case DT_HASH:
300 			d[DI_HASH] = &dp[i];
301 			di_mask |= (1 << DI_HASH);
302 			break;
303 		case DT_SYMENT:
304 			d[DI_SYMENT] = &dp[i];
305 			di_mask |= (1 << DI_SYMENT);
306 			break;
307 		case DT_SUNW_SYMTAB:
308 			d[DI_SUNW_SYMTAB] = &dp[i];
309 			break;
310 		case DT_SUNW_SYMSZ:
311 			d[DI_SUNW_SYMSZ] = &dp[i];
312 			break;
313 
314 		/* For the .dynstr section */
315 		case DT_STRTAB:
316 			d[DI_STRTAB] = &dp[i];
317 			di_mask |= (1 << DI_STRTAB);
318 			break;
319 		case DT_STRSZ:
320 			d[DI_STRSZ] = &dp[i];
321 			di_mask |= (1 << DI_STRSZ);
322 			break;
323 		}
324 	}
325 
326 	/* Ensure all required entries were collected */
327 	if ((di_mask & di_req_mask) != di_req_mask) {
328 		dprintf("text section missing required dynamic entries\n");
329 		goto bad;
330 	}
331 
332 	/* SUNW_ldynsym must be adjacent to dynsym. Ignore if not */
333 	if ((d[DI_SUNW_SYMTAB] != NULL) && (d[DI_SUNW_SYMSZ] != NULL) &&
334 	    ((d[DI_SYMTAB]->d_un.d_ptr <= d[DI_SUNW_SYMTAB]->d_un.d_ptr) ||
335 	    (d[DI_SYMTAB]->d_un.d_ptr >= (d[DI_SUNW_SYMTAB]->d_un.d_ptr +
336 	    d[DI_SUNW_SYMSZ]->d_un.d_val)))) {
337 		d[DI_SUNW_SYMTAB] = NULL;
338 		d[DI_SUNW_SYMSZ] = NULL;
339 	}
340 
341 	/* elf header */
342 	size = sizeof (Ehdr);
343 
344 	/* program headers from in-core elf fragment */
345 	size += phnum * ehdr->e_phentsize;
346 
347 	/* unused shdr, and .shstrtab section */
348 	size += sizeof (Shdr);
349 	size += sizeof (Shdr);
350 	size += roundup(sizeof (shstr), SH_ADDRALIGN);
351 
352 	if (d[DI_HASH] != NULL) {
353 		Word hash[2];
354 
355 		hptr = d[DI_HASH]->d_un.d_ptr;
356 		if (ehdr->e_type == ET_DYN)
357 			hptr += addr;
358 
359 		if (Pread(P, hash, sizeof (hash), hptr) != sizeof (hash)) {
360 			dprintf("Pread of .hash at %lx failed\n",
361 			    (long)(hptr));
362 			goto bad;
363 		}
364 
365 		hnbuckets = hash[0];
366 		hnchains = hash[1];
367 	}
368 
369 	/*
370 	 * .dynsym and .SUNW_ldynsym sections.
371 	 *
372 	 * The string table section used for the symbol table and
373 	 * dynamic sections lies immediately after the dynsym, so the
374 	 * presence of SUNW_ldynsym changes the dynstr section index.
375 	 */
376 	if (d[DI_SUNW_SYMTAB] != NULL) {
377 		size += sizeof (Shdr);	/* SUNW_ldynsym shdr */
378 		ldynsym_size = (size_t)d[DI_SUNW_SYMSZ]->d_un.d_val;
379 		dynsym_size = ldynsym_size - (d[DI_SYMTAB]->d_un.d_ptr
380 		    - d[DI_SUNW_SYMTAB]->d_un.d_ptr);
381 		ldynsym_size -= dynsym_size;
382 		dynstr_shndx = 4;
383 	} else {
384 		dynsym_size = sizeof (Sym) * hnchains;
385 		ldynsym_size = 0;
386 		dynstr_shndx = 3;
387 	}
388 	size += sizeof (Shdr) + ldynsym_size + dynsym_size;
389 
390 	/* .dynstr section */
391 	size += sizeof (Shdr);
392 	size += roundup(d[DI_STRSZ]->d_un.d_val, SH_ADDRALIGN);
393 
394 	/* .dynamic section */
395 	size += sizeof (Shdr);
396 	size += roundup(phdr->p_filesz, SH_ADDRALIGN);
397 
398 	/* .plt section */
399 	if (d[DI_PLTGOT] != NULL && d[DI_JMPREL] != NULL &&
400 	    d[DI_PLTRELSZ] != NULL && d[DI_PLTREL] != NULL) {
401 		size_t pltrelsz = d[DI_PLTRELSZ]->d_un.d_val;
402 
403 		if (d[DI_PLTREL]->d_un.d_val == DT_RELA) {
404 			pltentries = pltrelsz / sizeof (Rela);
405 		} else if (d[DI_PLTREL]->d_un.d_val == DT_REL) {
406 			pltentries = pltrelsz / sizeof (Rel);
407 		} else {
408 			/* fall back to the platform default */
409 #if ((defined(__i386) || defined(__amd64)) && !defined(_ELF64))
410 			pltentries = pltrelsz / sizeof (Rel);
411 			dprintf("DI_PLTREL not found, defaulting to Rel");
412 #else /* (!(__i386 || __amd64)) || _ELF64 */
413 			pltentries = pltrelsz / sizeof (Rela);
414 			dprintf("DI_PLTREL not found, defaulting to Rela");
415 #endif /* (!(__i386 || __amd64) || _ELF64 */
416 		}
417 
418 		if (pltentries < PLTREL_MIN_ENTRIES) {
419 			dprintf("too few PLT relocation entries "
420 			    "(found %lu, expected at least %d)\n",
421 			    (long)pltentries, PLTREL_MIN_ENTRIES);
422 			goto bad;
423 		}
424 		if (pltentries < PLTREL_MIN_ENTRIES + 2)
425 			goto done_with_plt;
426 
427 		/*
428 		 * Now that we know the number of plt relocation entries
429 		 * we can calculate the size of the plt.
430 		 */
431 		pltsz = (pltentries + M_PLT_XNumber) * M_PLT_ENTSIZE;
432 #if defined(__sparc)
433 		/* The sparc PLT always has a (delay slot) nop at the end */
434 		pltsz += 4;
435 #endif /* __sparc */
436 
437 		size += sizeof (Shdr);
438 		size += roundup(pltsz, SH_ADDRALIGN);
439 	}
440 done_with_plt:
441 
442 	if ((elfdata = calloc(1, size)) == NULL)
443 		goto bad;
444 
445 	/* LINTED - alignment */
446 	ep = (Ehdr *)elfdata;
447 	(void) memcpy(ep, ehdr, offsetof(Ehdr, e_phoff));
448 
449 	ep->e_ehsize = sizeof (Ehdr);
450 	ep->e_phoff = sizeof (Ehdr);
451 	ep->e_phentsize = ehdr->e_phentsize;
452 	ep->e_phnum = phnum;
453 	ep->e_shoff = ep->e_phoff + phnum * ep->e_phentsize;
454 	ep->e_shentsize = sizeof (Shdr);
455 	/*
456 	 * Plt and SUNW_ldynsym sections are optional. C logical
457 	 * binary operators return a 0 or 1 value, so the following
458 	 * adds 1 for each optional section present.
459 	 */
460 	ep->e_shnum = 5 + (pltsz != 0) + (d[DI_SUNW_SYMTAB] != NULL);
461 	ep->e_shstrndx = 1;
462 
463 	/* LINTED - alignment */
464 	sp = (Shdr *)(elfdata + ep->e_shoff);
465 	off = ep->e_shoff + ep->e_shentsize * ep->e_shnum;
466 
467 	/*
468 	 * Copying the program headers directly from the process's
469 	 * address space is a little suspect, but since we only
470 	 * use them for their address and size values, this is fine.
471 	 */
472 	if (Pread(P, &elfdata[ep->e_phoff], phnum * ep->e_phentsize,
473 	    addr + ehdr->e_phoff) != phnum * ep->e_phentsize) {
474 		dprintf("failed to read program headers\n");
475 		goto bad;
476 	}
477 
478 	/*
479 	 * The first elf section is always skipped.
480 	 */
481 	sp++;
482 
483 	/*
484 	 * Section Header: .shstrtab
485 	 */
486 	sp->sh_name = SHSTR_NDX_shstrtab;
487 	sp->sh_type = SHT_STRTAB;
488 	sp->sh_flags = SHF_STRINGS;
489 	sp->sh_addr = 0;
490 	sp->sh_offset = off;
491 	sp->sh_size = sizeof (shstr);
492 	sp->sh_link = 0;
493 	sp->sh_info = 0;
494 	sp->sh_addralign = 1;
495 	sp->sh_entsize = 0;
496 
497 	(void) memcpy(&elfdata[off], shstr, sizeof (shstr));
498 	off += roundup(sp->sh_size, SH_ADDRALIGN);
499 	sp++;
500 
501 	/*
502 	 * Section Header: .SUNW_ldynsym
503 	 */
504 	if (d[DI_SUNW_SYMTAB] != NULL) {
505 		sp->sh_name = SHSTR_NDX_SUNW_ldynsym;
506 		sp->sh_type = SHT_SUNW_LDYNSYM;
507 		sp->sh_flags = SHF_ALLOC;
508 		sp->sh_addr = d[DI_SUNW_SYMTAB]->d_un.d_ptr;
509 		if (ehdr->e_type == ET_DYN)
510 			sp->sh_addr += addr;
511 		sp->sh_offset = off;
512 		sp->sh_size = ldynsym_size;
513 		sp->sh_link = dynstr_shndx;
514 		/* Index of 1st global in table that has none == # items */
515 		sp->sh_info = sp->sh_size / sizeof (Sym);
516 		sp->sh_addralign = SH_ADDRALIGN;
517 		sp->sh_entsize = sizeof (Sym);
518 
519 		if (Pread(P, &elfdata[off], sp->sh_size,
520 		    sp->sh_addr) != sp->sh_size) {
521 			dprintf("failed to read .SUNW_ldynsym at %lx\n",
522 			    (long)sp->sh_addr);
523 			goto bad;
524 		}
525 		off += sp->sh_size;
526 		/* No need to round up ldynsym data. Dynsym data is same type */
527 		sp++;
528 	}
529 
530 	/*
531 	 * Section Header: .dynsym
532 	 */
533 	sp->sh_name = SHSTR_NDX_dynsym;
534 	sp->sh_type = SHT_DYNSYM;
535 	sp->sh_flags = SHF_ALLOC;
536 	sp->sh_addr = d[DI_SYMTAB]->d_un.d_ptr;
537 	if (ehdr->e_type == ET_DYN)
538 		sp->sh_addr += addr;
539 	sp->sh_offset = off;
540 	sp->sh_size = dynsym_size;
541 	sp->sh_link = dynstr_shndx;
542 	sp->sh_info = 1;	/* Index of 1st global in table */
543 	sp->sh_addralign = SH_ADDRALIGN;
544 	sp->sh_entsize = sizeof (Sym);
545 
546 	if (Pread(P, &elfdata[off], sp->sh_size,
547 	    sp->sh_addr) != sp->sh_size) {
548 		dprintf("failed to read .dynsym at %lx\n",
549 		    (long)sp->sh_addr);
550 		goto bad;
551 	}
552 
553 	off += roundup(sp->sh_size, SH_ADDRALIGN);
554 	sp++;
555 
556 	/*
557 	 * Section Header: .dynstr
558 	 */
559 	sp->sh_name = SHSTR_NDX_dynstr;
560 	sp->sh_type = SHT_STRTAB;
561 	sp->sh_flags = SHF_ALLOC | SHF_STRINGS;
562 	sp->sh_addr = d[DI_STRTAB]->d_un.d_ptr;
563 	if (ehdr->e_type == ET_DYN)
564 		sp->sh_addr += addr;
565 	sp->sh_offset = off;
566 	sp->sh_size = d[DI_STRSZ]->d_un.d_val;
567 	sp->sh_link = 0;
568 	sp->sh_info = 0;
569 	sp->sh_addralign = 1;
570 	sp->sh_entsize = 0;
571 
572 	if (Pread(P, &elfdata[off], sp->sh_size,
573 	    sp->sh_addr) != sp->sh_size) {
574 		dprintf("failed to read .dynstr\n");
575 		goto bad;
576 	}
577 	off += roundup(sp->sh_size, SH_ADDRALIGN);
578 	sp++;
579 
580 	/*
581 	 * Section Header: .dynamic
582 	 */
583 	sp->sh_name = SHSTR_NDX_dynamic;
584 	sp->sh_type = SHT_DYNAMIC;
585 	sp->sh_flags = SHF_WRITE | SHF_ALLOC;
586 	sp->sh_addr = phdr->p_vaddr;
587 	if (ehdr->e_type == ET_DYN)
588 		sp->sh_addr -= addr;
589 	sp->sh_offset = off;
590 	sp->sh_size = phdr->p_filesz;
591 	sp->sh_link = dynstr_shndx;
592 	sp->sh_info = 0;
593 	sp->sh_addralign = SH_ADDRALIGN;
594 	sp->sh_entsize = sizeof (Dyn);
595 
596 	(void) memcpy(&elfdata[off], dp, sp->sh_size);
597 	off += roundup(sp->sh_size, SH_ADDRALIGN);
598 	sp++;
599 
600 	/*
601 	 * Section Header: .plt
602 	 */
603 	if (pltsz != 0) {
604 		ulong_t		plt_symhash;
605 		uint_t		htmp, ndx;
606 		uintptr_t	strtabptr, strtabname;
607 		Sym		sym, *symtabptr;
608 		uint_t		*hash;
609 		char		strbuf[sizeof ("_PROCEDURE_LINKAGE_TABLE_")];
610 
611 		/*
612 		 * Now we need to find the address of the plt by looking
613 		 * up the "_PROCEDURE_LINKAGE_TABLE_" symbol.
614 		 */
615 
616 		/* get the address of the symtab and strtab sections */
617 		strtabptr = d[DI_STRTAB]->d_un.d_ptr;
618 		symtabptr = (Sym *)(uintptr_t)d[DI_SYMTAB]->d_un.d_ptr;
619 		if (ehdr->e_type == ET_DYN) {
620 			strtabptr += addr;
621 			symtabptr = (Sym*)((uintptr_t)symtabptr + addr);
622 		}
623 
624 		/* find the .hash bucket address for this symbol */
625 		plt_symhash = elf_hash("_PROCEDURE_LINKAGE_TABLE_");
626 		htmp = plt_symhash % hnbuckets;
627 		hash = &((uint_t *)hptr)[2 + htmp];
628 
629 		/* read the elf hash bucket index */
630 		if (Pread(P, &ndx, sizeof (ndx), (uintptr_t)hash) !=
631 		    sizeof (ndx)) {
632 			dprintf("Pread of .hash at %lx failed\n", (long)hash);
633 			goto bad;
634 		}
635 
636 		while (ndx) {
637 			if (Pread(P, &sym, sizeof (sym),
638 			    (uintptr_t)&symtabptr[ndx]) != sizeof (sym)) {
639 				dprintf("Pread of .symtab at %lx failed\n",
640 				    (long)&symtabptr[ndx]);
641 				goto bad;
642 			}
643 
644 			strtabname = strtabptr + sym.st_name;
645 			if (Pread_string(P, strbuf, sizeof (strbuf),
646 			    strtabname) < 0) {
647 				dprintf("Pread of .strtab at %lx failed\n",
648 				    (long)strtabname);
649 				goto bad;
650 			}
651 
652 			if (strcmp("_PROCEDURE_LINKAGE_TABLE_", strbuf) == 0)
653 				break;
654 
655 			hash = &((uint_t *)hptr)[2 + hnbuckets + ndx];
656 			if (Pread(P, &ndx, sizeof (ndx), (uintptr_t)hash) !=
657 			    sizeof (ndx)) {
658 				dprintf("Pread of .hash at %lx failed\n",
659 				    (long)hash);
660 				goto bad;
661 			}
662 		}
663 
664 #if defined(__sparc)
665 		if (sym.st_value != d[DI_PLTGOT]->d_un.d_ptr) {
666 			dprintf("warning: DI_PLTGOT (%lx) doesn't match "
667 			    ".plt symbol pointer (%lx)",
668 			    (long)d[DI_PLTGOT]->d_un.d_ptr,
669 			    (long)sym.st_value);
670 		}
671 #endif /* __sparc */
672 
673 		if (ndx == 0) {
674 			dprintf(
675 			    "Failed to find \"_PROCEDURE_LINKAGE_TABLE_\"\n");
676 			goto bad;
677 		}
678 
679 		sp->sh_name = SHSTR_NDX_plt;
680 		sp->sh_type = SHT_PROGBITS;
681 		sp->sh_flags = SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR;
682 		sp->sh_addr = sym.st_value;
683 		if (ehdr->e_type == ET_DYN)
684 			sp->sh_addr += addr;
685 		sp->sh_offset = off;
686 		sp->sh_size = pltsz;
687 		sp->sh_link = 0;
688 		sp->sh_info = 0;
689 		sp->sh_addralign = SH_ADDRALIGN;
690 		sp->sh_entsize = M_PLT_ENTSIZE;
691 
692 		if (Pread(P, &elfdata[off], sp->sh_size, sp->sh_addr) !=
693 		    sp->sh_size) {
694 			dprintf("failed to read .plt at %lx\n",
695 			    (long)sp->sh_addr);
696 			goto bad;
697 		}
698 		off += roundup(sp->sh_size, SH_ADDRALIGN);
699 		sp++;
700 	}
701 
702 	/* make sure we didn't write past the end of allocated memory */
703 	sp++;
704 	assert(((uintptr_t)(sp) - 1) < ((uintptr_t)elfdata + size));
705 
706 	free(dp);
707 	if ((elf = elf_memory(elfdata, size)) == NULL) {
708 		free(elfdata);
709 		return (NULL);
710 	}
711 
712 	fptr->file_elfmem = elfdata;
713 
714 	return (elf);
715 
716 bad:
717 	if (dp != NULL)
718 		free(dp);
719 	if (elfdata != NULL)
720 		free(elfdata);
721 	return (NULL);
722 }
723