![[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] / 43BSDReno / pgrm / nm|
Return to nm.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / nm |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Hans Huebner.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that: (1) source distributions retain this entire copyright
10: * notice and comment, and (2) distributions including binaries display
11: * the following acknowledgement: ``This product includes software
12: * developed by the University of California, Berkeley and its contributors''
13: * in the documentation or other materials provided with the distribution
14: * and in all advertising materials mentioning features or use of this
15: * software. Neither the name of the University nor the names of its
16: * contributors may be used to endorse or promote products derived
17: * from this software without specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: char copyright[] =
25: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\
26: All rights reserved.\n";
27: #endif /* not lint */
28:
29: #ifndef lint
30: static char sccsid[] = "@(#)nm.c 5.6 (Berkeley) 6/1/90";
31: #endif /* not lint */
32:
33: #include <sys/types.h>
34: #include <a.out.h>
35: #include <stab.h>
36: #include <ar.h>
37: #include <ranlib.h>
38: #include <unistd.h>
39: #include <errno.h>
40: #include <ctype.h>
41: #include <stdio.h>
42: #include <stdlib.h>
43: #include <string.h>
44:
45: int ignore_bad_archive_entries = 1;
46: int print_only_external_symbols;
47: int print_only_undefined_symbols;
48: int print_all_symbols;
49: int print_file_each_line;
50: int cmp_value(), cmp_name();
51: int (*sort_func)() = cmp_name;
52:
53: enum { FORWARD, BACKWARD } sort_direction = FORWARD;
54: int fcount;
55:
56: /* some macros for symbol type (nlist.n_type) handling */
57: #define IS_DEBUGGER_SYMBOL(x) ((x) & N_STAB)
58: #define IS_EXTERNAL(x) ((x) & N_EXT)
59: #define SYMBOL_TYPE(x) ((x) & (N_TYPE | N_STAB))
60:
61: /*
62: * main()
63: * parse command line, execute process_file() for each file
64: * specified on the command line.
65: */
66: main(argc, argv)
67: int argc;
68: char **argv;
69: {
70: extern int optind;
71: int ch, errors;
72:
73: while ((ch = getopt(argc, argv, "agnopruw")) != EOF) {
74: switch (ch) {
75: case 'a':
76: print_all_symbols = 1;
77: break;
78: case 'g':
79: print_only_external_symbols = 1;
80: break;
81: case 'n':
82: sort_func = cmp_value;
83: break;
84: case 'o':
85: print_file_each_line = 1;
86: break;
87: case 'p':
88: sort_func = NULL;
89: break;
90: case 'r':
91: sort_direction = BACKWARD;
92: break;
93: case 'u':
94: print_only_undefined_symbols = 1;
95: break;
96: case 'w':
97: ignore_bad_archive_entries = 0;
98: break;
99: case '?':
100: default:
101: usage();
102: }
103: }
104: fcount = argc - optind;
105: argv += optind;
106:
107: if (!fcount)
108: errors = process_file("a.out");
109: else {
110: errors = 0;
111: do {
112: errors |= process_file(*argv);
113: } while (*++argv);
114: }
115: exit(errors);
116: }
117:
118: /*
119: * process_file()
120: * show symbols in the file given as an argument. Accepts archive and
121: * object files as input.
122: */
123: process_file(fname)
124: char *fname;
125: {
126: struct exec exec_head;
127: FILE *fp;
128: int retval;
129: char magic[SARMAG];
130:
131: if (!(fp = fopen(fname, "r"))) {
132: (void)fprintf(stderr, "nm: cannot read %s.\n", fname);
133: return(1);
134: }
135:
136: if (fcount > 1)
137: (void)printf("\n%s:\n", fname);
138:
139: /*
140: * first check whether this is an object file - read a object
141: * header, and skip back to the beginning
142: */
143: if (fread((char *)&exec_head, sizeof(exec_head), (size_t)1, fp) != 1) {
144: (void)fprintf(stderr, "nm: %s: bad format.\n", fname);
145: (void)fclose(fp);
146: return(1);
147: }
148: rewind(fp);
149:
150: /* this could be an archive */
151: if (N_BADMAG(exec_head)) {
152: if (fread(magic, sizeof(magic), (size_t)1, fp) != 1 ||
153: strncmp(magic, ARMAG, SARMAG)) {
154: (void)fprintf(stderr,
155: "nm: %s: not object file or archive.\n", fname);
156: (void)fclose(fp);
157: return(1);
158: }
159: retval = show_archive(fname, fp);
160: } else
161: retval = show_objfile(fname, fp);
162: (void)fclose(fp);
163: return(retval);
164: }
165:
166: /*
167: * show_archive()
168: * show symbols in the given archive file
169: */
170: show_archive(fname, fp)
171: char *fname;
172: FILE *fp;
173: {
174: struct ar_hdr ar_head;
175: struct exec exec_head;
176: int i, rval;
177: long last_ar_off;
178: char *p, *name, *emalloc();
179: long atol();
180:
181: name = emalloc(sizeof(ar_head.ar_name) + strlen(fname) + 3);
182:
183: rval = 0;
184:
185: /* while there are more entries in the archive */
186: while (fread((char *)&ar_head, sizeof(ar_head), (size_t)1, fp) == 1) {
187: /* bad archive entry - stop processing this archive */
188: if (strncmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) {
189: (void)fprintf(stderr,
190: "nm: %s: bad format archive header", fname);
191: (void)free(name);
192: return(1);
193: }
194:
195: /*
196: * construct a name of the form "archive.a:obj.o:" for the
197: * current archive entry if the object name is to be printed
198: * on each output line
199: */
200: p = name;
201: if (print_file_each_line)
202: p += sprintf(p, "%s:", fname);
203: for (i = 0; i < sizeof(ar_head.ar_name); ++i)
204: if (ar_head.ar_name[i] && ar_head.ar_name[i] != ' ')
205: *p++ = ar_head.ar_name[i];
206: *p++ = '\0';
207:
208: /* remember start position of current archive object */
209: last_ar_off = ftell(fp);
210:
211: /* get and check current object's header */
212: if (fread((char *)&exec_head, sizeof(exec_head),
213: (size_t)1, fp) != 1) {
214: (void)fprintf(stderr, "nm: %s: premature EOF.\n", name);
215: (void)free(name);
216: return(1);
217: }
218: if (strcmp(name, RANLIBMAG))
219: if (N_BADMAG(exec_head)) {
220: if (!ignore_bad_archive_entries) {
221: (void)fprintf(stderr,
222: "nm: %s: bad format.\n", name);
223: rval = 1;
224: }
225: } else {
226: (void)fseek(fp, (long)-sizeof(exec_head),
227: SEEK_CUR);
228: if (!print_file_each_line)
229: (void)printf("\n%s:\n", name);
230: rval |= show_objfile(name, fp);
231: }
232:
233: /*
234: * skip to next archive object - it starts at the next
235: * even byte boundary
236: */
237: #define even(x) (((x) + 1) & ~1)
238: if (fseek(fp, last_ar_off + even(atol(ar_head.ar_size)),
239: SEEK_SET)) {
240: (void)fprintf(stderr,
241: "nm: %s: %s\n", fname, strerror(errno));
242: (void)free(name);
243: return(1);
244: }
245: }
246: (void)free(name);
247: return(rval);
248: }
249:
250: /*
251: * show_objfile()
252: * show symbols from the object file pointed to by fp. The current
253: * file pointer for fp is expected to be at the beginning of an a.out
254: * header.
255: */
256: show_objfile(objname, fp)
257: char *objname;
258: FILE *fp;
259: {
260: register struct nlist *names, *np;
261: register int i, nnames, nrawnames;
262: struct exec head;
263: long stabsize;
264: char *stab, *emalloc();
265:
266: /* read a.out header */
267: if (fread((char *)&head, sizeof(head), (size_t)1, fp) != 1) {
268: (void)fprintf(stderr,
269: "nm: %s: cannot read header.\n", objname);
270: return(1);
271: }
272:
273: /*
274: * skip back to the header - the N_-macros return values relative
275: * to the beginning of the a.out header
276: */
277: if (fseek(fp, (long)-sizeof(head), SEEK_CUR)) {
278: (void)fprintf(stderr,
279: "nm: %s: %s\n", objname, strerror(errno));
280: return(1);
281: }
282:
283: /* stop if this is no valid object file */
284: if (N_BADMAG(head)) {
285: (void)fprintf(stderr,
286: "nm: %s: bad format.\n", objname);
287: return(1);
288: }
289:
290: /* stop if the object file contains no symbol table */
291: if (!head.a_syms) {
292: (void)fprintf(stderr,
293: "nm: %s: no name list.\n", objname);
294: return(1);
295: }
296:
297: if (fseek(fp, (long)N_SYMOFF(head), SEEK_CUR)) {
298: (void)fprintf(stderr,
299: "nm: %s: %s\n", objname, strerror(errno));
300: return(1);
301: }
302:
303: /* get memory for the symbol table */
304: names = (struct nlist *)emalloc((size_t)head.a_syms);
305: nrawnames = head.a_syms / sizeof(*names);
306: if (fread((char *)names, (size_t)head.a_syms, (size_t)1, fp) != 1) {
307: (void)fprintf(stderr,
308: "nm: %s: cannot read symbol table.\n", objname);
309: (void)free((char *)names);
310: return(1);
311: }
312:
313: /*
314: * Following the symbol table comes the string table. The first
315: * 4-byte-integer gives the total size of the string table
316: * _including_ the size specification itself.
317: */
318: if (fread((char *)&stabsize, sizeof(stabsize), (size_t)1, fp) != 1) {
319: (void)fprintf(stderr,
320: "nm: %s: cannot read stab size.\n", objname);
321: (void)free((char *)names);
322: return(1);
323: }
324: stab = emalloc((size_t)stabsize);
325:
326: /*
327: * read the string table offset by 4 - all indices into the string
328: * table include the size specification.
329: */
330: stabsize -= 4; /* we already have the size */
331: if (fread(stab + 4, (size_t)stabsize, (size_t)1, fp) != 1) {
332: (void)fprintf(stderr,
333: "nm: %s: stab truncated..\n", objname);
334: (void)free((char *)names);
335: (void)free(stab);
336: return(1);
337: }
338:
339: /*
340: * fix up the symbol table and filter out unwanted entries
341: *
342: * common symbols are characterized by a n_type of N_UNDF and a
343: * non-zero n_value -- change n_type to N_COMM for all such
344: * symbols to make life easier later.
345: *
346: * filter out all entries which we don't want to print anyway
347: */
348: for (np = names, i = nnames = 0; i < nrawnames; np++, i++) {
349: if (SYMBOL_TYPE(np->n_type) == N_UNDF && np->n_value)
350: np->n_type = N_COMM | (np->n_type & N_EXT);
351: if (!print_all_symbols && IS_DEBUGGER_SYMBOL(np->n_type))
352: continue;
353: if (print_only_external_symbols && !IS_EXTERNAL(np->n_type))
354: continue;
355: if (print_only_undefined_symbols &&
356: SYMBOL_TYPE(np->n_type) != N_UNDF)
357: continue;
358:
359: /*
360: * make n_un.n_name a character pointer by adding the string
361: * table's base to n_un.n_strx
362: *
363: * don't mess with zero offsets
364: */
365: if (np->n_un.n_strx)
366: np->n_un.n_name = stab + np->n_un.n_strx;
367: else
368: np->n_un.n_name = "";
369: names[nnames++] = *np;
370: }
371:
372: /* sort the symbol table if applicable */
373: if (sort_func)
374: qsort((char *)names, (size_t)nnames, sizeof(*names), sort_func);
375:
376: /* print out symbols */
377: for (np = names, i = 0; i < nnames; np++, i++)
378: print_symbol(objname, np);
379:
380: (void)free((char *)names);
381: (void)free(stab);
382: return(0);
383: }
384:
385: /*
386: * print_symbol()
387: * show one symbol
388: */
389: print_symbol(objname, sym)
390: char *objname;
391: register struct nlist *sym;
392: {
393: char *typestring(), typeletter();
394:
395: if (print_file_each_line)
396: (void)printf("%s:", objname);
397:
398: /*
399: * handle undefined-only format seperately (no space is
400: * left for symbol values, no type field is printed)
401: */
402: if (print_only_undefined_symbols) {
403: (void)puts(sym->n_un.n_name);
404: return;
405: }
406:
407: /* print symbol's value */
408: if (SYMBOL_TYPE(sym->n_type) == N_UNDF)
409: (void)printf(" ");
410: else
411: (void)printf("%08lx", sym->n_value);
412:
413: /* print type information */
414: if (IS_DEBUGGER_SYMBOL(sym->n_type))
415: (void)printf(" - %02x %04x %5s ", sym->n_other,
416: sym->n_desc&0xffff, typestring(sym->n_type));
417: else
418: (void)printf(" %c ", typeletter(sym->n_type));
419:
420: /* print the symbol's name */
421: (void)puts(sym->n_un.n_name);
422: }
423:
424: /*
425: * typestring()
426: * return the a description string for an STAB entry
427: */
428: char *
429: typestring(type)
430: register u_char type;
431: {
432: switch(type) {
433: case N_BCOMM:
434: return("BCOMM");
435: case N_ECOML:
436: return("ECOML");
437: case N_ECOMM:
438: return("ECOMM");
439: case N_ENTRY:
440: return("ENTRY");
441: case N_FNAME:
442: return("FNAME");
443: case N_FUN:
444: return("FUN");
445: case N_GSYM:
446: return("GSYM");
447: case N_LBRAC:
448: return("LBRAC");
449: case N_LCSYM:
450: return("LCSYM");
451: case N_LENG:
452: return("LENG");
453: case N_LSYM:
454: return("LSYM");
455: case N_PC:
456: return("PC");
457: case N_PSYM:
458: return("PSYM");
459: case N_RBRAC:
460: return("RBRAC");
461: case N_RSYM:
462: return("RSYM");
463: case N_SLINE:
464: return("SLINE");
465: case N_SO:
466: return("SO");
467: case N_SOL:
468: return("SOL");
469: case N_SSYM:
470: return("SSYM");
471: case N_STSYM:
472: return("STSYM");
473: }
474: return("???");
475: }
476:
477: /*
478: * typeletter()
479: * return a description letter for the given basic type code of an
480: * symbol table entry. The return value will be upper case for
481: * external, lower case for internal symbols.
482: */
483: char
484: typeletter(type)
485: u_char type;
486: {
487: switch(SYMBOL_TYPE(type)) {
488: case N_ABS:
489: return(IS_EXTERNAL(type) ? 'A' : 'a');
490: case N_BSS:
491: return(IS_EXTERNAL(type) ? 'B' : 'b');
492: case N_COMM:
493: return(IS_EXTERNAL(type) ? 'C' : 'c');
494: case N_DATA:
495: return(IS_EXTERNAL(type) ? 'D' : 'd');
496: case N_FN:
497: return(IS_EXTERNAL(type) ? 'F' : 'f');
498: case N_TEXT:
499: return(IS_EXTERNAL(type) ? 'T' : 't');
500: case N_UNDF:
501: return(IS_EXTERNAL(type) ? 'U' : 'u');
502: }
503: return('?');
504: }
505:
506: /*
507: * cmp_name()
508: * compare two symbols by their names
509: */
510: cmp_name(a0, b0)
511: void *a0, *b0;
512: {
513: struct nlist *a = a0, *b = b0;
514:
515: return(sort_direction == FORWARD ?
516: strcmp(a->n_un.n_name, b->n_un.n_name) :
517: strcmp(b->n_un.n_name, a->n_un.n_name));
518: }
519:
520: /*
521: * cmp_value()
522: * compare two symbols by their values
523: */
524: cmp_value(a0, b0)
525: void *a0, *b0;
526: {
527: register struct nlist *a = a0, *b = b0;
528:
529: if (SYMBOL_TYPE(a->n_type) == N_UNDF)
530: if (SYMBOL_TYPE(b->n_type) == N_UNDF)
531: return(0);
532: else
533: return(-1);
534: else if (SYMBOL_TYPE(b->n_type) == N_UNDF)
535: return(1);
536: if (a->n_value == b->n_value)
537: return(cmp_name((void *)a, (void *)b));
538: return(sort_direction == FORWARD ? a->n_value > b->n_value :
539: a->n_value < b->n_value);
540: }
541:
542: char *
543: emalloc(size)
544: size_t size;
545: {
546: char *p;
547:
548: /* NOSTRICT */
549: if (!(p = malloc(size))) {
550: (void)fprintf(stderr, "nm: no more memory.\n");
551: exit(1);
552: }
553: return(p);
554: }
555:
556: usage()
557: {
558: (void)fprintf(stderr, "usage: nm [-agnopruw] [file ...]\n");
559: exit(1);
560: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.