xref: /original-bsd/old/sdb/symt.c (revision 1f3a482a) 
1 static	char sccsid[] = "@(#)symt.c 4.2 07/08/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 (-1);
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;
292 
293 slookinit() {
294 	clevel = level = fnameflag = comfound = incomm = 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 
310 	for (;;) {
311 		offset -= sizeof stentry;
312 		if (offset < ststart) break;
313 		if (bread(&sbuf, &stentry+1, -sizeof stentry)
314 			< sizeof stentry) break;
315 		class = stentry.n_type & STABMASK;
316 		switch (class & STABMASK) {
317 		case 0:
318 			break;
319 		case N_FUN:
320 			return(-1);
321 		case N_RBRAC:
322 			level++;
323 			break;
324 		case N_LBRAC:
325 			level--;
326 			break;
327 		case N_ECOMM:
328 			i = 0;
329 #ifndef FLEXNAMES
330 			for (q = &stentry.n_un.n_name[7]; q>=stentry.n_un.n_name; q--) {
331 				if (*q == '_') {
332 					*q = '\0';
333 					i++;
334 					break;
335 				}
336 			}
337 #else
338 			for (q = stentry.n_un.n_name; *q; q++)
339 				continue;
340 			if (*--q == '_')
341 				*q = 0, i++;
342 #endif
343 			if (eqpat(comblk, stentry.n_un.n_name))
344 				comfound = 1;
345 			if (i)
346 				*q = '_';
347 			incomm = 1;
348 		case N_ECOML:
349 			clevel++;
350 			break;
351 		case N_BCOMM:
352 			comfound = incomm = 0;
353 			clevel--;
354 			break;
355 		case N_FNAME:
356 			if (fnameflag)
357 				break;
358 			procp = findproc(stentry.n_un.n_name);
359 			for (p=procs; p->pname[0]; p++) {
360 				if (p->entrypt == 0 &&
361 					p->st_offset > procp->st_offset &&
362 					p->st_offset < offset)
363 						offset = p->st_offset;
364 			}
365 			clevel = level = 0;
366 			fnameflag++;
367 			blseek(&sbuf, offset, 0);
368 			break;
369 		default:
370 			if (level <= 0  &&  eqpat(pat, stentry.n_un.n_name) &&
371 				stentry.n_un.n_name[0] && class & STABTYPES &&
372 				(eqstr("*", comblk) ||
373 				 (comblk[0] == '\0' && incomm == 0) ||
374 				 comfound) &&
375 				(stelt == (class == N_SSYM))) {
376 				if (class == N_LENG) {
377 					sl_size = stentry.n_value;
378 					offset -= sizeof stentry;
379 					bread(&sbuf, &stentry+1,
380 							-sizeof stentry);
381 					if (stentry.n_type&~N_EXT == N_BSS) {
382 						bread(&sbuf, &stentry+1,
383 						    -sizeof stentry);
384 						offset -= sizeof stentry;
385 					}
386 				}
387 				else sl_size = 0;
388 				sl_class = stentry.n_type & STABMASK;
389 				sl_type = stentry.n_desc;
390 				sl_addr = stentry.n_value;
391 #ifndef FLEXNAMES
392 				for (i=0; i<8; i++) sl_name[i] =
393 						stentry.n_un.n_name[i];
394 #else
395 				sl_name = stentry.n_un.n_name;
396 #endif
397 				if (clevel != 0) docomm(offset);
398 				return(offset - sizeof stentry);
399 			}
400 		}
401 	}
402 	return(-1);
403 }
404 
405 /*
406  * Look up global variable matching pat starting at (filestart+sizeof stentry)
407  * Return its offset and symbol table entries decoded in sl_*
408  */
409 long
410 globallookup(pat, filestart, stelt)
411 char *pat; long filestart; {
412 	register int offset, i;
413 	struct nlist stentry;
414 	int class, clevel;
415 
416 	if (debug) printf("globallookup(%s,%d)\n", pat,filestart);
417 	blseek(&sbuf, filestart, 0);
418 	offset = filestart - sizeof stentry;
419 	clevel = 0;
420 	do {
421 		if (bread(&sbuf, &stentry, sizeof stentry) <
422 				sizeof stentry) return(-1);
423 		offset += sizeof stentry;
424 	} while ((stentry.n_type & STABMASK) == N_SO);
425 	for (;;) {
426 		class = stentry.n_type & STABMASK;
427 		switch (class & STABMASK) {
428 		case N_SO:
429 			return(-1);
430 		case N_ECOMM:
431 			clevel--;
432 			break;
433 		case N_BCOMM:
434 			clevel++;
435 			break;
436 		default:
437 		if (eqpat(pat, stentry.n_un.n_name)
438 				&& stentry.n_un.n_name[0] && class & STABTYPES) {
439 			sl_class = stentry.n_type & STABMASK;
440 			if (sl_class != N_GSYM && sl_class != N_SSYM &&
441 				sl_class != N_STSYM && sl_class != N_LCSYM) goto g1;
442 			if (stelt != (sl_class == N_SSYM)) goto g1;
443 			sl_size = 0;
444 			sl_type = stentry.n_desc;
445 			sl_addr = stentry.n_value;
446 #ifndef FLEXNAMES
447 			for (i=0; i<8; i++) sl_name[i] = stentry.n_un.n_name[i];
448 #else
449 			sl_name = stentry.n_un.n_name;
450 #endif
451 			if (clevel != 0) docomm(offset);
452 			goto g2;
453 		}
454 		}
455 g1:		if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
456 			return(-1);
457 		offset += sizeof stentry;
458 	}
459 g2:	bread(&sbuf, &stentry, sizeof stentry);
460 	if (stentry.n_type&~N_EXT==N_BSS) {
461 		bread(&sbuf, &stentry, sizeof stentry);
462 		offset += sizeof stentry;
463 	}
464 	if (((stentry.n_type & STABMASK) == N_LENG) &&
465 			(eqpat(sl_name, stentry.n_un.n_name)))
466 		sl_size = stentry.n_value;
467 
468 	if (sl_class == N_GSYM && (clevel == 0)) {
469 		blseek(&sbuf, extstart, 0);
470 		for(;;) {
471 			if (bread(&sbuf, &stentry, sizeof stentry)
472 					< sizeof stentry)
473 				return(-1);
474 			if (stentry.n_un.n_name[0] != '_') continue;
475 			if (eqpatr(sl_name, stentry.n_un.n_name+1, 1)) {
476 				sl_addr = stentry.n_value;
477 				break;
478 			}
479 		}
480 	}
481 	return(offset + sizeof stentry);
482 }
483 
484 /* core address to procedure (pointer to proc array) */
485 struct proct *
486 adrtoprocp(addr)
487 ADDR addr; {
488 	register struct proct *procp, *lastproc;
489 	lastproc = badproc;
490 	for (procp=procs; procp->pname[0]; procp++) {
491 		if (procp->paddr > addr) break;
492 		if (procp->entrypt == 0)
493 			lastproc = procp;
494 	}
495 	return (lastproc);
496 }
497 
498 
499 /* core address to file (pointer to file array) */
500 struct filet *
501 adrtofilep(addr)
502 ADDR addr; {
503 	register struct filet *filep;
504 	for (filep=files; filep->sfilename[0]; filep++) {
505 		if (filep->faddr > addr) break;
506 	}
507 	return (filep != files ? filep-1 : badfile);
508 }
509 
510 /*
511  * core address to linenumber
512  *  Sets external exactaddr to addr if addr is NOT the first instruction
513  * of a line, set to -1 otherwise.
514  *  Sets external lnfaddr to address of first statement in line.
515  */
516 long lastoffset;
517 
518 adrtolineno(addr)
519 ADDR addr; {
520 	register int lineno;
521 	long offset;
522 	struct nlist stentry;
523 
524 	exactaddr = addr;
525 	lineno = lastoffset = -1;
526 	offset = adrtoprocp(addr)->st_offset;
527 	blseek(&sbuf, offset, 0);
528 	for (;;) {
529 		if (bread(&sbuf, &stentry, sizeof stentry)
530 				< sizeof stentry) break;
531 		if (stentry.n_type == N_SO)
532 			break;
533 		if (stentry.n_type == N_SLINE) {
534 			if (stentry.n_value > addr)
535 				break;
536 			lastoffset = offset;
537 			lineno = stentry.n_desc;
538 			lnfaddr = stentry.n_value;
539 			if (stentry.n_value == addr)
540 				exactaddr = -1;
541 		}
542 		offset += sizeof stentry;
543 	}
544 	return (lineno);
545 }
546 
547 
548 /* address to a.out offset */
549 long
550 adrtostoffset(addr)
551 ADDR addr; {
552 	adrtolineno(addr);
553 	return(lastoffset);
554 }
555 
556 
557 /*
558  * Set (curfile, lineno) from core image.
559  * Returns 1 if there is a core image, 0 otherwise.
560  *
561  * Print the current line iff verbose is set.
562  */
563 setcur(verbose) {
564 	register struct proct *procp;
565 
566 	dot = *(ADDR *) (((ADDR) &u) + PC);
567 
568 	if (dot == 0) {
569 		printf("No core image\n");
570 		goto setmain;
571 	}
572 	procp = adrtoprocp(dot);
573 	if ((procp->sfptr) != badfile) {
574 		finit(adrtofilep(procp->paddr)->sfilename);
575 		ffind(adrtolineno(dot));
576 		if (verbose) {
577 			if (exactaddr != -1)
578 				printf("0x%x in ", exactaddr);
579 #ifndef FLEXNAMES
580 			printf("%.8s:", procp->pname);
581 #else
582 			printf("%s:", procp->pname);
583 #endif
584 			fprint();
585 		}
586 		return(1);
587 	}
588 	if (verbose) {
589 		if (procp->pname[0] == '_')
590 #ifndef FLEXNAMES
591 			printf("%.7s: address 0x%x\n", procp->pname+1, dot);
592 #else
593 			printf("%s: address 0x%x\n", procp->pname+1, dot);
594 #endif
595 		else
596 #ifndef FLEXNAMES
597 			printf("%.8s: address %d\n", procp->pname, dot);
598 #else
599 			printf("%s: address %d\n", procp->pname, dot);
600 #endif
601 	}
602 
603 setmain:
604 	procp = findproc("MAIN_");
605 	if ((procp->pname[0] != 'M') || (procp->sfptr == badfile)) {
606 		procp = findproc("main");
607 		if ((procp->pname[0] != 'm') || (procp->sfptr == badfile)) {
608 			/* printf("main not compiled with debug flag\n"); */
609 			return(0);
610 		}
611 	}
612 	finit(procp->sfptr->sfilename);
613 	ffind(procp->lineno);
614 	return(0);
615 }
616 
617 compar(a, b)
618 struct proct *a, *b; {
619 	if (a->paddr == b->paddr) {
620 		if (a->pname[0] == '_') return(-1);
621 		if (b->pname[0] == '_') return(1);
622 		return(0);
623 	}
624 	return(a->paddr < b->paddr ? -1 : 1);
625 }
626 
627 /* gets offset of file or procedure named s */
628 nametooffset(s)
629 char *s; {
630 	register struct filet *f;
631 	register struct proct *p;
632 
633 	if (*s == '\0')
634 		return(-1);
635 	if (eqany('.', s)) {
636 		f = findfile(s);
637 		return(f->sfilename[0] ? f->stf_offset : -1);
638 	}
639 	p = findproc(s);
640 	return(p->pname[0] ? p->st_offset : -1);
641 }
642 
643 /* returns s if its a filename, its file otherwise */
644 char *
645 nametofile(s)
646 char *s; {
647 	register struct proct *p;
648 
649 	if (eqany('.', s)) {
650 		return(s);
651 	}
652 	p = findproc(s);
653 	return(adrtofilep(p->paddr)->sfilename);
654 }
655 
656 
657 /* line number to address, starting at offset in a.out */
658 /* assumes that offset is within file */
659 lntoaddr(lineno, offset, file)
660 long offset; char *file; {
661 	struct nlist stentry;
662 	register int i, ignore = 0;
663 	register int bestln=BIGNUM;
664 	ADDR bestaddr;
665 	char *p;
666 
667 	blseek(&sbuf, offset, 0);
668 
669 	do {
670 		if (bread(&sbuf, &stentry, sizeof stentry) <
671 				sizeof stentry) return(-1);
672 	} while ((stentry.n_type & STABMASK) == N_SO);
673 	for (;;) {
674 		switch(stentry.n_type & STABMASK) {
675 		case N_SLINE:
676 			if (!ignore) {
677 				if (stentry.n_desc == lineno)
678 					return(stentry.n_value);
679 				if (stentry.n_desc > lineno &&
680 					stentry.n_desc < bestln) {
681 					bestln = stentry.n_desc;
682 					bestaddr = stentry.n_value;
683 				}
684 			}
685 			break;
686 
687 		case N_SO:
688 			goto ret;
689 
690 		case N_SOL:
691 			p = file;
692 #ifndef FLEXNAMES
693 			for (;;) {
694 				for (i=0; i<8; i++) {
695 					if (*p != stentry.n_un.n_name[i]) goto neq;
696 					if (*p++ == '\0') break;
697 				}
698 				if (stentry.n_un.n_name[7] == '\0')
699 					break;
700 				if (bread(&sbuf, &stentry, sizeof stentry)
701 						< sizeof stentry)
702 					error("Bad N_SO entry (1)");
703 				if ((stentry.n_type & STABMASK) !=
704 						(unsigned char) N_SOL)
705 					error("Bad N_SO entry (2)");
706 			}
707 #else
708 			if (strcmp(file, stentry.n_un.n_name))
709 				goto neq;
710 #endif
711 			ignore = 0;
712 			break;
713 
714 neq:			ignore++;
715 			break;
716 		}
717 		if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
718 			break;
719 	}
720 ret:	return(bestln == BIGNUM ? -1 : bestaddr);
721 }
722 
723 /* gets address of proc:number */
724 getaddr(proc,integ)
725 char *proc; {
726 	register long offset;
727 	register char *s, *f;
728 	ADDR addr;
729 
730 	s = proc[0] ? proc : curfile;
731 	if (*s == '\0')
732 		return(-1);
733 	offset = nametooffset(s);
734 	f = nametofile(s);
735 	if (debug) printf("getaddr() computed offset %d", offset);
736 	if (offset == -1) {
737 		addr = extaddr(proc);
738 		if (addr != -1) addr += 2;  /* MACHINE DEPENDENT */
739 		if (debug) printf(" extaddr computed %d\n", addr);
740 		return(addr);
741 	}
742 	if (integ)
743 		addr = lntoaddr(integ, offset, s);
744 	else {
745 		ADDR oldaddr;
746 		oldaddr = findproc(proc)->paddr + 2;  /* MACHINE DEPENDENT */
747 		addr = lntoaddr(adrtolineno(addr)+1, offset, f);
748 		if (addr == -1)
749 			addr = oldaddr;
750 	}
751 	if (debug) printf(" and addr %d\n", addr);
752 	if (addr == -1) return(-1);
753 	return(addr);
754 }
755 
756 /* returns address of external */
757 ADDR
758 extaddr(name)
759 char *name; {
760 	struct nlist stentry;
761 	blseek(&sbuf, extstart, 0);
762 
763 	for (;;) {
764 		if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
765 			return(-1);
766 		if (stentry.n_un.n_name[0] == '_' &&
767 			    eqpatr(name, stentry.n_un.n_name+1, 1))
768 			return(stentry.n_value);
769 	}
770 }
771 
772 
773 /*
774  * Look up external data symbol matching pat starting at
775  *  (filestart+sizeof stentry)
776  * Return its address in sl_addr and name in sl_name.
777  */
778 long
779 extlookup(pat, filestart)
780 char *pat; long filestart; {
781 	register int offset, i;
782 	struct nlist stentry;
783 
784 	blseek(&sbuf, filestart, 0);
785 	offset = filestart - sizeof stentry;
786 	do {
787 		if (bread(&sbuf, &stentry, sizeof stentry) <
788 				sizeof stentry) return(-1);
789 		offset += sizeof stentry;
790 	} while ((stentry.n_type & STABMASK) == N_SO);
791 	for (;;) {
792 		if (stentry.n_un.n_name[0] == '_' &&
793 			    stentry.n_type == (N_DATA | N_EXT) &&
794 			    eqpatr(pat, stentry.n_un.n_name+1, 1)) {
795 			sl_addr = stentry.n_value;
796 #ifndef FLEXNAMES
797 			for (i=0; i<7; i++) sl_name[i] = stentry.n_un.n_name[i+1];
798 #else
799 			sl_name = stentry.n_un.n_name;
800 #endif
801 			return(offset + sizeof stentry);
802 		}
803 g1:		if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
804 			return(-1);
805 		offset += sizeof stentry;
806 	}
807 }
808 
809 /* find enclosing common blocks and fix up addresses */
810 docomm(offset)
811 long offset; {
812 	struct nlist stentry;
813 	ADDR addr;
814 
815 	for (;;) {
816 		if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) {
817 			error("Bad common block");
818 			return;
819 		}
820 		sl_class = N_GSYM;
821 		if ((stentry.n_type & STABMASK) == N_ECOMM) {
822 			addr = extaddr(stentry.n_un.n_name);
823 			if (addr == -1)
824 				error("Lost common block");
825 			sl_addr +=addr;
826 			blseek(&sbuf, offset, 0);
827 			return;
828 		}
829 		if ((stentry.n_type & STABMASK) == N_ECOML) {
830 			sl_addr += stentry.n_value;
831 			blseek(&sbuf, offset, 0);
832 			return;
833 		}
834 	}
835 }
836 
837 /* determine if class is that of a variable */
838 char pctypes[] = {N_GSYM, N_STSYM, N_LCSYM, N_RSYM, N_SSYM, N_LSYM,
839 			N_PSYM, 0};
840 varclass(class)
841 char class; {
842 	char *p;
843 
844 	for (p=pctypes; *p; p++) {
845 		if (class == *p)
846 			return(1);
847 	}
848 	return(0);
849 }
850 
851 /*
852  * address to external name
853  * returns difference between addr and address of external
854  * name returned in sl_name
855  */
856 adrtoext(addr)
857 ADDR addr; {
858 	struct nlist stentry;
859 	register int i, prevdiff = MAXPOS, diff;
860 
861 	blseek(&sbuf, extstart, 0);
862 	for (;;) {
863 		if (bread(&sbuf, &stentry, sizeof stentry)
864 				< sizeof stentry)
865 			return (prevdiff!=MAXPOS ? prevdiff : -1);
866 		if (stentry.n_type == (N_DATA | N_EXT) ||
867 		    stentry.n_type == (N_BSS | N_EXT)) {
868 			diff = addr - stentry.n_value;
869 			if (diff >= 0 && diff < prevdiff) {
870 #ifndef FLEXNAMES
871 				for (i=0; i<7; i++)
872 					sl_name[i] = stentry.n_un.n_name[i+1];
873 #else
874 				sl_name = stentry.n_un.n_name;
875 #endif
876 				if (diff == 0)
877 					return(0);
878 				prevdiff = diff;
879 			}
880 		}
881 	}
882 }
883 
884 /*
885  * address to local name in procp
886  * returns difference between addr and address of local
887  * returned in sl_name
888  */
889 adrtolocal(addr, procp)
890 ADDR addr; struct proct *procp; {
891 	struct nlist stentry;
892 	register int i, prevdiff = MAXPOS, diff;
893 
894 	blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
895 	for (;;) {
896 		if (bread(&sbuf, &stentry, sizeof stentry)
897 				< sizeof stentry)
898 			return(prevdiff!=MAXPOS ? prevdiff : -1);
899 		if (stentry.n_type == N_FUN)
900 			return(prevdiff!=MAXPOS ? prevdiff : -1);
901 		if (stentry.n_type == N_LSYM) {
902 			diff = addr - stentry.n_value;
903 			if (diff >= 0 && diff < prevdiff) {
904 #ifndef FLEXNAMES
905 				for (i=0; i<8; i++)
906 					sl_name[i] = stentry.n_un.n_name[i];
907 #else
908 				sl_name = stentry.n_un.n_name;
909 #endif
910 				if (diff == 0)
911 					return(0);
912 				prevdiff = diff;
913 			}
914 		}
915 	}
916 }
917 
918 /*
919  * address to parameter name in procp
920  * returns difference between addr and address of local
921  * returned in sl_name
922  */
923 adrtoparam(addr, procp)
924 ADDR addr; struct proct *procp; {
925 	struct nlist stentry;
926 	register int i, prevdiff = MAXPOS, diff;
927 
928 	blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
929 	for (;;) {
930 		if (bread(&sbuf, &stentry, sizeof stentry)
931 				< sizeof stentry)
932 			return(prevdiff!=MAXPOS ? prevdiff : -1);
933 		if (stentry.n_type == N_FUN)
934 			return(prevdiff!=MAXPOS ? prevdiff : -1);
935 		if (stentry.n_type == N_PSYM) {
936 			diff = addr - stentry.n_value;
937 			if (diff >= 0 && diff < prevdiff) {
938 #ifndef FLEXNAMES
939 				for (i=0; i<8; i++)
940 					sl_name[i] = stentry.n_un.n_name[i];
941 #else
942 				sl_name = stentry.n_un.n_name;
943 #endif
944 				if (diff == 0)
945 					return(0);
946 				prevdiff = diff;
947 			}
948 		}
949 	}
950 }
951 
952 /*
953  * register number to register variable name in procp
954  * returned in sl_name
955  */
956 adrtoregvar(regno, procp)
957 ADDR regno; struct proct *procp; {
958 	struct nlist stentry;
959 	register int i;
960 
961 	blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
962 	for (;;) {
963 		if (bread(&sbuf, &stentry, sizeof stentry)
964 				< sizeof stentry) return(-1);
965 		if (stentry.n_type == N_FUN)
966 			return(-1);
967 		if (stentry.n_type == N_RSYM) {
968 			if (stentry.n_value == regno) {
969 #ifndef FLEXNAMES
970 				for (i=0; i<8; i++)
971 					sl_name[i] = stentry.n_un.n_name[i];
972 #else
973 				sl_name = stentry.n_un.n_name;
974 #endif
975 				return(0);
976 			}
977 		}
978 	}
979 }
980 
981 /* sets file map for M command */
982 setmap(s)
983 char *s; {
984 	union {
985 		MAP *m;
986 		L_INT *mp;
987 	} amap;
988 	int starflag = 0;
989 
990 	amap.mp = 0;
991 	for (; *s; s++) {
992 		switch (*s) {
993 		case '/':
994 			amap.m = &datmap;
995 			break;
996 		case '?':
997 			amap.m = &txtmap;
998 			break;
999 		case '*':
1000 			starflag++;
1001 			break;
1002 		default:
1003 			goto sout;
1004 		}
1005 	}
1006 
1007 sout:	if (amap.mp == 0) {
1008 		error("Map `?' or `/' must be specified");
1009 		return;
1010 	}
1011 	if (starflag)
1012 		amap.mp += 3;
1013 	for (; *s; s++) {
1014 		if (*s >= '0' && *s <= '9')
1015 			*(amap.mp)++ = readint(&s);
1016 	}
1017 }
1018