Subversion Repositories planix.SVN

/*

 * nm.c -- drive nm

 */

#include <u.h>

#include <libc.h>

#include <ar.h>

#include <bio.h>

#include <mach.h>

enum{

	CHUNK	=	256	/* must be power of 2 */

};

char	*errs;			/* exit status */

char	*filename;		/* current file */

char	symname[]="__.SYMDEF";	/* table of contents file name */

int	multifile;		/* processing multiple files */

int	aflag;

int	gflag;

int	hflag;

int	nflag;

int	sflag;

int	uflag;

int	Tflag;

Sym	**fnames;		/* file path translation table */

Sym	**symptr;

int	nsym;

Biobuf	bout;

int	cmp(void*, void*);

void	error(char*, ...);

void	execsyms(int);

void	psym(Sym*, void*);

void	printsyms(Sym**, long);

void	doar(Biobuf*);

void	dofile(Biobuf*);

void	zenter(Sym*);

void

usage(void)

{

	fprint(2, "usage: nm [-aghnsTu] file ...\n");

	exits("usage");

}

void

main(int argc, char *argv[])

{

	int i;

	Biobuf	*bin;

	Binit(&bout, 1, OWRITE);

	argv0 = argv[0];

	ARGBEGIN {

	default:	usage();

	case 'a':	aflag = 1; break;

	case 'g':	gflag = 1; break;

	case 'h':	hflag = 1; break;

	case 'n':	nflag = 1; break;

	case 's':	sflag = 1; break;

	case 'u':	uflag = 1; break;

	case 'T':	Tflag = 1; break;

	} ARGEND

	if (argc == 0)

		usage();

	if (argc > 1)

		multifile++;

	for(i=0; i<argc; i++){

		filename = argv[i];

		bin = Bopen(filename, OREAD);

		if(bin == 0){

			error("cannot open %s", filename);

			continue;

		}

		if (isar(bin))

			doar(bin);

		else{

			Bseek(bin, 0, 0);

			dofile(bin);

		}

		Bterm(bin);

	}

	exits(errs);

}

/*

 * read an archive file,

 * processing the symbols for each intermediate file in it.

 */

void

doar(Biobuf *bp)

{

	int offset, size, obj;

	char membername[SARNAME];

	multifile = 1;

	for (offset = Boffset(bp);;offset += size) {

		size = nextar(bp, offset, membername);

		if (size < 0) {

			error("phase error on ar header %ld", offset);

			return;

		}

		if (size == 0)

			return;

		if (strcmp(membername, symname) == 0)

			continue;

		obj = objtype(bp, 0);

		if (obj < 0) {

			error("inconsistent file %s in %s",

					membername, filename);

			return;

		}

		if (!readar(bp, obj, offset+size, 1)) {

			error("invalid symbol reference in file %s",

					membername);

			return;

		}

		filename = membername;

		nsym=0;

		objtraverse(psym, 0);

		printsyms(symptr, nsym);

	}

}

/*

 * process symbols in a file

 */

void

dofile(Biobuf *bp)

{

	int obj;

	obj = objtype(bp, 0);

	if (obj < 0)

		execsyms(Bfildes(bp));

	else

	if (readobj(bp, obj)) {

		nsym = 0;

		objtraverse(psym, 0);

		printsyms(symptr, nsym);

	}

}

/*

 * comparison routine for sorting the symbol table

 *	this screws up on 'z' records when aflag == 1

 */

int

cmp(void *vs, void *vt)

{

	Sym **s, **t;

	s = vs;

	t = vt;

	if(nflag)

		if((*s)->value < (*t)->value)

			return -1;

		else

			return (*s)->value > (*t)->value;

	return strcmp((*s)->name, (*t)->name);

}

/*

 * enter a symbol in the table of filename elements

 */

void

zenter(Sym *s)

{

	static int maxf = 0;

	if (s->value > maxf) {

		maxf = (s->value+CHUNK-1) &~ (CHUNK-1);

		fnames = realloc(fnames, (maxf+1)*sizeof(*fnames));

		if(fnames == 0) {

			error("out of memory", argv0);

			exits("memory");

		}

	}

	fnames[s->value] = s;

}

/*

 * get the symbol table from an executable file, if it has one

 */

void

execsyms(int fd)

{

	Fhdr f;

	Sym *s;

	long n;

	seek(fd, 0, 0);

	if (crackhdr(fd, &f) == 0) {

		error("Can't read header for %s", filename);

		return;

	}

	if (syminit(fd, &f) < 0)

		return;

	s = symbase(&n);

	nsym = 0;

	while(n--)

		psym(s++, 0);

	printsyms(symptr, nsym);

}

void

psym(Sym *s, void* p)

{

	USED(p);

	switch(s->type) {

	case 'T':

	case 'L':

	case 'D':

	case 'B':

		if (uflag)

			return;

		if (!aflag && ((s->name[0] == '.' || s->name[0] == '$')))

			return;

		break;

	case 'b':

	case 'd':

	case 'l':

	case 't':

		if (uflag || gflag)

			return;

		if (!aflag && ((s->name[0] == '.' || s->name[0] == '$')))

			return;

		break;

	case 'U':

		if (gflag)

			return;

		break;

	case 'Z':

		if (!aflag)

			return;

		break;

	case 'm':

	case 'f':	/* we only see a 'z' when the following is true*/

		if(!aflag || uflag || gflag)

			return;

		if (strcmp(s->name, ".frame"))

			zenter(s);

		break;

	case 'a':

	case 'p':

	case 'z':

	default:

		if(!aflag || uflag || gflag)

			return;

		break;

	}

	symptr = realloc(symptr, (nsym+1)*sizeof(Sym*));

	if (symptr == 0) {

		error("out of memory");

		exits("memory");

	}

	symptr[nsym++] = s;

}

void

printsyms(Sym **symptr, long nsym)

{

	int i, wid;

	Sym *s;

	char *cp;

	char path[512];

	if(!sflag)

		qsort(symptr, nsym, sizeof(*symptr), cmp);

	wid = 0;

	for (i=0; i<nsym; i++) {

		s = symptr[i];

		if (s->value && wid == 0)

			wid = 8;

		else if (s->value >= 0x100000000LL && wid == 8)

			wid = 16;

	}	

	for (i=0; i<nsym; i++) {

		s = symptr[i];

		if (multifile && !hflag)

			Bprint(&bout, "%s:", filename);

		if (s->type == 'z') {

			fileelem(fnames, (uchar *) s->name, path, 512);

			cp = path;

		} else

			cp = s->name;

		if (Tflag)

			Bprint(&bout, "%8ux ", s->sig);

		if (s->value || s->type == 'a' || s->type == 'p')

			Bprint(&bout, "%*llux ", wid, s->value);

		else

			Bprint(&bout, "%*s ", wid, "");

		Bprint(&bout, "%c %s\n", s->type, cp);

	}

}

void

error(char *fmt, ...)

{

	Fmt f;

	char buf[128];

	va_list arg;

	fmtfdinit(&f, 2, buf, sizeof buf);

	fmtprint(&f, "%s: ", argv0);

	va_start(arg, fmt);

	fmtvprint(&f, fmt, arg);

	va_end(arg);

	fmtprint(&f, "\n");

	fmtfdflush(&f);

	errs = "errors";

}