![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / bin|
Return to nm.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / bin |
1.1 root 1: /*
2: * Copyright (c) 1987 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)nm.c 4.8 4/7/87";
9: #endif
10:
11: /*
12: * nm - print name list; VAX string table version
13: */
14:
15: #include <sys/types.h>
16: #include <sys/file.h>
17: #include <ar.h>
18: #include <stdio.h>
19: #include <ctype.h>
20: #include <a.out.h>
21: #include <stab.h>
22: #include <ranlib.h>
23:
24: #define OARMAG 0177545 /* OLD archive magic number */
25: #define SELECT (archive ? archdr.ar_name : *xargv)
26:
27: #define YES 1
28: #define NO 0
29:
30: #define u_strx n_un.n_strx
31: #define u_name n_un.n_name
32:
33: typedef struct nlist NLIST;
34:
35: union { /* exec header, or magic string from library */
36: char mag_armag[SARMAG + 1];
37: struct exec mag_exp;
38: } mag_un;
39:
40: struct ar_hdr archdr; /* archive file header structure */
41: FILE *fi; /* input file stream */
42: off_t off; /* offset into file */
43: int aflg, /* print debugger symbols */
44: gflg, /* print only global (external symbols */
45: nflg, /* sort numerically, not alphabetically */
46: oflg, /* prepend element name to each output line */
47: pflg, /* don't sort */
48: rflg = 1, /* how to sort */
49: uflg, /* print only undefined symbols */
50: narg, /* global number of arguments */
51: errs, /* global error flag */
52: archive; /* if file is an archive */
53: char **xargv; /* global pointer to file name */
54:
55: main(argc, argv)
56: int argc;
57: char **argv;
58: {
59: extern int optind;
60: int ch; /* getopts char */
61:
62: while ((ch = getopt(argc, argv, "agnopru")) != EOF)
63: switch((char)ch) {
64: case 'a':
65: aflg = YES;
66: break;
67: case 'g':
68: gflg = YES;
69: break;
70: case 'n':
71: nflg = YES;
72: break;
73: case 'o':
74: oflg = YES;
75: break;
76: case 'p':
77: pflg = YES;
78: break;
79: case 'r':
80: rflg = -1;
81: break;
82: case 'u':
83: uflg = YES;
84: break;
85: case '?':
86: default:
87: fputs("usage: nm [-agnopru] [file ...]\n", stderr);
88: exit(2);
89: }
90: argc -= optind;
91: argv += optind;
92: if (!argc) {
93: argc = 1;
94: argv[0] = "a.out";
95: }
96: narg = argc;
97: for (xargv = argv; argc--; ++xargv)
98: if (fi = fopen(*xargv, "r")) {
99: namelist();
100: (void)fclose(fi);
101: }
102: else
103: error(NO, "cannot open");
104: exit(errs);
105: }
106:
107: namelist()
108: {
109: register NLIST *N, **L;
110: register int symcount, nsyms;
111: static NLIST *symp, **list;
112: static int lastnsyms = -1,
113: laststrsiz = -1;
114: static char *strp;
115: off_t strsiz;
116: long lseek();
117: int compare();
118: char *malloc(), *realloc();
119:
120: /*
121: * read first few bytes, determine if an archive,
122: * or executable; if executable, check magic number
123: */
124: /*NOSTRICT*/
125: if (!fread((char *)&mag_un, sizeof(mag_un), 1, fi)) {
126: error(NO, "unable to read file");
127: return;
128: }
129: if (mag_un.mag_exp.a_magic == OARMAG) {
130: error(NO, "old archive");
131: return;
132: }
133: if (bcmp(mag_un.mag_armag, ARMAG, SARMAG)) {
134: if (N_BADMAG(mag_un.mag_exp)) {
135: error(NO, "bad format");
136: return;
137: }
138: archive = NO;
139: rewind(fi);
140: }
141: else {
142: /*
143: * if archive, skip first entry
144: * if ranlib'd, skip second entry
145: */
146: off = SARMAG; /* see nextel() */
147: (void)nextel();
148: if (!strcmp(RANLIBMAG, archdr.ar_name))
149: (void)nextel();
150: if (narg > 1)
151: printf("\n%s:\n", *xargv);
152: archive = YES;
153: }
154:
155: do {
156: /* check for bad magic number */
157: /*NOSTRICT*/
158: if (!fread((char *)&mag_un.mag_exp, sizeof(struct exec), 1, fi)) {
159: error(NO, "unable to read magic number");
160: return;
161: }
162: if (N_BADMAG(mag_un.mag_exp))
163: continue;
164:
165: /* calculate number of symbols in object */
166: if (!(nsyms = mag_un.mag_exp.a_syms / sizeof(NLIST))) {
167: error(NO, "no name list");
168: continue;
169: }
170:
171: /* seek to and read symbols */
172: (void)fseek(fi, (long)(N_SYMOFF(mag_un.mag_exp) - sizeof(struct exec)), L_INCR);
173: if (!symp || nsyms > lastnsyms) {
174: if (!symp) {
175: /*NOSTRICT*/
176: symp = (NLIST *)malloc((u_int)(nsyms * sizeof(NLIST)));
177: /*NOSTRICT*/
178: list = (NLIST **)malloc((u_int)(nsyms * sizeof(NLIST *)));
179: }
180: else {
181: /*NOSTRICT*/
182: symp = (NLIST *)realloc((char *)symp, (u_int)(nsyms * sizeof(NLIST)));
183: /*NOSTRICT*/
184: list = (NLIST **)realloc((char *)list, (u_int)(nsyms * sizeof(NLIST *)));
185: }
186: if (!symp || !list)
187: error(YES, "out of memory");
188: lastnsyms = nsyms;
189: }
190: /*NOSTRICT*/
191: if (fread((char *)symp, sizeof(NLIST), nsyms, fi) != nsyms) {
192: error(NO, "bad symbol table");
193: continue;
194: }
195:
196: /* read number of strings, string table */
197: /*NOSTRICT*/
198: if (!fread((char *)&strsiz, sizeof(strsiz), 1, fi)) {
199: error(NO, "no string table (old format .o?)");
200: continue;
201: }
202: if (!strp || strsiz > laststrsiz) {
203: strp = strp ? realloc(strp, (u_int)strsiz) : malloc((u_int)strsiz);
204: if (!strp)
205: error(YES, "out of memory");
206: laststrsiz = strsiz;
207: }
208: if (!fread(strp + sizeof(strsiz), 1, (int)(strsiz - sizeof(strsiz)), fi)) {
209: error(NO, "no string table (old format .o?)");
210: continue;
211: }
212:
213: for (symcount = nsyms, L = list, N = symp;--nsyms >= 0;++N)
214: if (!(N->n_type & N_EXT) && gflg || N->n_type & N_STAB && (!aflg || gflg || uflg))
215: --symcount;
216: else {
217: N->u_name = N->u_strx ? strp + N->u_strx : "";
218: *L++ = N;
219: }
220:
221: if (!pflg)
222: qsort(list, symcount, sizeof(NLIST *), compare);
223:
224: if ((archive || narg > 1) && !oflg)
225: printf("\n%s:\n", SELECT);
226:
227: psyms(list, symcount);
228: } while(archive && nextel());
229: }
230:
231: psyms(list, nsyms)
232: NLIST **list;
233: register int nsyms;
234: {
235: register NLIST *L;
236: register u_char type;
237: char *stab();
238:
239: while (nsyms--) {
240: L = *list++;
241: type = L->n_type;
242: if (type & N_STAB) {
243: if (oflg) {
244: if (archive)
245: printf("%s:", *xargv);
246: printf("%s:", SELECT);
247: }
248: printf("%08x - %02x %04x %5.5s %s\n", (int)L->n_value, L->n_other & 0xff, L->n_desc & 0xffff, stab(L->n_type), L->u_name);
249: continue;
250: }
251: switch (type & N_TYPE) {
252: case N_UNDF:
253: type = L->n_value ? 'c' : 'u';
254: break;
255: case N_ABS:
256: type = 'a';
257: break;
258: case N_TEXT:
259: type = 't';
260: break;
261: case N_DATA:
262: type = 'd';
263: break;
264: case N_BSS:
265: type = 'b';
266: break;
267: case N_FN:
268: type = 'f';
269: break;
270: default:
271: type = '?';
272: break;
273: }
274: if (uflg && type != 'u')
275: continue;
276: if (oflg) {
277: if (archive)
278: printf("%s:", *xargv);
279: printf("%s:", SELECT);
280: }
281: if (L->n_type & N_EXT)
282: type = toupper(type);
283: if (!uflg) {
284: if (type == 'u' || type == 'U')
285: fputs(" ", stdout);
286: else
287: printf(N_FORMAT, (int)L->n_value);
288: printf(" %c ", (char)type);
289: }
290: puts(L->u_name);
291: }
292: }
293:
294: compare(p1, p2)
295: NLIST **p1, **p2;
296: {
297: if (nflg) {
298: if ((*p1)->n_value > (*p2)->n_value)
299: return(rflg);
300: if ((*p1)->n_value < (*p2)->n_value)
301: return(-rflg);
302: }
303: return(rflg * strcmp((*p1)->u_name, (*p2)->u_name));
304: }
305:
306: nextel()
307: {
308: register char *cp;
309: long arsize,
310: lseek();
311:
312: (void)fseek(fi, off, L_SET);
313: /*NOSTRICT*/
314: if (!fread((char *)&archdr, sizeof(struct ar_hdr), 1, fi))
315: return(0);
316: for (cp = archdr.ar_name; cp < &archdr.ar_name[sizeof(archdr.ar_name)]; ++cp)
317: if (*cp == ' ') {
318: *cp = '\0';
319: break;
320: }
321: arsize = atol(archdr.ar_size);
322: if (arsize & 1)
323: ++arsize;
324: off = ftell(fi) + arsize; /* beginning of next element */
325: return(1);
326: }
327:
328: struct stabnames {
329: int st_value;
330: char *st_name;
331: } stabnames[] ={
332: N_GSYM, "GSYM",
333: N_FNAME, "FNAME",
334: N_FUN, "FUN",
335: N_STSYM, "STSYM",
336: N_LCSYM, "LCSYM",
337: N_RSYM, "RSYM",
338: N_SLINE, "SLINE",
339: N_SSYM, "SSYM",
340: N_SO, "SO",
341: N_LSYM, "LSYM",
342: N_SOL, "SOL",
343: N_PSYM, "PSYM",
344: N_ENTRY, "ENTRY",
345: N_LBRAC, "LBRAC",
346: N_RBRAC, "RBRAC",
347: N_BCOMM, "BCOMM",
348: N_ECOMM, "ECOMM",
349: N_ECOML, "ECOML",
350: N_LENG, "LENG",
351: N_PC, "PC",
352: 0, 0
353: };
354:
355: char *
356: stab(val)
357: register u_char val;
358: {
359: register struct stabnames *sp;
360: static char prbuf[5];
361:
362: for (sp = stabnames; sp->st_value; ++sp)
363: if (sp->st_value == val)
364: return(sp->st_name);
365: (void)sprintf(prbuf, "%02x", (int)val);
366: return(prbuf);
367: }
368:
369: error(doexit, msg)
370: int doexit;
371: char *msg;
372: {
373: fprintf(stderr, "nm: %s:", *xargv);
374: if (archive)
375: fprintf(stderr, "(%s): %s\n", archdr.ar_name, msg);
376: else
377: fprintf(stderr, " %s\n", msg);
378: if (doexit)
379: exit(2);
380: errs = 1;
381: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.