![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / sdb|
Return to symt.c CVS log | Up to [Research Unix] / researchv10no / cmd / sdb |
1.1 root 1: static char sccsid[] = "@(#)symt.c 4.2 7/8/81";
2: #include "head.h"
3: #include <a.out.h>
4: #include <stab.h>
5:
6: #ifndef STABTYPES
7: #define STABTYPES N_STAB
8: #endif
9: #include <sys/stat.h>
10:
11: struct user u;
12: int compar();
13: char *symfil;
14:
15: #ifdef FLEXNAMES
16:
17: struct nlist *symtab;
18: char nullname[] = {0,0,0,0,0,0,0,0,0}; /* a few 0 bytes */
19: off_t stoff;
20:
21: stread(buff, nbytes)
22: struct nlist *buff;
23: int nbytes;
24: {
25: register int from = stoff;
26:
27: stoff += nbytes;
28: if (stoff >= gstart)
29: return (0);
30: if (nbytes < 0) {
31: from = stoff;
32: buff--;
33: }
34: from = (from - ststart);
35: *buff = symtab[from/sizeof (struct nlist)];
36: return (sizeof (struct nlist));
37: }
38:
39: stseek(off, rel)
40: long off;
41: {
42:
43: if (rel == 1)
44: stoff += off;
45: else
46: stoff = off;
47: }
48: #define bread(a,b,c) stread(b,c)
49: #define blseek(a,b,c) stseek(b,c)
50: #endif
51:
52: /* initialize file and procedure tables */
53: initfp() {
54: struct nlist stentry;
55: register struct proct *procp;
56: register struct filet *filep;
57: struct stat stbuf;
58:
59: long soffset;
60: int i, gflag = 0;
61: char class;
62: register char *p, *q;
63:
64: #ifdef FLEXNAMES
65: register struct nlist *sp;
66: int malformed = 0;
67: lseek(txtmap.ufd, gstart, 0);
68: if (read(txtmap.ufd, &ssiz, sizeof(ssiz)) != sizeof (ssiz)) {
69: printf("%s: no string table (old format?)\n", symfil);
70: exit(1);
71: }
72: strtab = (char *)malloc(ssiz);
73: if (strtab == 0) {
74: printf("no room for %d bytes of string table\n", ssiz);
75: exit(1);
76: }
77: ssiz -= sizeof (ssiz);
78: if (read(txtmap.ufd, strtab+sizeof (ssiz), ssiz) != ssiz) {
79: printf("%s: error reading string table\n", symfil);
80: exit(1);
81: }
82: i = gstart - ststart;
83: symtab = (struct nlist *)malloc(i);
84: if (symtab == 0) {
85: printf("no room for %d bytes of symbol table\n", i);
86: exit(1);
87: }
88: lseek(txtmap.ufd, ststart, 0);
89: if (read(txtmap.ufd, symtab, i) != i) {
90: printf("%s: error reading symbol table\n", symfil);
91: exit(1);
92: }
93: for (sp = &symtab[i/sizeof (struct nlist)]; --sp >= symtab; )
94: if (sp->n_un.n_strx != 0) {
95: if (sp->n_un.n_strx < sizeof (ssiz) || sp->n_un.n_strx >= ssiz) {
96: if (malformed == 0) {
97: printf("danger: mangled symbol table\n");
98: malformed = 1;
99: }
100: sp->n_un.n_name = nullname;
101: } else
102: sp->n_un.n_name = strtab + sp->n_un.n_strx;
103: } else
104: sp->n_un.n_name = nullname;
105: #endif
106: #ifndef VMUNIX
107: sbuf.fd = txtmap.ufd;
108: #endif
109: firstdata = MAXPOS;
110: soffset = ststart;
111: blseek(&sbuf,ststart,0);
112: filep = files = badfile = (struct filet *) sbrk(sizeof filep[0]);
113: procp = procs = badproc = (struct proct *) sbrk(sizeof procp[0]);
114:
115: for(;;) {
116: if (bread(&sbuf, &stentry, sizeof stentry) <
117: sizeof stentry) break;
118: class = stentry.n_type & STABMASK;
119: switch (class & STABMASK) {
120: case N_SO:
121: case N_SOL:
122: gflag++;
123: if (filep == badfile) {
124: p = sbrk(FILEINCR*sizeof filep[0]);
125: if (p < 0) {
126: perror("sdb");
127: exit(4);
128: }
129: q = p + FILEINCR*sizeof filep[0];
130: while (p > (char *) procs)
131: *--q = *--p;
132: badfile += FILEINCR;
133: procp = (struct proct *)
134: ((char *) procp +
135: FILEINCR*sizeof filep[0]);
136: procs = (struct proct *)
137: ((char *) procs +
138: FILEINCR*sizeof filep[0]);
139: badproc = (struct proct *)
140: ((char *)badproc +
141: FILEINCR*sizeof filep[0]);
142: }
143: filep->faddr = stentry.n_value;
144: filep->lineflag = (class == N_SOL);
145: filep->stf_offset = soffset;
146: #ifndef FLEXNAMES
147: p = filep->sfilename;
148: for (;;) {
149: for (i=0; i<8; i++) *p++ = stentry.n_un.n_name[i];
150: if (*(p-1) == '\0') break;
151: if (bread(&sbuf, &stentry, sizeof stentry)
152: < sizeof stentry)
153: error("Bad N_SO entry (1)");
154: if ((stentry.n_type & STABMASK) !=
155: (unsigned char) class)
156: error("Bad N_SO entry (2)");
157: soffset += sizeof stentry;
158: }
159: #else
160: filep->sfilename = stentry.n_un.n_name;
161: #endif
162: q = filep->sfilename;
163: for (p=fp; *q; *p++ = *q++) ;
164: *p = 0;
165: if (stat(filework, &stbuf) == -1)
166: printf("Warning: `%s' not found\n",
167: filep->sfilename);
168: else if (stbuf.st_mtime > symtime)
169: printf("Warning: `%s' newer than `%s'\n",
170: filep->sfilename,
171: symfil);
172: filep++;
173: break;
174:
175: case N_TEXT:
176: if (stentry.n_un.n_name[0] != '_') break;
177: case N_FUN:
178: case N_ENTRY:
179: if (procp == badproc) {
180: if (sbrk(PROCINCR*sizeof procp[0]) < 0) {
181: perror("sdb");
182: exit(4);
183: }
184: badproc += PROCINCR;
185: }
186: #ifndef FLEXNAMES
187: for(i=0; i<8; i++)
188: procp->pname[i] = stentry.n_un.n_name[i];
189: #else
190: procp->pname = stentry.n_un.n_name;
191: #endif
192: procp->paddr = stentry.n_value;
193: procp->st_offset = soffset;
194: procp->sfptr = (class != N_TEXT) ? filep - 1 : badfile;
195: procp->lineno = (class != N_TEXT) ? stentry.n_desc : 0;
196: procp->entrypt = (class & STABMASK) == N_ENTRY;
197: procp++;
198: break;
199: }
200: if (stentry.n_type & N_EXT) {
201: if (!extstart)
202: extstart = soffset;
203: if (stentry.n_type == N_DATA | N_EXT ||
204: stentry.n_type == N_BSS | N_EXT ||
205: stentry.n_value < firstdata)
206: firstdata = stentry.n_value;
207: }
208: soffset += sizeof stentry;
209: }
210: qsort(procs, procp-procs, sizeof procs[0], compar);
211: badproc->st_offset = badfile->stf_offset = soffset;
212: badproc->sfptr = procp->sfptr = badfile;
213: #ifndef FLEXNAMES
214: badproc->pname[0] = badfile->sfilename[0]=
215: procp->pname[0] = filep->sfilename[0] = '\0';
216: #else
217: badproc->pname = badfile->sfilename=
218: procp->pname = filep->sfilename = nullname;
219: #endif
220:
221: if (!gflag)
222: printf("Warning: `%s' not compiled with -g\n", symfil);
223: setcur(1);
224: }
225:
226: /* returns current procedure from state (curfile, fline) */
227: struct proct *
228: curproc() {
229: register ADDR addr;
230:
231: addr = getaddr("", fline ? fline : 1);
232: if (addr == -1) return(badproc);
233: return(adrtoprocp(addr));
234:
235: }
236:
237: /* returns procedure s, uses curproc() if s == NULL */
238:
239: struct proct *
240: findproc(s)
241: char *s; {
242: register struct proct *p, *altproc;
243:
244: if (s[0] == '\0') return(curproc());
245: altproc = badproc;
246:
247: for (p=procs; p->pname[0]; p++) {
248: if (eqpat(s, p->pname)) return(p);
249: if (p->pname[0] == '_' && eqpatr(s, p->pname+1, 1))
250: altproc = p;
251: }
252: return(altproc);
253: }
254:
255: /* returns file s containing filename */
256: struct filet *
257: findfile(s)
258: char *s; {
259: register struct filet *f;
260: if (s == 0 || *s == 0)
261: return(files); /* start at beginning if no cur file */
262: for (f=files; f->sfilename[0]; f++) {
263: if (eqpat(f->sfilename, s)) {
264: for( ; f->lineflag; f--) ;
265: if (f < files) error("Bad file array");
266: return(f);
267: }
268: }
269: return(f);
270: }
271:
272: /*
273: * slookup():
274: * looks up variable matching pat starting at (offset + sizeof stentry)
275: * in a.out, searching backwards,
276: * ignoring nested blocks to beginning to procedure.
277: * Returns its offset and symbol table entries decoded in sl_*
278: *
279: * If comblk == "*" then match both within and outside common blocks,
280: * if comblk == "" then match only outside common blocks,
281: * else match only within comblk.
282: */
283:
284: long
285: slookup(pat, poffset, stelt)
286: long poffset; char *pat; {
287: slookinit();
288: slooknext(pat, poffset, stelt, "*");
289: }
290:
291: int clevel, level, fnameflag, comfound, incomm, arghack;
292:
293: slookinit() {
294: clevel = level = fnameflag = comfound = incomm = arghack = 0;
295: }
296:
297: long
298: slooknext(pat, poffset, stelt, comblk)
299: long poffset; char *pat, *comblk; {
300: register int i;
301: register long offset;
302: char class, *q;
303: struct nlist stentry;
304: struct proct *procp, *p;
305:
306: offset = poffset + sizeof stentry;
307: if (debug) printf("slookup(%s,%d)\n",pat,offset);
308: blseek(&sbuf, offset, 0);
309: for (;; offset += sizeof stentry) {
310: if (bread(&sbuf, &stentry, sizeof stentry)
311: < sizeof stentry) break;
312: class = stentry.n_type & STABMASK;
313: switch (class & STABMASK) {
314: case 0:
315: break;
316: case N_EFUN:
317: if (arghack)
318: return (-1);
319: do {
320: if (offset < ststart)
321: return (-1);
322: if (bread(&sbuf, &stentry + 1, -sizeof(stentry)) != sizeof(stentry))
323: return (-1);
324: offset -= sizeof(stentry);
325: } while (stentry.n_type != N_BFUN);
326: arghack++;
327: offset += sizeof(stentry); /* skip BFUN */
328: blseek(&sbuf, offset + sizeof(stentry), 0);
329: level = 0;
330: break;
331: case N_BFUN:
332: return(-1);
333: case N_LBRAC:
334: if (arghack)
335: return (-1);
336: level++;
337: break;
338: case N_RBRAC:
339: level--;
340: break;
341: case N_BCOMM:
342: i = 0;
343: #ifndef FLEXNAMES
344: for (q = &stentry.n_un.n_name[7]; q>=stentry.n_un.n_name; q--) {
345: if (*q == '_') {
346: *q = '\0';
347: i++;
348: break;
349: }
350: }
351: #else
352: for (q = stentry.n_un.n_name; *q; q++)
353: continue;
354: if (*--q == '_')
355: *q = 0, i++;
356: #endif
357: if (eqpat(comblk, stentry.n_un.n_name))
358: comfound = 1;
359: if (i)
360: *q = '_';
361: incomm = 1;
362: case N_ECOML:
363: case N_ECOMM:
364: comfound = incomm = 0;
365: clevel--;
366: break;
367: default:
368: break;
369: case N_STSYM:
370: case N_GSYM:
371: case N_LCSYM:
372: case N_RSYM:
373: case N_SSYM:
374: case N_SFLD: /* well ... */
375: case N_LSYM:
376: case N_PSYM:
377: if (level > 0)
378: break;
379: if (stentry.n_un.n_name[0] == 0)
380: break;
381: if (incomm == 0 && stelt && (class != N_SSYM))
382: break;
383: if (eqstr("*", comblk) == 0) {
384: if (incomm && comfound == 0)
385: break;
386: if (incomm == 0 && comblk[0])
387: break;
388: }
389: if (eqpat(pat, stentry.n_un.n_name) == 0)
390: break;
391: sl_size = 0; /* hack */
392: sl_class = stentry.n_type & STABMASK;
393: sl_type = stentry.n_desc;
394: sl_addr = stentry.n_value;
395: #ifndef FLEXNAMES
396: for (i=0; i<8; i++) sl_name[i] =
397: stentry.n_un.n_name[i];
398: #else
399: sl_name = stentry.n_un.n_name;
400: #endif
401: if (clevel != 0) docomm(offset);
402: return(offset);
403: }
404: }
405: return(-1);
406: }
407:
408: /*
409: * Look up global variable matching pat starting at (filestart+sizeof stentry)
410: * Return its offset and symbol table entries decoded in sl_*
411: */
412: long
413: globallookup(pat, filestart, stelt)
414: char *pat; long filestart; {
415: register int offset, i;
416: struct nlist stentry;
417: int class, clevel;
418:
419: if (debug) printf("globallookup(%s,%d)\n", pat,filestart);
420: blseek(&sbuf, filestart, 0);
421: offset = filestart - sizeof stentry;
422: clevel = 0;
423: do {
424: if (bread(&sbuf, &stentry, sizeof stentry) <
425: sizeof stentry) return(-1);
426: offset += sizeof stentry;
427: } while ((stentry.n_type & STABMASK) == N_SO);
428: for (;;) {
429: class = stentry.n_type & STABMASK;
430: switch (class & STABMASK) {
431: case N_SO:
432: return(-1);
433: case N_ECOMM:
434: clevel--;
435: break;
436: case N_BCOMM:
437: clevel++;
438: break;
439: default:
440: if (eqpat(pat, stentry.n_un.n_name)
441: && stentry.n_un.n_name[0] && class & STABTYPES) {
442: sl_class = stentry.n_type & STABMASK;
443: if (sl_class != N_GSYM && sl_class != N_SSYM &&
444: sl_class != N_STSYM && sl_class != N_LCSYM) goto g1;
445: if (stelt != (sl_class == N_SSYM)) goto g1;
446: sl_size = 0;
447: sl_type = stentry.n_desc;
448: sl_addr = stentry.n_value;
449: #ifndef FLEXNAMES
450: for (i=0; i<8; i++) sl_name[i] = stentry.n_un.n_name[i];
451: #else
452: sl_name = stentry.n_un.n_name;
453: #endif
454: if (clevel != 0) docomm(offset);
455: goto g2;
456: }
457: }
458: g1: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
459: return(-1);
460: offset += sizeof stentry;
461: }
462: g2: bread(&sbuf, &stentry, sizeof stentry);
463: if (stentry.n_type&~N_EXT==N_BSS) {
464: bread(&sbuf, &stentry, sizeof stentry);
465: offset += sizeof stentry;
466: }
467: if (((stentry.n_type & STABMASK) == N_LENG) &&
468: (eqpat(sl_name, stentry.n_un.n_name)))
469: sl_size = stentry.n_value;
470:
471: if (sl_class == N_GSYM && (clevel == 0)) {
472: blseek(&sbuf, extstart, 0);
473: for(;;) {
474: if (bread(&sbuf, &stentry, sizeof stentry)
475: < sizeof stentry)
476: return(-1);
477: if (stentry.n_un.n_name[0] != '_') continue;
478: if (eqpatr(sl_name, stentry.n_un.n_name+1, 1)) {
479: sl_addr = stentry.n_value;
480: break;
481: }
482: }
483: }
484: return(offset + sizeof stentry);
485: }
486:
487: /* core address to procedure (pointer to proc array) */
488: struct proct *
489: adrtoprocp(addr)
490: ADDR addr; {
491: register struct proct *procp, *lastproc;
492: lastproc = badproc;
493: for (procp=procs; procp->pname[0]; procp++) {
494: if (procp->paddr > addr) break;
495: if (procp->entrypt == 0)
496: lastproc = procp;
497: }
498: return (lastproc);
499: }
500:
501:
502: /* core address to file (pointer to file array) */
503: struct filet *
504: adrtofilep(addr)
505: ADDR addr; {
506: register struct filet *filep;
507: for (filep=files; filep->sfilename[0]; filep++) {
508: if (filep->faddr > addr) break;
509: }
510: return (filep != files ? filep-1 : badfile);
511: }
512:
513: /*
514: * core address to linenumber
515: * Sets external exactaddr to addr if addr is NOT the first instruction
516: * of a line, set to -1 otherwise.
517: * Sets external lnfaddr to address of first statement in line.
518: */
519: long lastoffset;
520:
521: adrtolineno(addr)
522: ADDR addr; {
523: register int lineno;
524: long offset;
525: struct nlist stentry;
526:
527: exactaddr = addr;
528: lineno = lastoffset = -1;
529: offset = adrtoprocp(addr)->st_offset;
530: blseek(&sbuf, offset, 0);
531: for (;;) {
532: if (bread(&sbuf, &stentry, sizeof stentry)
533: < sizeof stentry) break;
534: if (stentry.n_type == N_SO)
535: break;
536: if (stentry.n_type == N_SLINE) {
537: if (stentry.n_value > addr)
538: break;
539: lastoffset = offset;
540: lineno = stentry.n_desc;
541: lnfaddr = stentry.n_value;
542: if (stentry.n_value == addr)
543: exactaddr = -1;
544: }
545: offset += sizeof stentry;
546: }
547: return (lineno);
548: }
549:
550:
551: /* address to a.out offset */
552: long
553: adrtostoffset(addr)
554: ADDR addr; {
555: adrtolineno(addr);
556: return(lastoffset);
557: }
558:
559:
560: /*
561: * Set (curfile, lineno) from core image.
562: * Returns 1 if there is a core image, 0 otherwise.
563: *
564: * Print the current line iff verbose is set.
565: */
566: setcur(verbose) {
567: register struct proct *procp;
568:
569: dot = *(ADDR *) (((ADDR) &u) + PC);
570:
571: if (dot == 0) {
572: printf("No core image\n");
573: goto setmain;
574: }
575: procp = adrtoprocp(dot);
576: if ((procp->sfptr) != badfile) {
577: finit(adrtofilep(procp->paddr)->sfilename);
578: ffind(adrtolineno(dot));
579: if (verbose) {
580: if (exactaddr != -1)
581: printf("0x%x in ", exactaddr);
582: #ifndef FLEXNAMES
583: printf("%.8s:", procp->pname);
584: #else
585: printf("%s:", procp->pname);
586: #endif
587: fprint();
588: }
589: return(1);
590: }
591: if (verbose) {
592: if (procp->pname[0] == '_')
593: #ifndef FLEXNAMES
594: printf("%.7s: address 0x%x\n", procp->pname+1, dot);
595: #else
596: printf("%s: address 0x%x\n", procp->pname+1, dot);
597: #endif
598: else
599: #ifndef FLEXNAMES
600: printf("%.8s: address %d\n", procp->pname, dot);
601: #else
602: printf("%s: address %d\n", procp->pname, dot);
603: #endif
604: }
605:
606: setmain:
607: procp = findproc("MAIN_");
608: if ((procp->pname[0] != 'M') || (procp->sfptr == badfile)) {
609: procp = findproc("main");
610: if ((procp->pname[0] != 'm') || (procp->sfptr == badfile)) {
611: /* printf("main not compiled with debug flag\n"); */
612: return(0);
613: }
614: }
615: finit(procp->sfptr->sfilename);
616: ffind(procp->lineno);
617: return(0);
618: }
619:
620: compar(a, b)
621: struct proct *a, *b; {
622: if (a->paddr == b->paddr) {
623: if (a->pname[0] == '_') return(-1);
624: if (b->pname[0] == '_') return(1);
625: return(0);
626: }
627: return(a->paddr < b->paddr ? -1 : 1);
628: }
629:
630: /* gets offset of file or procedure named s */
631: nametooffset(s)
632: char *s; {
633: register struct filet *f;
634: register struct proct *p;
635:
636: if (*s == '\0')
637: return(-1);
638: if (eqany('.', s)) {
639: f = findfile(s);
640: return(f->sfilename[0] ? f->stf_offset : -1);
641: }
642: p = findproc(s);
643: return(p->pname[0] ? p->st_offset : -1);
644: }
645:
646: /* returns s if its a filename, its file otherwise */
647: char *
648: nametofile(s)
649: char *s; {
650: register struct proct *p;
651:
652: if (eqany('.', s)) {
653: return(s);
654: }
655: p = findproc(s);
656: return(adrtofilep(p->paddr)->sfilename);
657: }
658:
659:
660: /* line number to address, starting at offset in a.out */
661: /* assumes that offset is within file */
662: lntoaddr(lineno, offset, file)
663: long offset; char *file; {
664: struct nlist stentry;
665: register int i, ignore = 0;
666: register int bestln=BIGNUM;
667: ADDR bestaddr;
668: char *p;
669:
670: blseek(&sbuf, offset, 0);
671:
672: do {
673: if (bread(&sbuf, &stentry, sizeof stentry) <
674: sizeof stentry) return(-1);
675: } while ((stentry.n_type & STABMASK) == N_SO);
676: for (;;) {
677: switch(stentry.n_type & STABMASK) {
678: case N_SLINE:
679: if (!ignore) {
680: if (stentry.n_desc == lineno)
681: return(stentry.n_value);
682: if (stentry.n_desc > lineno &&
683: stentry.n_desc < bestln) {
684: bestln = stentry.n_desc;
685: bestaddr = stentry.n_value;
686: }
687: }
688: break;
689:
690: case N_SO:
691: goto ret;
692:
693: case N_SOL:
694: p = file;
695: #ifndef FLEXNAMES
696: for (;;) {
697: for (i=0; i<8; i++) {
698: if (*p != stentry.n_un.n_name[i]) goto neq;
699: if (*p++ == '\0') break;
700: }
701: if (stentry.n_un.n_name[7] == '\0')
702: break;
703: if (bread(&sbuf, &stentry, sizeof stentry)
704: < sizeof stentry)
705: error("Bad N_SO entry (1)");
706: if ((stentry.n_type & STABMASK) !=
707: (unsigned char) N_SOL)
708: error("Bad N_SO entry (2)");
709: }
710: #else
711: if (strcmp(file, stentry.n_un.n_name))
712: goto neq;
713: #endif
714: ignore = 0;
715: break;
716:
717: neq: ignore++;
718: break;
719: }
720: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
721: break;
722: }
723: ret: return(bestln == BIGNUM ? -1 : bestaddr);
724: }
725:
726: /* gets address of proc:number */
727: getaddr(proc,integ)
728: char *proc; {
729: register long offset;
730: register char *s, *f;
731: ADDR addr;
732:
733: s = proc[0] ? proc : curfile;
734: if (*s == '\0')
735: return(-1);
736: offset = nametooffset(s);
737: f = nametofile(s);
738: if (debug) printf("getaddr() computed offset %d", offset);
739: if (offset == -1) {
740: addr = extaddr(proc);
741: if (addr != -1) addr += 2; /* MACHINE DEPENDENT */
742: if (debug) printf(" extaddr computed %d\n", addr);
743: return(addr);
744: }
745: if (integ)
746: addr = lntoaddr(integ, offset, s);
747: else {
748: ADDR oldaddr;
749: oldaddr = findproc(proc)->paddr + 2; /* MACHINE DEPENDENT */
750: addr = lntoaddr(adrtolineno(addr)+1, offset, f);
751: if (addr == -1)
752: addr = oldaddr;
753: }
754: if (debug) printf(" and addr %d\n", addr);
755: if (addr == -1) return(-1);
756: return(addr);
757: }
758:
759: /* returns address of external */
760: ADDR
761: extaddr(name)
762: char *name; {
763: struct nlist stentry;
764: blseek(&sbuf, extstart, 0);
765:
766: for (;;) {
767: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
768: return(-1);
769: if (stentry.n_un.n_name[0] == '_' &&
770: eqpatr(name, stentry.n_un.n_name+1, 1))
771: return(stentry.n_value);
772: }
773: }
774:
775:
776: /*
777: * Look up external data symbol matching pat starting at
778: * (filestart+sizeof stentry)
779: * Return its address in sl_addr and name in sl_name.
780: */
781: long
782: extlookup(pat, filestart)
783: char *pat; long filestart; {
784: register int offset, i;
785: struct nlist stentry;
786:
787: blseek(&sbuf, filestart, 0);
788: offset = filestart - sizeof stentry;
789: do {
790: if (bread(&sbuf, &stentry, sizeof stentry) <
791: sizeof stentry) return(-1);
792: offset += sizeof stentry;
793: } while ((stentry.n_type & STABMASK) == N_SO);
794: for (;;) {
795: if (stentry.n_un.n_name[0] == '_' &&
796: stentry.n_type == (N_DATA | N_EXT) &&
797: eqpatr(pat, stentry.n_un.n_name+1, 1)) {
798: sl_addr = stentry.n_value;
799: #ifndef FLEXNAMES
800: for (i=0; i<7; i++) sl_name[i] = stentry.n_un.n_name[i+1];
801: #else
802: sl_name = stentry.n_un.n_name;
803: #endif
804: return(offset + sizeof stentry);
805: }
806: g1: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
807: return(-1);
808: offset += sizeof stentry;
809: }
810: }
811:
812: /* find enclosing common blocks and fix up addresses */
813: docomm(offset)
814: long offset; {
815: struct nlist stentry;
816: ADDR addr;
817:
818: for (;;) {
819: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry
820: || stentry.n_type == N_BFUN
821: || stentry.n_type == N_EFUN) {
822: error("Bad common block");
823: return;
824: }
825: if ((stentry.n_type & STABMASK) == N_ECOMM) {
826: addr = extaddr(stentry.n_un.n_name);
827: if (addr == -1)
828: error("Lost common block");
829: sl_addr +=addr;
830: blseek(&sbuf, offset, 0);
831: sl_class = N_GSYM;
832: return;
833: }
834: if ((stentry.n_type & STABMASK) == N_ECOML) {
835: sl_addr += stentry.n_value;
836: blseek(&sbuf, offset, 0);
837: sl_class = N_GSYM;
838: return;
839: }
840: }
841: }
842:
843: /* determine if class is that of a variable */
844: char pctypes[] = {N_GSYM, N_STSYM, N_LCSYM, N_RSYM, N_SSYM, N_LSYM,
845: N_PSYM, 0};
846: varclass(class)
847: char class; {
848: char *p;
849:
850: for (p=pctypes; *p; p++) {
851: if (class == *p)
852: return(1);
853: }
854: return(0);
855: }
856:
857: /*
858: * address to external name
859: * returns difference between addr and address of external
860: * name returned in sl_name
861: */
862: adrtoext(addr)
863: ADDR addr; {
864: struct nlist stentry;
865: register int i, prevdiff = MAXPOS, diff;
866:
867: blseek(&sbuf, extstart, 0);
868: for (;;) {
869: if (bread(&sbuf, &stentry, sizeof stentry)
870: < sizeof stentry)
871: return (prevdiff!=MAXPOS ? prevdiff : -1);
872: if (stentry.n_type == (N_DATA | N_EXT) ||
873: stentry.n_type == (N_BSS | N_EXT)) {
874: diff = addr - stentry.n_value;
875: if (diff >= 0 && diff < prevdiff) {
876: #ifndef FLEXNAMES
877: for (i=0; i<7; i++)
878: sl_name[i] = stentry.n_un.n_name[i+1];
879: #else
880: sl_name = stentry.n_un.n_name;
881: #endif
882: if (diff == 0)
883: return(0);
884: prevdiff = diff;
885: }
886: }
887: }
888: }
889:
890: /*
891: * address to local name in procp
892: * returns difference between addr and address of local
893: * returned in sl_name
894: */
895: adrtolocal(addr, procp)
896: ADDR addr; struct proct *procp; {
897: struct nlist stentry;
898: register int i, prevdiff = MAXPOS, diff;
899:
900: blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
901: for (;;) {
902: if (bread(&sbuf, &stentry, sizeof stentry)
903: < sizeof stentry)
904: return(prevdiff!=MAXPOS ? prevdiff : -1);
905: if (stentry.n_type == N_FUN)
906: return(prevdiff!=MAXPOS ? prevdiff : -1);
907: if (stentry.n_type == N_LSYM) {
908: diff = addr - stentry.n_value;
909: if (diff >= 0 && diff < prevdiff) {
910: #ifndef FLEXNAMES
911: for (i=0; i<8; i++)
912: sl_name[i] = stentry.n_un.n_name[i];
913: #else
914: sl_name = stentry.n_un.n_name;
915: #endif
916: if (diff == 0)
917: return(0);
918: prevdiff = diff;
919: }
920: }
921: }
922: }
923:
924: /*
925: * address to parameter name in procp
926: * returns difference between addr and address of local
927: * returned in sl_name
928: */
929: adrtoparam(addr, procp)
930: ADDR addr; struct proct *procp; {
931: struct nlist stentry;
932: register int i, prevdiff = MAXPOS, diff;
933:
934: blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
935: for (;;) {
936: if (bread(&sbuf, &stentry, sizeof stentry)
937: < sizeof stentry)
938: return(prevdiff!=MAXPOS ? prevdiff : -1);
939: if (stentry.n_type == N_FUN)
940: return(prevdiff!=MAXPOS ? prevdiff : -1);
941: if (stentry.n_type == N_PSYM) {
942: diff = addr - stentry.n_value;
943: if (diff >= 0 && diff < prevdiff) {
944: #ifndef FLEXNAMES
945: for (i=0; i<8; i++)
946: sl_name[i] = stentry.n_un.n_name[i];
947: #else
948: sl_name = stentry.n_un.n_name;
949: #endif
950: if (diff == 0)
951: return(0);
952: prevdiff = diff;
953: }
954: }
955: }
956: }
957:
958: /*
959: * register number to register variable name in procp
960: * returned in sl_name
961: */
962: adrtoregvar(regno, procp)
963: ADDR regno; struct proct *procp; {
964: struct nlist stentry;
965: register int i;
966:
967: blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
968: for (;;) {
969: if (bread(&sbuf, &stentry, sizeof stentry)
970: < sizeof stentry) return(-1);
971: if (stentry.n_type == N_FUN)
972: return(-1);
973: if (stentry.n_type == N_RSYM) {
974: if (stentry.n_value == regno) {
975: #ifndef FLEXNAMES
976: for (i=0; i<8; i++)
977: sl_name[i] = stentry.n_un.n_name[i];
978: #else
979: sl_name = stentry.n_un.n_name;
980: #endif
981: return(0);
982: }
983: }
984: }
985: }
986:
987: /* sets file map for M command */
988: setmap(s)
989: char *s; {
990: union {
991: MAP *m;
992: L_INT *mp;
993: } amap;
994: int starflag = 0;
995:
996: amap.mp = 0;
997: for (; *s; s++) {
998: switch (*s) {
999: case '/':
1000: amap.m = &datmap;
1001: break;
1002: case '?':
1003: amap.m = &txtmap;
1004: break;
1005: case '*':
1006: starflag++;
1007: break;
1008: default:
1009: goto sout;
1010: }
1011: }
1012:
1013: sout: if (amap.mp == 0) {
1014: error("Map `?' or `/' must be specified");
1015: return;
1016: }
1017: if (starflag)
1018: amap.mp += 3;
1019: for (; *s; s++) {
1020: if (*s >= '0' && *s <= '9')
1021: *(amap.mp)++ = readint(&s);
1022: }
1023: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.