From 54ee732674a4962c47add910cb7c8ae5e24d5d2b Mon Sep 17 00:00:00 2001 From: Bill Joy Date: Sun, 26 Aug 1979 20:56:09 -0800 Subject: [PATCH] BSD 3 development Work on file usr/src/cmd/adb/input.c Work on file usr/src/cmd/adb/mac.h Work on file usr/src/cmd/adb/main.c Work on file usr/src/cmd/adb/mode.h Work on file usr/src/cmd/adb/message.c Work on file usr/src/cmd/adb/opset.c Work on file usr/src/cmd/adb/output.c Work on file usr/src/cmd/adb/pcs.c Work on file usr/src/cmd/adb/print.c Work on file usr/src/cmd/adb/oldsym.c Synthesized-from: 3bsd --- usr/src/cmd/adb/input.c | 106 +++++++++ usr/src/cmd/adb/mac.h | 49 +++++ usr/src/cmd/adb/main.c | 163 ++++++++++++++ usr/src/cmd/adb/message.c | 45 ++++ usr/src/cmd/adb/mode.h | 79 +++++++ "usr/src/cmd/adb/old\031sym.c" | 215 ++++++++++++++++++ usr/src/cmd/adb/opset.c | 147 +++++++++++++ usr/src/cmd/adb/output.c | 373 ++++++++++++++++++++++++++++++++ usr/src/cmd/adb/pcs.c | 119 ++++++++++ usr/src/cmd/adb/print.c | 383 +++++++++++++++++++++++++++++++++ 10 files changed, 1679 insertions(+) create mode 100644 usr/src/cmd/adb/input.c create mode 100644 usr/src/cmd/adb/mac.h create mode 100644 usr/src/cmd/adb/main.c create mode 100644 usr/src/cmd/adb/message.c create mode 100644 usr/src/cmd/adb/mode.h create mode 100644 "usr/src/cmd/adb/old\031sym.c" create mode 100644 usr/src/cmd/adb/opset.c create mode 100644 usr/src/cmd/adb/output.c create mode 100644 usr/src/cmd/adb/pcs.c create mode 100644 usr/src/cmd/adb/print.c diff --git a/usr/src/cmd/adb/input.c b/usr/src/cmd/adb/input.c new file mode 100644 index 0000000000..1c2531bd41 --- /dev/null +++ b/usr/src/cmd/adb/input.c @@ -0,0 +1,106 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)input.c 2.2); + +INT mkfault; +CHAR line[LINSIZ]; +INT infile; +CHAR *lp; +CHAR peekc,lastc = EOR; +INT eof; + +/* input routines */ + +eol(c) +CHAR c; +{ + return(c==EOR ORF c==';'); +} + +rdc() +{ REP readchar(); + PER lastc==SP ORF lastc==TB + DONE + return(lastc); +} + +readchar() +{ + IF eof + THEN lastc=EOF; + ELSE IF lp==0 + THEN lp=line; +#ifdef EDDT + getcon(lp); eof=0; while (*lp++!=EOR); +#else + REP eof = read(infile,lp,1)==0; + IF mkfault THEN error(0); FI + PER eof==0 ANDF *lp++!=EOR DONE +#endif + *lp=0; lp=line; + FI + IF lastc = peekc THEN peekc=0; + ELIF lastc = *lp THEN lp++; + FI + FI + return(lastc); +} + +nextchar() +{ + IF eol(rdc()) + THEN lp--; return(0); + ELSE return(lastc); + FI +} + +quotchar() +{ + IF readchar()=='\\' + THEN return(readchar()); + ELIF lastc=='\'' + THEN return(0); + ELSE return(lastc); + FI +} + +getformat(deformat) +STRING deformat; +{ + REG STRING fptr; + REG BOOL quote; + fptr=deformat; quote=FALSE; + WHILE (quote ? readchar()!=EOR : !eol(readchar())) + DO IF (*fptr++ = lastc)=='"' + THEN quote = ~quote; + FI + OD + lp--; + IF fptr!=deformat THEN *fptr++ = '\0'; FI +} + +#ifdef EDDT +getcon(cs) register char *cs; { +register char *p=cs; +for(;;) { + putchar(*p++=getcnsl()); + if (p[-1]=='\r') {putchar(p[-1]='\n'); *p++='\0'; return;} + if (p[-1]=='\\') {p[-1]=getcnsl(); continue;} + if (p[-1]=='#') {p -= 2; continue;} + if (p[-1]=='@') {putchar('\r'); putchar('\n'); p=cs; continue;} +}} + +getcnsl() { +# define RXCS 32 /* receiver control/staus */ +# define RXDB 33 /* receiver data */ +# define RXCS_DONE 0x80 /* receiver done */ +while ((mfpr(RXCS) & RXCS_DONE)==0); +return (mfpr(RXDB) & 0177); +} +#endif diff --git a/usr/src/cmd/adb/mac.h b/usr/src/cmd/adb/mac.h new file mode 100644 index 0000000000..9c0e0af43f --- /dev/null +++ b/usr/src/cmd/adb/mac.h @@ -0,0 +1,49 @@ +# +/* + * UNIX debugger + */ + +#define TYPE typedef +#define STRUCT struct +#define UNION union +#define REG register + +#define BEGIN { +#define END } + +#define IF if( +#define THEN ){ +#define ELSE } else { +#define ELIF } else if ( +#define FI } + +#define FOR for( +#define WHILE while( +#define DO ){ +#define OD } +#define REP do{ +#define PER }while( +#define DONE ); +#define LOOP for(;;){ +#define POOL } + +#define SKIP ; +#define DIV / +#define REM % +#define NEQ ^ +#define ANDF && +#define ORF || + +#define TRUE (-1) +#define FALSE 0 +#define LOBYTE 0377 +#define HIBYTE 0177400 +#define STRIP 0177 +#define HEXMSK 017 + +#define SP ' ' +#define TB '\t' +#define NL '\n' +#define EOF 0 + +#define SCCSID(arg) static char Sccsid[] = "arg" diff --git a/usr/src/cmd/adb/main.c b/usr/src/cmd/adb/main.c new file mode 100644 index 0000000000..f53df41a44 --- /dev/null +++ b/usr/src/cmd/adb/main.c @@ -0,0 +1,163 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)main.c 2.2); + + +MSG NOEOR; + +INT mkfault; +INT executing; +INT infile; +CHAR *lp; +L_INT maxoff; +L_INT maxpos; +ADDR sigint; +ADDR sigqit; +INT wtflag; +L_INT maxfile; +L_INT maxstor; +L_INT txtsiz; +L_INT datsiz; +L_INT datbas; +L_INT stksiz; +STRING errflg; +L_INT exitflg; +INT magic; +L_INT entrypt; + +CHAR lastc; +INT eof; + +INT lastcom; +L_INT var[36]; +STRING symfil; +STRING corfil; +CHAR printbuf[]; +CHAR *printptr; + + +L_INT +round(a,b) +REG L_INT a, b; +{ + REG L_INT w; + w = (a/b)*b; + IF a!=w THEN w += b; FI + return(w); +} + +/* error handling */ + +chkerr() +{ + IF errflg ORF mkfault + THEN error(errflg); + FI +} + +error(n) + STRING n; +{ + errflg=n; + iclose(); oclose(); +#ifndef EDDT + reset(); +#endif +} + +fault(a) +{ + signal(a,fault); +#ifndef EDDT + lseek(infile,0L,2); +#endif + mkfault++; +} + +/* set up files and initial address mappings */ +INT argcount; + +#ifndef EDDT +main(argc, argv) +#else +eddt(argc, argv) +#endif +REG STRING *argv; +REG INT argc; +{ + maxfile=1L<<24; maxstor=1L<<31; + mkioptab(); + + WHILE argc>1 + DO IF eqstr("-w",argv[1]) + THEN wtflag=2; argc--; argv++; + ELSE break; + FI + OD + + IF argc>1 THEN symfil = argv[1]; FI + IF argc>2 THEN corfil = argv[2]; FI + argcount=argc; + setsym(); setcor(); + + /* set up variables for user */ + maxoff=MAXOFF; maxpos=MAXPOS; + var[VARB] = datbas; + var[VARD] = datsiz; + var[VARE] = entrypt; + var[VARM] = magic; + var[VARS] = stksiz; + var[VART] = txtsiz; + +#ifndef EDDT + IF (sigint=signal(SIGINT,01))!=01 + THEN sigint=fault; signal(SIGINT,fault); + FI + sigqit=signal(SIGQUIT,1); + setexit(); +#endif + IF executing THEN delbp(); FI + executing=FALSE; +#ifdef EDDT + prints(DBNAME); +#endif + + LOOP flushbuf(); + IF errflg + THEN printf("%s\n",errflg); + exitflg=errflg; + errflg=0; + FI + IF mkfault + THEN mkfault=0; printc(EOR); prints(DBNAME); + FI + lp=0; rdc(); lp--; + IF eof + THEN IF infile +#ifndef EDDT + THEN iclose(); eof=0; reset(); +#else + THEN iclose(); eof=0; +#endif + ELSE done(); + FI + ELSE exitflg=0; + FI + command(0,lastcom); + IF lp ANDF lastc!=EOR THEN error(NOEOR); FI + POOL +} + +#ifndef EDDT +done() +{ + endpcs(); + exit(exitflg); +} +#endif diff --git a/usr/src/cmd/adb/message.c b/usr/src/cmd/adb/message.c new file mode 100644 index 0000000000..577eb77367 --- /dev/null +++ b/usr/src/cmd/adb/message.c @@ -0,0 +1,45 @@ +# +/* + * + * UNIX debugger + * + */ + + + +#include "mac.h" +SCCSID(@(#)message.c 2.2); +#include "mode.h" + +MSG VERSION = "\nVERSION vax2.1 DATE 780917\n"; + +MSG BADMOD = "bad modifier"; +MSG BADCOM = "bad command"; +MSG BADSYM = "symbol not found"; +MSG BADLOC = "automatic variable not found"; +MSG NOCFN = "c routine not found"; +MSG NOMATCH = "cannot locate value"; +MSG NOBKPT = "no breakpoint set"; +MSG BADKET = "unexpected ')'"; +MSG NOADR = "address expected"; +MSG NOPCS = "no process"; +MSG BADVAR = "bad variable"; +MSG BADTXT = "text address not found"; +MSG BADDAT = "data address not found"; +MSG ODDADR = "odd address"; +MSG EXBKPT = "too many breakpoints"; +MSG A68BAD = "bad a68 frame"; +MSG A68LNK = "bad a68 link"; +MSG ADWRAP = "address wrap around"; +MSG BADEQ = "unexpected `='"; +MSG BADWAIT = "wait error: process disappeared!"; +MSG ENDPCS = "process terminated"; +MSG NOFORK = "try again"; +MSG BADSYN = "syntax error"; +MSG NOEOR = "newline expected"; +MSG SZBKPT = "bkpt: command too long"; +MSG BADFIL = "bad file format"; +MSG BADNAM = "not enough space for symbols"; +MSG LONGFIL = "filename too long"; +MSG NOTOPEN = "cannot open"; +MSG BADMAG = "bad core magic number"; diff --git a/usr/src/cmd/adb/mode.h b/usr/src/cmd/adb/mode.h new file mode 100644 index 0000000000..65036ce359 --- /dev/null +++ b/usr/src/cmd/adb/mode.h @@ -0,0 +1,79 @@ +#include "machine.h" +/* + * UNIX debugger + */ + +#define MAXCOM 64 +#define MAXARG 32 +#define LINSIZ 256 +TYPE long ADDR; +#ifndef vax +TYPE int INT; +#else +TYPE short INT; +#endif +TYPE int VOID; +TYPE long int L_INT; +TYPE float REAL; +TYPE double L_REAL; +TYPE unsigned POS; +TYPE char BOOL; +TYPE char CHAR; +TYPE char *STRING; +TYPE char MSG[]; +TYPE struct map MAP; +TYPE MAP *MAPPTR; +TYPE struct symtab SYMTAB; +TYPE SYMTAB *SYMPTR; +TYPE struct symslave SYMSLAVE; +TYPE struct bkpt BKPT; +TYPE BKPT *BKPTR; + + +/* file address maps */ +struct map { + L_INT b1; + L_INT e1; + L_INT f1; + L_INT b2; + L_INT e2; + L_INT f2; + INT ufd; +}; + + +/* slave table for symbols */ +struct symslave { + SYMV valslave; + INT typslave; +}; + +struct bkpt { + ADDR loc; + ADDR ins; + INT count; + INT initcnt; + INT flag; + CHAR comm[MAXCOM]; + BKPT *nxtbkpt; +}; + +TYPE struct reglist REGLIST; +TYPE REGLIST *REGPTR; +struct reglist { + STRING rname; + INT roffs; +}; + +struct { + INT junk[2]; + INT fpsr; + REAL Sfr[6]; +}; + +struct { + INT junk[2]; + INT fpsr; + L_REAL Lfr[6]; +}; + diff --git "a/usr/src/cmd/adb/old\031sym.c" "b/usr/src/cmd/adb/old\031sym.c" new file mode 100644 index 0000000000..e69b3938d3 --- /dev/null +++ "b/usr/src/cmd/adb/old\031sym.c" @@ -0,0 +1,215 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)sym.c 2.4); +#include "a.out.h" + + +MSG BADFIL; + +SYMTAB symbol; +BOOL localok; +ADDR lastframe; +SYMSLAVE *symvec; +ADDR maxoff; +ADDR maxstor; + +/* symbol management */ +L_INT symbas; +L_INT symcnt; +L_INT symnum; +ADDR localval; +char symrqd = -1; +SYMTAB symbuf[SYMSIZ]; +SYMPTR symnxt; +SYMPTR symend; + + +INT fsym; +STRING errflg; +POS findsym(); + + +/* symbol table and file handling service routines */ + +longseek(f, a) +L_INT a; +{ +#ifndef EDDT + return(lseek(f,a,0) != -1); +#endif +} + +valpr(v,idsp) +{ + POS d; + d = findsym(v,idsp); + IF d < maxoff + THEN printf("%.8s", symbol.symc); + IF d + THEN printf(OFFMODE, d); + FI + FI +} + +localsym(cframe,cargp) +ADDR cframe,cargp; +{ +#ifndef EDDT + INT symflg; + WHILE nextsym() + ANDF symbol.symc[0]!='_' + ANDF (symflg=symbol.symf)!=N_FN + DO IF symflg>=N_TEXT ANDF symflg<=(N_BSS|N_EXT) + THEN localval=symbol.symv; + return(TRUE); + ELIF symflg==N_ABS + THEN localval=(symbol.symv<0 ? cframe:cargp)+symbol.symv; + return(TRUE); + FI + OD +#endif + return(FALSE); +} +psymoff(v,type,s) +L_INT v; int type; char *s; +{ + POS w; + IF (v!=0) THEN w = findsym(v,type); FI + IF v==0 ORF w >= maxoff ORF (shorten(v)typslave)!=ESYM + DO IF (type==0 ORF symtyp==type) ANDF symptr->typslave != XSYM + THEN symval=symptr->valslave; + IF value-symval=symval + THEN diff = value-symval; + symsav=symptr; + FI + FI + symptr++; + OD + IF symsav + THEN offset=leng(symsav-symvec); + symcnt=symnum-offset; + longseek(fsym, symbas+offset*SYMTABSIZ); + read(fsym,&symbol,SYMTABSIZ); + FI + FI +#else + THEN WHILE diff ANDF symptrsymv=symptr->symv + THEN diff = value-symptr->symv; + symsav=symptr; + FI + symptr++; + OD + IF symsav THEN cpsym(symsav,&symbol); FI + FI +#endif + return(diff); +} + +#ifdef EDDT +cpsym(fm,to) register char *fm,*to;{ +register int i=12; do *to++= *fm++; while (--i); +} +#endif + +nextsym() +{ + IF (--symcnt)<0 + THEN return(FALSE); +#ifndef EDDT + ELSE return(longseek(fsym, symbas+(symnum-symcnt)*SYMTABSIZ)!=0 ANDF + read(fsym,&symbol,SYMTABSIZ)==SYMTABSIZ); +#endif + FI +} + + + +/* sequential search through file */ +symset() +{ + symcnt = symnum; +#ifndef EDDT + symnxt = symbuf; + IF symrqd + THEN longseek(fsym, symbas); + symread(); symrqd=FALSE; + ELSE longseek(fsym, symbas+sizeof symbuf); + FI +#else + symnxt=symvec; +#endif +} + +SYMPTR symget() +{ +#ifndef EDDT + REG INT rc; + IF symnxt >= symend + THEN rc=symread(); symrqd=TRUE; + ELSE rc=TRUE; + FI + IF --symcnt>0 ANDF rc==0 THEN errflg=BADFIL; FI + return( (symcnt>=0 && rc) ? symnxt++ : 0); +#else + IF --symcnt>=0 THEN return(symnxt++); ELSE return(0); FI +#endif +} + +#ifndef EDDT +symread() +{ + INT symlen; +#ifndef vax + short t; SYMTAB *p; +#endif + + symlen=read(fsym,symbuf,sizeof symbuf); +#ifndef vax + p=symbuf; + while ((char *)p<(char*)symbuf+symlen) { + t=p->symv.hiword; p->symv.hiword=p->symv.loword; p->symv.loword=t; + p++; + } +#endif + IF symlen>=SYMTABSIZ + THEN symnxt = symbuf; + symend = &symbuf[symlen/SYMTABSIZ]; + return(TRUE); + ELSE return(FALSE); + FI +} +#endif diff --git a/usr/src/cmd/adb/opset.c b/usr/src/cmd/adb/opset.c new file mode 100644 index 0000000000..3a268783cb --- /dev/null +++ b/usr/src/cmd/adb/opset.c @@ -0,0 +1,147 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)opset.c 2.3); + +STRING errflg; +L_INT dot; +INT dotinc; +L_INT var[]; + + +/* instruction printing */ + +/* + * Argument access types + */ +#define ACCA (8<<3) /* address only */ +#define ACCR (1<<3) /* read */ +#define ACCW (2<<3) /* write */ +#define ACCM (3<<3) /* modify */ +#define ACCB (4<<3) /* branch displacement */ +#define ACCI (5<<3) /* XFC code */ + +/* + * Argument data types + */ +#define TYPB 0 /* byte */ +#define TYPW 1 /* word */ +#define TYPL 2 /* long */ +#define TYPQ 3 /* quad */ +#define TYPF 4 /* floating */ +#define TYPD 5 /* double floating */ + + +TYPE struct optab *OPTAB; +struct optab { + char *iname; + char val; + char nargs; + char argtype[6]; +} optab[]; +#define SYSTAB struct systab +SYSTAB { + int argc; + char *sname; +} systab[]; +STRING regname[]; +STRING fltimm[]; +POS type, space, incp; + +int ioptab[256]; /* index by opcode to optab */ + +mkioptab() {/* set up ioptab */ +REG OPTAB p=optab; while (p->iname) {ioptab[p->val&LOBYTE]=p-optab; p++;} +} + +extern char *fmtr; +extern char *fmtR; + +printins(f,idsp,ins) +#ifndef vax +REG INT ins; +#else +REG L_INT ins; +#endif +{ + short i,b,mode; char **r; long d; char *fmat; + REG char * ap; + REG OPTAB ip; +#ifndef vax + struct {char b2,b3,b0,b1;}; +#else + struct {char b0,b1,b2,b3;}; +#endif + + type=DSYM; space=idsp; + ins &= LOBYTE; + ip=optab+ioptab[ins]; printf("%s%8t",ip->iname); incp=1; + ap=ip->argtype; + for (i=0; inargs; i++,ap++) { + var[i]=0x80000000; + if (i!=0) printc(','); + top: + if (*ap&ACCB) b= 0xAF + ((*ap&7)<<5); /* branch displacement */ + else {b=bchkget(inkdot(incp),idsp); ++incp;} + if (b&0300) {/* not short literal */ + r= ®name[b&0xF]; mode= b >>= 4; + mid: + switch ((int)mode) { + case 4: /* [r] */ printf("[%s]",*r); goto top; + case 5: /* r */ printf("%s",*r); break; + case 7: /* -(r) */ printc('-'); + base: + case 6: /* (r) */ printf("(%s)",*r); break; + case 9: /* *(r)+ */ printc('*'); + case 8: /* (r)+ */ + if (r==(regname+0xF)) {/* PC: immediate or absolute */ + printc('$'); if (b==9) goto abs; + mode=((*ap&7)<<1)+0xA; goto mid; + } + printf("(%s)+",*r); break; + case 0xB: printc('*'); + case 0xA: d=bchkget(inkdot(incp),idsp); ++incp; + if (d&0x80) d -= 0x100; fmat=fmtr; + disp: + var[i]=d; + if (r==(regname+0xF) && b>=0xA) var[i] += dot+incp; + psymoff(var[i],type,""); + if (r!=regname+0xF) goto base; + break; + case 0xD: printc('*'); + case 0xC: d=0; + d.b0 = bchkget(inkdot(incp),idsp); ++incp; + d.b1 = bchkget(inkdot(incp),idsp); ++incp; + if (d&0x8000) d -= 0x10000; fmat=fmtr; + goto disp; + case 0xF: printc('*'); + case 0xE: + abs: + d.b0 = bchkget(inkdot(incp),idsp); ++incp; + d.b1 = bchkget(inkdot(incp),idsp); ++incp; + d.b2 = bchkget(inkdot(incp),idsp); ++incp; + d.b3 = bchkget(inkdot(incp),idsp); ++incp; + fmat=fmtR; goto disp; + } + } else {/* short literal */ + var[i]=b; + if ((*ap&7)==TYPF || (*ap&7)==TYPD) printf("$%s",fltimm[b]); + else printf("$%r",b); + } + } + if (ins==0xCF || ins==0xAF || ins==0x8F) {/* CASEx instr */ + for (i=0; i<=var[2]; ++i) { + printc(EOR); printf(" %R: ",i+var[1]); + d=get(inkdot(incp+i+i),idsp)&0xFFFF; + if (d&0x8000) d -= 0x10000; + psymoff(inkdot(incp)+d,type,""); + } + incp += var[2]+var[2]+2; + } + dotinc=incp; +} diff --git a/usr/src/cmd/adb/output.c b/usr/src/cmd/adb/output.c new file mode 100644 index 0000000000..ca45e3876a --- /dev/null +++ b/usr/src/cmd/adb/output.c @@ -0,0 +1,373 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)output.c 2.3); +#include + + +INT mkfault; +INT infile; +INT outfile = 1; +L_INT maxpos; +L_INT maxoff; +INT radix = 16; + +CHAR printbuf[MAXLIN]; +CHAR *printptr = printbuf; +CHAR *digitptr; + + +eqstr(s1, s2) + REG STRING s1, s2; +{ + REG STRING es1; + es1 = s1+8; + WHILE *s1++ == *s2 + DO IF *s2++ == 0 ORF s1>=es1 + THEN return(1); + FI + OD + return(0); +} + +length(s) + REG STRING s; +{ + INT n = 0; + WHILE *s++ DO n++; OD + return(n); +} + +printc(c) + CHAR c; +{ + CHAR d; + STRING q; + INT posn, tabs, p; + + IF mkfault + THEN return; + ELIF (*printptr=c)==EOR + THEN tabs=0; posn=0; q=printbuf; + FOR p=0; p0 DO *q++=TB; tabs--; OD + WHILE posn>0 DO *q++=SP; posn--; OD + *q++=d; + FI + OD + *q++=EOR; +#ifdef EDDT + printptr=printbuf; do putchar(*printptr++); while (printptr0 THEN decpt--; FI + *digitptr++ = '.'; + WHILE *s ANDF prec-- DO *digitptr++ = *s++; OD + WHILE *--digitptr=='0' DONE + digitptr += (digitptr-digits>=3 ? 1 : 2); + IF decpt + THEN *digitptr++ = 'e'; printnum(decpt,'d',10); + FI + s=0; prec = -1; break; +#endif +#endif + case 'm': + vptr--; break; + case 'M': + width=x; break; + case 'T': + case 't': + IF c=='T' + THEN width=x; +#ifndef vax + ELSE vptr--; +#else + ELSE dptr--; +#endif + FI + IF width + THEN width -= charpos()%width; + FI + break; + default: +#ifndef vax + printc(c); vptr--; +#else + printc(c); dptr--; +#endif + } + + IF s==0 + THEN *digitptr=0; s=digits; + FI + n=length(s); + n=(prec=0 ? prec : n); + width -= n; + IF adj=='r' + THEN WHILE width-- > 0 + DO printc(SP); OD + FI + WHILE n-- DO printc(*s++); OD + WHILE width-- > 0 DO printc(SP); OD + digitptr=digits; + FI + OD +} + +printdate(tvec) + L_INT tvec; +{ + REG INT i; + REG STRING timeptr; +#ifndef EDDT + timeptr = ctime(&tvec); +#else + timeptr="????????????????????????"; +#endif + FOR i=20; i<24; i++ DO *digitptr++ = *(timeptr+i); OD + FOR i=3; i<19; i++ DO *digitptr++ = *(timeptr+i); OD +} /*printdate*/ + +prints(s) +char *s; +{ printf("%s",s); +} + +newline() +{ + printc(EOR); +} + +convert(cp) +REG STRING *cp; +{ + REG CHAR c; + INT n; + n=0; + WHILE ((c = *(*cp)++)>='0') ANDF (c<='9') DO n=n*10+c-'0'; OD + (*cp)--; + return(n); +} + +printnum(n,fmat,base) + REG INT n; +{ + REG CHAR k; + REG INT *dptr; + INT digs[15]; + dptr=digs; + IF n<0 ANDF fmat=='d' THEN n = -n; *digitptr++ = '-'; FI + WHILE n + DO *dptr++ = ((POS)n)%base; + n=((POS)n)/base; + OD + IF dptr==digs THEN *dptr++=0; FI + WHILE dptr!=digs + DO k = *--dptr; + *digitptr++ = (k+(k<=9 ? '0' : 'a'-10)); + OD +} + +printoct(o,s) + L_INT o; + INT s; +{ + INT i; + L_INT po = o; + CHAR digs[12]; + + IF s + THEN IF po<0 + THEN po = -po; *digitptr++='-'; + ELSE IF s>0 THEN *digitptr++='+'; FI + FI + FI + FOR i=0;i<=11;i++ + DO digs[i] = po&7; po >>= 3; OD + digs[10] &= 03; digs[11]=0; + FOR i=11;i>=0;i-- + DO IF digs[i] THEN break; FI OD + FOR i++;i>=0;i-- + DO *digitptr++=digs[i]+'0'; OD +} + +#ifndef vax +printdbl(lx,ly,fmat,base) +INT lx, ly; char fmat; int base; +#else +printdbl(lxy,fmat,base) +L_INT lxy; char fmat; int base; +#endif +{ int digs[20]; int *dptr; char k; +#ifndef MULD2 + register char *cp1; + cp1=digs; if ((lxy&0xFFFF0000L)==0xFFFF0000L) {*cp1++='-'; lxy= -lxy;} + sprintf(cp1,base==16 ? "%X" : "%D",lxy); + cp1=digs; while (*digitptr++= *cp1++); --digitptr; +#else + L_REAL f ,g; long q; +#ifdef vax + INT lx,ly; + ly=lxy; lx=(lxy>>16)&0xFFFF; +#endif + dptr=digs; + IF fmat=='D' ORF fmat=='r' + THEN f=itol(lx,ly); + IF f<0 THEN *digitptr++='-'; f = -f; FI + ELSE + IF lx==-1 + THEN *digitptr++='-'; f=leng(-ly); + ELSE f=leng(lx); f *= itol(1,0); f += leng(ly); + FI + IF fmat=='x' THEN *digitptr++='#'; FI + FI + WHILE f + DO q=f/base; g=q; + *dptr++ = f-g*base; + f=q; + OD + IF dptr==digs ORF dptr[-1]>9 THEN *dptr++=0; FI + WHILE dptr!=digs + DO k = *--dptr; + *digitptr++ = (k+(k<=9 ? '0' : 'a'-10)); + OD +#endif +} + +iclose() +{ + IF infile + THEN close(infile); infile=0; + FI +} + +oclose() +{ + IF outfile!=1 + THEN flushbuf(); close(outfile); outfile=1; + FI +} + +endline() +{ +#ifndef vax + IF charpos()>=maxpos +#else + IF maxpos<=charpos() +#endif + THEN printf("\n"); + FI +} diff --git a/usr/src/cmd/adb/pcs.c b/usr/src/cmd/adb/pcs.c new file mode 100644 index 0000000000..275443cee8 --- /dev/null +++ b/usr/src/cmd/adb/pcs.c @@ -0,0 +1,119 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)pcs.c 2.3); + + +MSG NOBKPT; +MSG SZBKPT; +MSG EXBKPT; +MSG NOPCS; +MSG BADMOD; + +/* breakpoints */ +BKPTR bkpthead; + +CHAR *lp; +CHAR lastc; +struct user u; + +INT signo; +L_INT dot; +INT pid; +L_INT cntval; +L_INT loopcnt; + + + +/* sub process control */ + +subpcs(modif) +{ + REG INT check; + INT execsig,runmode; + REG BKPTR bkptr; + STRING comptr; + execsig=0; loopcnt=cntval; + + switch (modif) { + + /* delete breakpoint */ + case 'd': case 'D': + IF (bkptr=scanbkpt(dot)) + THEN bkptr->flag=0; return; + ELSE error(NOBKPT); + FI + + /* set breakpoint */ + case 'b': case 'B': + IF (bkptr=scanbkpt(dot)) + THEN bkptr->flag=0; + FI + FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt + DO IF bkptr->flag == 0 + THEN break; + FI + OD + IF bkptr==0 + THEN IF (bkptr=sbrk(sizeof *bkptr)) == -1 + THEN error(SZBKPT); + ELSE bkptr->nxtbkpt=bkpthead; + bkpthead=bkptr; + FI + FI + bkptr->loc = dot; + bkptr->initcnt = bkptr->count = cntval; + bkptr->flag = BKPTSET; + check=MAXCOM-1; comptr=bkptr->comm; rdc(); lp--; + REP *comptr++ = readchar(); + PER check-- ANDF lastc!=EOR DONE + *comptr=0; lp--; + IF check + THEN return; + ELSE error(EXBKPT); + FI + + /* exit */ + case 'k' :case 'K': + IF pid + THEN printf("%d: killed", pid); endpcs(); return; + FI + error(NOPCS); + + /* run program */ + case 'r': case 'R': + endpcs(); + setup(); runmode=CONTIN; + break; + + /* single step */ + case 's': case 'S': + IF pid + THEN + runmode=SINGLE; execsig=getsig(signo); + ELSE setup(); loopcnt--; + FI + break; + + /* continue with optional signal */ + case 'c': case 'C': case 0: + IF pid==0 THEN error(NOPCS); FI + runmode=CONTIN; execsig=getsig(signo); + break; + + default: error(BADMOD); + } + + IF loopcnt>0 ANDF runpcs(runmode,execsig) + THEN printf("breakpoint%16t"); + ELSE printf("stopped at%16t"); + FI + delbp(); + printpc(); +} + diff --git a/usr/src/cmd/adb/print.c b/usr/src/cmd/adb/print.c new file mode 100644 index 0000000000..22be5259dc --- /dev/null +++ b/usr/src/cmd/adb/print.c @@ -0,0 +1,383 @@ +# +/* + * + * UNIX debugger + * + */ + +#include "defs.h" +SCCSID(@(#)print.c 2.9); +#include "a.out.h" +struct user u; + + +MSG LONGFIL; +MSG NOTOPEN; +MSG A68BAD; +MSG A68LNK; +MSG BADMOD; + +MAP txtmap; +MAP datmap; + +SYMTAB symbol; +ADDR lastframe; +ADDR callpc; + +INT infile; +INT outfile; +CHAR *lp; +L_INT maxoff; +L_INT maxpos; +INT radix; + +/* symbol management */ +L_INT localval; + +/* breakpoints */ +BKPTR bkpthead; + +REGLIST reglist [] = { + "p1lr", P1LR, + "p1br",P1BR, + "p0lr", P0LR, + "p0br",P0BR, + "ksp",KSP, + "esp",ESP, + "ssp",SSP, + "psl", PSL, + "pc", PC, + "usp",USP, + "fp", FP, + "ap", AP, + "r11", R11, + "r10", R10, + "r9", R9, + "r8", R8, + "r7", R7, + "r6", R6, + "r5", R5, + "r4", R4, + "r3", R3, + "r2", R2, + "r1", R1, + "r0", R0, +}; + +char lastc; + +INT fcor; +STRING errflg; +INT signo; + + +L_INT dot; +L_INT var[]; +STRING symfil; +STRING corfil; +INT pid; +L_INT adrval; +INT adrflg; +L_INT cntval; +INT cntflg; + +STRING signals[] = { + "", + "hangup", + "interrupt", + "quit", + "illegal instruction", + "trace/BPT", + "IOT", + "EMT", + "floating exception", + "killed", + "bus error", + "memory fault", + "bad system call", + "broken pipe", + "alarm call", + "terminated", +}; +#define MAXSIG 15 + + + + +/* general printing routines ($) */ + +printtrace(modif) +{ + INT narg, i, stat, name, limit; + POS dynam; + REG BKPTR bkptr; + CHAR hi, lo; + ADDR word; + STRING comptr; + ADDR argp, frame, link; + SYMPTR symp; + + IF cntflg==0 THEN cntval = -1; FI + + switch (modif) { + + case '<': + case '>': + {CHAR file[64]; + INT index; + + index=0; + IF modif=='<' + THEN iclose(); + ELSE oclose(); + FI + IF rdc()!=EOR + THEN REP file[index++]=lastc; + IF index>=63 THEN error(LONGFIL); FI + PER readchar()!=EOR DONE + file[index]=0; + IF modif=='<' + THEN infile=open(file,0); + IF infile<0 + THEN infile=0; error(NOTOPEN); + FI + ELSE outfile=open(file,1); + IF outfile<0 + THEN outfile=creat(file,0644); +#ifndef EDDT + ELSE lseek(outfile,0L,2); +#endif + FI + FI + + FI + lp--; + } + break; + + case 'd': + if (adrflg) { + if (adrval<2 || adrval>16) {printf("must have 2 <= radix <= 16"); break;} + printf("radix=%d base ten",radix=adrval); + } + break; + + case 'q': case 'Q': case '%': + done(); + + case 'w': case 'W': + maxpos=(adrflg?adrval:MAXPOS); + break; + + case 's': case 'S': + maxoff=(adrflg?adrval:MAXOFF); + break; + + case 'v': case 'V': + prints("variables\n"); + FOR i=0;i<=35;i++ + DO IF var[i] + THEN printc((i<=9 ? '0' : 'a'-10) + i); + printf(" = %Q\n",var[i]); + FI + OD + break; + + case 'm': case 'M': + printmap("? map",&txtmap); + printmap("/ map",&datmap); + break; + + case 0: case '?': + IF pid + THEN printf("pcs id = %d\n",pid); + ELSE prints("no process\n"); + FI + sigprint(); flushbuf(); + + case 'r': case 'R': + printregs(); + return; + + case 'c': case 'C': + IF adrflg + THEN frame=adrval; + word=get(adrval+6,DSP)&0xFFFF; + IF word&0x2000 + THEN /* 'calls', can figure out argp */ + argp=adrval+20+((word>>14)&3); word &= 0xFFF; + WHILE word DO IF word&1 THEN argp+=4; FI word>>=1; OD + ELSE /* 'callg', can't tell where argp is */ argp=frame; + FI + callpc=get(frame+16,DSP); + ELSE argp= *(ADDR *)(((ADDR)&u)+AP); + frame= *(ADDR *)(((ADDR)&u)+FP); + callpc= *(ADDR *)(((ADDR)&u)+PC); + FI + lastframe=0; + WHILE cntval-- + DO chkerr(); + printf("%.8s(", findsym(callpc,ISYM)==-1 ? "?":symbol.symc); + narg = get(argp,DSP); IF narg&~0xFF THEN narg=0; FI + LOOP IF narg==0 THEN break; FI + printf("%R", get(argp += 4, DSP)); + IF --narg!=0 THEN printc(','); FI + POOL + prints(")\n"); + + IF modif=='C' + THEN WHILE localsym(frame,argp) + DO word=get(localval,DSP); + printf("%8t%.8s:%10t", symbol.symc); + IF errflg THEN prints("?\n"); errflg=0; ELSE printf("%R\n",word); FI + OD + FI + + callpc=get(frame+16, DSP); + argp=get(frame+8, DSP); + lastframe=frame; + frame=get(frame+12, DSP)&EVEN; + IF frame==0 ORF (!adrflg ANDF (frame&0xF0000000)!=0x70000000) + THEN break; + FI + OD + break; + +#ifndef EDDT + /*print externals*/ + case 'e': case 'E': + symset(); + WHILE symp=symget() + DO chkerr(); + IF symp->symf==(N_DATA|N_EXT) ORF symp->symf==(N_BSS|N_EXT) + THEN printf("%.8s:%12t%R\n", symp->symc, get(symp->symv,DSP)); + FI + OD + break; + + case 'a': case 'A': + frame=(adrflg ? adrval : *(ADDR *)(((ADDR)&u)+FP)); + + WHILE cntval-- + DO chkerr(); + stat=get(frame,DSP); dynam=get(frame+2,DSP); link=get(frame+4,DSP); + IF modif=='A' + THEN printf("%8O:%8t%-8o,%-8o,%-8o",frame,stat,dynam,link); + FI + IF stat==1 THEN break; FI + IF errflg THEN error(A68BAD); FI + + IF get(link-4,ISP)!=04767 + THEN IF get(link-2,ISP)!=04775 + THEN error(A68LNK); + ELSE /*compute entry point of routine*/ + prints(" ? "); + FI + ELSE printf("%8t"); + valpr(name=shorten(link)+get(link-2,ISP),ISYM); + name=get(leng(name-2),ISP); + printf("%8t\""); limit=8; + REP word=get(leng(name),DSP); name += 2; + lo=word&LOBYTE; hi=(word>>8)&LOBYTE; + printc(lo); printc(hi); + PER lo ANDF hi ANDF limit-- DONE + printc('"'); + FI + limit=4; i=6; printf("%24targs:%8t"); + WHILE limit-- + DO printf("%8t%o",get(frame+i,DSP)); i += 2; OD + printc(EOR); + + frame=dynam; + OD + errflg=0; + flushbuf(); + break; +#endif + + /*set default c frame*/ + /*print breakpoints*/ + case 'b': case 'B': + printf("breakpoints\ncount%8tbkpt%24tcommand\n"); + FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt + DO IF bkptr->flag + THEN printf("%-8.8d",bkptr->count); + psymoff(leng(bkptr->loc),ISYM,"%24t"); + comptr=bkptr->comm; + WHILE *comptr DO printc(*comptr++); OD + FI + OD + break; + + default: error(BADMOD); + } + +} + +printmap(s,amap) +STRING s; MAP *amap; +{ + int file; + file=amap->ufd; + printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil))); + printf("b1 = %-16R",amap->b1); + printf("e1 = %-16R",amap->e1); + printf("f1 = %-16R",amap->f1); + printf("\nb2 = %-16R",amap->b2); + printf("e2 = %-16R",amap->e2); + printf("f2 = %-16R",amap->f2); + printc(EOR); +} + +printregs() +{ + REG REGPTR p; + L_INT v; + + FOR p=reglist; p < ®list[24]; p++ + DO printf("%s%6t%R %16t", p->rname, v= *(ADDR *)(((ADDR)&u)+p->roffs)); + valpr(v,(p->roffs==PC?ISYM:DSYM)); + printc(EOR); + OD + printpc(); +} + +getreg(regnam) +{ + REG REGPTR p; + REG STRING regptr; + CHAR *olp; + CHAR regnxt; + + olp=lp; + FOR p=reglist; p < ®list[24]; p++ + DO regptr=p->rname; + IF (regnam == *regptr++) + THEN + WHILE *regptr + DO IF (regnxt=readchar()) != *regptr++ + THEN --regptr; break; + FI + OD + IF *regptr + THEN lp=olp; + ELSE return(p->roffs); + FI + FI + OD + lp=olp; + return(0); +} + +printpc() +{ + dot= *(ADDR *)(((ADDR)&u)+PC); + psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP)); + printc(EOR); +} + +sigprint() +{ + IF (signo>=0) ANDF (signo<=MAXSIG) THEN prints(signals[signo]); FI +} + -- 2.20.1