Edit
IABSD.fr/src/usr.bin/nm/nm.c
jsg
- usr.bin/nm/nm.c
-
/* $OpenBSD: nm.c,v 1.56 2024/05/21 05:00:48 jsg Exp $ */ /* $NetBSD: nm.c,v 1.7 1996/01/14 23:04:03 pk Exp $ */ /* * Copyright (c) 1989, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Hans Huebner. * * 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. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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 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/types.h> #include <sys/mman.h> #include <a.out.h> #include <elf.h> #include <ar.h> #include <ranlib.h> #include <unistd.h> #include <err.h> #include <errno.h> #include <ctype.h> #include <link.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <getopt.h> #include "util.h" #include "elfuncs.h" #define SYMTABMAG "/ " #define STRTABMAG "//" #define SYM64MAG "/SYM64/ " union hdr { Elf32_Ehdr elf32; Elf64_Ehdr elf64; }; int armap; int demangle; int non_object_warning; int print_only_external_symbols; int print_only_undefined_symbols; int print_all_symbols; int print_file_each_line; int show_extensions; int issize; char posix_fmtstr[6]; int posix_output; char posix_radix = 'x'; int usemmap = 1; int dynamic_only; /* size vars */ unsigned long total_text, total_data, total_bss, total_total; int non_object_warning, print_totals; int rev; int fname(const void *, const void *); int rname(const void *, const void *); int value(const void *, const void *); int (*sfunc)(const void *, const void *) = fname; char typeletter(struct xnlist *); int mmbr_name(struct ar_hdr *, char **, int, int *, FILE *); int show_symtab(off_t, u_long, const char *, FILE *); int show_symdef(off_t, u_long, const char *, FILE *); /* some macros for symbol type (nlist.n_type) handling */ #define IS_EXTERNAL(x) ((x) & N_EXT) #define SYMBOL_TYPE(x) ((x) & (N_TYPE | N_STAB)) void pipe2cppfilt(void); void usage(void); char *symname(struct xnlist *); int process_file(int, const char *); int show_archive(int, const char *, FILE *); int show_file(int, int, const char *, FILE *fp, off_t, union hdr *); void print_symbol(const char *, struct xnlist *); #define OPTSTRING_NM "aABCDegnopPrst:uvw" const struct option longopts_nm[] = { { "debug-syms", no_argument, 0, 'a' }, { "demangle", no_argument, 0, 'C' }, { "dynamic", no_argument, 0, 'D' }, { "extern-only", no_argument, 0, 'g' }, /* { "line-numbers", no_argument, 0, 'l' }, */ { "no-sort", no_argument, 0, 'p' }, { "numeric-sort", no_argument, 0, 'n' }, { "print-armap", no_argument, 0, 's' }, { "print-file-name", no_argument, 0, 'o' }, { "reverse-sort", no_argument, 0, 'r' }, /* { "size-sort", no_argument, &szval, 1 }, */ { "undefined-only", no_argument, 0, 'u' }, { "help", no_argument, 0, '?' }, { NULL } }; /* * main() * parse command line, execute process_file() for each file * specified on the command line. */ int main(int argc, char *argv[]) { extern char *__progname; extern int optind; const char *optstr; const struct option *lopts; int ch, eval; if (pledge("stdio rpath proc exec", NULL) == -1) err(1, "pledge"); optstr = OPTSTRING_NM; lopts = longopts_nm; if (!strcmp(__progname, "size")) { if (pledge("stdio rpath", NULL) == -1) err(1, "pledge"); issize = 1; optstr = "tw"; lopts = NULL; } while ((ch = getopt_long(argc, argv, optstr, lopts, NULL)) != -1) { switch (ch) { case 'a': print_all_symbols = 1; break; case 'B': /* no-op, compat with gnu-nm */ break; case 'C': demangle = 1; break; case 'D': dynamic_only = 1; break; case 'e': show_extensions = 1; break; case 'g': print_only_external_symbols = 1; break; case 'n': case 'v': sfunc = value; break; case 'A': case 'o': print_file_each_line = 1; break; case 'p': sfunc = NULL; break; case 'P': posix_output = 1; break; case 'r': rev = 1; break; case 's': armap = 1; break; case 'u': print_only_undefined_symbols = 1; break; case 'w': non_object_warning = 1; break; case 't': if (issize) { print_totals = 1; } else { posix_radix = *optarg; if (strlen(optarg) != 1 || (posix_radix != 'd' && posix_radix != 'o' && posix_radix != 'x')) usage(); } break; default: usage(); } } if (posix_output) (void)snprintf(posix_fmtstr, sizeof posix_fmtstr, "%%%c %%%c", posix_radix, posix_radix); if (demangle) pipe2cppfilt(); if (pledge("stdio rpath", NULL) == -1) err(1, "pledge"); argv += optind; argc -= optind; if (rev && sfunc == fname) sfunc = rname; eval = 0; if (*argv) do { eval |= process_file(argc, *argv); } while (*++argv); else eval |= process_file(1, "a.out"); if (issize && print_totals) printf("\n%lu\t%lu\t%lu\t%lu\t%lx\tTOTAL\n", total_text, total_data, total_bss, total_total, total_total); exit(eval); } /* * process_file() * show symbols in the file given as an argument. Accepts archive and * object files as input. */ int process_file(int count, const char *fname) { union hdr exec_head; FILE *fp; int retval; size_t bytes; char magic[SARMAG]; if (!(fp = fopen(fname, "r"))) { warn("cannot read %s", fname); return(1); } if (!issize && count > 1) (void)printf("\n%s:\n", fname); /* * first check whether this is an object file - read a object * header, and skip back to the beginning */ bzero(&exec_head, sizeof(exec_head)); bytes = fread((char *)&exec_head, 1, sizeof(exec_head), fp); if (bytes < sizeof(exec_head)) { if (bytes < sizeof(exec_head.elf32) || IS_ELF(exec_head.elf32)) { warnx("%s: bad format", fname); (void)fclose(fp); return(1); } } rewind(fp); /* this could be an archive */ if (!IS_ELF(exec_head.elf32)) { if (fread(magic, sizeof(magic), (size_t)1, fp) != 1 || strncmp(magic, ARMAG, SARMAG)) { warnx("%s: not object file or archive", fname); (void)fclose(fp); return(1); } retval = show_archive(count, fname, fp); } else retval = show_file(count, 1, fname, fp, 0, &exec_head); (void)fclose(fp); return(retval); } char *nametab; /* * * given the archive member header -- produce member name */ int mmbr_name(struct ar_hdr *arh, char **name, int baselen, int *namelen, FILE *fp) { char *p = *name + strlen(*name); long i; if (nametab && arh->ar_name[0] == '/') { int len; i = atol(&arh->ar_name[1]); len = strlen(&nametab[i]) + 1; if (len > *namelen) { p -= (long)*name; if ((*name = realloc(*name, baselen+len)) == NULL) err(1, NULL); *namelen = len; p += (long)*name; } strlcpy(p, &nametab[i], len); p += len - 1; } else #ifdef AR_EFMT1 /* * BSD 4.4 extended AR format: #1/<namelen>, with name as the * first <namelen> bytes of the file */ if ((arh->ar_name[0] == '#') && (arh->ar_name[1] == '1') && (arh->ar_name[2] == '/') && (isdigit((unsigned char)arh->ar_name[3]))) { int len = atoi(&arh->ar_name[3]); if (len > *namelen) { p -= (long)*name; if ((*name = realloc(*name, baselen+len)) == NULL) err(1, NULL); *namelen = len; p += (long)*name; } if (fread(p, len, 1, fp) != 1) { warnx("%s: premature EOF", *name); free(*name); return(1); } p += len; } else #endif for (i = 0; i < sizeof(arh->ar_name); ++i) if (arh->ar_name[i] && arh->ar_name[i] != ' ') *p++ = arh->ar_name[i]; *p = '\0'; if (p[-1] == '/') *--p = '\0'; return (0); } /* * show_symtab() * show archive ranlib index (fs5) */ int show_symtab(off_t off, u_long len, const char *name, FILE *fp) { struct ar_hdr ar_head; int *symtab, *ps; char *strtab, *p; int num, rval = 0; int namelen; off_t restore; restore = ftello(fp); MMAP(symtab, len, PROT_READ, MAP_PRIVATE|MAP_FILE, fileno(fp), off); if (symtab == MAP_FAILED) return (1); namelen = sizeof(ar_head.ar_name); if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) { warn("%s: malloc", name); MUNMAP(symtab, len); return (1); } printf("\nArchive index:\n"); num = betoh32(*symtab); strtab = (char *)(symtab + num + 1); for (ps = symtab + 1; num--; ps++, strtab += strlen(strtab) + 1) { if (fseeko(fp, betoh32(*ps), SEEK_SET)) { warn("%s: fseeko", name); rval = 1; break; } if (fread(&ar_head, sizeof(ar_head), 1, fp) != 1 || memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) { warnx("%s: member fseeko", name); rval = 1; break; } *p = '\0'; if (mmbr_name(&ar_head, &p, 0, &namelen, fp)) { rval = 1; break; } printf("%s in %s\n", strtab, p); } fseeko(fp, restore, SEEK_SET); free(p); MUNMAP(symtab, len); return (rval); } /* * show_symdef() * show archive ranlib index (gob) */ int show_symdef(off_t off, u_long len, const char *name, FILE *fp) { struct ranlib *prn, *eprn; struct ar_hdr ar_head; char *symdef; char *strtab, *p; u_long size; int namelen, rval = 0; MMAP(symdef, len, PROT_READ, MAP_PRIVATE|MAP_FILE, fileno(fp), off); if (symdef == MAP_FAILED) return (1); if (usemmap) (void)madvise(symdef, len, MADV_SEQUENTIAL); namelen = sizeof(ar_head.ar_name); if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) { warn("%s: malloc", name); MUNMAP(symdef, len); return (1); } size = *(u_long *)symdef; prn = (struct ranlib *)(symdef + sizeof(u_long)); eprn = prn + size / sizeof(*prn); strtab = symdef + sizeof(u_long) + size + sizeof(u_long); printf("\nArchive index:\n"); for (; prn < eprn; prn++) { if (fseeko(fp, prn->ran_off, SEEK_SET)) { warn("%s: fseeko", name); rval = 1; break; } if (fread(&ar_head, sizeof(ar_head), 1, fp) != 1 || memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) { warnx("%s: member fseeko", name); rval = 1; break; } *p = '\0'; if (mmbr_name(&ar_head, &p, 0, &namelen, fp)) { rval = 1; break; } printf("%s in %s\n", strtab + prn->ran_un.ran_strx, p); } free(p); MUNMAP(symdef, len); return (rval); } /* * show_archive() * show symbols in the given archive file */ int show_archive(int count, const char *fname, FILE *fp) { struct ar_hdr ar_head; union hdr exec_head; int i, rval; off_t last_ar_off, foff, symtaboff; char *name; int baselen, namelen; u_long mmbrlen, symtablen; baselen = strlen(fname) + 3; if (posix_output) baselen += 2; namelen = sizeof(ar_head.ar_name); if ((name = malloc(baselen + namelen)) == NULL) err(1, NULL); rval = 0; nametab = NULL; symtaboff = 0; symtablen = 0; /* while there are more entries in the archive */ while (fread(&ar_head, sizeof(ar_head), 1, fp) == 1) { /* bad archive entry - stop processing this archive */ if (memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) { warnx("%s: bad format archive header", fname); rval = 1; break; } /* remember start position of current archive object */ last_ar_off = ftello(fp); mmbrlen = atol(ar_head.ar_size); if (strncmp(ar_head.ar_name, RANLIBMAG, sizeof(RANLIBMAG) - 1) == 0) { if (!issize && armap && show_symdef(last_ar_off, mmbrlen, fname, fp)) { rval = 1; break; } goto skip; } else if (strncmp(ar_head.ar_name, SYMTABMAG, sizeof(SYMTABMAG) - 1) == 0) { /* if nametab hasn't been seen yet -- doit later */ if (!nametab) { symtablen = mmbrlen; symtaboff = last_ar_off; goto skip; } /* load the Sys5 long names table */ } else if (strncmp(ar_head.ar_name, STRTABMAG, sizeof(STRTABMAG) - 1) == 0) { char *p; if ((nametab = malloc(mmbrlen)) == NULL) { warn("%s: nametab", fname); rval = 1; break; } if (fread(nametab, mmbrlen, (size_t)1, fp) != 1) { warnx("%s: premature EOF", fname); rval = 1; break; } for (p = nametab, i = mmbrlen; i--; p++) if (*p == '\n') *p = '\0'; if (issize || !armap || !symtablen || !symtaboff) goto skip; } #ifdef __mips64 else if (memcmp(ar_head.ar_name, SYM64MAG, sizeof(ar_head.ar_name)) == 0) { /* IRIX6-compatible archive map */ goto skip; } #endif if (!issize && armap && symtablen && symtaboff) { if (show_symtab(symtaboff, symtablen, fname, fp)) { rval = 1; break; } else { symtaboff = 0; symtablen = 0; } } /* * construct a name of the form "archive.a:obj.o:" for the * current archive entry if the object name is to be printed * on each output line */ *name = '\0'; if (posix_output) snprintf(name, baselen - 1, "%s[", fname); else if (count > 1) snprintf(name, baselen - 1, "%s:", fname); if (mmbr_name(&ar_head, &name, baselen, &namelen, fp)) { rval = 1; break; } if (posix_output) strlcat(name, "]", baselen + namelen); foff = ftello(fp); /* get and check current object's header */ if (fread((char *)&exec_head, sizeof(exec_head), (size_t)1, fp) != 1) { warnx("%s: premature EOF", fname); rval = 1; break; } rval |= show_file(2, non_object_warning, name, fp, foff, &exec_head); /* * skip to next archive object - it starts at the next * even byte boundary */ #define even(x) (((x) + 1) & ~1) skip: if (fseeko(fp, last_ar_off + even(mmbrlen), SEEK_SET)) { warn("%s", fname); rval = 1; break; } } free(nametab); nametab = NULL; free(name); return(rval); } char *stab; /* * show_file() * show symbols from the object file pointed to by fp. The current * file pointer for fp is expected to be at the beginning of an object * file header. */ int show_file(int count, int warn_fmt, const char *name, FILE *fp, off_t foff, union hdr *head) { u_long text, data, bss, total; struct xnlist *np, *names, **snames; int i, nrawnames, nnames; size_t stabsize; if (IS_ELF(head->elf32) && head->elf32.e_ident[EI_CLASS] == ELFCLASS32 && head->elf32.e_ident[EI_VERSION] == ELF_TARG_VER) { void *shdr; if (!(shdr = elf32_load_shdrs(name, fp, foff, &head->elf32))) return (1); i = issize? elf32_size(&head->elf32, shdr, &text, &data, &bss) : elf32_symload(name, fp, foff, &head->elf32, shdr, &names, &snames, &stabsize, &nrawnames); free(shdr); if (i) return (i); } else if (IS_ELF(head->elf64) && head->elf64.e_ident[EI_CLASS] == ELFCLASS64 && head->elf64.e_ident[EI_VERSION] == ELF_TARG_VER) { void *shdr; if (!(shdr = elf64_load_shdrs(name, fp, foff, &head->elf64))) return (1); i = issize? elf64_size(&head->elf64, shdr, &text, &data, &bss) : elf64_symload(name, fp, foff, &head->elf64, shdr, &names, &snames, &stabsize, &nrawnames); free(shdr); if (i) return (i); } else { if (warn_fmt) warnx("%s: bad format", name); return (1); } if (issize) { static int first = 1; if (first) { first = 0; printf("text\tdata\tbss\tdec\thex\n"); } total = text + data + bss; printf("%lu\t%lu\t%lu\t%lu\t%lx", text, data, bss, total, total); if (count > 1) (void)printf("\t%s", name); total_text += text; total_data += data; total_bss += bss; total_total += total; printf("\n"); return (0); } /* else we are nm */ /* * it seems that string table is sequential * relative to the symbol table order */ if (sfunc == NULL && usemmap) (void)madvise(stab, stabsize, MADV_SEQUENTIAL); /* * fix up the symbol table and filter out unwanted entries * * common symbols are characterized by a n_type of N_UNDF and a * non-zero n_value -- change n_type to N_COMM for all such * symbols to make life easier later. * * filter out all entries which we don't want to print anyway */ for (np = names, i = nnames = 0; i < nrawnames; np++, i++) { /* * make n_un.n_name a character pointer by adding the string * table's base to n_un.n_strx * * don't mess with zero offsets */ if (np->nl.n_un.n_strx) np->nl.n_un.n_name = stab + np->nl.n_un.n_strx; else np->nl.n_un.n_name = ""; if (print_only_external_symbols && !IS_EXTERNAL(np->nl.n_type)) continue; if (print_only_undefined_symbols && SYMBOL_TYPE(np->nl.n_type) != N_UNDF) continue; snames[nnames++] = np; } /* sort the symbol table if applicable */ if (sfunc) qsort(snames, (size_t)nnames, sizeof(*snames), sfunc); if (count > 1) (void)printf("\n%s:\n", name); /* print out symbols */ for (i = 0; i < nnames; i++) print_symbol(name, snames[i]); free(snames); free(names); MUNMAP(stab, stabsize); return(0); } char * symname(struct xnlist *sym) { return sym->nl.n_un.n_name; } /* * print_symbol() * show one symbol */ void print_symbol(const char *name, struct xnlist *sym) { if (print_file_each_line) { if (posix_output) (void)printf("%s: ", name); else (void)printf("%s:", name); } if (posix_output) { (void)printf("%s %c ", symname(sym), typeletter(sym)); if (SYMBOL_TYPE(sym->nl.n_type) != N_UNDF) (void)printf(posix_fmtstr, sym->nl.n_value, sym->n_size); (void)printf("\n"); } else { /* * handle undefined-only format especially (no space is * left for symbol values, no type field is printed) */ if (!print_only_undefined_symbols) { /* print symbol's value */ if (SYMBOL_TYPE(sym->nl.n_type) == N_UNDF) (void)printf(" "); else (void)printf("%08lx", sym->nl.n_value); /* print type information */ if (show_extensions) (void)printf(" %c ", typeletter(sym)); else (void)printf(" %c ", typeletter(sym)); } (void)puts(symname(sym)); } } /* * typeletter() * return a description letter for the given basic type code of an * symbol table entry. The return value will be upper case for * external, lower case for internal symbols. */ char typeletter(struct xnlist *np) { int ext = IS_EXTERNAL(np->nl.n_type); if (np->nl.n_other) return np->nl.n_other; switch(SYMBOL_TYPE(np->nl.n_type)) { case N_ABS: return(ext? 'A' : 'a'); case N_BSS: return(ext? 'B' : 'b'); case N_COMM: return(ext? 'C' : 'c'); case N_DATA: return(ext? 'D' : 'd'); case N_FN: /* NOTE: N_FN == N_WARNING, * in this case, the N_EXT bit is to considered as * part of the symbol's type itself. */ return(ext? 'F' : 'W'); case N_TEXT: return(ext? 'T' : 't'); case N_SIZE: return(ext? 'S' : 's'); case N_UNDF: return(ext? 'U' : 'u'); } return('?'); } int fname(const void *a0, const void *b0) { struct xnlist * const *a = a0, * const *b = b0; return(strcmp((*a)->nl.n_un.n_name, (*b)->nl.n_un.n_name)); } int rname(const void *a0, const void *b0) { struct xnlist * const *a = a0, * const *b = b0; return(strcmp((*b)->nl.n_un.n_name, (*a)->nl.n_un.n_name)); } int value(const void *a0, const void *b0) { struct xnlist * const *a = a0, * const *b = b0; if (SYMBOL_TYPE((*a)->nl.n_type) == N_UNDF) if (SYMBOL_TYPE((*b)->nl.n_type) == N_UNDF) return(0); else return(-1); else if (SYMBOL_TYPE((*b)->nl.n_type) == N_UNDF) return(1); if (rev) { if ((*a)->nl.n_value == (*b)->nl.n_value) return(rname(a0, b0)); return((*b)->nl.n_value > (*a)->nl.n_value ? 1 : -1); } else { if ((*a)->nl.n_value == (*b)->nl.n_value) return(fname(a0, b0)); return((*a)->nl.n_value > (*b)->nl.n_value ? 1 : -1); } } #define CPPFILT "/usr/bin/c++filt" void pipe2cppfilt(void) { int pip[2]; char *argv[2]; argv[0] = "c++filt"; argv[1] = NULL; if (pipe(pip) == -1) err(1, "pipe"); switch(fork()) { case -1: err(1, "fork"); default: dup2(pip[0], 0); close(pip[0]); close(pip[1]); execve(CPPFILT, argv, NULL); err(1, "execve"); case 0: dup2(pip[1], 1); close(pip[1]); close(pip[0]); } } void usage(void) { extern char *__progname; if (issize) fprintf(stderr, "usage: %s [-tw] [file ...]\n", __progname); else fprintf(stderr, "usage: %s [-AaCDegnoPprsuw] [-t d|o|x] [file ...]\n", __progname); exit(1); }