![[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 [MW Coherent from dump] / coherent / d / bin|
Return to nm.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * List a coff symbol table.
3: */
4: #include <misc.h>
5: #include <canon.h>
6: #include <l.out.h>
7: #include <ar.h>
8: #include <errno.h>
9:
10: FILE *fd; /* Current input file */
11:
12: int asw; /* list all symbols */
13: int dsw; /* list only defined symbols */
14: int gsw; /* print only global symbols */
15: int nsw; /* list numerically not alphabetically */
16: int osw; /* append file name to each line */
17: int psw; /* print symbols in symbol table order */
18: int rsw; /* print in reverse alpha order */
19: int usw; /* print only undefined symbols */
20: int vsw; /* print coff type symbols */
21:
22: int namesw; /* one if header is required */
23: char *str_tab;
24: char *fname;
25:
26: /*
27: * Old form sort logic.
28: */
29: ncomp_old(s1, s2)
30: struct nlist *s1, *s2;
31: {
32: long i;
33:
34: if (!(i = (s1->n_value - s2->n_value)))
35: return (0);
36: if (i < 0)
37: return (-1);
38: return (1);
39: }
40:
41: acomp_old(s1, s2)
42: struct nlist *s1, *s2;
43: {
44: return(strncmp(s1->n_name, s2->n_name, NCPLN));
45: }
46:
47: rcomp_old(s1, s2)
48: struct nlist *s1, *s2;
49: {
50: return(strncmp(s2->n_name, s1->n_name, NCPLN));
51: }
52:
53: /*
54: * Process old ar files.
55: */
56: old_ar(filen, at)
57: char *filen;
58: long at;
59: {
60: long arhend;
61: struct old_ar_hdr arh;
62:
63: namesw = 0;
64: for (arhend = at + sizeof(short); ; ) {
65: fseek(fd, arhend, 0);
66: if (1 != fread(&arh, sizeof(arh), 1, fd))
67: break;
68: arhend += sizeof(arh);
69: arh.ar_date = 0; /* terminate name */
70: cansize(arh.ar_size);
71: if (strcmp(arh.ar_name, HDRNAME)) {
72: printf("%s(%s)\n", filen, arh.ar_name);
73: readHeaders(arhend, arh.ar_size);
74: }
75: arhend += arh.ar_size;
76: }
77: namesw = 1;
78: }
79:
80: /*
81: * Process old form stuff.
82: */
83: old_nout(at)
84: long at;
85: {
86: struct ldheader ldh;
87: struct ldsym *sym, *s;
88: register unsigned i, syms, ct;
89: long toSym;
90: short type;
91: extern char *realloc();
92:
93: fseek(fd, at, 0);
94: xread(&ldh, sizeof(ldh), "n.out header");
95: if (!ldh.l_ssize[L_SYM]) {
96: printf("No symbols in %s\n", fname);
97: return;
98: }
99:
100: if (namesw)
101: printf("%s:\n", fname);
102:
103: canshort(ldh.l_machine);
104: toSym = ldh.l_entry + sizeof(ldh);
105:
106: for (i = 0; i < L_SYM; i++) {
107: cansize(ldh.l_ssize[i]);
108: if (i != L_BSSI && i != L_BSSD)
109: toSym += ldh.l_ssize[i];
110: }
111:
112: fseek(fd, at + toSym, 0);
113: cansize(ldh.l_ssize[L_SYM]);
114: i = ldh.l_ssize[L_SYM];
115: if (i != ldh.l_ssize[L_SYM])
116: fatal("Out of space");
117: sym = alloc(i);
118: xread(sym, i, "symbol table");
119: ct = i / sizeof(*sym);
120:
121: /* squeeze out unneeded stuff before sort */
122: for (i = syms = 0; i < ct; i++) {
123: canshort(sym[i].ls_type);
124: canshort(sym[i].ls_addr);
125: type = sym[i].ls_type;
126: if (gsw && !(type & L_GLOBAL))
127: continue;
128: if ((type & ~L_GLOBAL) == L_REF) { /* a reference */
129: if (dsw) /* list only defined */
130: continue;
131: if (usw && sym[i].ls_addr)
132: continue;
133: }
134: else if (usw)
135: continue;
136: if (!asw && !csymbol(sym + i))
137: continue;
138: if (i != syms)
139: sym[syms] = sym[i];
140: syms++;
141: }
142: sym = realloc(sym, syms * sizeof(*sym));
143:
144: if (nsw)
145: qsort(sym, syms, sizeof(*sym), ncomp_old);
146: else if (rsw)
147: qsort(sym, syms, sizeof(*sym), rcomp_old);
148: else if (!psw)
149: qsort(sym, syms, sizeof(*sym), acomp_old);
150:
151: for (s = sym; s < (sym + syms); s++) {
152: static char *gn[] = {
153: "SI", "PI", "BI",
154: "SD", "PD", "BD",
155: " D", " ", " ",
156: " A", " C", "??"
157: };
158: static char *ln[] = {
159: "si", "pi", "bi",
160: "sd", "pd", "bd",
161: " d", " ", " ",
162: " a", " c", "??"
163: };
164: if (osw)
165: printf("%s ", fname);
166: i = s->ls_type & L_GLOBAL;
167: type = s->ls_type & ~ L_GLOBAL;
168: if (type < L_SHRI || type > L_REF)
169: type = L_REF + 1;
170: if (type == L_REF && !s->ls_addr)
171: printf(" %c", i ? 'U' : 'u');
172: else
173: printf("%04x %s",
174: s->ls_addr,
175: i ? gn[type] : ln[type]);
176: printf(" %.*s\n", NCPLN, s->ls_id);
177: }
178:
179: free(sym);
180: }
181:
182: /*
183: * This routine gets called if we
184: * are not in '-a' mode. It determines if
185: * the symbol pointed to by 'sp' is a C
186: * style symbol (trailing '_' or longer than
187: * (NCPLN-1) characters). If it is it eats the '_'
188: * and returns true.
189: */
190: csymbol(sp)
191: register struct ldsym *sp;
192: {
193: register char *cp1, *cp2;
194:
195: cp1 = &sp->ls_id[0];
196: cp2 = &sp->ls_id[NCPLN];
197: while (cp2!=cp1 && *--cp2==0)
198: ;
199: if (*cp2 != 0) {
200: if (*cp2 == '_') {
201: *cp2 = 0;
202: return (1);
203: }
204: if (cp2-cp1 >= (NCPLN-1))
205: return (1);
206: }
207: return (0);
208: }
209:
210: /*
211: * Note some #defines in these include files interferes with
212: * items in preceeding include files. Hence the strange
213: * program order.
214: */
215: #include <coff.h>
216: #include <arcoff.h>
217:
218: #define cx(x) case C_ ## x: printf("%6.6s ", #x); break
219: #define ct(x) case T_ ## x: printf("%6.6s ", #x); break
220:
221: static char helpmsg[] =
222: "-d list only defined symbols\n"
223: "-g print only global symbols\n"
224: "-n list numerically not alphabetically\n"
225: "-o append file name to each line\n"
226: "-p print symbols in symbol table order\n"
227: "-r print in reverse alpha order\n"
228: "-u print only undefined symbols\n"
229: "-v print coff type symbols\n";
230:
231: FILEHDR fh;
232: SCNHDR *scns;
233:
234: /*
235: * Symbol name.
236: */
237: static char *
238: symName(sym, work)
239: SYMENT *sym;
240: char *work;
241: {
242: if (!sym->n_zeroes)
243: return (str_tab + sym->n_offset - 4);
244:
245: /* make sure it's zero terminated */
246: memcpy(work, sym->n_name, SYMNMLEN);
247: work[SYMNMLEN] = '\0';
248: return (work);
249: }
250:
251: main(argc, argv)
252: char *argv[];
253: {
254: char c;
255: extern int optind;
256: extern char *optarg;
257:
258: while (EOF != (c = getopt(argc, argv, "adgnopruv?"))) {
259: switch (c) {
260: case '?':
261: printf(helpmsg);
262: break;
263: case 'a':
264: asw = 1;
265: case 'd':
266: dsw = 1;
267: break;
268: case 'g':
269: gsw = 1;
270: break;
271: case 'n':
272: nsw = 1;
273: break;
274: case 'o':
275: osw = 1;
276: break;
277: case 'p':
278: psw = 1;
279: break;
280: case 'r':
281: rsw = 1;
282: break;
283: case 'u':
284: usw = 1;
285: break;
286: case 'v':
287: vsw = 1;
288: break;
289: default:
290: printf("usage: nm [-dgnopruv?] file ...\n");
291: exit(1);
292: }
293: }
294:
295: if ((psw + rsw + nsw) > 1)
296: fatal("More than one sort order");
297:
298: namesw = (argc - optind) > 1;
299: for (; optind < argc; optind++) {
300: fd = xopen(fname = argv[optind], "rb");
301:
302: readHeaders(0L, 0L);
303: fclose(fd);
304: }
305:
306: exit (0);
307: }
308:
309: static
310: xread(to, size, msg)
311: char *to;
312: unsigned size;
313: char *msg;
314: {
315: if (1 != fread(to, size, 1, fd))
316: fatal("Error reading %s - %s", fname, msg);
317: }
318:
319: static
320: readHeaders(at, size)
321: long at, size;
322: {
323: unsigned i;
324:
325: xread(&fh, sizeof(fh), "coff header");
326: if (C_386_MAGIC != fh.f_magic) {
327: if (!memcmp(ARMAG, &fh, SARMAG))
328: return(archive(at));
329:
330: canshort(fh.f_magic);
331: if (fh.f_magic == OLD_ARMAG)
332: return (old_ar(fname, at));
333: if (fh.f_magic == L_MAGIC)
334: return (old_nout(at));
335: printf("Inappropriate filetype %s\n", fname);
336: return (0);
337: }
338: if (fh.f_opthdr) /* pass opt hdr */
339: fseek(fd, at + sizeof(fh) + fh.f_opthdr, 0);
340: scns = alloc(i = (fh.f_nscns * sizeof(SCNHDR)));
341: xread(scns, i, "section headers");
342:
343: if (fh.f_nsyms)
344: readSymbols(at, size);
345: else
346: printf("No symbols in %s\n", fname);
347:
348: }
349:
350: /*
351: * Sort by alpha.
352: */
353: acomp(s1, s2)
354: SYMENT *s1, *s2;
355: {
356: char w1[SYMNMLEN + 1], w2[SYMNMLEN + 1];
357:
358: return (strcmp(symName(s1, w1), symName(s2, w2)));
359: }
360:
361: /*
362: * Sort by reverse alpha.
363: */
364: rcomp(s1, s2)
365: SYMENT *s1, *s2;
366: {
367: char w1[SYMNMLEN + 1], w2[SYMNMLEN + 1];
368:
369: return (- strcmp(symName(s1, w1), symName(s2, w2)));
370: }
371:
372: /*
373: * Sort by value;
374: */
375: ncomp(s1, s2)
376: SYMENT *s1, *s2;
377: {
378: long i;
379:
380: if (!(i = (s1->n_value - s2->n_value)))
381: return (0);
382: if (i < 0)
383: return (-1);
384: return (1);
385: }
386:
387: static
388: readSymbols(at, size)
389: long at;
390: {
391: register SYMENT *s;
392: SYMENT *sym;
393: long str_len;
394: unsigned len;
395: int i, aux, syms;
396: extern char *realloc();
397:
398: /* read whole symbol table */
399: fseek(fd, at + fh.f_symptr, 0);
400: len = str_len = SYMESZ * fh.f_nsyms;
401: if (str_len != len)
402: fatal("Cannot process small model");
403: sym = alloc(len);
404: xread(sym, len, "symbol table");
405:
406: /* squeeze out unneeded stuff before sort */
407: for (i = aux = syms = 0; i < fh.f_nsyms; i++) {
408: if (aux) {
409: aux--;
410: continue;
411: }
412: s = sym + i;
413: aux = s->n_numaux;
414: switch (s->n_sclass) {
415: case C_EXT:
416: if (s->n_scnum || s->n_value) { /* defined */
417: if (usw) /* print only undefined */
418: continue;
419: } else { /* undefined */
420: if (dsw) /* print only defined */
421: continue;
422: }
423: break;
424: case C_EXTDEF:
425: if (dsw)
426: continue;
427: break;
428: case C_STAT:
429: if (gsw || usw)
430: continue;
431: switch (s->n_scnum) {
432: case 1:
433: if (!strcmp(s->n_name, ".text"))
434: continue;
435: break;
436: case 2:
437: if (!strcmp(s->n_name, ".data"))
438: continue;
439: break;
440: case 3:
441: if (!strcmp(s->n_name, ".bss"))
442: continue;
443: break;
444: }
445: break;
446: default:
447: if (!vsw)
448: continue;
449: }
450: if (i != syms)
451: sym[syms] = *s;
452: syms++;
453: }
454: sym = realloc(sym, syms * SYMESZ);
455:
456: str_len = 0;
457: if (!size || ((fh.f_symptr + len + sizeof(long)) < size))
458: if (1 != fread(&str_len, sizeof(str_len), 1, fd))
459: str_len = 0;
460: if (str_len) {
461: len = str_len -= 4;
462: if (len != str_len)
463: fatal("Cannot process small model");
464: str_tab = alloc(len);
465: xread(str_tab, len, "string table");
466: }
467:
468: if (nsw)
469: qsort(sym, syms, SYMESZ, ncomp);
470: else if (rsw)
471: qsort(sym, syms, SYMESZ, rcomp);
472: else if (!psw)
473: qsort(sym, syms, SYMESZ, acomp);
474:
475: for (s = sym; s < (sym + syms); s++) {
476: char w1[SYMNMLEN + 1], *n;
477:
478: i = strlen(n = symName(s, w1));
479:
480: if (osw)
481: printf("%s ", fname);
482:
483: /* display section name */
484: switch (s->n_scnum) {
485: case N_DEBUG:
486: printf("DEBUG ");
487: break;
488: case N_ABS:
489: printf("ABSOLUTE ");
490: break;
491: case N_TV:
492: printf("TV ");
493: break;
494: case N_UNDEF:
495: if (s->n_value)
496: printf(".comm ");
497: else
498: printf("UNDEF ");
499: break;
500: default:
501: printf("%-8.8s ", scns[s->n_scnum - 1].s_name);
502: }
503:
504: if (vsw) { /* print coff type data */
505: /* display storage class */
506: switch (s->n_sclass) {
507: cx(EFCN);
508: cx(NULL);
509: cx(AUTO);
510: cx(EXT);
511: cx(STAT);
512: cx(REG);
513: cx(EXTDEF);
514: cx(LABEL);
515: cx(ULABEL);
516: cx(MOS);
517: cx(ARG);
518: cx(STRTAG);
519: cx(MOU);
520: cx(UNTAG);
521: cx(TPDEF);
522: cx(USTATIC);
523: cx(ENTAG);
524: cx(MOE);
525: cx(REGPARM);
526: cx(FIELD);
527: cx(BLOCK);
528: cx(FCN);
529: cx(EOS);
530: cx(FILE);
531: default:
532: printf("unknown ");
533: }
534:
535: if (s->n_type & N_TMASK) {
536: if (ISPTR(s->n_type))
537: printf("pointer ");
538: else if (ISFCN(s->n_type))
539: printf("function ");
540: else if (ISARY(s->n_type))
541: printf("array ");
542: else if (ISTAG(s->n_type))
543: printf("struct ");
544: else if (INCREF(s->n_type))
545: printf("union ");
546: else if (DECREF(s->n_type))
547: printf("enum ");
548: }
549: else
550: printf("- ");
551:
552: /* display type */
553: switch (BTYPE(s->n_type)) {
554: ct(NULL);
555: ct(ARG);
556: ct(CHAR);
557: ct(SHORT);
558: ct(INT);
559: ct(LONG);
560: ct(FLOAT);
561: ct(DOUBLE);
562: ct(STRUCT);
563: ct(UNION);
564: ct(ENUM);
565: ct(MOE);
566: ct(UCHAR);
567: ct(USHORT);
568: ct(UINT);
569: ct(ULONG);
570: default:
571: printf("unknown ");
572: }
573: }
574:
575: printf("%08lX %s\n", s->n_value, n);
576: }
577: free(sym);
578: }
579:
580: /*
581: * Print members of archive.
582: */
583: archive(at)
584: long at;
585: {
586: long arhend;
587: struct ar_hdr coff_arh;
588: struct old_ar_hdr arh;
589: char *p;
590: extern char *strchr();
591:
592: namesw = 0;
593: for (arhend = at + SARMAG; ; ) {
594: fseek(fd, arhend, 0);
595: if (1 != fread(&coff_arh, sizeof(coff_arh), 1, fd))
596: break;
597: memset(&arh, '\0', sizeof(arh));
598: memcpy(arh.ar_name, coff_arh.ar_name, DIRSIZ);
599: if (NULL != (p = strchr(arh.ar_name, '/')))
600: *p = '\0';
601:
602: sscanf(coff_arh.ar_date, "%ld %d %d %o %ld",
603: &arh.ar_date, &arh.ar_uid,
604: &arh.ar_gid, &arh.ar_mode, &arh.ar_size);
605:
606: arhend += sizeof(coff_arh);
607: if (arh.ar_name[0]) {
608: printf("%s(%s)\n", fname, arh.ar_name);
609: readHeaders(arhend, arh.ar_size);
610: }
611: arhend += arh.ar_size;
612: if (arhend & 1)
613: arhend++;
614: }
615: namesw = 1;
616: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.