Complete reworking of opset.c to make its operation understandable

Allow 2 byte opcodes for extended VAX architecture (G and H numbers).
Opset.c is shared between adb and sdb.  Use a common instruction data base
with adb, sdb, as and c2

SCCS-vsn: old/adb/adb.vax/opset.c 4.2
SCCS-vsn: old/adb/adb.vax/Makefile 4.3
SCCS-vsn: old/adb/adb.vax/optab.c 4.3

diff --git a/usr/src/old/adb/adb.vax/Makefile b/usr/src/old/adb/adb.vax/Makefile
index 5aca281..cebc771 100644 (file)
--- a/usr/src/old/adb/adb.vax/Makefile
+++ b/usr/src/old/adb/adb.vax/Makefile
@@ -1,13 +1,19 @@
 #
 #

-#      Makefile        4.2     81/05/14
+#      Makefile        4.3     82/10/27

 #
 DESTDIR= 
 #
 DESTDIR= 

-CFLAGS=        -O -w
+DFLAGS = -DADB
+CFLAGS=        -O -w ${DFLAGS}

 CFILES= access.c command.c expr.c format.c input.c main.c message.c \
        opset.c optab.c output.c pcs.c print.c runpcs.c setup.c sym.c
 OFILES= access.o command.o expr.o format.o input.o main.o message.o \
        opset.o optab.o output.o pcs.o print.o runpcs.o setup.o sym.o
 
 CFILES= access.c command.c expr.c format.c input.c main.c message.c \
        opset.c optab.c output.c pcs.c print.c runpcs.c setup.c sym.c
 OFILES= access.o command.o expr.o format.o input.o main.o message.o \
        opset.o optab.o output.o pcs.o print.o runpcs.o setup.o sym.o
 

+#
+#      path to the directory containing as
+#
+AS =   /usr/src/bin/as
+

 adb:   ${OFILES}
        ${CC} -o adb ${OFILES}
 
 adb:   ${OFILES}
        ${CC} -o adb ${OFILES}
 


@@ -22,16 +28,19 @@ input.o:    defs.h input.c
 main.o:                defs.h main.c
 message.o:     mac.h mode.h message.c
        ${CC} -c -R message.c
 main.o:                defs.h main.c
 message.o:     mac.h mode.h message.c
        ${CC} -c -R message.c

-opset.o:       defs.h opset.c
-optab.o:       defs.h optab.c
-       ${CC} -c -R  optab.c
-output.o:      defs.h output.c

 pcs.o:         defs.h pcs.c
 print.o:       defs.h print.c
 runpcs.o:      defs.h runpcs.c
 setup.o:       defs.h setup.c
 sym.o:         defs.h sym.c
 
 pcs.o:         defs.h pcs.c
 print.o:       defs.h print.c
 runpcs.o:      defs.h runpcs.c
 setup.o:       defs.h setup.c
 sym.o:         defs.h sym.c
 

+opset.o:       defs.h opset.c
+       ${CC} ${CFLAGS} -c    -I. -I$(AS) opset.c
+optab.o:       defs.h optab.c instrs.adb
+       ${CC} ${CFLAGS} -c -R -I. -I$(AS) optab.c
+instrs.adb: $(AS)/instrs
+       (echo FLAVOR ADB; cat $(AS)/instrs) | awk -f $(AS)/instrs > instrs.adb
+

 install:
        install -s adb ${DESTDIR}/bin
 
 install:
        install -s adb ${DESTDIR}/bin
 

diff --git a/usr/src/old/adb/adb.vax/opset.c b/usr/src/old/adb/adb.vax/opset.c
index aba588e..3ad5ec8 100644 (file)
--- a/usr/src/old/adb/adb.vax/opset.c
+++ b/usr/src/old/adb/adb.vax/opset.c
@@ -1,203 +1,259 @@
-#
+#ifndef lint
+static char sccsid[] = "@(#)opset.c 4.2 %G%";
+#endif lint

 /*
 /*

- *

  *     UNIX debugger
  *     UNIX debugger

- *
+ *     Instruction printing routines.
+ *     MACHINE DEPENDENT

  */
 
  */
 

+#ifdef ADB

 #include "defs.h"
 #include "defs.h"

-static char sccsid[] = "@(#)opset.c 4.1 %G%";
+#endif ADB
+#ifdef SDB
+#include "head.h"
+#endif SDB

 
 

-STRING         errflg;

 L_INT          dot;
 INT            dotinc;
 L_INT          dot;
 INT            dotinc;

-L_INT          var[];
+L_INT          insoutvar[36];
+#ifdef ADB
+L_INT          var[36];
+#endif ADB

 
 

+#undef INSTTAB
+#include "instrs.h"

 
 

-/* instruction printing */
-
+STRING regname[];
+STRING fltimm[];
+POS    type, space, incp;

 /*
 /*

- * Argument access types
+ *     Definitions for registers and for operand classes

  */
  */

-#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 */
+char   *insregname();  /* how to print a register */
+
+#define        R_PC            0xF
+
+#define        OC_IMM0         0x0
+#define        OC_IMM1         0x1
+#define        OC_IMM2         0x2
+#define        OC_IMM3         0x3
+#define        OC_INDEX        0x4
+#define        OC_REG          0x5
+#define        OC_DREG         0x6
+#define        OC_ADREG        0x7
+#define        OC_AIREG        0x8
+#define        OC_DAIREG       0x9
+
+#define        OC_BDISP        0xA
+#define        OC_DBDISP       0xB
+#define        OC_WDISP        0xC
+#define        OC_DWDISP       0xD
+#define        OC_LDISP        0xE
+#define        OC_DLDISP       0xF
+
+#define        OC_SHIFT        4
+#define        OC_CONS(oc,reg) (((oc & 0xF) << OC_SHIFT) | (reg & 0xF))
+#define        OC_AMEXT(x)     (((x) >> OC_SHIFT) & 0xF)
+#define        OC_REGEXT(x)    ((x) & 0xF)

 
 /*
 
 /*

- * Argument data types
+ *     Definitions for large numbers

  */
  */

-#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;
+#include "asnumber.h"
+typedef        struct  as_number       *numberp;
+numberp snarf();
+numberp snarfreloc();
+/*
+ *     Definitions for special instructions
+ */
+#define        CASEB   0x8F
+#define        CASEW   0xAF
+#define        CASEL   0xCF
+/*
+ *     Definitions for converting TYP's into numbers, booleans, etc.
+ *     These are shared with the assembler.
+ */
+extern int     ty_NORELOC[];
+extern int     ty_float[];
+extern int     ty_nbyte[];
+extern int     ty_nlg[];
+extern char    *ty_string[];
+
+short ioptab[3][256];  /* two level index by opcode into insttab */
+
+int mapescbyte(byte)
+       u_char  byte;
+{
+       switch(byte){
+       default:        return(0);
+       case ESCD:      return(1);
+       case ESCF:      return(2);
+       }
+}

 
 

-int ioptab[256]; /* index by opcode to optab */
+mkioptab()
+{
+       REG     struct insttab *p;
+               int     mapchar;

 
 

-mkioptab() {/* set up ioptab */
-       REG OPTAB p=optab;
-       while (p->iname){
-               ioptab[p->val&LOBYTE]=p-optab;
-               p++;
+       for(p = insttab; p->iname; p++){
+               mapchar = mapescbyte(p->eopcode);
+               if (ioptab[mapchar][p->popcode])
+                       continue;
+               ioptab[mapchar][p->popcode] = p - insttab;

        }
 }
 
        }
 }
 

-extern char *fmtr;     /* not used */
-extern char *fmtR;     /* not used */
+u_char snarfuchar();
+/*
+ *     Global variables for communicating with the minions and printins
+ */
+static int     idsp;
+static short   argno;          /* which argument one is working on */
+static char    insoutfmt[2];   /* how to format the relocated symbols */
+#ifdef SDB
+static struct  proct   *procp;
+#endif SDB
+
+static savevar(val)
+       long    val;
+{
+       var[argno] = val;
+       insoutvar[argno] = val;
+}

 
 

-printins(f,idsp,ins)
+printins(fmt, Idsp, ins)
+       char    fmt;

 #ifndef vax
 #ifndef vax

-       REG INT         ins;
+       u_char  ins;

 #else
 #else

-       REG L_INT       ins;
+       u_char  ins;

 #endif
 #endif

+       int     Idsp;

 {
 {

-       short   argno;          /* argument index */
-       short   mode;           /* mode */
-       char    **r;            /* register name */
-       long    d;              /* assembled byte, word, long or float */
-       long    snarf();
-       REG char *      ap;
-       REG OPTAB       ip;
+               u_char  mode;           /* mode */
+               u_char  ins2;
+               char    *indexreg;      /* print of which register indexes */
+               char    *indexed;       /* we indexed */
+               char    *operandout();
+       REG     u_char  *ap;
+       REG     struct insttab *ip;
+               u_char  optype;
+               int     mapchar;

 
 

+       idsp = Idsp;

        type = DSYM;
        space = idsp;
        type = DSYM;
        space = idsp;

-       ins &= LOBYTE;
-       ip=optab+ioptab[ins];
-       printf("%s%8t",ip->iname);
+#ifdef SDB
+       procp = adrtoprocp(dot);
+       if (procp->paddr == dot){
+               printf("0x%04.4x", ins);
+               incp = 2;
+               goto ret;
+       }
+#endif SDB
+
+#ifdef ADB
+       insoutfmt[0] = 0;
+#endif ADB
+#ifdef SDB
+       insoutfmt[0] = fmt;
+#endif SDB
+

        incp = 1;
        incp = 1;

-       ap = ip->argtype;
-       for (argno=0; argno<ip->nargs; argno++,ap++) {
-               var[argno] = 0x80000000;
-               if (argno!=0) printc(',');
-         top:
-               if (*ap&ACCB)
-                       mode = 0xAF + ((*ap&7)<<5);  /* branch displacement */
-               else{
-                       mode = bchkget(inkdot(incp),idsp); ++incp;
+       if ((mapchar = mapescbyte(ins)) != 0){
+               ins2 = snarfuchar();
+               if (ioptab[mapchar][ins2] == 0){
+                       /*
+                        *      Oops; not a defined instruction;
+                        *      back over this escape byte.
+                        */
+                       incp -= 1;
+                       mapchar = 0;
+               } else {
+                       ins = ins2;

                }
                }

-               if (mode & 0300) {/* not short literal */
-                       r = &regname[mode&0xF];
-                       mode >>= 4;
-                       switch ((int)mode) {
-                               case 4: /* [r] */
-                                       printf("[%s]",*r);
-                                       goto top;
-                               case 5: /* r */
-                                       printf("%s",*r);
-                                       break;
-                               case 6: /* (r) */
-                                       printf("(%s)",*r);
-                                       break;
-                               case 7: /* -(r) */
-                                       printf("-(%s)",*r);
+       }
+       if (ioptab[mapchar][ins] == 0){
+               printf("<undefined operator byte>: %x", ins);
+               goto ret;
+       }
+       ip = &insttab[ioptab[mapchar][ins]];
+       printf("%s\t", ip->iname);
+
+       for (ap = ip->argtype, argno = 0; argno < ip->nargs; argno++, ap++) {
+               savevar(0x80000000);    /* an illegal symbol */
+               optype = *ap;
+               if (argno != 0)
+                       printc(',');
+               indexreg = 0;
+               indexed = 0;
+               do{
+                       if (A_ACCEXT(optype) & ACCB){
+                               switch(A_TYPEXT(optype)){
+                               case TYPB:
+                                       mode = OC_CONS(OC_BDISP, R_PC);

                                        break;
                                        break;

-                               case 9: /* *(r)+ */
-                                       printc('*');
-                               case 8: /* (r)+ */
-                                 if (r==(regname+0xF)) {
-                                       printc('$');
-                                       if (mode==9){   /* PC absolute, always 4 bytes*/
-                                               d = snarf(4, idsp);
-                                               goto disp;
-                                       }
-                                       switch(*ap&7){
-                                        case TYPB:
-                                               d = snarf(1, idsp);
-                                               goto disp;
-                                        case TYPW:
-                                               d = snarf(2, idsp);
-                                               goto disp;
-                                        case TYPL:
-                                               d = snarf(4, idsp);
-                                               goto disp;
-                                        case TYPQ:
-                                               d = snarf(4, idsp);
-                                               printquad(d, snarf(4, idsp));
-                                               break;
-                                        case TYPF:
-                                               printfloating(TYPF, snarf(4, idsp), 0);
-                                               break;
-                                        case TYPD:
-                                               d = snarf(4, idsp);
-                                               printfloating(TYPQ, d, snarf(4, idsp));
-                                               break;
-                                       } /*end of type switch */
-                                       /*
-                                        *      here only for TYPQ, TYPf, TYPD
-                                        *      others went to disp
-                                        */
-                                 } else {      /*it's not PC immediate or abs*/
-                                         printf("(%s)+",*r);
-                                 }
-                                 break;
-                               case 0xB:       /* byte displacement defferred*/
-                                       printc('*');
-                               case 0xA:       /* byte displacement */
-                                       d = snarf(1, idsp);
-                                       goto disp;
-                               case 0xD:       /* word displacement deferred */
-                                       printc('*');
-                               case 0xC:       /* word displacement */
-                                       d = snarf(2, idsp);
-                                       goto disp;
-                               case 0xF:       /* long displacement deferred */
-                                       printc('*');
-                               case 0xE:       /* long displacement */
-                                       d = snarf(4, idsp);
-                                       goto disp;
-                       disp:
-                                       var[argno]=d;
-                                       if (r==(regname+0xF) && mode>=0xA){
-                                               /* PC offset addressing */
-                                               var[argno] += dot+incp;
-                                       }
-                                       psymoff(var[argno],type,"");
-                                       if (r != regname+0xF)
-                                               printf("(%s)",*r);
+                               case TYPW:
+                                       mode = OC_CONS(OC_WDISP, R_PC);

                                        break;
                                        break;

-                       } /* end of the mode switch */
-               } else {   /* short literal */
-                       var[argno]=mode;
-                       if(   (*ap&7)==TYPF
-                          || (*ap&7)==TYPD)
-                               printf("$%s",fltimm[mode]);
-                       else
-                               printf("$%r",mode);
-               }
+                               }
+                       } else {
+                               mode = snarfuchar();
+                       }
+                       indexreg = operandout(mode, optype);
+                       if (indexed)
+                               printf("[%s]", indexed);
+                       indexed = indexreg;
+               } while(indexed);

        }
        }

-       if (ins==0xCF || ins==0xAF || ins==0x8F) {/* CASEx instr */
-               for (argno=0; argno<=var[2]; ++argno) {
-                       printc(EOR);
-                       printf("    %R:  ",argno+var[1]);
-                       d=get(inkdot(incp+argno+argno),idsp)&0xFFFF;
-                       if (d&0x8000) d -= 0x10000;
-                       psymoff(inkdot(incp)+d,type,"");
+       if (mapchar == 0){
+               switch(ins){
+               case CASEB:
+               case CASEW:
+               case CASEL:
+                       casebody(insoutvar[1], insoutvar[2]);
+                       break;
+               default:
+                       break;

                }
                }

-               incp += var[2]+var[2]+2;

        }
        }

-       dotinc=incp;
+   ret: ;
+
+#ifdef SDB
+       oincr = incp;
+#endif SDB
+#ifdef ADB
+       dotinc = incp;
+#endif ADB
+}
+
+casebody(base, limit)
+       long    base;
+       long    limit;
+{
+       int     i;
+       POS     baseincp;
+       POS     advincp;
+       struct  as_number       *valuep;
+#define        OSIZE (sizeof(short))
+       argno = 0;
+       baseincp = incp;
+       for (i = 0; i <= limit; i++) {
+               printc(EOR);
+#ifdef SDB
+               printf("    %d:  ", i + base);
+#endif SDB
+#ifdef ADB
+               printf("    %R:  ", i + base);
+#endif ADB
+               valuep = snarfreloc(OSIZE, 0);
+               advincp = incp;
+               incp = baseincp;
+               dispaddress(valuep, OC_CONS(OC_WDISP, R_PC));
+               incp = advincp;
+       }

 }
 
 /*
 }
 
 /*


@@ -207,72 +263,309 @@ printins(f,idsp,ins)
                              /* 0      1       2       3       4 */
 static long magic_masks[5] =   {0,     0x80,   0x8000, 0,      0};     
 static long magic_compl[5] =   {0,     0x100,  0x10000,0,      0};
                              /* 0      1       2       3       4 */
 static long magic_masks[5] =   {0,     0x80,   0x8000, 0,      0};     
 static long magic_compl[5] =   {0,     0x100,  0x10000,0,      0};

+/*
+ *     Snarf up some bytes, and put in the magic relocation flags
+ */
+numberp snarfreloc(nbytes)
+       int     nbytes;
+{
+       numberp back;
+       back = snarf(nbytes);
+       if (back->num_ulong[0] & magic_masks[nbytes])
+               back->num_ulong[0] -= magic_compl[nbytes];
+       return(back);
+}
+/*
+ *     The following code is NOT portable from the PDP 11 to the VAX
+ *     because of the byte ordering problem.
+ */
+numberp snarf(nbytes)
+       int     nbytes;
+{
+       REG     int     i;
+
+       static  struct  as_number       backnumber;
+       static  struct  as_number       znumber;        /* init'ed to 0 */

 
 

+       backnumber = znumber;
+       for (i = 0; i < nbytes; i++)
+               backnumber.num_uchar[i] = snarfuchar();
+       return(&backnumber);
+}

 /*
 /*

- *     The following code is NO LONGER portable from the PDP 11 to the VAX
+ *     Read one single character, and advance the dot

  */
  */

-long snarf (nbytes, idsp)
-                       int     nbytes;
+u_char snarfuchar()

 {
 {

-       register        int     byteindex;
-       union Long{
-               char    long_bytes[4];
-               long    long_value;
-       } d;
-
-       d.long_value = 0;
-       for (byteindex = 0; byteindex < nbytes; byteindex++){
-               d.long_bytes[byteindex] = bchkget(inkdot(incp), idsp);
-               ++incp;
+       u_char  back;
+       /*
+        *      assert: bchkget and inkdot don't have side effects
+        */
+       back = (u_char)bchkget(inkdot(incp), idsp);
+       incp += 1;
+       return(back);
+}
+/*
+ *     normal operand; return non zero pointer to register
+ *     name if this is an index instruction.
+ */
+char *operandout(mode, optype)
+       u_char  mode;
+       u_char  optype;
+{
+       char    *r;
+       int     regnumber;
+       int     nbytes;
+
+       regnumber = OC_REGEXT(mode);
+       r = insregname(regnumber);
+       switch (OC_AMEXT(mode)){
+       case OC_IMM0:
+       case OC_IMM1:
+       case OC_IMM2:
+       case OC_IMM3:
+               shortliteral(mode, optype);
+               return(0);
+       case OC_INDEX:
+               return(r);              /* will be printed later */
+       case OC_REG:
+               printf("%s", r);
+               return(0);
+       case OC_DREG:
+               printf("(%s)", r);
+               return(0);
+       case OC_ADREG:
+               printf("-(%s)", r);
+               return(0);
+       case OC_DAIREG:
+               printc('*');
+       case OC_AIREG:
+               if (regnumber == R_PC){
+                       pcimmediate(mode, optype);
+               } else {
+                       printf("(%s)+", r);
+               }
+               return(0);
+       case OC_DBDISP:
+               printc('*');
+       case OC_BDISP:
+               nbytes = 1;
+               break;
+       case OC_DWDISP:
+               printc('*');
+       case OC_WDISP:
+               nbytes = 2;
+               break;
+       case OC_DLDISP:
+               printc('*');
+       case OC_LDISP:
+               nbytes = 4;
+               break;

        }
        }

-       if (d.long_value & magic_masks[nbytes])
-               d.long_value -= magic_compl[nbytes];
-       return(d.long_value);
+       dispaddress(snarfreloc(nbytes), mode);
+       return(0);

 }
 
 }
 

-printfloating(type, word_first, word_last)
-       int     type;
-       long    word_first;
-       long    word_last;
+dispaddress(valuep, mode)
+       numberp valuep;
+       u_char  mode;

 {
 {

-       union   Double{
-               struct {
-                       long    word_first;
-                       long    word_last;
-               } composite;
-               double  dvalue;
-       } reconstructed;
-
-       reconstructed.composite.word_first = word_first;
-       reconstructed.composite.word_last = word_last;
-       printf( "%f", reconstructed.dvalue);
+       int     regnumber = OC_REGEXT(mode);
+
+       switch(OC_AMEXT(mode)){
+       case OC_BDISP:
+       case OC_DBDISP:
+       case OC_WDISP:
+       case OC_DWDISP:
+       case OC_LDISP:
+       case OC_DLDISP:
+               if (regnumber == R_PC){
+                       /* PC offset addressing */
+                       valuep->num_ulong[0] += inkdot(incp);
+               }
+       }
+#ifdef ADB
+       psymoff(valuep->num_ulong[0], type, &insoutfmt[0]);
+       if (regnumber != R_PC){         /* } */
+#endif ADB
+#ifdef SDB
+       if(psymoff(valuep->num_ulong[0], regnumber, &insoutfmt[0])
+          && (regnumber != R_PC)){
+#endif SDB
+               printf("(%s)", insregname(regnumber));
+       }
+       savevar((long)valuep->num_ulong[0]);
+}
+/*
+ *     get a register name
+ */
+char *insregname(regnumber)
+       int     regnumber;
+{
+       char    *r;
+       r = regname[regnumber];
+#ifdef SDB
+       if (   (insoutfmt[0] == 'i')
+           && (regnumber >= 6)
+           && (regnumber <= 11)
+           && (adrtoregvar(regnumber, procp) != -1)) {
+               r = sl_name;
+       }
+#endif SDB
+       return(r);
+}
+/*
+ *     print out a short literal
+ */
+shortliteral(mode, optype)
+       u_char  mode;
+       u_char  optype;
+{
+       savevar((long)mode);
+       switch(A_TYPEXT(optype)){
+       case TYPF:
+       case TYPD:
+       case TYPG:
+       case TYPH:
+               printf("$%s", fltimm[mode]);
+               break;
+       default:
+#ifdef ADB
+               printf("$%r", mode);
+#endif ADB
+#ifdef SDB
+               printf("$%d", mode);
+#endif SDB
+               break;
+       }

 }
 
 }
 

-printquad(word_first, word_last)
-       long    word_first;
-       long    word_last;
+pcimmediate(mode, optype)
+       u_char  mode;
+       u_char  optype;

 {
 {

-       union Quad {
-               char    quad_bytes[8];
-               long    quad_long[2];
-       } reconstructed;
+       int     nbytes;
+
+       printc('$');
+       if (mode == OC_DAIREG){ /* PC absolute, always 4 bytes*/
+               dispaddress(snarfreloc(4), mode);
+               return;
+       }
+       nbytes = ty_nbyte[A_TYPEXT(optype)];
+       if (! ty_NORELOC[A_TYPEXT(optype)]){
+               dispaddress(snarfreloc(nbytes), mode);
+               return;
+       }
+       bignumprint(nbytes, optype);
+}
+
+bignumprint(nbytes, optype)
+       int     nbytes;
+       u_char  optype;
+{
+       numberp valuep;

        int     leading_zero = 1;
        int     leading_zero = 1;

-       int     byteindex;
-       int     nibbleindex;
-       register        int     ch;
-
-       reconstructed.quad_long[0] = word_first;
-       reconstructed.quad_long[1] = word_last;
-       for (byteindex = 7; byteindex >= 0; --byteindex){
-               for (nibbleindex = 4; nibbleindex >= 0; nibbleindex -= 4){
-                       ch = (reconstructed.quad_bytes[byteindex]
-                               >> nibbleindex) & 0x0F;
-                       if ( ! (leading_zero &= (ch == 0) ) ){
-                               if (ch <= 0x09)
-                                       printc(ch + '0');
-                               else
-                                       printc(ch - 0x0A + 'a');
+       REG     int     bindex;
+       REG     int     nindex;
+       REG     int     ch;
+
+       valuep = snarf(nbytes);
+       switch(A_TYPEXT(optype)){
+       case TYPF:      
+               printf("0f%f", valuep->num_num.numFf_float.Ff_value);
+               break;
+       case TYPD:
+               printf("0d%f", valuep->num_num.numFd_float.Fd_value);
+               break;
+       case TYPG:
+               printf("0g::"); goto qprint;
+       case TYPH:
+               printf("0h::"); goto qprint;
+       case TYPQ:
+       case TYPO:
+       qprint:
+               for (bindex = nbytes - 1; bindex >= 0; --bindex){
+                       for (nindex = 4; nindex >= 0; nindex -= 4){
+                               ch = (valuep->num_uchar[bindex] >> nindex);
+                               ch &= 0x0F;
+                               if ( ! (leading_zero &= (ch == 0) ) ){
+                                       if (ch <= 0x09)
+                                               printc(ch + '0');
+                                       else
+                                               printc(ch - 0x0A + 'a');
+                               }
+                       }
+               }
+               break;
+       }
+}
+#ifdef SDB
+
+L_INT inkdot(incr)
+       int     incr;
+{
+       L_INT           newdot;
+
+       newdot = dot + incr;
+       return(newdot);
+}
+
+printc(c)
+       char c;
+{
+       printf("%c", c);
+}
+
+psymoff(v, regnumber, fmt)
+       L_INT   v;
+       char    *fmt;
+{
+       struct  proct   *procp;
+       REG     int diff;
+       if (fmt[0] == 'i') {
+               switch(regnumber){
+               case 12:        /* parameter */
+                       if ((diff = adrtoparam((ADDR) v, adrtoprocp(dot)))
+                                       != -1) {
+                               printf("%s", sl_name);
+                               prdiff(diff);
+                               return(0);
+                       }
+                       break;
+               case 13:        /* local */
+                       if ((diff = adrtolocal((ADDR) -v, adrtoprocp(dot))
+                                       ) != -1) {
+                               printf("%s", sl_name);
+                               prdiff(diff);
+                               return(0);
+                       }
+                       break;
+               default:
+                       break;
+               }
+               if (v < firstdata) {
+                       if ((procp = adrtoprocp((ADDR) v)) != badproc) {
+                               prlnoff(procp, v);
+                               return(0);
+                       }
+               } else {
+                       if ((diff = adrtoext((ADDR) v)) != -1) {
+                               printf("%s", sl_name);
+                               prdiff(diff);
+                               return(0);

                        }
                }
        }
                        }
                }
        }

+       prhex(v);
+       return(1);
+}
+
+prdiff(diff)
+{
+       if (diff) {
+               printf("+");
+               prhex(diff);
+       }

 }
 }

+
+#endif SDB

diff --git a/usr/src/old/adb/adb.vax/optab.c b/usr/src/old/adb/adb.vax/optab.c
index 8d101c2..9b7476e 100644 (file)
--- a/usr/src/old/adb/adb.vax/optab.c
+++ b/usr/src/old/adb/adb.vax/optab.c
@@ -1,36 +1,22 @@
+#ifndef lint
+static char optab_sccsid[] = "@(#)optab.c 4.3 %G%";
+#endif not lint
+#ifdef ADB

 #include "defs.h"
 #include "defs.h"

-static char sccsid[] = "@(#)optab.c 4.2 %G%";
-/*
- * 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 */
+#endif ADB
+#ifdef SDB
+#include "defs.h"
+#endif SDB

 
 

-/*
- * 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 */
+#undef INSTTAB

 
 

+#include "instrs.h"

 
 

-TYPE   struct optab    *OPTAB;
-struct optab {
-       char *iname;
-       char val;
-       char nargs;
-       char argtype[6];
-} optab[] = {
-#define OP(a,b,c,d,e,f,g,h,i) {a,b,c,d,e,f,g,h,i}
-#include "instrs"
+struct insttab insttab[] = {
+#include "instrs.adb"

 0};
 0};

+#include "assizetab.c"
+#undef ADB

 
 #define SYSTAB struct systab
 SYSTAB {
 
 #define SYSTAB struct systab
 SYSTAB {


@@ -116,5 +102,31 @@ STRING     fltimm[] = {
 "64.0", "72.0", "80.0", "88.0", "96.0", "104.0", "112.0", "120.0"
 };
 
 "64.0", "72.0", "80.0", "88.0", "96.0", "104.0", "112.0", "120.0"
 };
 

-char *fmtr = {"%r"};
-char *fmtR = {"%R"};
+#ifdef SDB
+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,
+};
+#endif SDB