Bell 32V development

Work on file usr/src/cmd/adb/setup.c
Work on file usr/src/cmd/adb/sym.c

Co-Authored-By: John Reiser <jfr@research.uucp>
Synthesized-from: 32v

diff --git a/usr/src/cmd/adb/setup.c b/usr/src/cmd/adb/setup.c
new file mode 100644 (file)
index 0000000..d2f50e1
--- /dev/null
+++ b/usr/src/cmd/adb/setup.c
@@ -0,0 +1,168 @@
+#
+/*
+ *
+ *     UNIX debugger
+ *
+ */
+
+#include "defs.h"
+#include "a.out.h"
+SCCSID(@(#)setup.c     2.5);
+
+
+MSG            BADNAM;
+MSG            BADMAG;
+
+MAP            txtmap;
+MAP            datmap;
+SYMSLAVE       *symvec;
+INT            wtflag;
+INT            fcor;
+INT            fsym;
+L_INT          maxfile;
+L_INT          maxstor;
+L_INT          txtsiz;
+L_INT          datsiz;
+L_INT          datbas;
+L_INT          stksiz;
+STRING         errflg;
+INT            magic;
+L_INT          symbas;
+L_INT          symnum;
+L_INT          entrypt;
+
+INT            argcount;
+INT            signo;
+struct user u;
+
+STRING         symfil  = "a.out";
+STRING         corfil  = "core";
+
+#define TXTHDRSIZ      (sizeof(txthdr))
+
+#ifndef EDDT
+readl(f,p,n) int f,n; long * p;{
+#ifndef vax
+       int t=0;
+       do {t += read(f,&(p->loword),2); t += read(f,&(p->hiword),2); p++;} while (--n);
+       return(t);
+#else
+       return(read(f,p,n*sizeof(long)));
+#endif
+}
+#endif
+
+setsym()
+{
+#ifndef EDDT
+       INT             relflg;
+       INT             symval, symflg;
+       SYMSLAVE        *symptr;
+       SYMPTR          symp;
+       TXTHDR          txthdr;
+
+       fsym=getfile(symfil,1);
+       txtmap.ufd=fsym;
+       IF readl(fsym, txthdr, TXTHDRSIZ/sizeof(txthdr[0]))==TXTHDRSIZ
+       THEN    magic=txthdr[0];
+               IF magic!=0411 ANDF magic!=0410 ANDF magic!=0407 ANDF magic!=0405
+               THEN    magic=0;
+               ELSE    symnum=txthdr[4]/SYMTABSIZ;
+                       txtsiz=txthdr[1];
+                       datsiz=txthdr[2];
+                       symbas=txtsiz+datsiz;
+                       txtmap.b1=0;
+                       txtmap.e1=(magic==0407?symbas:txtsiz);
+                       txtmap.f1 = TXTHDRSIZ;
+                       txtmap.b2=datbas=(magic==0410?round(txtsiz,TXTRNDSIZ):0);
+                       txtmap.e2=txtmap.b2+(magic==0407?symbas:datsiz);
+                       txtmap.f2 = TXTHDRSIZ+(magic==0407?0:txtmap.e1);
+                       entrypt=txthdr[5];
+       /*              relflg=txthdr[7];
+       /*              IF relflg!=1 THEN symbas =<< 1; FI
+       */
+                       symbas += txthdr[6]+txthdr[7];
+                       symbas += TXTHDRSIZ;
+
+                       /* set up symvec */
+                       symvec=sbrk(shorten((1+symnum))*sizeof (SYMSLAVE));
+                       IF (symptr=symvec)==-1
+                       THEN    printf("%s\n",BADNAM);
+                               symptr=symvec=sbrk(sizeof (SYMSLAVE));
+                       ELSE    symset();
+                               WHILE (symp=symget()) ANDF errflg==0
+                               DO 
+                                   symflg=symp->symf;
+                                   symptr->valslave=symp->symv;
+                                   symptr->typslave=SYMTYPE(symflg);
+                                   IF (symflg & STABTYPES) != 0
+                                   THEN
+                                       symptr->typslave=XSYM;
+                                   FI
+                                   symptr++;
+                               OD
+                       FI
+                       symptr->typslave=ESYM;
+               FI
+       FI
+       IF magic==0 THEN txtmap.e1=maxfile; FI
+#endif
+}
+
+setcor()
+{
+#ifndef EDDT
+       fcor=getfile(corfil,2);
+       datmap.ufd=fcor;
+       IF read(fcor, &u, ctob(4))==ctob(4)
+          ANDF (u.u_pcb.pcb_ksp & 0xF0000000L)==0x80000000L
+          ANDF (u.u_pcb.pcb_usp & 0xF0000000L)==0x70000000L
+       THEN    signo = u.u_arg[0]&017;
+               txtsiz = ctob(u.u_tsize);
+               datsiz = ctob(u.u_dsize);
+               stksiz = ctob(u.u_ssize);
+               datmap.b1 = datbas = (magic==0410?round(txtsiz,TXTRNDSIZ):0);
+               datmap.e1=(magic==0407?txtsiz:datmap.b1)+datsiz;
+               datmap.f1 = ctob(USIZE);
+               datmap.b2 = maxstor-stksiz;
+               datmap.e2 = maxstor;
+               datmap.f2 = ctob(USIZE)+(magic==0410?datsiz:datmap.e1);
+               signo = *(ADDR *)(((ADDR)&u)+ctob(4)-4*4);
+               IF magic ANDF magic!=u.u_exdata.ux_mag
+               THEN    printf("%s\n",BADMAG);
+               FI
+       ELSE    datmap.e1 = maxfile;
+       FI
+#endif
+}
+
+#ifndef EDDT
+create(f)
+STRING f;
+{      int fd;
+       IF (fd=creat(f,0644))>=0
+       THEN close(fd); return(open(f,wtflag));
+       ELSE return(-1);
+       FI
+}
+
+getfile(filnam,cnt)
+STRING filnam;
+{
+       REG INT         fsym;
+
+       IF !eqstr("-",filnam)
+       THEN    fsym=open(filnam,wtflag);
+               IF fsym<0 ANDF argcount>cnt
+               THEN    IF wtflag
+                       THEN    fsym=create(filnam);
+                       FI
+                       IF fsym<0
+                       THEN printf("cannot open `%s'\n", filnam);
+                       FI
+               FI
+       ELSE    fsym = -1;
+       FI
+       return(fsym);
+}
+#endif

diff --git a/usr/src/cmd/adb/sym.c b/usr/src/cmd/adb/sym.c
new file mode 100644 (file)
index 0000000..32ed95d
--- /dev/null
+++ b/usr/src/cmd/adb/sym.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)<maxoff ANDF w!=0)
+       THEN printf(LPRMODE,v);
+       ELSE printf("%.8s", symbol.symc);
+            IF w THEN printf(OFFMODE,w); FI
+       FI
+       printf(s);
+}
+
+POS
+findsym(svalue,type)
+L_INT  svalue;
+INT    type;
+{
+       L_INT           diff, value, symval, offset;
+       INT             symtyp;
+#ifndef EDDT
+       REG SYMSLAVE    *symptr;
+       SYMSLAVE        *symsav;
+#else
+       REG SYMPTR      *symptr;
+       SYMPTR  *symsav;
+#endif
+       value=svalue; diff = 0x7fffffffL; symsav=0;
+       IF type!=NSYM ANDF (symptr=symvec)
+#ifndef EDDT
+       THEN    WHILE diff ANDF (symtyp=symptr->typslave)!=ESYM
+               DO  IF (type==0 ORF symtyp==type) ANDF symtyp != XSYM
+                   THEN symval=symptr->valslave;
+                        IF value-symval<diff
+                           ANDF value>=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 symptr<symend
+               DO  IF value-symptr->symv<diff
+                           ANDF value>=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