/*	$OpenBSD: nm.c,v 1.52 2017/09/12 08:32:44 mpi 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;

	optstr = OPTSTRING_NM;

	lopts = longopts_nm;

		optstr = "tw";

		lopts = NULL;

	}

		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':

			}

			break;

		case '?':

		default:

		}

	}

	eval = 0;

		do {

	else

}

/*

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

{

	FILE *fp;

	int retval;

	size_t bytes;

	}

	/*

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

	 * header, and skip back to the beginning

	 */

		}

	}

	/* this could be an archive */

		}

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;

		}

#ifdef AR_EFMT1

	/*

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

	 * first <namelen> bytes of the file

	 */

		}

		}

#endif

/*

 * show_symtab()

 *	show archive ranlib index (fs5)

 */

int

show_symtab(off_t off, u_long len, const char *name, FILE *fp)

{

	int *symtab, *ps;

	int num, rval = 0;

	off_t restore;

	}

			rval = 1;

		}

			rval = 1;

		}

			rval = 1;

		}

	}

}

/*

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

	char *symdef;

	u_long size;

	}

			rval = 1;

		}

			rval = 1;

		}

			rval = 1;

		}

	}

}

/*

 * show_archive()

 *	show symbols in the given archive file

 */

int

show_archive(int count, const char *fname, FILE *fp)

{

	int i, rval;

	off_t last_ar_off, foff, symtaboff;

	u_long mmbrlen, symtablen;

	rval = 0;

	symtaboff = 0;

	symtablen = 0;

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

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

			rval = 1;

		}

		/* remember start position of current archive object */

				rval = 1;

			}

			goto skip;

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

				symtablen = mmbrlen;

				symtaboff = last_ar_off;

			}

			/* load the Sys5 long names table */

			char *p;

				rval = 1;

			}

				rval = 1;

			}

		}

#ifdef __mips64

		else if (memcmp(ar_head.ar_name, SYM64MAG,

		    sizeof(ar_head.ar_name)) == 0) {

			/* IRIX6-compatible archive map */

			goto skip;

		}

#endif

				rval = 1;

			} 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

		 */

			rval = 1;

		}

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

			rval = 1;

		}

		/*

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

		 * even byte boundary

		 */

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

			rval = 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)

{

		void *shdr;

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

		void *shdr;

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

	}

		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

			np->nl.n_un.n_name = "";

			continue;

			continue;

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

	}

		/*

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

{

	case -1:

	default:

	case 0:

	}

void

usage(void)

{

	extern char *__progname;

	else

		    __progname);

}