Return to opset.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / adb

Annotation of 3BSD/cmd/adb/opset.c, revision 1.1.1.1

1.1       root        1: #
                      2: /*
                      3:  *
                      4:  *     UNIX debugger
                      5:  *
                      6:  */
                      7: 
                      8: #include "defs.h"
                      9: SCCSID(@(#)opset.c     2.3);
                     10: 
                     11: STRING         errflg;
                     12: L_INT          dot;
                     13: INT            dotinc;
                     14: L_INT          var[];
                     15: 
                     16: 
                     17: /* instruction printing */
                     18: 
                     19: /*
                     20:  * Argument access types
                     21:  */
                     22: #define ACCA   (8<<3)  /* address only */
                     23: #define ACCR   (1<<3)  /* read */
                     24: #define ACCW   (2<<3)  /* write */
                     25: #define ACCM   (3<<3)  /* modify */
                     26: #define ACCB   (4<<3)  /* branch displacement */
                     27: #define ACCI   (5<<3)  /* XFC code */
                     28: 
                     29: /*
                     30:  * Argument data types
                     31:  */
                     32: #define TYPB   0       /* byte */
                     33: #define TYPW   1       /* word */
                     34: #define TYPL   2       /* long */
                     35: #define TYPQ   3       /* quad */
                     36: #define TYPF   4       /* floating */
                     37: #define TYPD   5       /* double floating */
                     38: 
                     39: 
                     40: TYPE   struct optab    *OPTAB;
                     41: struct optab {
                     42:        char *iname;
                     43:        char val;
                     44:        char nargs;
                     45:        char argtype[6];
                     46: } optab[];
                     47: #define SYSTAB struct systab
                     48: SYSTAB {
                     49:        int     argc;
                     50:        char    *sname;
                     51: } systab[];
                     52: STRING regname[];
                     53: STRING fltimm[];
                     54: POS    type, space, incp;
                     55: 
                     56: int ioptab[256]; /* index by opcode to optab */
                     57: 
                     58: mkioptab() {/* set up ioptab */
                     59: REG OPTAB p=optab; while (p->iname) {ioptab[p->val&LOBYTE]=p-optab; p++;}
                     60: }
                     61: 
                     62: extern char *fmtr;
                     63: extern char *fmtR;
                     64: 
                     65: printins(f,idsp,ins)
                     66: #ifndef vax
                     67: REG INT                ins;
                     68: #else
                     69: REG L_INT      ins;
                     70: #endif
                     71: {
                     72:        short i,b,mode; char **r; long d; char *fmat;
                     73:        REG char *      ap;
                     74:        REG OPTAB       ip;
                     75: #ifndef vax
                     76:        struct {char b2,b3,b0,b1;};
                     77: #else
                     78:        struct {char b0,b1,b2,b3;};
                     79: #endif
                     80: 
                     81:        type=DSYM; space=idsp;
                     82:        ins &= LOBYTE;
                     83:        ip=optab+ioptab[ins]; printf("%s%8t",ip->iname); incp=1;
                     84:        ap=ip->argtype;
                     85:        for (i=0; i<ip->nargs; i++,ap++) {
                     86:                var[i]=0x80000000;
                     87:                if (i!=0) printc(',');
                     88:          top:
                     89:                if (*ap&ACCB) b= 0xAF + ((*ap&7)<<5);  /* branch displacement */
                     90:                else {b=bchkget(inkdot(incp),idsp); ++incp;}
                     91:                if (b&0300) {/* not short literal */
                     92:                        r= &regname[b&0xF]; mode= b >>= 4;
                     93:                  mid:
                     94:                        switch ((int)mode) {
                     95:                                case 4: /* [r] */ printf("[%s]",*r); goto top;
                     96:                                case 5: /* r */ printf("%s",*r); break;
                     97:                                case 7: /* -(r) */ printc('-');
                     98:                          base:
                     99:                                case 6: /* (r) */ printf("(%s)",*r); break;
                    100:                                case 9: /* *(r)+ */ printc('*');
                    101:                                case 8: /* (r)+ */
                    102:                                  if (r==(regname+0xF)) {/* PC: immediate or absolute */
                    103:                                        printc('$'); if (b==9) goto abs;
                    104:                                        mode=((*ap&7)<<1)+0xA; goto mid;
                    105:                                  }
                    106:                                  printf("(%s)+",*r); break;
                    107:                                case 0xB: printc('*');
                    108:                                case 0xA: d=bchkget(inkdot(incp),idsp); ++incp;
                    109:                                  if (d&0x80) d -= 0x100; fmat=fmtr;
                    110:                          disp:
                    111:                                  var[i]=d;
                    112:                                  if (r==(regname+0xF) && b>=0xA) var[i] += dot+incp;
                    113:                                  psymoff(var[i],type,"");
                    114:                                  if (r!=regname+0xF) goto base;
                    115:                                  break;
                    116:                                case 0xD: printc('*');
                    117:                                case 0xC: d=0;
                    118:                                        d.b0 = bchkget(inkdot(incp),idsp); ++incp;
                    119:                                        d.b1 = bchkget(inkdot(incp),idsp); ++incp;
                    120:                                        if (d&0x8000) d -= 0x10000; fmat=fmtr;
                    121:                                        goto disp;
                    122:                                case 0xF: printc('*');
                    123:                                case 0xE:
                    124:                          abs:
                    125:                                        d.b0 = bchkget(inkdot(incp),idsp); ++incp;
                    126:                                        d.b1 = bchkget(inkdot(incp),idsp); ++incp;
                    127:                                        d.b2 = bchkget(inkdot(incp),idsp); ++incp;
                    128:                                        d.b3 = bchkget(inkdot(incp),idsp); ++incp;
                    129:                                        fmat=fmtR; goto disp;
                    130:                        }
                    131:                } else {/* short literal */
                    132:                        var[i]=b;
                    133:                        if ((*ap&7)==TYPF || (*ap&7)==TYPD) printf("$%s",fltimm[b]);
                    134:                        else printf("$%r",b);
                    135:                }
                    136:        }
                    137:        if (ins==0xCF || ins==0xAF || ins==0x8F) {/* CASEx instr */
                    138:                for (i=0; i<=var[2]; ++i) {
                    139:                        printc(EOR); printf("    %R:  ",i+var[1]);
                    140:                        d=get(inkdot(incp+i+i),idsp)&0xFFFF;
                    141:                        if (d&0x8000) d -= 0x10000;
                    142:                        psymoff(inkdot(incp)+d,type,"");
                    143:                }
                    144:                incp += var[2]+var[2]+2;
                    145:        }
                    146:        dotinc=incp;
                    147: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.