syms.c revision 20c1c3551cb3b3117591ae38463d16aada597c48
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
*/
#include <stdio.h>
#include <string.h>
#include <libelf.h>
#include "rdb.h"
/*
* Given a symbol index, look up the corresponding symbol from the
* given symbol table.
*
* This function allows the caller to treat the symbol table as a single
* logical entity even though there may be 2 actual ELF symbol tables
* involved. See the comments in Pcontrol.h for details.
*/
static GElf_Sym *
symtab_getsym(sym_tbl_t *symtab, int ndx, GElf_Sym *dst)
{
/* If index is in range of primary symtab, look it up there */
if (ndx >= symtab->st_symn_aux) {
return (gelf_getsym(symtab->st_syms_pri,
ndx - symtab->st_symn_aux, dst));
}
/* Not in primary: Look it up in the auxiliary symtab */
return (gelf_getsym(symtab->st_syms_aux, ndx, dst));
}
retc_t
str_map_sym(const char *symname, map_info_t *mp, GElf_Sym *symptr, char **str)
{
sym_tbl_t *symp;
char *strs;
int i;
if (mp->mi_symtab.st_syms_pri)
symp = &(mp->mi_symtab);
else if (mp->mi_dynsym.st_syms_pri)
symp = &(mp->mi_dynsym);
else
return (RET_FAILED);
strs = symp->st_strs;
for (i = 0; i < (int)symp->st_symn; i++) {
GElf_Sym sym;
if (symtab_getsym(symp, i, &sym) == NULL) {
(void) printf("symtab_getsym(): %s\n", elf_errmsg(-1));
return (RET_FAILED);
}
if (sym.st_name == 0)
continue;
if ((sym.st_shndx == SHN_UNDEF) ||
(strcmp(strs + sym.st_name, symname) != 0))
continue;
*symptr = sym;
if (str != NULL)
*str = (char *)strs + symptr->st_name;
if ((mp->mi_flags & FLG_MI_EXEC) == 0)
symptr->st_value += (GElf_Addr)(mp->mi_addr);
return (RET_OK);
}
return (RET_FAILED);
}
/*
* If two syms are of equal value this routine will
* favor one over the other based off of it's symbol
* type.
*/
static GElf_Sym
sym_swap(GElf_Sym * s1, GElf_Sym * s2)
{
int t1 = GELF_ST_TYPE(s1->st_info);
int t2 = GELF_ST_TYPE(s2->st_info);
if ((t1 == STT_FUNC) || (t2 == STT_FUNC)) {
if (t1 == STT_FUNC)
return (*s1);
return (*s2);
}
if ((t1 == STT_OBJECT) || (t2 == STT_OBJECT)) {
if (t1 == STT_OBJECT)
return (*s1);
return (*s2);
}
if ((t1 == STT_OBJECT) || (t2 == STT_OBJECT)) {
if (t1 == STT_OBJECT)
return (*s1);
return (*s2);
}
return (*s1);
}
static retc_t
addr_map_sym(map_info_t *mp, ulong_t addr, GElf_Sym *symptr, char **str)
{
sym_tbl_t *symp;
GElf_Sym sym;
GElf_Sym *symr = NULL;
GElf_Sym *lsymr = NULL;
GElf_Sym rsym;
GElf_Sym lsym;
ulong_t baseaddr = 0;
int i;
if ((mp->mi_flags & FLG_MI_EXEC) == 0)
baseaddr = (ulong_t)mp->mi_addr;
if (mp->mi_symtab.st_syms_pri)
symp = &(mp->mi_symtab);
else if (mp->mi_dynsym.st_syms_pri)
symp = &(mp->mi_dynsym);
else
return (RET_FAILED);
/*
* normalize address
*/
addr -= baseaddr;
for (i = 0; i < (int)symp->st_symn; i++) {
ulong_t svalue;
if (symtab_getsym(symp, i, &sym) == NULL) {
(void) printf("symtab_getsym(): %s\n", elf_errmsg(-1));
return (RET_FAILED);
}
if ((sym.st_name == 0) || (sym.st_shndx == SHN_UNDEF))
continue;
svalue = (ulong_t)sym.st_value;
if (svalue <= addr) {
/*
* track both the best local and best
* global fit for this address. Later
* we will favor the global over the local
*/
if ((GELF_ST_BIND(sym.st_info) == STB_LOCAL) &&
((lsymr == NULL) ||
(svalue >= (ulong_t)lsymr->st_value))) {
if (lsymr && (lsymr->st_value == svalue))
*lsymr = sym_swap(lsymr, &sym);
else {
lsymr = &lsym;
*lsymr = sym;
}
} else if ((symr == NULL) ||
(svalue >= (ulong_t)symr->st_value)) {
if (symr && (symr->st_value == svalue))
*symr = sym_swap(symr, &sym);
else {
symr = &rsym;
*symr = sym;
}
}
}
}
if ((symr == NULL) && (lsymr == NULL))
return (RET_FAILED);
if (lsymr) {
/*
* If a possible local symbol was found should
* we use it.
*/
if (symr && (lsymr->st_value > symr->st_value))
symr = lsymr;
else if (symr == NULL)
symr = lsymr;
}
*symptr = *symr;
*str = (char *)(symp->st_strs + symptr->st_name);
symptr->st_value += baseaddr;
return (RET_OK);
}
retc_t
addr_to_sym(struct ps_prochandle *ph, ulong_t addr,
GElf_Sym *symp, char **str)
{
map_info_t *mip;
if ((mip = addr_to_map(ph, addr)) == NULL)
return (RET_FAILED);
return (addr_map_sym(mip, addr, symp, str));
}
retc_t
str_to_sym(struct ps_prochandle *ph, const char *name, GElf_Sym *symp)
{
map_info_t *mip;
if (ph->pp_lmaplist.ml_head == NULL) {
if (str_map_sym(name, &(ph->pp_ldsomap), symp, NULL) == RET_OK)
return (RET_OK);
return (str_map_sym(name, &(ph->pp_execmap), symp, NULL));
}
for (mip = ph->pp_lmaplist.ml_head; mip; mip = mip->mi_next)
if (str_map_sym(name, mip, symp, NULL) == RET_OK)
return (RET_OK);
return (RET_FAILED);
}