Psymtab_machelf32.c revision 044d68fe853b07e9e4ff16d7aecb76fefd609ab5
0N/A/*
0N/A * CDDL HEADER START
0N/A *
0N/A * The contents of this file are subject to the terms of the
0N/A * Common Development and Distribution License (the "License").
0N/A * You may not use this file except in compliance with the License.
0N/A *
0N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
0N/A * or http://www.opensolaris.org/os/licensing.
0N/A * See the License for the specific language governing permissions
0N/A * and limitations under the License.
0N/A *
0N/A * When distributing Covered Code, include this CDDL HEADER in each
0N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
0N/A * If applicable, add the following below this CDDL HEADER, with the
0N/A * fields enclosed by brackets "[]" replaced with your own identifying
0N/A * information: Portions Copyright [yyyy] [name of copyright owner]
0N/A *
0N/A * CDDL HEADER END
0N/A */
0N/A
0N/A/*
0N/A * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
0N/A * Use is subject to license terms.
0N/A */
0N/A
0N/A/*
0N/A * Copyright (c) 2015, Joyent, Inc. All rights reserved.
0N/A */
0N/A
0N/A#include <assert.h>
0N/A#include <stdio.h>
0N/A#include <stdlib.h>
0N/A#include <stddef.h>
0N/A#include <string.h>
0N/A#include <memory.h>
0N/A#include <sys/sysmacros.h>
0N/A#include <sys/machelf.h>
0N/A
0N/A#include "Pcontrol.h"
0N/A#include "Psymtab_machelf.h"
0N/A
0N/A
0N/A/*
0N/A * This file contains code for use by Psymtab.c that is compiled once
0N/A * for each supported ELFCLASS.
0N/A *
0N/A * When processing ELF files, it is common to encounter a situation where
0N/A * a program with one ELFCLASS (32 or 64-bit) is required to examine a
0N/A * file with a different ELFCLASS. For example, the 32-bit linker (ld) may
0N/A * be used to link a 64-bit program. The simplest solution to this problem
0N/A * is to duplicate each such piece of code, modifying only the data types,
0N/A * and to use if statements to select the code to run. The problem with
0N/A * doing it that way is that the resulting code is difficult to maintain.
0N/A * It is inevitable that the copies will not always get modified identically,
0N/A * and will drift apart. The only robust solution is to generate the
0N/A * multiple instances of code automatically from a single piece of code.
0N/A *
0N/A * The solution used within the Solaris linker is to write the code once,
0N/A * using the data types defined in sys/machelf.h, and then to compile that
0N/A * code twice, once with _ELF64 defined (to generate ELFCLASS64 code) and
0N/A * once without (to generate ELFCLASS32). We use the same approach here.
0N/A *
0N/A * Note that the _ELF64 definition does not refer to the ELFCLASS of
0N/A * the resulting code, but rather, to the ELFCLASS of the data it
0N/A * examines. By repeating the above double-compilation for both 32-bit
0N/A * and 64-bit builds, we end up with 4 instances, which collectively
0N/A * can handle any combination of program and ELF data class:
0N/A *
0N/A * \ Compilation class
0N/A * \ 32 64
0N/A * \------------------
0N/A * |
0N/A * 32 | X X
0N/A * ELF Data Class |
0N/A * 64 | X X
0N/A */
0N/A
0N/A
0N/A
0N/A/*
0N/A * Read data from the specified process and construct an in memory
0N/A * image of an ELF file that will let us use libelf for most of the
0N/A * work we need to later (e.g. symbol table lookups). This is used
0N/A * in cases where no usable on-disk image for the process is available.
0N/A * We need sections for the dynsym, dynstr, and plt, and we need
0N/A * the program headers from the text section. The former is used in
0N/A * Pbuild_file_symtab(); the latter is used in several functions in
0N/A * Pcore.c to reconstruct the origin of each mapping from the load
0N/A * object that spawned it.
0N/A *
0N/A * Here are some useful pieces of elf trivia that will help
0N/A * to elucidate this code.
0N/A *
0N/A * All the information we need about the dynstr can be found in these
0N/A * two entries in the dynamic section:
0N/A *
0N/A * DT_STRTAB base of dynstr
0N/A * DT_STRSZ size of dynstr
0N/A *
0N/A * So deciphering the dynstr is pretty straightforward.
0N/A *
0N/A * The dynsym is a little trickier.
0N/A *
0N/A * DT_SYMTAB base of dynsym
0N/A * DT_SYMENT size of a dynstr entry (Elf{32,64}_Sym)
0N/A * DT_HASH base of hash table for dynamic lookups
0N/A *
0N/A * The DT_SYMTAB entry gives us any easy way of getting to the base
0N/A * of the dynsym, but getting the size involves rooting around in the
0N/A * dynamic lookup hash table. Here's the layout of the hash table:
0N/A *
0N/A * +-------------------+
0N/A * | nbucket | All values are 32-bit
0N/A * +-------------------+ (Elf32_Word or Elf64_Word)
0N/A * | nchain |
0N/A * +-------------------+
0N/A * | bucket[0] |
0N/A * | . . . |
0N/A * | bucket[nbucket-1] |
0N/A * +-------------------+
0N/A * | chain[0] |
0N/A * | . . . |
0N/A * | chain[nchain-1] |
0N/A * +-------------------+
0N/A * (figure 5-12 from the SYS V Generic ABI)
0N/A *
0N/A * Symbols names are hashed into a particular bucket which contains
0N/A * an index into the symbol table. Each entry in the symbol table
0N/A * has a corresponding entry in the chain table which tells the
0N/A * consumer where the next entry in the hash chain is. We can use
0N/A * the nchain field to find out the size of the dynsym.
0N/A *
0N/A * If there is a dynsym present, there may also be an optional
0N/A * section called the SUNW_ldynsym that augments the dynsym by
0N/A * providing local function symbols. When the Solaris linker lays
0N/A * out a file that has both of these sections, it makes sure that
0N/A * the data for the two sections is adjacent with the SUNW_ldynsym
0N/A * in front. This allows the runtime linker to treat these two
0N/A * symbol tables as being a single larger table. There are two
0N/A * items in the dynamic section for this:
0N/A *
0N/A * DT_SUNW_SYMTAB base of the SUNW_ldynsym
0N/A * DT_SUNW_SYMSZ total size of SUNW_ldynsym and dynsym
0N/A * added together. We can figure out the
0N/A * size of the SUNW_ldynsym section by
0N/A * subtracting the size of the dynsym
0N/A * (described above) from this value.
0N/A *
0N/A * We can figure out the size of the .plt section, but it takes some
0N/A * doing. We need to use the following information:
0N/A *
0N/A * DT_PLTGOT GOT PLT entry offset (on x86) or PLT offset (on sparc)
0N/A * DT_JMPREL base of the PLT's relocation section
0N/A * DT_PLTRELSZ size of the PLT's relocation section
0N/A * DT_PLTREL type of the PLT's relocation section
0N/A *
0N/A * We can use the number of relocation entries to calculate the size of
0N/A * the PLT. We get the address of the PLT by looking up the
0N/A * _PROCEDURE_LINKAGE_TABLE_ symbol.
0N/A *
0N/A * For more information, check out the System V Generic ABI.
0N/A */
0N/A
0N/A
0N/A/*
0N/A * The fake_elfXX() function generated by this file uses the following
0N/A * string as the string table for the section names. Since it is critical
0N/A * to count correctly, and to improve readability, the SHSTR_NDX_ macros
0N/A * supply the proper offset for each name within the string.
0N/A */
0N/Astatic char shstr[] =
0N/A ".shstrtab\0.dynsym\0.dynstr\0.dynamic\0.plt\0.SUNW_ldynsym";
0N/A
0N/A/* Offsets within shstr for each name */
0N/A#define SHSTR_NDX_shstrtab 0
0N/A#define SHSTR_NDX_dynsym 10
0N/A#define SHSTR_NDX_dynstr 18
0N/A#define SHSTR_NDX_dynamic 26
0N/A#define SHSTR_NDX_plt 35
0N/A#define SHSTR_NDX_SUNW_ldynsym 40
0N/A
0N/A
0N/A/*
0N/A * Section header alignment for 32 and 64-bit ELF files differs
0N/A */
0N/A#ifdef _ELF64
0N/A#define SH_ADDRALIGN 8
0N/A#else
0N/A#define SH_ADDRALIGN 4
0N/A#endif
0N/A
0N/A/*
0N/A * This is the smallest number of PLT relocation entries allowed in a proper
0N/A * .plt section.
0N/A */
0N/A#ifdef __sparc
0N/A#define PLTREL_MIN_ENTRIES 4 /* SPARC psABI 3.0 and SCD 2.4 */
0N/A#else
0N/A#ifdef __lint
0N/A/*
0N/A * On x86, lint would complain about unsigned comparison with
0N/A * PLTREL_MIN_ENTRIES. This define fakes up the value of PLTREL_MIN_ENTRIES
0N/A * and silences lint. On SPARC, there is no such issue.
0N/A */
0N/A#define PLTREL_MIN_ENTRIES 1
0N/A#else
0N/A#define PLTREL_MIN_ENTRIES 0
0N/A#endif
0N/A#endif
0N/A
0N/A#ifdef _ELF64
0N/AElf *
0N/Afake_elf64(struct ps_prochandle *P, file_info_t *fptr, uintptr_t addr,
0N/A Ehdr *ehdr, uint_t phnum, Phdr *phdr)
0N/A#else
0N/AElf *
0N/Afake_elf32(struct ps_prochandle *P, file_info_t *fptr, uintptr_t addr,
0N/A Ehdr *ehdr, uint_t phnum, Phdr *phdr)
0N/A#endif
0N/A{
0N/A enum {
0N/A DI_PLTGOT,
0N/A DI_JMPREL,
0N/A DI_PLTRELSZ,
0N/A DI_PLTREL,
0N/A DI_SYMTAB,
0N/A DI_HASH,
0N/A DI_SYMENT,
0N/A DI_STRTAB,
0N/A DI_STRSZ,
0N/A DI_SUNW_SYMTAB,
0N/A DI_SUNW_SYMSZ,
0N/A DI_NENT
0N/A };
0N/A /*
0N/A * Mask of dynamic options that must be present in a well
0N/A * formed dynamic section. We need all of these in order to
0N/A * put together a complete set of elf sections. They are
0N/A * mandatory in both executables and shared objects so if one
0N/A * of them is missing, we're in some trouble and should abort.
0N/A * The PLT items are expected, but we will let them slide if
0N/A * need be. The DI_SUNW_SYM* items are completely optional, so
0N/A * we use them if they are present and ignore them otherwise.
0N/A */
0N/A const int di_req_mask = (1 << DI_SYMTAB) |
0N/A (1 << DI_SYMENT) | (1 << DI_STRTAB) | (1 << DI_STRSZ);
0N/A int di_mask = 0;
0N/A size_t size = 0;
0N/A caddr_t elfdata = NULL;
0N/A Elf *elf;
0N/A size_t dynsym_size = 0, ldynsym_size;
0N/A int dynstr_shndx;
0N/A Ehdr *ep;
0N/A Shdr *sp;
0N/A Dyn *dp = NULL;
0N/A Dyn *d[DI_NENT] = { 0 };
0N/A uint_t i;
0N/A Off off;
0N/A size_t pltsz = 0, pltentries = 0;
0N/A uintptr_t hptr = NULL;
0N/A Word hnchains = 0, hnbuckets = 0;
0N/A
0N/A if (ehdr->e_type == ET_DYN)
0N/A phdr->p_vaddr += addr;
0N/A
0N/A if (P->rap != NULL) {
0N/A if (rd_get_dyns(P->rap, addr, (void **)&dp, NULL) != RD_OK)
0N/A goto bad;
0N/A } else {
0N/A if ((dp = malloc(phdr->p_filesz)) == NULL)
0N/A goto bad;
0N/A if (Pread(P, dp, phdr->p_filesz, phdr->p_vaddr) !=
0N/A phdr->p_filesz)
0N/A goto bad;
0N/A }
0N/A
/*
* Iterate over the items in the dynamic section, grabbing
* the address of items we want and saving them in dp[].
*/
for (i = 0; i < phdr->p_filesz / sizeof (Dyn); i++) {
switch (dp[i].d_tag) {
/* For the .plt section */
case DT_PLTGOT:
d[DI_PLTGOT] = &dp[i];
break;
case DT_JMPREL:
d[DI_JMPREL] = &dp[i];
break;
case DT_PLTRELSZ:
d[DI_PLTRELSZ] = &dp[i];
break;
case DT_PLTREL:
d[DI_PLTREL] = &dp[i];
break;
/* For the .dynsym section */
case DT_SYMTAB:
d[DI_SYMTAB] = &dp[i];
di_mask |= (1 << DI_SYMTAB);
break;
case DT_HASH:
d[DI_HASH] = &dp[i];
di_mask |= (1 << DI_HASH);
break;
case DT_SYMENT:
d[DI_SYMENT] = &dp[i];
di_mask |= (1 << DI_SYMENT);
break;
case DT_SUNW_SYMTAB:
d[DI_SUNW_SYMTAB] = &dp[i];
break;
case DT_SUNW_SYMSZ:
d[DI_SUNW_SYMSZ] = &dp[i];
break;
/* For the .dynstr section */
case DT_STRTAB:
d[DI_STRTAB] = &dp[i];
di_mask |= (1 << DI_STRTAB);
break;
case DT_STRSZ:
d[DI_STRSZ] = &dp[i];
di_mask |= (1 << DI_STRSZ);
break;
}
}
/* Ensure all required entries were collected */
if ((di_mask & di_req_mask) != di_req_mask) {
dprintf("text section missing required dynamic entries: "
"required 0x%x, found 0x%x\n", di_req_mask, di_mask);
goto bad;
}
/* SUNW_ldynsym must be adjacent to dynsym. Ignore if not */
if ((d[DI_SUNW_SYMTAB] != NULL) && (d[DI_SUNW_SYMSZ] != NULL) &&
((d[DI_SYMTAB]->d_un.d_ptr <= d[DI_SUNW_SYMTAB]->d_un.d_ptr) ||
(d[DI_SYMTAB]->d_un.d_ptr >= (d[DI_SUNW_SYMTAB]->d_un.d_ptr +
d[DI_SUNW_SYMSZ]->d_un.d_val)))) {
d[DI_SUNW_SYMTAB] = NULL;
d[DI_SUNW_SYMSZ] = NULL;
}
/* elf header */
size = sizeof (Ehdr);
/* program headers from in-core elf fragment */
size += phnum * ehdr->e_phentsize;
/* unused shdr, and .shstrtab section */
size += sizeof (Shdr);
size += sizeof (Shdr);
size += roundup(sizeof (shstr), SH_ADDRALIGN);
if (d[DI_HASH] != NULL) {
Word hash[2];
hptr = d[DI_HASH]->d_un.d_ptr;
if (ehdr->e_type == ET_DYN)
hptr += addr;
if (Pread(P, hash, sizeof (hash), hptr) != sizeof (hash)) {
dprintf("Pread of .hash at %lx failed\n",
(long)(hptr));
goto bad;
}
hnbuckets = hash[0];
hnchains = hash[1];
}
/*
* .dynsym and .SUNW_ldynsym sections.
*
* The string table section used for the symbol table and
* dynamic sections lies immediately after the dynsym, so the
* presence of SUNW_ldynsym changes the dynstr section index.
*/
if (d[DI_SUNW_SYMTAB] != NULL) {
size += sizeof (Shdr); /* SUNW_ldynsym shdr */
ldynsym_size = (size_t)d[DI_SUNW_SYMSZ]->d_un.d_val;
dynsym_size = ldynsym_size - (d[DI_SYMTAB]->d_un.d_ptr
- d[DI_SUNW_SYMTAB]->d_un.d_ptr);
ldynsym_size -= dynsym_size;
dynstr_shndx = 4;
} else {
dynsym_size = sizeof (Sym) * hnchains;
ldynsym_size = 0;
dynstr_shndx = 3;
}
size += sizeof (Shdr) + ldynsym_size + dynsym_size;
/* .dynstr section */
size += sizeof (Shdr);
size += roundup(d[DI_STRSZ]->d_un.d_val, SH_ADDRALIGN);
/* .dynamic section */
size += sizeof (Shdr);
size += roundup(phdr->p_filesz, SH_ADDRALIGN);
/* .plt section */
if (d[DI_PLTGOT] != NULL && d[DI_JMPREL] != NULL &&
d[DI_PLTRELSZ] != NULL && d[DI_PLTREL] != NULL) {
size_t pltrelsz = d[DI_PLTRELSZ]->d_un.d_val;
if (d[DI_PLTREL]->d_un.d_val == DT_RELA) {
pltentries = pltrelsz / sizeof (Rela);
} else if (d[DI_PLTREL]->d_un.d_val == DT_REL) {
pltentries = pltrelsz / sizeof (Rel);
} else {
/* fall back to the platform default */
#if ((defined(__i386) || defined(__amd64)) && !defined(_ELF64))
pltentries = pltrelsz / sizeof (Rel);
dprintf("DI_PLTREL not found, defaulting to Rel");
#else /* (!(__i386 || __amd64)) || _ELF64 */
pltentries = pltrelsz / sizeof (Rela);
dprintf("DI_PLTREL not found, defaulting to Rela");
#endif /* (!(__i386 || __amd64) || _ELF64 */
}
if (pltentries < PLTREL_MIN_ENTRIES) {
dprintf("too few PLT relocation entries "
"(found %lu, expected at least %d)\n",
(long)pltentries, PLTREL_MIN_ENTRIES);
goto bad;
}
if (pltentries < PLTREL_MIN_ENTRIES + 2)
goto done_with_plt;
/*
* Now that we know the number of plt relocation entries
* we can calculate the size of the plt.
*/
pltsz = (pltentries + M_PLT_XNumber) * M_PLT_ENTSIZE;
#if defined(__sparc)
/* The sparc PLT always has a (delay slot) nop at the end */
pltsz += 4;
#endif /* __sparc */
size += sizeof (Shdr);
size += roundup(pltsz, SH_ADDRALIGN);
}
done_with_plt:
if ((elfdata = calloc(1, size)) == NULL) {
dprintf("failed to allocate size %ld\n", (long)size);
goto bad;
}
/* LINTED - alignment */
ep = (Ehdr *)elfdata;
(void) memcpy(ep, ehdr, offsetof(Ehdr, e_phoff));
ep->e_ehsize = sizeof (Ehdr);
ep->e_phoff = sizeof (Ehdr);
ep->e_phentsize = ehdr->e_phentsize;
ep->e_phnum = phnum;
ep->e_shoff = ep->e_phoff + phnum * ep->e_phentsize;
ep->e_shentsize = sizeof (Shdr);
/*
* Plt and SUNW_ldynsym sections are optional. C logical
* binary operators return a 0 or 1 value, so the following
* adds 1 for each optional section present.
*/
ep->e_shnum = 5 + (pltsz != 0) + (d[DI_SUNW_SYMTAB] != NULL);
ep->e_shstrndx = 1;
/* LINTED - alignment */
sp = (Shdr *)(elfdata + ep->e_shoff);
off = ep->e_shoff + ep->e_shentsize * ep->e_shnum;
/*
* Copying the program headers directly from the process's
* address space is a little suspect, but since we only
* use them for their address and size values, this is fine.
*/
if (Pread(P, &elfdata[ep->e_phoff], phnum * ep->e_phentsize,
addr + ehdr->e_phoff) != phnum * ep->e_phentsize) {
dprintf("failed to read program headers\n");
goto bad;
}
/*
* The first elf section is always skipped.
*/
sp++;
/*
* Section Header: .shstrtab
*/
sp->sh_name = SHSTR_NDX_shstrtab;
sp->sh_type = SHT_STRTAB;
sp->sh_flags = SHF_STRINGS;
sp->sh_addr = 0;
sp->sh_offset = off;
sp->sh_size = sizeof (shstr);
sp->sh_link = 0;
sp->sh_info = 0;
sp->sh_addralign = 1;
sp->sh_entsize = 0;
(void) memcpy(&elfdata[off], shstr, sizeof (shstr));
off += roundup(sp->sh_size, SH_ADDRALIGN);
sp++;
/*
* Section Header: .SUNW_ldynsym
*/
if (d[DI_SUNW_SYMTAB] != NULL) {
sp->sh_name = SHSTR_NDX_SUNW_ldynsym;
sp->sh_type = SHT_SUNW_LDYNSYM;
sp->sh_flags = SHF_ALLOC;
sp->sh_addr = d[DI_SUNW_SYMTAB]->d_un.d_ptr;
if (ehdr->e_type == ET_DYN)
sp->sh_addr += addr;
sp->sh_offset = off;
sp->sh_size = ldynsym_size;
sp->sh_link = dynstr_shndx;
/* Index of 1st global in table that has none == # items */
sp->sh_info = sp->sh_size / sizeof (Sym);
sp->sh_addralign = SH_ADDRALIGN;
sp->sh_entsize = sizeof (Sym);
if (Pread(P, &elfdata[off], sp->sh_size,
sp->sh_addr) != sp->sh_size) {
dprintf("failed to read .SUNW_ldynsym at %lx\n",
(long)sp->sh_addr);
goto bad;
}
off += sp->sh_size;
/* No need to round up ldynsym data. Dynsym data is same type */
sp++;
}
/*
* Section Header: .dynsym
*/
sp->sh_name = SHSTR_NDX_dynsym;
sp->sh_type = SHT_DYNSYM;
sp->sh_flags = SHF_ALLOC;
sp->sh_addr = d[DI_SYMTAB]->d_un.d_ptr;
if (ehdr->e_type == ET_DYN)
sp->sh_addr += addr;
sp->sh_offset = off;
sp->sh_size = dynsym_size;
sp->sh_link = dynstr_shndx;
sp->sh_info = 1; /* Index of 1st global in table */
sp->sh_addralign = SH_ADDRALIGN;
sp->sh_entsize = sizeof (Sym);
if (Pread(P, &elfdata[off], sp->sh_size,
sp->sh_addr) != sp->sh_size) {
dprintf("failed to read .dynsym at %lx\n",
(long)sp->sh_addr);
goto bad;
}
off += roundup(sp->sh_size, SH_ADDRALIGN);
sp++;
/*
* Section Header: .dynstr
*/
sp->sh_name = SHSTR_NDX_dynstr;
sp->sh_type = SHT_STRTAB;
sp->sh_flags = SHF_ALLOC | SHF_STRINGS;
sp->sh_addr = d[DI_STRTAB]->d_un.d_ptr;
if (ehdr->e_type == ET_DYN)
sp->sh_addr += addr;
sp->sh_offset = off;
sp->sh_size = d[DI_STRSZ]->d_un.d_val;
sp->sh_link = 0;
sp->sh_info = 0;
sp->sh_addralign = 1;
sp->sh_entsize = 0;
if (Pread(P, &elfdata[off], sp->sh_size,
sp->sh_addr) != sp->sh_size) {
dprintf("failed to read .dynstr\n");
goto bad;
}
off += roundup(sp->sh_size, SH_ADDRALIGN);
sp++;
/*
* Section Header: .dynamic
*/
sp->sh_name = SHSTR_NDX_dynamic;
sp->sh_type = SHT_DYNAMIC;
sp->sh_flags = SHF_WRITE | SHF_ALLOC;
sp->sh_addr = phdr->p_vaddr;
if (ehdr->e_type == ET_DYN)
sp->sh_addr -= addr;
sp->sh_offset = off;
sp->sh_size = phdr->p_filesz;
sp->sh_link = dynstr_shndx;
sp->sh_info = 0;
sp->sh_addralign = SH_ADDRALIGN;
sp->sh_entsize = sizeof (Dyn);
(void) memcpy(&elfdata[off], dp, sp->sh_size);
off += roundup(sp->sh_size, SH_ADDRALIGN);
sp++;
/*
* Section Header: .plt
*/
if (pltsz != 0) {
ulong_t plt_symhash;
uint_t htmp, ndx;
uintptr_t strtabptr, strtabname;
Sym sym, *symtabptr;
uint_t *hash;
char strbuf[sizeof ("_PROCEDURE_LINKAGE_TABLE_")];
/*
* Now we need to find the address of the plt by looking
* up the "_PROCEDURE_LINKAGE_TABLE_" symbol.
*/
/* get the address of the symtab and strtab sections */
strtabptr = d[DI_STRTAB]->d_un.d_ptr;
symtabptr = (Sym *)(uintptr_t)d[DI_SYMTAB]->d_un.d_ptr;
if (ehdr->e_type == ET_DYN) {
strtabptr += addr;
symtabptr = (Sym*)((uintptr_t)symtabptr + addr);
}
if ((hptr == NULL) || (hnbuckets == 0) || (hnchains == 0)) {
dprintf("empty or missing .hash\n");
goto badplt;
}
/* find the .hash bucket address for this symbol */
plt_symhash = elf_hash("_PROCEDURE_LINKAGE_TABLE_");
htmp = plt_symhash % hnbuckets;
hash = &((uint_t *)hptr)[2 + htmp];
/* read the elf hash bucket index */
if (Pread(P, &ndx, sizeof (ndx), (uintptr_t)hash) !=
sizeof (ndx)) {
dprintf("Pread of .hash at %lx failed\n", (long)hash);
goto badplt;
}
while (ndx) {
if (Pread(P, &sym, sizeof (sym),
(uintptr_t)&symtabptr[ndx]) != sizeof (sym)) {
dprintf("Pread of .symtab at %lx failed\n",
(long)&symtabptr[ndx]);
goto badplt;
}
strtabname = strtabptr + sym.st_name;
if (Pread_string(P, strbuf, sizeof (strbuf),
strtabname) < 0) {
dprintf("Pread of .strtab at %lx failed\n",
(long)strtabname);
goto badplt;
}
if (strcmp("_PROCEDURE_LINKAGE_TABLE_", strbuf) == 0)
break;
hash = &((uint_t *)hptr)[2 + hnbuckets + ndx];
if (Pread(P, &ndx, sizeof (ndx), (uintptr_t)hash) !=
sizeof (ndx)) {
dprintf("Pread of .hash at %lx failed\n",
(long)hash);
goto badplt;
}
}
#if defined(__sparc)
if (sym.st_value != d[DI_PLTGOT]->d_un.d_ptr) {
dprintf("warning: DI_PLTGOT (%lx) doesn't match "
".plt symbol pointer (%lx)",
(long)d[DI_PLTGOT]->d_un.d_ptr,
(long)sym.st_value);
}
#endif /* __sparc */
if (ndx == 0) {
dprintf(
"Failed to find \"_PROCEDURE_LINKAGE_TABLE_\"\n");
goto badplt;
}
sp->sh_name = SHSTR_NDX_plt;
sp->sh_type = SHT_PROGBITS;
sp->sh_flags = SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR;
sp->sh_addr = sym.st_value;
if (ehdr->e_type == ET_DYN)
sp->sh_addr += addr;
sp->sh_offset = off;
sp->sh_size = pltsz;
sp->sh_link = 0;
sp->sh_info = 0;
sp->sh_addralign = SH_ADDRALIGN;
sp->sh_entsize = M_PLT_ENTSIZE;
if (Pread(P, &elfdata[off], sp->sh_size, sp->sh_addr) !=
sp->sh_size) {
dprintf("failed to read .plt at %lx\n",
(long)sp->sh_addr);
goto badplt;
}
off += roundup(sp->sh_size, SH_ADDRALIGN);
sp++;
}
badplt:
/* make sure we didn't write past the end of allocated memory */
sp++;
assert(((uintptr_t)(sp) - 1) < ((uintptr_t)elfdata + size));
free(dp);
if ((elf = elf_memory(elfdata, size)) == NULL) {
dprintf("failed to create ELF object "
"in memory for size %ld\n", (long)size);
free(elfdata);
return (NULL);
}
fptr->file_elfmem = elfdata;
return (elf);
bad:
if (dp != NULL)
free(dp);
if (elfdata != NULL)
free(elfdata);
return (NULL);
}