/*	$OpenBSD: nm.c,v 1.51 2015/12/09 19:28:34 mmcc 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_abi.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 *);

char *otherstring(struct xnlist *);

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;

	}

		case 'a':

		case 'B':

			/* no-op, compat with gnu-nm */

			break;

		case 'C':

		case 'D':

		case 'e':

		case 'g':

		case 'n':

		case 'v':

		case 'A':

		case 'o':

		case 'p':

		case 'P':

		case 'r':

		case 's':

		case 'u':

		case 'w':

		case 't':

			} else {

				    (posix_radix != 'd' && posix_radix != 'o' &&

				     posix_radix != 'x'))

			}

			break;

		case '?':

		default:

		}

	}

		    posix_radix, posix_radix);

		do {

	else

		    total_text, total_data, total_bss,

		    total_total, total_total);

}

/*

 * 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];

	}

	/*

	 * first check whether this is an object file - read a object

	 * header, and skip back to the beginning

	 */

		}

	}

	/* this could be an archive */

		    strncmp(magic, ARMAG, SARMAG)) {

		}

	} else

}

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)

{

	long i;

		int len;

		}

	} else

#ifdef AR_EFMT1

	/*

	 * BSD 4.4 extended AR format: #1/<namelen>, with name as the

	 * first <namelen> bytes of the file

	 */

	    (arh->ar_name[1] == '1') &&

	    (arh->ar_name[2] == '/') &&

	    (isdigit((unsigned char)arh->ar_name[3]))) {

		}

		}

	} else

#endif

}

/*

 * 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 namelen;

	off_t restore;

	}

		}

		    memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) {

		}

		}

	}

}

/*

 * 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;

	}

		}

		    memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) {

		}

		}

	}

}

/*

 * 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;

	/* while there are more entries in the archive */

		/* bad archive entry - stop processing this archive */

		}

		/* remember start position of current archive object */

		    sizeof(RANLIBMAG) - 1) == 0) {

			    show_symdef(last_ar_off, mmbrlen, fname, fp)) {

			}

			goto skip;

		    sizeof(SYMTABMAG) - 1) == 0) {

			/* if nametab hasn't been seen yet -- doit later */

			}

			/* load the Sys5 long names table */

		    sizeof(STRTABMAG) - 1) == 0) {

			char *p;

			}

			}

				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

			} else {

			}

		}

		/*

		 * 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

		 */

		}

		/* get and check current object's header */

		    (size_t)1, fp) != 1) {

		}

		/*

		 * skip to next archive object - it starts at the next

		 * even byte boundary

		 */

#define even(x) (((x) + 1) & ~1)

		}

	}

}

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;

	    head->elf32.e_ident[EI_CLASS] == ELFCLASS32 &&

	    head->elf32.e_ident[EI_VERSION] == ELF_TARG_VER) {

		void *shdr;

		    elf32_size(&head->elf32, shdr, &text, &data, &bss) :

		    elf32_symload(name, fp, foff, &head->elf32, shdr,

			&names, &snames, &stabsize, &nrawnames);

	    head->elf64.e_ident[EI_CLASS] == ELFCLASS64 &&

	    head->elf64.e_ident[EI_VERSION] == ELF_TARG_VER) {

		void *shdr;

		    elf64_size(&head->elf64, shdr, &text, &data, &bss) :

		    elf64_symload(name, fp, foff, &head->elf64, shdr,

			&names, &snames, &stabsize, &nrawnames);

	} else {

	}

		static int first = 1;

		}

		    text, data, bss, total, total);

	}

	/* else we are nm */

	/*

	 * it seems that string table is sequential

	 * relative to the symbol table order

	 */

	/*

	 * 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

	 */

		/*

		 * 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

		 */

		else

		    SYMBOL_TYPE(np->nl.n_type) != N_UNDF)

	}

	/* sort the symbol table if applicable */

	/* print out symbols */

}

char *

symname(struct xnlist *sym)

{

}

/*

 * print_symbol()

 *	show one symbol

 */

void

print_symbol(const char *name, struct xnlist *sym)

{

		else

	}

			    sym->n_size);

	} else {

		/*

		 * handle undefined-only format especially (no space is

		 * left for symbol values, no type field is printed)

		 */

			/* print symbol's value */

			else

			/* print type information */

			else

		}

	}

}

/*

 * 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)

{

	case N_ABS:

	case N_BSS:

	case N_COMM:

	case N_DATA:

	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.

		 */

	case N_TEXT:

	case N_SIZE:

	case N_UNDF:

	}

}

int

fname(const void *a0, const void *b0)

{

}

int

rname(const void *a0, const void *b0)

{

}

int

value(const void *a0, const void *b0)

{

		else

	} else {

	}

}

#define CPPFILT	"/usr/bin/c++filt"

void

pipe2cppfilt(void)

{

	int pip[2];

	char *argv[2];

	case -1:

	default:

	case 0:

	}

}

void

usage(void)

{

	extern char *__progname;

	else

		    __progname);

}