File: [local] / src / usr.bin / nm / elf.c (download)
Revision 1.39, Sun Nov 7 08:09:04 2021 UTC (2 years, 7 months ago) by semarie
Branch: MAIN
CVS Tags: OPENBSD_7_5_BASE, OPENBSD_7_5, OPENBSD_7_4_BASE, OPENBSD_7_4, OPENBSD_7_3_BASE, OPENBSD_7_3, OPENBSD_7_2_BASE, OPENBSD_7_2, OPENBSD_7_1_BASE, OPENBSD_7_1, HEAD Changes since 1.38: +4 -1 lines
nm: add some .text.* support for symbols
.text.* are generated when using -ffunction-sections.
makes nm(1) to correctly identify the function symbols as N_TEXT.
found while debugging librsvg build error, where some symbols where not found by libtool(1) (which is using nm(1)).
ok gkoehler@
|
/* $OpenBSD: elf.c,v 1.39 2021/11/07 08:09:04 semarie Exp $ */
/*
* Copyright (c) 2003 Michael Shalayeff
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/mman.h>
#include <unistd.h>
#include <a.out.h>
#include <elf.h>
#include <errno.h>
#include <err.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "util.h"
#include "elfuncs.h"
#if ELFSIZE == 32
#define swap_addr swap32
#define swap_off swap32
#define swap_sword swap32
#define swap_word swap32
#define swap_sxword swap32
#define swap_xword swap32
#define swap_half swap16
#define swap_quarter swap16
#define elf_fix_header elf32_fix_header
#define elf_load_shdrs elf32_load_shdrs
#define elf_fix_shdrs elf32_fix_shdrs
#define elf_fix_sym elf32_fix_sym
#define elf_size elf32_size
#define elf_symloadx elf32_symloadx
#define elf_symload elf32_symload
#define elf2nlist elf32_2nlist
#define elf_shn2type elf32_shn2type
#elif ELFSIZE == 64
#define swap_addr swap64
#define swap_off swap64
#ifdef __alpha__
#define swap_sword swap64
#define swap_word swap64
#else
#define swap_sword swap32
#define swap_word swap32
#endif
#define swap_sxword swap64
#define swap_xword swap64
#define swap_half swap64
#define swap_quarter swap16
#define elf_fix_header elf64_fix_header
#define elf_load_shdrs elf64_load_shdrs
#define elf_fix_shdrs elf64_fix_shdrs
#define elf_fix_sym elf64_fix_sym
#define elf_size elf64_size
#define elf_symloadx elf64_symloadx
#define elf_symload elf64_symload
#define elf2nlist elf64_2nlist
#define elf_shn2type elf64_shn2type
#else
#error "Unsupported ELF class"
#endif
#define ELF_SDATA ".sdata"
#define ELF_TDATA ".tdata"
#define ELF_SBSS ".sbss"
#define ELF_TBSS ".tbss"
#define ELF_PLT ".plt"
#ifndef SHN_MIPS_ACOMMON
#define SHN_MIPS_ACOMMON SHN_LOPROC + 0
#endif
#ifndef SHN_MIPS_TEXT
#define SHN_MIPS_TEXT SHN_LOPROC + 1
#endif
#ifndef SHN_MIPS_DATA
#define SHN_MIPS_DATA SHN_LOPROC + 2
#endif
#ifndef SHN_MIPS_SUNDEFINED
#define SHN_MIPS_SUNDEFINED SHN_LOPROC + 4
#endif
#ifndef SHN_MIPS_SCOMMON
#define SHN_MIPS_SCOMMON SHN_LOPROC + 3
#endif
#ifndef STT_PARISC_MILLI
#define STT_PARISC_MILLI STT_LOPROC + 0
#endif
static int elf_fix_header(Elf_Ehdr *);
static int elf_fix_shdrs(Elf_Ehdr *, Elf_Shdr *);
static int elf_fix_sym(Elf_Ehdr *, Elf_Sym *);
static int elf_shn2type(Elf_Ehdr *, u_int _shn, const char *_sn);
static int elf2nlist(Elf_Sym *, Elf_Ehdr *, Elf_Shdr *, char *_shstr,
struct xnlist *_np);
static int elf_symloadx(const char *_name, FILE *, off_t, Elf_Ehdr *,
Elf_Shdr *, char *_shstr, long _shstrsize, struct xnlist **_pnames,
struct xnlist ***_psnames, size_t *_pstabsize, int *_pnrawnames,
const char *_strtab, const char *_symtab);
int
elf_fix_header(Elf_Ehdr *eh)
{
/* nothing to do */
if (eh->e_ident[EI_DATA] == ELF_TARG_DATA)
return (0);
eh->e_type = swap16(eh->e_type);
eh->e_machine = swap16(eh->e_machine);
eh->e_version = swap32(eh->e_version);
eh->e_entry = swap_addr(eh->e_entry);
eh->e_phoff = swap_off(eh->e_phoff);
eh->e_shoff = swap_off(eh->e_shoff);
eh->e_flags = swap32(eh->e_flags);
eh->e_ehsize = swap16(eh->e_ehsize);
eh->e_phentsize = swap16(eh->e_phentsize);
eh->e_phnum = swap16(eh->e_phnum);
eh->e_shentsize = swap16(eh->e_shentsize);
eh->e_shnum = swap16(eh->e_shnum);
eh->e_shstrndx = swap16(eh->e_shstrndx);
return (1);
}
Elf_Shdr *
elf_load_shdrs(const char *name, FILE *fp, off_t foff, Elf_Ehdr *head)
{
Elf_Shdr *shdr;
elf_fix_header(head);
if (head->e_shnum == 0) {
warnx("%s: no section header table", name);
return (NULL);
}
if (head->e_shstrndx >= head->e_shnum) {
warnx("%s: inconsistent section header table", name);
return (NULL);
}
if (head->e_shentsize < sizeof(Elf_Shdr)) {
warnx("%s: inconsistent section header size", name);
return (NULL);
}
if ((shdr = calloc(head->e_shnum, head->e_shentsize)) == NULL) {
warn("%s: malloc shdr", name);
return (NULL);
}
if (fseeko(fp, foff + head->e_shoff, SEEK_SET)) {
warn("%s: fseeko", name);
free(shdr);
return (NULL);
}
if (fread(shdr, head->e_shentsize, head->e_shnum, fp) != head->e_shnum) {
warnx("%s: premature EOF", name);
free(shdr);
return (NULL);
}
elf_fix_shdrs(head, shdr);
return (shdr);
}
int
elf_fix_shdrs(Elf_Ehdr *eh, Elf_Shdr *shdr)
{
int i;
/* nothing to do */
if (eh->e_ident[EI_DATA] == ELF_TARG_DATA)
return (0);
for (i = eh->e_shnum; i--; shdr++) {
shdr->sh_name = swap32(shdr->sh_name);
shdr->sh_type = swap32(shdr->sh_type);
shdr->sh_flags = swap_xword(shdr->sh_flags);
shdr->sh_addr = swap_addr(shdr->sh_addr);
shdr->sh_offset = swap_off(shdr->sh_offset);
shdr->sh_size = swap_xword(shdr->sh_size);
shdr->sh_link = swap32(shdr->sh_link);
shdr->sh_info = swap32(shdr->sh_info);
shdr->sh_addralign = swap_xword(shdr->sh_addralign);
shdr->sh_entsize = swap_xword(shdr->sh_entsize);
}
return (1);
}
int
elf_fix_sym(Elf_Ehdr *eh, Elf_Sym *sym)
{
/* nothing to do */
if (eh->e_ident[EI_DATA] == ELF_TARG_DATA)
return (0);
sym->st_name = swap32(sym->st_name);
sym->st_shndx = swap16(sym->st_shndx);
sym->st_value = swap_addr(sym->st_value);
sym->st_size = swap_xword(sym->st_size);
return (1);
}
int
elf_shn2type(Elf_Ehdr *eh, u_int shn, const char *sn)
{
switch (shn) {
case SHN_MIPS_SUNDEFINED:
if (eh->e_machine == EM_MIPS)
return (N_UNDF | N_EXT);
break;
case SHN_UNDEF:
return (N_UNDF | N_EXT);
case SHN_ABS:
return (N_ABS);
case SHN_MIPS_ACOMMON:
if (eh->e_machine == EM_MIPS)
return (N_COMM);
break;
case SHN_MIPS_SCOMMON:
if (eh->e_machine == EM_MIPS)
return (N_COMM);
break;
case SHN_COMMON:
return (N_COMM);
case SHN_MIPS_TEXT:
if (eh->e_machine == EM_MIPS)
return (N_TEXT);
break;
case SHN_MIPS_DATA:
if (eh->e_machine == EM_MIPS)
return (N_DATA);
break;
default:
/* TODO: beyond 8 a table-driven binsearch should be used */
if (sn == NULL)
return (-1);
else if (!strcmp(sn, ELF_TEXT))
return (N_TEXT);
else if (!strncmp(sn, ".text.", 6))
return (N_TEXT);
else if (!strcmp(sn, ELF_RODATA))
return (N_SIZE);
else if (!strcmp(sn, ELF_OPENBSDRANDOMDATA))
return (N_SIZE);
else if (!strcmp(sn, ELF_DATA))
return (N_DATA);
else if (!strcmp(sn, ELF_SDATA))
return (N_DATA);
else if (!strcmp(sn, ELF_TDATA))
return (N_DATA);
else if (!strcmp(sn, ELF_BSS))
return (N_BSS);
else if (!strcmp(sn, ELF_SBSS))
return (N_BSS);
else if (!strcmp(sn, ELF_TBSS))
return (N_BSS);
else if (!strncmp(sn, ELF_GOT, sizeof(ELF_GOT) - 1))
return (N_DATA);
else if (!strncmp(sn, ELF_PLT, sizeof(ELF_PLT) - 1))
return (N_DATA);
}
return (-1);
}
/*
* Devise xnlist's type from Elf_Sym.
* XXX this task is done as well in libc and kvm_mkdb.
*/
int
elf2nlist(Elf_Sym *sym, Elf_Ehdr *eh, Elf_Shdr *shdr, char *shstr,
struct xnlist *np)
{
u_char stt;
const char *sn;
int type;
if (sym->st_shndx < eh->e_shnum)
sn = shstr + shdr[sym->st_shndx].sh_name;
else
sn = NULL;
#if 0
{
extern char *stab;
printf("%d:%s %d %d %s\n", sym->st_shndx, sn? sn : "",
ELF_ST_TYPE(sym->st_info), ELF_ST_BIND(sym->st_info),
stab + sym->st_name);
}
#endif
switch (stt = ELF_ST_TYPE(sym->st_info)) {
case STT_NOTYPE:
case STT_OBJECT:
case STT_TLS:
type = elf_shn2type(eh, sym->st_shndx, sn);
if (type < 0) {
if (sn == NULL)
np->nl.n_other = '?';
else
np->nl.n_type = stt == STT_NOTYPE ?
N_COMM : N_DATA;
} else {
/* a hack for .rodata check (; */
if (type == N_SIZE) {
np->nl.n_type = N_DATA;
np->nl.n_other = 'r';
} else
np->nl.n_type = type;
}
if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
np->nl.n_other = 'W';
break;
case STT_FUNC:
type = elf_shn2type(eh, sym->st_shndx, NULL);
np->nl.n_type = type < 0? N_TEXT : type;
if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
np->nl.n_other = 'W';
} else if (sn != NULL && *sn != 0 &&
strcmp(sn, ELF_INIT) &&
strcmp(sn, ELF_TEXT) &&
strncmp(sn, ".text.", 6) &&
strcmp(sn, ELF_FINI)) /* XXX GNU compat */
np->nl.n_other = '?';
break;
case STT_SECTION:
type = elf_shn2type(eh, sym->st_shndx, NULL);
if (type < 0)
np->nl.n_other = '?';
else
np->nl.n_type = type;
break;
case STT_FILE:
np->nl.n_type = N_FN | N_EXT;
break;
case STT_PARISC_MILLI:
if (eh->e_machine == EM_PARISC)
np->nl.n_type = N_TEXT;
else
np->nl.n_other = '?';
break;
default:
np->nl.n_other = '?';
break;
}
if (np->nl.n_type != N_UNDF && ELF_ST_BIND(sym->st_info) != STB_LOCAL) {
np->nl.n_type |= N_EXT;
if (np->nl.n_other)
np->nl.n_other = toupper((unsigned char)np->nl.n_other);
}
return (0);
}
int
elf_size(Elf_Ehdr *head, Elf_Shdr *shdr,
u_long *ptext, u_long *pdata, u_long *pbss)
{
int i;
*ptext = *pdata = *pbss = 0;
for (i = 0; i < head->e_shnum; i++) {
if (!(shdr[i].sh_flags & SHF_ALLOC))
;
else if (shdr[i].sh_flags & SHF_EXECINSTR ||
!(shdr[i].sh_flags & SHF_WRITE))
*ptext += shdr[i].sh_size;
else if (shdr[i].sh_type == SHT_NOBITS)
*pbss += shdr[i].sh_size;
else
*pdata += shdr[i].sh_size;
}
return (0);
}
int
elf_symloadx(const char *name, FILE *fp, off_t foff, Elf_Ehdr *eh,
Elf_Shdr *shdr, char *shstr, long shstrsize, struct xnlist **pnames,
struct xnlist ***psnames, size_t *pstabsize, int *pnrawnames,
const char *strtab, const char *symtab)
{
long symsize;
struct xnlist *np;
Elf_Sym sbuf;
int i;
for (i = 0; i < eh->e_shnum; i++) {
if (shdr[i].sh_name >= shstrsize) {
warnx("%s: corrupt file", name);
return (1);
}
if (!strcmp(shstr + shdr[i].sh_name, strtab)) {
*pstabsize = shdr[i].sh_size;
if (*pstabsize > SIZE_MAX) {
warnx("%s: corrupt file", name);
return (1);
}
MMAP(stab, *pstabsize, PROT_READ, MAP_PRIVATE|MAP_FILE,
fileno(fp), foff + shdr[i].sh_offset);
if (stab == MAP_FAILED)
return (1);
}
}
for (i = 0; i < eh->e_shnum; i++) {
if (!strcmp(shstr + shdr[i].sh_name, symtab)) {
symsize = shdr[i].sh_size;
if (fseeko(fp, foff + shdr[i].sh_offset, SEEK_SET)) {
warn("%s: fseeko", name);
if (stab)
MUNMAP(stab, *pstabsize);
return (1);
}
*pnrawnames = symsize / sizeof(sbuf);
if ((*pnames = calloc(*pnrawnames, sizeof(*np))) == NULL) {
warn("%s: malloc names", name);
if (stab)
MUNMAP(stab, *pstabsize);
*pnrawnames = 0;
return (1);
}
if ((*psnames = calloc(*pnrawnames, sizeof(np))) == NULL) {
warn("%s: malloc snames", name);
if (stab)
MUNMAP(stab, *pstabsize);
free(*pnames);
*pnames = NULL;
*pnrawnames = 0;
return (1);
}
for (np = *pnames; symsize > 0; symsize -= sizeof(sbuf)) {
if (fread(&sbuf, 1, sizeof(sbuf),
fp) != sizeof(sbuf)) {
warn("%s: read symbol", name);
if (stab)
MUNMAP(stab, *pstabsize);
free(*pnames);
free(*psnames);
*pnames = NULL;
*psnames = NULL;
*pnrawnames = 0;
return (1);
}
elf_fix_sym(eh, &sbuf);
if (!sbuf.st_name ||
sbuf.st_name > *pstabsize)
continue;
elf2nlist(&sbuf, eh, shdr, shstr, np);
np->nl.n_value = sbuf.st_value;
np->nl.n_un.n_strx = sbuf.st_name;
np->n_size = sbuf.st_size;
np++;
}
*pnrawnames = np - *pnames;
}
}
return (0);
}
int
elf_symload(const char *name, FILE *fp, off_t foff, Elf_Ehdr *eh,
Elf_Shdr *shdr, struct xnlist **pnames, struct xnlist ***psnames,
size_t *pstabsize, int *pnrawnames)
{
long shstrsize;
char *shstr;
shstrsize = shdr[eh->e_shstrndx].sh_size;
if (shstrsize == 0) {
warnx("%s: no name list", name);
return (1);
}
if ((shstr = malloc(shstrsize)) == NULL) {
warn("%s: malloc shstr", name);
return (1);
}
if (fseeko(fp, foff + shdr[eh->e_shstrndx].sh_offset, SEEK_SET)) {
warn("%s: fseeko", name);
free(shstr);
return (1);
}
if (fread(shstr, 1, shstrsize, fp) != shstrsize) {
warnx("%s: premature EOF", name);
free(shstr);
return(1);
}
stab = NULL;
*pnames = NULL; *psnames = NULL; *pnrawnames = 0;
if (!dynamic_only) {
elf_symloadx(name, fp, foff, eh, shdr, shstr, shstrsize, pnames,
psnames, pstabsize, pnrawnames, ELF_STRTAB, ELF_SYMTAB);
}
if (stab == NULL) {
elf_symloadx(name, fp, foff, eh, shdr, shstr, shstrsize, pnames,
psnames, pstabsize, pnrawnames, ELF_DYNSTR, ELF_DYNSYM);
}
free(shstr);
if (stab == NULL) {
warnx("%s: no name list", name);
free(*pnames);
free(*psnames);
return (1);
}
return (0);
}