From b44848504fff72e226d0d3cda795231c01721c3b Mon Sep 17 00:00:00 2001 From: Howard Katseff Date: Sun, 16 Dec 1979 08:05:44 -0800 Subject: [PATCH] BSD 3 development Work on file usr/src/cmd/sdb/docomm.c.old Work on file usr/src/cmd/sdb/symt.c.old Work on file usr/src/cmd/sdb/docomm.c Work on file usr/src/cmd/sdb/symt.c Work on file usr/src/cmd/sdb/version.c Synthesized-from: 3bsd --- usr/src/cmd/sdb/docomm.c | 419 +++++++++++++++++++++++ usr/src/cmd/sdb/docomm.c.old | 418 +++++++++++++++++++++++ usr/src/cmd/sdb/symt.c | 632 +++++++++++++++++++++++++++++++++++ usr/src/cmd/sdb/symt.c.old | 629 ++++++++++++++++++++++++++++++++++ usr/src/cmd/sdb/version.c | 3 + 5 files changed, 2101 insertions(+) create mode 100644 usr/src/cmd/sdb/docomm.c create mode 100644 usr/src/cmd/sdb/docomm.c.old create mode 100644 usr/src/cmd/sdb/symt.c create mode 100644 usr/src/cmd/sdb/symt.c.old create mode 100644 usr/src/cmd/sdb/version.c diff --git a/usr/src/cmd/sdb/docomm.c b/usr/src/cmd/sdb/docomm.c new file mode 100644 index 0000000000..09b6ecb5db --- /dev/null +++ b/usr/src/cmd/sdb/docomm.c @@ -0,0 +1,419 @@ +#include +#include "head.h" +#include + +struct user u; +L_INT cntval; +INT signo; +INT adrflg; +INT pid; +ADDR userpc; +char *s; +enum {NOCOM, PRCOM, DSCOM} lastcom; + +docommand() { + register char *p; + register int i; + register ADDR addr, bkaddr; + struct proct *procp; + + cntval = 1; + adrflg = 0; + errflg = 0; + + if (scallf) { + doscall(); + setcur(1); + lastcom = NOCOM; + return; + } + + if (reflag) { /* search for regular expression */ + dore(); + lastcom = PRCOM; + return; + } + + if (cmd == '\0') { + if (integ != 0 && var[0] != '\0') { + error("Invalid command (1)"); + return; + } + if (integ != 0) { /* print line number */ + ffind(integ); + fprint(); + lastcom = PRCOM; + return; + } + if (var[0] != 0) { + printf("Unexpected null command\n"); + return; + } + } + + switch (cmd) { + + case 'Y': + debug = !debug; + break; + + case 'V': + version(); + break; + + case 'a': + if (integ) { + cpstr(args, "l\n"); + } else if (proc[0]) { + cpall(args, "T\n"); + } else { + error("Bad arguments"); + break; + } + goto setbrk; + break; + + case 'l': + setcur(1); + lastcom = NOCOM; + break; + + case 'T': + prfrx(1); + lastcom = NOCOM; + break; + + case 't': + prframe(); + lastcom = NOCOM; + break; + + case 'e': + p = args; + if (*p == '\0') { + printf("%.8s() in \"%s\"\n", + curproc()->pname, curfile); + break; + } + + while (*p != '\0') + if (*p++ == '.') goto l1; + /* argument is procedure name */ + procp = findproc(args); + if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) { + finit(adrtofilep(procp->paddr)->sfilename); + ffind(procp->lineno); + } + else printf("Can't find %s\n", args); + printf("%.8s() in \"%s\"\n", curproc()->pname, curfile); + lastcom = NOCOM; + break; + + l1: /* argument is filename */ + finit(args); + printf("\"%s\"\n", curfile); + lastcom = NOCOM; + break; + + case 'p': + if (integ) ffind(integ); + fprint(); + lastcom = PRCOM; + break; + + case 'q': + exit(0); + + case 'w': + if (integ) ffind(integ); + i = fline; + fback(WINDOW/2); + fprintn(WINDOW); + ffind(i); + lastcom = PRCOM; + break; + + case 'X': + prdebug(); + break; + + case 'z': + if (integ) ffind(integ); + fprintn(WINDOW); + lastcom = PRCOM; + break; + + case '-': + fback(integ ? integ : 1); + fpargs(); + lastcom = PRCOM; + break; + + case '+': + fforward(integ ? integ : 1); + fpargs(); + lastcom = PRCOM; + break; + + case '\n': + switch (lastcom) { + case PRCOM: + fforward(1); + fprint(); + break; + case DSCOM: + oaddr += oincr ? oincr : typetosize(otype, WORDSIZE); + printf("0x%x/ ", oaddr); + dispf((ADDR) oaddr, odesc, + oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0); + break; + } + break; + + case '\004': + fforward(1); + printf("\b"); + fprintn(WINDOW); + lastcom = PRCOM; + break; + + case 'r': + if (args[0] == '\0') getargs(); + case 'R': + signo = 0; + cpstr(oldargs, args); + if (debug) error("calling dopcs"); + if (integ) cntval = integ; + if (!executing) { + executing = TRUE; + if (integ) cntval = integ; + dopcs('r'); + executing = FALSE; + } + if (debug) error("exiting dopcs"); + bkaddr = -1; + goto f1; + + case 'c': + signo = 0; + case 'C': + if (proc[0] != '\0' || integ != 0) { + dot = getaddr(proc, integ); + if (dot == -1) { + error("Cannot set temporary breakpoint"); + break; + } + dopcs('b'); + bkaddr = dot; + } else + bkaddr = -1; + integ = atoi(args); + +f1: if (debug) error("calling dopcs"); + if (integ) cntval = integ; + dopcs('c'); + if (debug) error("exiting dopcs"); + if (bkaddr != -1) { + ADDR dotsave; + dotsave = dot; + dot = bkaddr; + dopcs('d'); + dot = dotsave; + } + if (!signo) printf("Breakpoint"); + printf(" at\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'S': + case 's': + signo = 0; + integ = atoi(args); + singstep(integ ? integ : 1, cmd); + if (signo) printf("\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'g': + if (pid == 0 || signo) { + error("Not stopped at breakpoint"); + } + dot = getaddr(proc, integ); + if (dot == -1) { + error("Bad address"); + break; + } + adrflg = 1; + integ = atoi(args); + if (integ) cntval = integ; + dopcs('c'); + if (!signo) printf("Breakpoint"); + printf(" at\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'k': + if (scallx) { + userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs; + *(ADDR *)(((ADDR)&u)+FP) = fps; + *(ADDR *)(((ADDR)&u)+AP) = aps; + if (bkpts) + bkpts->flag = flagss; + scallx = 0; + error("Procedure killed"); + longjmp(env, 0); + } else { + dopcs('k'); + printf("\n"); + lastcom = NOCOM; + break; + } + + case 'B': + prbkpt(); + break; + + case 'b': + setbrk: + if (proc[0] == '\0' && integ == 0) { + integ = fline; + } + dot = getaddr(proc,integ); + if (dot == -1 || dot == 0) { + error("Cannot set breakpoint"); + break; + } + dopcs('b'); + s = " b\n"; + s[1] = cmd; + printbkpt(s, adrtoprocp(dot)->pname, + adrtolineno(dot)); + break; + + case 'd': + if (proc[0] == '\0' && integ == 0) { + idbkpt(); + break; + } + dot = getaddr(proc,integ); + if (dot == -1) { + error("Non existent breakpoint"); + break; + } + dopcs('d'); + break; + + case 'D': + dabkpt(); + error("All breakpoints deleted"); + break; + + case 'm': + addr = varaddr(proc[0] ? proc : curproc()->pname, var); + printf("stopped with value %d\n", monex(addr, 'd')); + setcur(1); + lastcom = NOCOM; + break; + + case '/': + if (var[0] == '.' && var[1] == '\0') { + if (integ == 0) integ = oaddr; + dispf((ADDR) integ, args[0] ? args : odesc, + oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0); + oaddr = integ; + } else + if (integ && (var[0] == '\0')) { + dispf((ADDR) integ, args, N_GSYM, 0, 0, 0); + oaddr = integ; + cpstr(odesc, args); + oclass = N_GSYM; + otype = 0; + } else + dispvar(proc, var, args); + lastcom = DSCOM; + break; + + case '=': + if (var[0] == '\0') { + if (proc[0]) { + addr = getaddr(proc, integ); + if (addr == -1) { + error("Unknown address"); + break; + } + } + else + addr = integ; + dispf(addr, args[0] ? args : "x", 0, -1, 0, 0); + } else + findvar(proc, var, args[0] ? args : "x", 2); + break; + + case '!': + if (var[0] == '\0') + addr = getaddr(proc, integ); + else + addr = varaddr(proc, var); + if (addr == -1) + error("Unknown variable"); + else { + if (number(args[0]) || eqany(args[0], ".-")) { + char *p; + double atof(); + union { + struct{ + int w1, w2; + }; + struct { + double d; + }; + } dbl; + + p = (args[0] == '-') ? args+1 : args; + for (; *p != '.' && *p != 'e'; p++) { + if (!number(*p)) goto l2; + } + dbl.d = atof(args); + putval(addr, 'd', dbl.w1); + if (typetodesc(sl_type,0)[0] == 'g') + putval(addr+WORDSIZE, 'd', dbl.w2); + break; + } +l2: if (sl_class == N_RSYM && addr < 16) + putreg(addr,typetodesc(sl_type,subflag)[0], + argvalue(args)); + else + putval(addr,typetodesc(sl_type,subflag)[0], + argvalue(args)); + } + lastcom = NOCOM; + break; + + case '"': + printf(args); + break; + } +} + +fpargs() { + register int i; + + switch(args[0]) { + case 'p': + case '\0': + fprint(); + break; +case 'w': + i = fline; + fback(WINDOW/2); + fprintn(WINDOW); + ffind(i); + break; + case 'z': + fprintn(WINDOW); + break; + } +} diff --git a/usr/src/cmd/sdb/docomm.c.old b/usr/src/cmd/sdb/docomm.c.old new file mode 100644 index 0000000000..8d2c8c7d47 --- /dev/null +++ b/usr/src/cmd/sdb/docomm.c.old @@ -0,0 +1,418 @@ +#include +#include "head.h" +#include + +struct user u; +L_INT cntval; +INT signo; +INT adrflg; +INT pid; +ADDR userpc; +char *s; +enum {NOCOM, PRCOM, DSCOM} lastcom; + +docommand() { + register char *p; + register int i; + register ADDR addr, bkaddr; + struct proct *procp; + + cntval = 1; + adrflg = 0; + errflg = 0; + + if (scallf) { + doscall(); + setcur(1); + lastcom = NOCOM; + return; + } + + if (reflag) { /* search for regular expression */ + dore(); + lastcom = PRCOM; + return; + } + + if (cmd == '\0') { + if (integ != 0 && var[0] != '\0') { + error("Invalid command (1)"); + return; + } + if (integ != 0) { /* print line number */ + ffind(integ); + fprint(); + lastcom = PRCOM; + return; + } + if (var[0] != 0) { + printf("Unexpected null command\n"); + return; + } + } + + switch (cmd) { + + case 'Y': + debug = !debug; + break; + + case 'V': + version(); + break; + + case 'a': + if (integ) { + cpstr(args, "l\n"); + } else if (proc[0]) { + cpall(args, "T\n"); + } else { + error("Bad arguments"); + break; + } + goto setbrk; + break; + + case 'l': + setcur(1); + lastcom = NOCOM; + break; + + case 'T': + prfrx(1); + lastcom = NOCOM; + break; + + case 't': + prframe(); + lastcom = NOCOM; + break; + + case 'e': + p = args; + if (*p == '\0') { + printf("%.8s() in \"%s\"\n", + curproc()->pname, curfile); + break; + } + + while (*p != '\0') + if (*p++ == '.') goto l1; + /* argument is procedure name */ + procp = findproc(args); + if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) { + finit(adrtofilep(procp->paddr)->sfilename); + ffind(procp->lineno); + } + else printf("Can't find %s\n", args); + printf("%.8s() in \"%s\"\n", curproc()->pname, curfile); + lastcom = NOCOM; + break; + + l1: /* argument is filename */ + finit(args); + printf("\"%s\"\n", curfile); + lastcom = NOCOM; + break; + + case 'p': + if (integ) ffind(integ); + fprint(); + lastcom = PRCOM; + break; + + case 'q': + exit(0); + + case 'w': + if (integ) ffind(integ); + i = fline; + fback(WINDOW/2); + fprintn(WINDOW); + ffind(i); + lastcom = PRCOM; + break; + + case 'X': + prdebug(); + break; + + case 'z': + if (integ) ffind(integ); + fprintn(WINDOW); + lastcom = PRCOM; + break; + + case '-': + fback(integ ? integ : 1); + fpargs(); + lastcom = PRCOM; + break; + + case '+': + fforward(integ ? integ : 1); + fpargs(); + lastcom = PRCOM; + break; + + case '\n': + switch (lastcom) { + case PRCOM: + fforward(1); + fprint(); + break; + case DSCOM: + oaddr += oincr ? oincr : typetosize(otype, WORDSIZE); + printf("0x%x/ ", oaddr); + dispf((ADDR) oaddr, odesc, + oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0); + break; + } + break; + + case '\004': + fforward(1); + printf("\b"); + fprintn(WINDOW); + lastcom = PRCOM; + break; + + case 'r': + if (args[0] == '\0') getargs(); + case 'R': + signo = 0; + cpstr(oldargs, args); + if (debug) error("calling dopcs"); + if (integ) cntval = integ; + if (!executing) { + executing = TRUE; + if (integ) cntval = integ; + dopcs('r'); + executing = FALSE; + } + if (debug) error("exiting dopcs"); + bkaddr = -1; + goto f1; + + case 'c': + signo = 0; + case 'C': + if (proc[0] != '\0' || integ != 0) { + dot = getaddr(proc, integ); + if (dot == -1) { + error("Cannot set temporary breakpoint"); + break; + } + dopcs('b'); + bkaddr = dot; + } else + bkaddr = -1; + integ = atoi(args); + +f1: if (debug) error("calling dopcs"); + if (integ) cntval = integ; + dopcs('c'); + if (debug) error("exiting dopcs"); + if (bkaddr != -1) { + ADDR dotsave; + dotsave = dot; + dot = bkaddr; + dopcs('d'); + dot = dotsave; + } + if (!signo) printf("Breakpoint"); + printf(" at\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'S': + case 's': + signo = 0; + singstep(integ ? integ : 1, cmd); + if (signo) printf("\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'g': + if (pid == 0 || signo) { + error("Not stopped at breakpoint"); + } + dot = getaddr(proc, integ); + if (dot == -1) { + error("Bad address"); + break; + } + adrflg = 1; + integ = atoi(args); + if (integ) cntval = integ; + dopcs('c'); + if (!signo) printf("Breakpoint"); + printf(" at\n"); + setcur(1); + lastcom = NOCOM; + break; + + case 'k': + if (scallx) { + userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs; + *(ADDR *)(((ADDR)&u)+FP) = fps; + *(ADDR *)(((ADDR)&u)+AP) = aps; + if (bkpts) + bkpts->flag = flagss; + scallx = 0; + error("Procedure killed"); + longjmp(env, 0); + } else { + dopcs('k'); + printf("\n"); + lastcom = NOCOM; + break; + } + + case 'B': + prbkpt(); + break; + + case 'b': + setbrk: + if (proc[0] == '\0' && integ == 0) { + integ = fline; + } + dot = getaddr(proc,integ); + if (dot == -1 || dot == 0) { + error("Cannot set breakpoint"); + break; + } + dopcs('b'); + s = " b\n"; + s[1] = cmd; + printbkpt(s, adrtoprocp(dot)->pname, + adrtolineno(dot)); + break; + + case 'd': + if (proc[0] == '\0' && integ == 0) { + idbkpt(); + break; + } + dot = getaddr(proc,integ); + if (dot == -1) { + error("Non existent breakpoint"); + break; + } + dopcs('d'); + break; + + case 'D': + dabkpt(); + error("All breakpoints deleted"); + break; + + case 'm': + addr = varaddr(proc[0] ? proc : curproc()->pname, var); + printf("stopped with value %d\n", monex(addr, 'd')); + setcur(1); + lastcom = NOCOM; + break; + + case '/': + if (var[0] == '.' && var[1] == '\0') { + if (integ == 0) integ = oaddr; + dispf((ADDR) integ, args[0] ? args : odesc, + oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0); + oaddr = integ; + } else + if (integ && (var[0] == '\0')) { + dispf((ADDR) integ, args, N_GSYM, 0, 0, 0); + oaddr = integ; + cpstr(odesc, args); + oclass = N_GSYM; + otype = 0; + } else + dispvar(proc, var, args); + lastcom = DSCOM; + break; + + case '=': + if (var[0] == '\0') { + if (proc[0]) { + addr = getaddr(proc, integ); + if (addr == -1) { + error("Unknown address"); + break; + } + } + else + addr = integ; + dispf(addr, args[0] ? args : "x", 0, -1, 0, 0); + } else + findvar(proc, var, args[0] ? args : "x", 2); + break; + + case '!': + if (var[0] == '\0') + addr = getaddr(proc, integ); + else + addr = varaddr(proc, var); + if (addr == -1) + error("Unknown variable"); + else { + if (number(args[0]) || eqany(args[0], ".-")) { + char *p; + double atof(); + union { + struct{ + int w1, w2; + }; + struct { + double d; + }; + } dbl; + + p = (args[0] == '-') ? args+1 : args; + for (; *p != '.' && *p != 'e'; p++) { + if (!number(*p)) goto l2; + } + dbl.d = atof(args); + putval(addr, 'd', dbl.w1); + if (typetodesc(sl_type,0)[0] == 'g') + putval(addr+WORDSIZE, 'd', dbl.w2); + break; + } +l2: if (sl_class == N_RSYM && addr < 16) + putreg(addr,typetodesc(sl_type,subflag)[0], + argvalue(args)); + else + putval(addr,typetodesc(sl_type,subflag)[0], + argvalue(args)); + } + lastcom = NOCOM; + break; + + case '"': + printf(args); + break; + } +} + +fpargs() { + register int i; + + switch(args[0]) { + case 'p': + case '\0': + fprint(); + break; +case 'w': + i = fline; + fback(WINDOW/2); + fprintn(WINDOW); + ffind(i); + break; + case 'z': + fprintn(WINDOW); + break; + } +} diff --git a/usr/src/cmd/sdb/symt.c b/usr/src/cmd/sdb/symt.c new file mode 100644 index 0000000000..a7d46ca6ec --- /dev/null +++ b/usr/src/cmd/sdb/symt.c @@ -0,0 +1,632 @@ +#include "head.h" +#include +#include + +struct user u; +int compar(); +char *symfil; + +/* initialize file and procedure tables */ +initfp() { + struct nlist stentry; + register struct proct *procp; + register struct filet *filep; + struct stat stbuf; + + long soffset; + int i; + char class; + register char *p, *q; + + sbuf.fd = txtmap.ufd; + soffset = ststart; + blseek(&sbuf,ststart,0); + filep = files = badfile = (struct filet *) sbrk(sizeof filep[0]); + procp = procs = badproc = (struct proct *) sbrk(sizeof procp[0]); + + for(;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) break; + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case N_SO: + case N_SOL: + if (filep == badfile) { + p = sbrk(FILEINCR*sizeof filep[0]); + if (p < 0) { + perror("sdb"); + exit(4); + } + q = p + FILEINCR*sizeof filep[0]; + while (p > (char *) procs) + *--q = *--p; + badfile += FILEINCR; + procp = (struct proct *) + ((char *) procp + + FILEINCR*sizeof filep[0]); + procs = (struct proct *) + ((char *) procs + + FILEINCR*sizeof filep[0]); + badproc = (struct proct *) + ((char *)badproc + + FILEINCR*sizeof filep[0]); + } + filep->faddr = stentry.n_value; + filep->lineflag = (class == N_SOL); + filep->stf_offset = soffset; + p = filep->sfilename; + for (;;) { + for (i=0; i<8; i++) *p++ = stentry.n_name[i]; + if (*(p-1) == '\0') break; + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + error("Bad N_SO entry (1)"); + if ((stentry.n_type & STABMASK) != + (unsigned char) class) + error("Bad N_SO entry (2)"); + soffset += sizeof stentry; + } + q = filep->sfilename; + for (p=fp; *q; *p++ = *q++) ; + *p = 0; + if (stat(filework, &stbuf) == -1) + printf("Warning: `%s' not found\n", + filep->sfilename); + else if (stbuf.st_mtime > symtime) + printf("Warning: `%s' newer than `%s'\n", + filep->sfilename, + symfil); + filep++; + break; + + case N_TEXT: + if (stentry.n_name[0] != '_') break; + case N_FUN: + case N_ENTRY: + if (procp == badproc) { + if (sbrk(PROCINCR*sizeof procp[0]) < 0) { + perror("sdb"); + exit(4); + } + badproc += PROCINCR; + } + for(i=0; i<8; i++) + procp->pname[i] = stentry.n_name[i]; + procp->paddr = stentry.n_value; + procp->st_offset = soffset; + procp->sfptr = (class != N_TEXT) ? filep - 1 : badfile; + procp->lineno = (class != N_TEXT) ? stentry.n_desc : 0; + procp->entrypt = (class & STABMASK) == N_ENTRY; + procp++; + break; + } + if (stentry.n_type & N_EXT && !extstart) { + extstart = soffset; + } + soffset += sizeof stentry; + } + qsort(procs, procp-procs, sizeof procs[0], compar); + badproc->st_offset = soffset; + badproc->sfptr = procp->sfptr = badfile; + badproc->pname[0] = badfile->sfilename[0]= + procp->pname[0] = filep->sfilename[0] = '\0'; + + setcur(1); +} + +/* returns current procedure from state (curfile, fline) */ +struct proct * +curproc() { + register ADDR addr; + + addr = getaddr("", fline); + if (addr == -1) return(badproc); + return(adrtoprocp(addr)); + +} + +/* returns procedure s, uses curproc() if s == NULL */ + +struct proct * +findproc(s) +char *s; { + register struct proct *p; + + if (s[0] == '\0') return(curproc()); + + for(p=procs; p->pname[0]; p++) + if (eqstr(p->pname, s)) return(p); + + if (debug) printf("%s(): unknown name\n", s); + return(badproc); +} + +/* returns file s containing filename */ +struct filet * +findfile(s) +char *s; { + register struct filet *f; + for (f=files; f->sfilename[0]; f++) { + if (eqstr(f->sfilename, s)) { + for( ; f->lineflag; f--) ; + if (f < files) error("Bad file array"); + return(f); + } + } + return(f); +} + +/* + * slookup(): + * looks up variable matching pat starting at offset in a.out, searching + * backwards, ignoring nested blocks to beginning to procedure. + * Returns its offset and symbol table entries decoded in sl_* + * + * If comblk == "*" then match both within and outside common blocks, + * if comblk == "" then match only outside common blocks, + * else match only within comblk. + */ + +long +slookup(pat, poffset, stelt) +long poffset; char *pat; { + slookinit(); + slooknext(pat, poffset, stelt, "*"); +} + +int clevel, level, fnameflag, comfound, incomm; + +slookinit() { + clevel = level = fnameflag = comfound = incomm = 0; +} + +long +slooknext(pat, poffset, stelt, comblk) +long poffset; char *pat, *comblk; { + register int i; + register long offset; + char class, *q; + struct nlist stentry; + struct proct *procp, *p; + + offset = poffset + sizeof stentry; + if (debug) printf("slookup(%s,%d)\n",pat,offset); + blseek(&sbuf, offset, 0); + + for (;;) { + offset -= sizeof stentry; + if (offset < ststart) break; + if (bread(&sbuf, &stentry+1, -sizeof stentry) + < sizeof stentry) break; + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case 0: + break; + case N_FUN: + return(-1); + case N_RBRAC: + level++; + break; + case N_LBRAC: + level--; + break; + case N_ECOMM: + for (q = &stentry.n_name[7]; q>=stentry.n_name; q--) { + if (*q == '_') { + *q = '\0'; + break; + } + } + if (eqpat(comblk, stentry.n_name)) + comfound = 1; + incomm = 1; + case N_ECOML: + clevel++; + break; + case N_BCOMM: + comfound = incomm = 0; + clevel--; + break; + case N_FNAME: + if (fnameflag) + break; + procp = findproc(stentry.n_name); + for (p=procs; p->pname[0]; p++) { + if (p->entrypt == 0 && + p->st_offset > procp->st_offset && + p->st_offset < offset) + offset = p->st_offset; + } + clevel = level = 0; + fnameflag++; + blseek(&sbuf, offset, 0); + break; + default: + if (level <= 0 && eqpat(pat, stentry.n_name) && + stentry.n_name[0] && class & STABTYPES && + (eqstr("*", comblk) || + (comblk[0] == '\0' && incomm == 0) || + comfound) && + (stelt == (class == N_SSYM))) { + if (class == N_LENG) { + sl_size = stentry.n_value; + offset -= sizeof stentry; + bread(&sbuf, &stentry+1, + -sizeof stentry); + } + else sl_size = 0; + sl_class = stentry.n_type & STABMASK; + sl_type = stentry.n_desc; + sl_addr = stentry.n_value; + for (i=0; i<8; i++) sl_name[i] = + stentry.n_name[i]; + if (clevel != 0) docomm(offset); + return(offset - sizeof stentry); + } + } + } + return(-1); +} + +/* + * Look up global variable matching pat + * Return its offset and symbol table entries decoded in sl_* + */ +long +globallookup(pat, filestart, stelt) +char *pat; long filestart; { + register int offset, i; + struct nlist stentry; + int class, clevel; + + if (debug) printf("globallookup(%s,%d)\n", pat,filestart); + blseek(&sbuf, filestart, 0); + offset = filestart - sizeof stentry; + clevel = 0; + do { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) return(-1); + offset += sizeof stentry; + } while ((stentry.n_type & STABMASK) == N_SO); + for (;;) { + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case N_SO: + return(-1); + case N_ECOMM: + clevel--; + break; + case N_BCOMM: + clevel++; + break; + default: + if (eqpat(pat, stentry.n_name) + && stentry.n_name[0] && class & STABTYPES) { + sl_class = stentry.n_type & STABMASK; + if (sl_class != N_GSYM && sl_class != N_SSYM && + sl_class != N_STSYM) goto g1; + if (stelt != (sl_class == N_SSYM)) goto g1; + sl_size = 0; + sl_type = stentry.n_desc; + sl_addr = stentry.n_value; + for (i=0; i<8; i++) sl_name[i] = stentry.n_name[i]; + if (clevel != 0) docomm(offset); + goto g2; + } + } +g1: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + return(-1); + offset += sizeof stentry; + } +g2: bread(&sbuf, &stentry, sizeof stentry); + if (((stentry.n_type & STABMASK) == N_LENG) && + (eqpat(sl_name, stentry.n_name))) + sl_size = stentry.n_value; + + if (sl_class == N_GSYM && (clevel == 0)) { + blseek(&sbuf, extstart, 0); + for(;;) { + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + return(-1); + if (stentry.n_name[0] != '_') continue; + if (eqpatr(sl_name, stentry.n_name+1, 1)) { + sl_addr = stentry.n_value; + break; + } + } + } + return(offset + sizeof stentry); +} + +/* core address to procedure (pointer to proc array) */ +struct proct * +adrtoprocp(addr) +ADDR addr; { + register struct proct *procp, *lastproc; + lastproc = badproc; + for (procp=procs; procp->pname[0]; procp++) { + if (procp->paddr > addr) break; + if (procp->entrypt == 0) + lastproc = procp; + } + return (lastproc); +} + + +/* core address to file (pointer to file array) */ +struct filet * +adrtofilep(addr) +ADDR addr; { + register struct filet *filep; + for (filep=files; filep->sfilename[0]; filep++) { + if (filep->faddr > addr) break; + } + return (filep != files ? filep-1 : badfile); +} + +/* core address to linenumber */ +long lastoffset; + +adrtolineno(addr) +ADDR addr; { + register int lineno; + long offset; + struct nlist stentry; + + lineno = lastoffset = -1; + offset = adrtoproc(addr)->st_offset; + blseek(&sbuf, offset, 0); + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) break; + if (stentry.n_type == N_SLINE) { + if (stentry.n_value > addr) break; + lastoffset = offset; + lineno = stentry.n_desc; + } + offset += sizeof stentry; + } + return (lineno); +} + + +/* address to a.out offset */ +long +adrtostoffset(addr) +ADDR addr; { + adrtolineno(addr); + return(lastoffset); +} + + +/* + * Set (curfile, lineno) from core image. + * Returns 1 if there is a core image, 0 otherwise. + * + * Print the current line iff verbose is set. + */ +setcur(verbose) { + register struct proct *procp; + + dot = *(ADDR *) (((ADDR) &u) + PC); + + if (dot == 0) { + printf("No core image\n"); + goto setmain; + } + procp = adrtoprocp(dot); + if ((procp->sfptr) != badfile) { + finit(adrtofilep(procp->paddr)->sfilename); + ffind(adrtolineno(dot)); + if (verbose) { + printf("%.8s:", procp->pname); + fprint(); + } + return(1); + } + if (verbose) { + if (procp->pname[0] == '_') + printf("%.7s: address 0x%x\n", procp->pname+1, dot); + else + printf("%.8s: address %d\n", procp->pname, dot); + } + +setmain: + procp = findproc("MAIN_"); + if ((procp->pname[0] != 'M') || (procp->sfptr == badfile)) { + procp = findproc("main"); + if ((procp->pname[0] != 'm') || (procp->sfptr == badfile)) { + nolines = 1; + printf("main not compiled with debug flag\n"); + return(0); + } + } + finit(procp->sfptr->sfilename); + ffind(procp->lineno); + return(0); +} + +compar(a, b) +struct proct *a, *b; { + if (a->paddr == b->paddr) { + if (a->pname[0] == '_') return(-1); + if (b->pname[0] == '_') return(1); + return(0); + } + return(a->paddr < b->paddr ? -1 : 1); +} + +/* gets offset of file or procedure named s */ +nametooffset(s) +char *s; { + register struct filet *f; + register struct proct *p; + + if (*s == '\0') + return(-1); + if (eqany('.', s)) { + f = findfile(s); + return(f->sfilename[0] ? f->stf_offset : -1); + } + p = findproc(s); + return(p->pname[0] ? p->st_offset : -1); +} +/* returns s if its a filename, its file otherwise */ +char * +nametofile(s) +char *s; { + register struct proct *p; + + if (eqany('.', s)) { + return(s); + } + p = findproc(s); + return(adrtofilep(p->paddr)->sfilename); +} + + +/* line number to address, starting at offset in a.out */ +/* assumes that offset is within file */ +lntoaddr(lineno, offset, file) +long offset; char *file; { + struct nlist stentry; + register int i, ignore = 0; + register int bestln=BIGNUM; + ADDR bestaddr; + char *p; + + blseek(&sbuf, offset, 0); + + do { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) return(-1); + } while ((stentry.n_type & STABMASK) == N_SO); + for (;;) { + switch(stentry.n_type & STABMASK) { + case N_SLINE: + if (!ignore) { + if (stentry.n_desc == lineno) + return(stentry.n_value); + if (stentry.n_desc > lineno && + stentry.n_desc < bestln) { + bestln = stentry.n_desc; + bestaddr = stentry.n_value; + } + } + break; + + case N_SO: + goto ret; + + case N_SOL: + p = file; + for (;;) { + for (i=0; i<8; i++) { + if (*p != stentry.n_name[i]) goto neq; + if (*p++ == '\0') break; + } + if (stentry.n_name[7] == '\0') + break; + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + error("Bad N_SO entry (1)"); + if ((stentry.n_type & STABMASK) != + (unsigned char) N_SOL) + error("Bad N_SO entry (2)"); + } + ignore = 0; + break; + +neq: ignore++; + break; + } + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + break; + } +ret: return(bestln == BIGNUM ? -1 : bestaddr); +} + +/* gets address of proc:number */ +getaddr(proc,integ) +char *proc; { + register long offset; + register char *s, *f; + ADDR addr; + + s = proc[0] ? proc : curfile; + if (*s == '\0') + return(-1); + offset = nametooffset(s); + f = nametofile(s); + if (debug) printf("getaddr() computed offset %d", offset); + if (offset == -1) { + addr = extaddr(proc); + if (addr != -1) addr += 2; /* MACHINE DEPENDENT */ + if (debug) printf(" extaddr computed %d\n", addr); + return(addr); + } + if (integ) + addr = lntoaddr(integ, offset, s); + else { + addr = findproc(proc)->paddr + 2; /* MACHINE DEPENDENT */ + addr = lntoaddr(adrtolineno(addr)+1, offset, f); + } + if (debug) printf(" and addr %d\n", addr); + if (addr == -1) return(-1); + return(addr); +} + +/* returns address of external */ +ADDR +extaddr(name) +char *name; { + struct nlist stentry; + blseek(&sbuf, extstart, 0); + + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + return(-1); + if (stentry.n_name[0] == '_' && + eqpatr(name, stentry.n_name+1, 1)) + return(stentry.n_value); + } +} + +/* find enclosing common blocks and fix up addresses */ +docomm(offset) +long offset; { + struct nlist stentry; + + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) { + error("Bad common block"); + return; + } + sl_class = N_GSYM; + if ((stentry.n_type & STABMASK) == N_ECOMM) { + sl_addr += extaddr(stentry.n_name); + blseek(&sbuf, offset, 0); + return; + } + if ((stentry.n_type & STABMASK) == N_ECOML) { + sl_addr += stentry.n_value; + blseek(&sbuf, offset, 0); + return; + } + } +} + +/* determine if class is that of a variable */ +char pctypes[] = {N_GSYM, N_STSYM, N_LCSYM, N_RSYM, N_SSYM, N_LSYM, + N_PSYM, 0}; +varclass(class) +char class; { + char *p; + + for (p=pctypes; *p; p++) { + if (class == *p) + return(1); + } + return(0); +} diff --git a/usr/src/cmd/sdb/symt.c.old b/usr/src/cmd/sdb/symt.c.old new file mode 100644 index 0000000000..82410302e7 --- /dev/null +++ b/usr/src/cmd/sdb/symt.c.old @@ -0,0 +1,629 @@ +#include "head.h" +#include +#include + +struct user u; +int compar(); +char *symfil; + +/* initialize file and procedure tables */ +initfp() { + struct nlist stentry; + register struct proct *procp; + register struct filet *filep; + struct stat stbuf; + + long soffset; + int i; + char class; + register char *p, *q; + + sbuf.fd = txtmap.ufd; + soffset = ststart; + blseek(&sbuf,ststart,0); + filep = files = badfile = (struct filet *) sbrk(sizeof filep[0]); + procp = procs = badproc = (struct proct *) sbrk(sizeof procp[0]); + + for(;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) break; + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case N_SO: + case N_SOL: + if (filep == badfile) { + p = sbrk(FILEINCR*sizeof filep[0]); + if (p < 0) { + perror("sdb"); + exit(4); + } + q = p + FILEINCR*sizeof filep[0]; + while (p > (char *) procs) + *--q = *--p; + badfile += FILEINCR; + procp = (struct proct *) + ((char *) procp + + FILEINCR*sizeof filep[0]); + procs = (struct proct *) + ((char *) procs + + FILEINCR*sizeof filep[0]); + badproc = (struct proct *) + ((char *)badproc + + FILEINCR*sizeof filep[0]); + } + filep->faddr = stentry.n_value; + filep->lineflag = (class == N_SOL); + filep->stf_offset = soffset; + p = filep->sfilename; + for (;;) { + for (i=0; i<8; i++) *p++ = stentry.n_name[i]; + if (*(p-1) == '\0') break; + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + error("Bad N_SO entry (1)"); + if ((stentry.n_type & STABMASK) != + (unsigned char) class) + error("Bad N_SO entry (2)"); + soffset += sizeof stentry; + } + if (stat(filep->sfilename, &stbuf) == -1) + printf("Warning: `%s' not found\n", + filep->sfilename); + else if (stbuf.st_mtime > symtime) + printf("Warning: `%s' newer than `%s'\n", + filep->sfilename, + symfil); + filep++; + break; + + case N_TEXT: + if (stentry.n_name[0] != '_') break; + case N_FUN: + case N_ENTRY: + if (procp == badproc) { + if (sbrk(PROCINCR*sizeof procp[0]) < 0) { + perror("sdb"); + exit(4); + } + badproc += PROCINCR; + } + for(i=0; i<8; i++) + procp->pname[i] = stentry.n_name[i]; + procp->paddr = stentry.n_value; + procp->st_offset = soffset; + procp->sfptr = (class != N_TEXT) ? filep - 1 : badfile; + procp->lineno = (class != N_TEXT) ? stentry.n_desc : 0; + procp->entrypt = (class & STABMASK) == N_ENTRY; + procp++; + break; + } + if (stentry.n_type & N_EXT && !extstart) { + extstart = soffset; + } + soffset += sizeof stentry; + } + qsort(procs, procp-procs, sizeof procs[0], compar); + badproc->st_offset = soffset; + badproc->sfptr = procp->sfptr = badfile; + badproc->pname[0] = badfile->sfilename[0]= + procp->pname[0] = filep->sfilename[0] = '\0'; + + setcur(1); +} + +/* returns current procedure from state (curfile, fline) */ +struct proct * +curproc() { + register ADDR addr; + + addr = getaddr("", fline); + if (addr == -1) return(badproc); + return(adrtoprocp(addr)); + +} + +/* returns procedure s, uses curproc() if s == NULL */ + +struct proct * +findproc(s) +char *s; { + register struct proct *p; + + if (s[0] == '\0') return(curproc()); + + for(p=procs; p->pname[0]; p++) + if (eqstr(p->pname, s)) return(p); + + if (debug) printf("%s(): unknown name\n", s); + return(badproc); +} + +/* returns file s containing filename */ +struct filet * +findfile(s) +char *s; { + register struct filet *f; + for (f=files; f->sfilename[0]; f++) { + if (eqstr(f->sfilename, s)) { + for( ; f->lineflag; f--) ; + if (f < files) error("Bad file array"); + return(f); + } + } + return(f); +} + +/* + * slookup(): + * looks up variable matching pat starting at offset in a.out, searching + * backwards, ignoring nested blocks to beginning to procedure. + * Returns its offset and symbol table entries decoded in sl_* + * + * If comblk == "*" then match both within and outside common blocks, + * if comblk == "" then match only outside common blocks, + * else match only within comblk. + */ + +long +slookup(pat, poffset, stelt) +long poffset; char *pat; { + slookinit(); + slooknext(pat, poffset, stelt, "*"); +} + +int clevel, level, fnameflag, comfound, incomm; + +slookinit() { + clevel = level = fnameflag = comfound = incomm = 0; +} + +long +slooknext(pat, poffset, stelt, comblk) +long poffset; char *pat, *comblk; { + register int i; + register long offset; + char class, *q; + struct nlist stentry; + struct proct *procp, *p; + + offset = poffset + sizeof stentry; + if (debug) printf("slookup(%s,%d)\n",pat,offset); + blseek(&sbuf, offset, 0); + + for (;;) { + offset -= sizeof stentry; + if (offset < ststart) break; + if (bread(&sbuf, &stentry+1, -sizeof stentry) + < sizeof stentry) break; + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case 0: + break; + case N_FUN: + return(-1); + case N_RBRAC: + level++; + break; + case N_LBRAC: + level--; + break; + case N_ECOMM: + for (q = &stentry.n_name[7]; q>=stentry.n_name; q--) { + if (*q == '_') { + *q = '\0'; + break; + } + } + if (eqpat(comblk, stentry.n_name)) + comfound = 1; + incomm = 1; + case N_ECOML: + clevel++; + break; + case N_BCOMM: + comfound = incomm = 0; + clevel--; + break; + case N_FNAME: + if (fnameflag) + break; + procp = findproc(stentry.n_name); + for (p=procs; p->pname[0]; p++) { + if (p->entrypt == 0 && + p->st_offset > procp->st_offset && + p->st_offset < offset) + offset = p->st_offset; + } + clevel = level = 0; + fnameflag++; + blseek(&sbuf, offset, 0); + break; + default: + if (level <= 0 && eqpat(pat, stentry.n_name) && + stentry.n_name[0] && class & STABTYPES && + (eqstr("*", comblk) || + (comblk[0] == '\0' && incomm == 0) || + comfound) && + (stelt == (class == N_SSYM))) { + if (class == N_LENG) { + sl_size = stentry.n_value; + offset -= sizeof stentry; + bread(&sbuf, &stentry+1, + -sizeof stentry); + } + else sl_size = 0; + sl_class = stentry.n_type & STABMASK; + sl_type = stentry.n_desc; + sl_addr = stentry.n_value; + for (i=0; i<8; i++) sl_name[i] = + stentry.n_name[i]; + if (clevel != 0) docomm(offset); + return(offset - sizeof stentry); + } + } + } + return(-1); +} + +/* + * Look up global variable matching pat + * Return its offset and symbol table entries decoded in sl_* + */ +long +globallookup(pat, filestart, stelt) +char *pat; long filestart; { + register int offset, i; + struct nlist stentry; + int class, clevel; + + if (debug) printf("globallookup(%s,%d)\n", pat,filestart); + blseek(&sbuf, filestart, 0); + offset = filestart - sizeof stentry; + clevel = 0; + do { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) return(-1); + offset += sizeof stentry; + } while ((stentry.n_type & STABMASK) == N_SO); + for (;;) { + class = stentry.n_type & STABMASK; + switch (class & STABMASK) { + case N_SO: + return(-1); + case N_ECOMM: + clevel--; + break; + case N_BCOMM: + clevel++; + break; + default: + if (eqpat(pat, stentry.n_name) + && stentry.n_name[0] && class & STABTYPES) { + sl_class = stentry.n_type & STABMASK; + if (sl_class != N_GSYM && sl_class != N_SSYM && + sl_class != N_STSYM) goto g1; + if (stelt != (sl_class == N_SSYM)) goto g1; + sl_size = 0; + sl_type = stentry.n_desc; + sl_addr = stentry.n_value; + for (i=0; i<8; i++) sl_name[i] = stentry.n_name[i]; + if (clevel != 0) docomm(offset); + goto g2; + } + } +g1: if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + return(-1); + offset += sizeof stentry; + } +g2: bread(&sbuf, &stentry, sizeof stentry); + if (((stentry.n_type & STABMASK) == N_LENG) && + (eqpat(sl_name, stentry.n_name))) + sl_size = stentry.n_value; + + if (sl_class == N_GSYM && (clevel == 0)) { + blseek(&sbuf, extstart, 0); + for(;;) { + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + return(-1); + if (stentry.n_name[0] != '_') continue; + if (eqpatr(sl_name, stentry.n_name+1, 1)) { + sl_addr = stentry.n_value; + break; + } + } + } + return(offset + sizeof stentry); +} + +/* core address to procedure (pointer to proc array) */ +struct proct * +adrtoprocp(addr) +ADDR addr; { + register struct proct *procp, *lastproc; + lastproc = badproc; + for (procp=procs; procp->pname[0]; procp++) { + if (procp->paddr > addr) break; + if (procp->entrypt == 0) + lastproc = procp; + } + return (lastproc); +} + + +/* core address to file (pointer to file array) */ +struct filet * +adrtofilep(addr) +ADDR addr; { + register struct filet *filep; + for (filep=files; filep->sfilename[0]; filep++) { + if (filep->faddr > addr) break; + } + return (filep != files ? filep-1 : badfile); +} + +/* core address to linenumber */ +long lastoffset; + +adrtolineno(addr) +ADDR addr; { + register int lineno; + long offset; + struct nlist stentry; + + lineno = lastoffset = -1; + offset = adrtoproc(addr)->st_offset; + blseek(&sbuf, offset, 0); + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) break; + if (stentry.n_type == N_SLINE) { + if (stentry.n_value > addr) break; + lastoffset = offset; + lineno = stentry.n_desc; + } + offset += sizeof stentry; + } + return (lineno); +} + + +/* address to a.out offset */ +long +adrtostoffset(addr) +ADDR addr; { + adrtolineno(addr); + return(lastoffset); +} + + +/* + * Set (curfile, lineno) from core image. + * Returns 1 if there is a core image, 0 otherwise. + * + * Print the current line iff verbose is set. + */ +setcur(verbose) { + register struct proct *procp; + + dot = *(ADDR *) (((ADDR) &u) + PC); + + if (dot == 0) { + printf("No core image\n"); + goto setmain; + } + procp = adrtoprocp(dot); + if ((procp->sfptr) != badfile) { + finit(adrtofilep(dot)->sfilename); + ffind(adrtolineno(dot)); + if (verbose) { + printf("%.8s:", procp->pname); + fprint(); + } + return(1); + } + if (verbose) { + if (procp->pname[0] == '_') + printf("%.7s: address 0x%x\n", procp->pname+1, dot); + else + printf("%.8s: address %d\n", procp->pname, dot); + } + +setmain: + procp = findproc("MAIN_"); + if ((procp->pname[0] != 'M') || (procp->sfptr == badfile)) { + procp = findproc("main"); + if ((procp->pname[0] != 'm') || (procp->sfptr == badfile)) { + nolines = 1; + printf("main not compiled with debug flag\n"); + return(0); + } + } + finit(procp->sfptr->sfilename); + ffind(procp->lineno); + return(0); +} + +compar(a, b) +struct proct *a, *b; { + if (a->paddr == b->paddr) { + if (a->pname[0] == '_') return(-1); + if (b->pname[0] == '_') return(1); + return(0); + } + return(a->paddr < b->paddr ? -1 : 1); +} + +/* gets offset of file or procedure named s */ +nametooffset(s) +char *s; { + register struct filet *f; + register struct proct *p; + + if (*s == '\0') + return(-1); + if (eqany('.', s)) { + f = findfile(s); + return(f->sfilename[0] ? f->stf_offset : -1); + } + p = findproc(s); + return(p->pname[0] ? p->st_offset : -1); +} +/* returns s if its a filename, its file otherwise */ +char * +nametofile(s) +char *s; { + register struct proct *p; + + if (eqany('.', s)) { + return(s); + } + p = findproc(s); + return(adrtofilep(p->paddr)->sfilename); +} + + +/* line number to address, starting at offset in a.out */ +/* assumes that offset is within file */ +lntoaddr(lineno, offset, file) +long offset; char *file; { + struct nlist stentry; + register int i, ignore = 0; + register int bestln=BIGNUM; + ADDR bestaddr; + char *p; + + blseek(&sbuf, offset, 0); + + do { + if (bread(&sbuf, &stentry, sizeof stentry) < + sizeof stentry) return(-1); + } while ((stentry.n_type & STABMASK) == N_SO); + for (;;) { + switch(stentry.n_type & STABMASK) { + case N_SLINE: + if (!ignore) { + if (stentry.n_desc == lineno) + return(stentry.n_value); + if (stentry.n_desc > lineno && + stentry.n_desc < bestln) { + bestln = stentry.n_desc; + bestaddr = stentry.n_value; + } + } + break; + + case N_SO: + goto ret; + + case N_SOL: + p = file; + for (;;) { + for (i=0; i<8; i++) { + if (*p != stentry.n_name[i]) goto neq; + if (*p++ == '\0') break; + } + if (stentry.n_name[7] == '\0') + break; + if (bread(&sbuf, &stentry, sizeof stentry) + < sizeof stentry) + error("Bad N_SO entry (1)"); + if ((stentry.n_type & STABMASK) != + (unsigned char) N_SOL) + error("Bad N_SO entry (2)"); + } + ignore = 0; + break; + +neq: ignore++; + break; + } + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + break; + } +ret: return(bestln == BIGNUM ? -1 : bestaddr); +} + +/* gets address of proc:number */ +getaddr(proc,integ) +char *proc; { + register long offset; + register char *s, *f; + ADDR addr; + + s = proc[0] ? proc : curfile; + if (*s == '\0') + return(-1); + offset = nametooffset(s); + f = nametofile(s); + if (debug) printf("getaddr() computed offset %d", offset); + if (offset == -1) { + addr = extaddr(proc); + if (addr != -1) addr += 2; /* MACHINE DEPENDENT */ + if (debug) printf(" extaddr computed %d\n", addr); + return(addr); + } + if (integ) + addr = lntoaddr(integ, offset, s); + else { + addr = findproc(proc)->paddr + 2; /* MACHINE DEPENDENT */ + addr = lntoaddr(adrtolineno(addr)+1, offset, f); + } + if (debug) printf(" and addr %d\n", addr); + if (addr == -1) return(-1); + return(addr); +} + +/* returns address of external */ +ADDR +extaddr(name) +char *name; { + struct nlist stentry; + blseek(&sbuf, extstart, 0); + + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) + return(-1); + if (stentry.n_name[0] == '_' && + eqpatr(name, stentry.n_name+1, 1)) + return(stentry.n_value); + } +} + +/* find enclosing common blocks and fix up addresses */ +docomm(offset) +long offset; { + struct nlist stentry; + + for (;;) { + if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) { + error("Bad common block"); + return; + } + sl_class = N_GSYM; + if ((stentry.n_type & STABMASK) == N_ECOMM) { + sl_addr += extaddr(stentry.n_name); + blseek(&sbuf, offset, 0); + return; + } + if ((stentry.n_type & STABMASK) == N_ECOML) { + sl_addr += stentry.n_value; + blseek(&sbuf, offset, 0); + return; + } + } +} + +/* determine if class is that of a variable */ +char pctypes[] = {N_GSYM, N_STSYM, N_LCSYM, N_RSYM, N_SSYM, N_LSYM, + N_PSYM, 0}; +varclass(class) +char class; { + char *p; + + for (p=pctypes; *p; p++) { + if (class == *p) + return(1); + } + return(0); +} diff --git a/usr/src/cmd/sdb/version.c b/usr/src/cmd/sdb/version.c new file mode 100644 index 0000000000..14fe9cd96b --- /dev/null +++ b/usr/src/cmd/sdb/version.c @@ -0,0 +1,3 @@ +version() { + error("Version 2.5+"); +} -- 2.20.1