UNIX 7th Ed. - /usr/src/cmd/adb/opset.c

   1: #
   2: /*
   3:  *
   4:  *	UNIX debugger
   5:  *
   6:  */
   7: 
   8: #include "defs.h"
   9: 
  10: STRING      errflg;
  11: L_INT       dot;
  12: INT     dotinc;
  13: L_INT       var[];
  14: 
  15: 
  16: /* instruction printing */
  17: 
  18: #define DOUBLE  0
  19: #define DOUBLW  1
  20: #define SINGLE  2
  21: #define SINGLW  3
  22: #define REVERS  4
  23: #define BRANCH  5
  24: #define NOADDR  6
  25: #define DFAULT  7
  26: #define TRAP    8
  27: #define SYS 9
  28: #define SOB 10
  29: #define JMP 11
  30: #define JSR 12
  31: 
  32: 
  33: TYPE    struct optab    *OPTAB;
  34: struct optab {
  35:     int mask;
  36:     int val;
  37:     int itype;
  38:     char    *iname;
  39: } optab[] {
  40:     0107777, 0010000, DOUBLE, "mov",
  41:     0107777, 0020000, DOUBLE, "cmp",
  42:     0107777, 0030000, DOUBLE, "bit",
  43:     0107777, 0040000, DOUBLE, "bic",
  44:     0107777, 0050000, DOUBLE, "bis",
  45:     0007777, 0060000, DOUBLE, "add",
  46:     0007777, 0160000, DOUBLE, "su",
  47:     0100077, 0005000, SINGLE, "clr",
  48:     0100077, 0005100, SINGLE, "com",
  49:     0100077, 0005200, SINGLE, "inc",
  50:     0100077, 0005300, SINGLE, "dec",
  51:     0100077, 0005400, SINGLE, "neg",
  52:     0100077, 0005500, SINGLE, "adc",
  53:     0100077, 0005600, SINGLE, "sbc",
  54:     0100077, 0005700, SINGLE, "tst",
  55:     0100077, 0006000, SINGLE, "ror",
  56:     0100077, 0006100, SINGLE, "rol",
  57:     0100077, 0006200, SINGLE, "asr",
  58:     0100077, 0006300, SINGLE, "asl",
  59:     0000077, 0000100, JMP,    "jmp",
  60:     0000077, 0000300, SINGLE, "swab",
  61:     0000077, 0170100, SINGLW, "ldfps",
  62:     0000077, 0170200, SINGLW, "stfps",
  63:     0000077, 0170300, SINGLW, "stst",
  64:     0000077, 0170400, SINGLW, "clrf",
  65:     0000077, 0170500, SINGLW, "tstf",
  66:     0000077, 0170600, SINGLW, "absf",
  67:     0000077, 0170700, SINGLW, "negf",
  68:     0000077, 0006700, SINGLW, "sxt",
  69:     0000077, 0006600, SINGLW, "mtpi",
  70:     0000077, 0106600, SINGLW, "mtpd",
  71:     0000077, 0006500, SINGLW, "mfpi",
  72:     0000077, 0106500, SINGLW, "mfpd",
  73:     0000777, 0070000, REVERS, "mul",
  74:     0000777, 0071000, REVERS, "div",
  75:     0000777, 0072000, REVERS, "ash",
  76:     0000777, 0073000, REVERS, "ashc",
  77:     LOBYTE,  0000400, BRANCH, "br",
  78:     LOBYTE,  0001000, BRANCH, "bne",
  79:     LOBYTE,  0001400, BRANCH, "beq",
  80:     LOBYTE,  0002000, BRANCH, "bge",
  81:     LOBYTE,  0002400, BRANCH, "blt",
  82:     LOBYTE,  0003000, BRANCH, "bgt",
  83:     LOBYTE,  0003400, BRANCH, "ble",
  84:     LOBYTE,  0100000, BRANCH, "bpl",
  85:     LOBYTE,  0100400, BRANCH, "bmi",
  86:     LOBYTE,  0101000, BRANCH, "bhi",
  87:     LOBYTE,  0101400, BRANCH, "blos",
  88:     LOBYTE,  0102000, BRANCH, "bvc",
  89:     LOBYTE,  0102400, BRANCH, "bvs",
  90:     LOBYTE,  0103000, BRANCH, "bcc",
  91:     LOBYTE,  0103400, BRANCH, "bcs",
  92:     0000000, 0000000, NOADDR, "halt",
  93:     0000000, 0000001, NOADDR, "wait",
  94:     0000000, 0000002, NOADDR, "rti",
  95:     0000000, 0000003, NOADDR, "bpt",
  96:     0000000, 0000004, NOADDR, "iot",
  97:     0000000, 0000005, NOADDR, "reset",
  98:     LOBYTE,  0171000, REVERS, "mulf",
  99:     LOBYTE,  0171400, REVERS, "modf",
 100:     LOBYTE,  0172000, REVERS, "addf",
 101:     LOBYTE,  0172400, REVERS, "movf",
 102:     LOBYTE,  0173000, REVERS, "subf",
 103:     LOBYTE,  0173400, REVERS, "cmpf",
 104:     LOBYTE,  0174000, DOUBLW, "movf",
 105:     LOBYTE,  0174400, REVERS, "divf",
 106:     LOBYTE,  0175000, DOUBLW, "movei",
 107:     LOBYTE,  0175400, DOUBLW, "movfi",
 108:     LOBYTE,  0176000, DOUBLW, "movfo",
 109:     LOBYTE,  0176400, REVERS, "movie",
 110:     LOBYTE,  0177000, REVERS, "movif",
 111:     LOBYTE,  0177400, REVERS, "movof",
 112:     0000000, 0170000, NOADDR, "cfcc",
 113:     0000000, 0170001, NOADDR, "setf",
 114:     0000000, 0170002, NOADDR, "seti",
 115:     0000000, 0170011, NOADDR, "setd",
 116:     0000000, 0170012, NOADDR, "setl",
 117:     0000777, 0004000, JSR,    "jsr",
 118:     0000777, 0074000, DOUBLE, "xor",
 119:     0000007, 0000200, SINGLE, "rts",
 120:     0000017, 0000240, DFAULT, "cflg",
 121:     0000017, 0000260, DFAULT, "sflg",
 122:     LOBYTE,  0104000, TRAP,   "emt",
 123:     LOBYTE,  0104400, SYS,    "sys",
 124:     0000077, 0006400, TRAP,   "mark",
 125:     0000777, 0077000, SOB,    "sob",
 126:     0000007, 0000230, TRAP,   "spl",
 127:     0177777, 0000000, DFAULT, "",
 128: };
 129: 
 130: #define SYSTAB struct systab
 131: SYSTAB {
 132:     int argc;
 133:     char    *sname;
 134: } systab[] {
 135:     1, "indir",
 136:     0, "exit",
 137:     0, "fork",
 138:     2, "read",
 139:     2, "write",
 140:     2, "open",
 141:     0, "close",
 142:     0, "wait",
 143:     2, "creat",
 144:     2, "link",
 145:     1, "unlink",
 146:     2, "exec",
 147:     1, "chdir",
 148:     0, "time",
 149:     3, "mknod",
 150:     2, "chmod",
 151:     2, "chown",
 152:     1, "break",
 153:     2, "stat",
 154:     2, "seek",
 155:     0, "getpid",
 156:     3, "mount",
 157:     1, "umount",
 158:     0, "setuid",
 159:     0, "getuid",
 160:     0, "stime",
 161:     3, "ptrace",
 162:     0, "alarm",
 163:     1, "fstat",
 164:     0, "pause",
 165:     1, "30",
 166:     1, "stty",
 167:     1, "gtty",
 168:     0, "access",
 169:     0, "nice",
 170:     0, "sleep",
 171:     0, "sync",
 172:     1, "kill",
 173:     0, "csw",
 174:     0, "setpgrp",
 175:     0, "tell",
 176:     0, "dup",
 177:     0, "pipe",
 178:     1, "times",
 179:     4, "profil",
 180:     0, "tiu",
 181:     0, "setgid",
 182:     0, "getgid",
 183:     2, "signal",
 184:     0, "49",
 185:     0, "50",
 186:     0, "51",
 187:     0, "52",
 188:     0, "53",
 189:     0, "54",
 190:     0, "55",
 191:     0, "56",
 192:     0, "57",
 193:     0, "58",
 194:     0, "59",
 195:     0, "60",
 196:     0, "61",
 197:     0, "62",
 198:     0, "63",
 199: };
 200: 
 201: STRING  regname[] { "r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc"};
 202: 
 203: POS type, space, incp;
 204: 
 205: printins(f,idsp,ins)
 206: REG INT     ins;
 207: {
 208:     INT     byte;
 209:     REG OPTAB   p;
 210: 
 211:     type=DSYM; space=idsp; incp=2;
 212:     FOR p=optab;; p++
 213:     DO  IF (ins & ~p->mask) == p->val
 214:         THEN    break;
 215:         FI
 216:     OD
 217:     prints(p->iname); byte=ins&0100000; ins &= p->mask;
 218:     switch (p->itype) {
 219: 
 220:         case JMP:
 221:         type=ISYM;
 222: 
 223:         case SINGLE:
 224:         IF byte THEN printc('b'); FI
 225:         case SINGLW:
 226:         paddr("%8t",ins);
 227:         break;
 228: 
 229:         case REVERS:
 230:         doubl(ins&077,(ins>>6)&07);
 231:         break;
 232: 
 233:         case JSR:
 234:         type=ISYM;
 235: 
 236:         case DOUBLE:
 237:         IF byte THEN printc('b'); FI
 238:         case DOUBLW:
 239:         doubl(ins>>6,ins);
 240: 
 241:         case NOADDR:
 242:         break;
 243: 
 244:         case SOB:
 245:         paddr("%8t",(ins>>6)&07);
 246:         branch(",",-(ins&077));
 247:         break;
 248: 
 249:         case BRANCH:
 250:         branch("%8t",ins);
 251:         break;
 252: 
 253:         case SYS:
 254:         BEGIN
 255:            INT      indir;
 256:            REG INT  w;
 257:            printf("%8t%s", systab[ins &= 077].sname);
 258:            IF ins==0 ANDF f==0 ANDF idsp!=NSP   /* indir */
 259:            THEN w=dot; dot=chkget(inkdot(2),idsp);
 260:             prints(" {");
 261:             indir=get(dot,DSP);
 262:             IF errflg
 263:             THEN errflg=0; printc('?');
 264:             ELSE printins(1,DSP,indir);
 265:             FI
 266:             printc('}');
 267:             dot=w; incp=4;
 268:            ELSE w = systab[ins].argc;
 269:             WHILE w-- ANDF idsp!=NSP
 270:             DO prints("; ");
 271:                psymoff(leng(get(inkdot(incp),idsp)), NSYM, "");
 272:                incp += 2;
 273:             OD
 274:            FI
 275:         END
 276:         break;
 277: 
 278:         case TRAP:
 279:         case DFAULT:
 280:         default:
 281:         printf("%8t%o", ins);
 282:     }
 283:     dotinc=incp;
 284: }
 285: 
 286: doubl(a,b)
 287: {
 288:     paddr("%8t",a); paddr(",",b);
 289: }
 290: 
 291: branch(s,ins)
 292: STRING      s;
 293: REG INT     ins;
 294: {
 295:     printf(s);
 296:     IF ins&0200 THEN ins |= 0177400; FI
 297:     ins = shorten(dot) + (ins<<1) + 2;
 298:     psymoff(leng(ins),ISYM,"");
 299: }
 300: 
 301: paddr(s, a)
 302: STRING      s;
 303: REG INT     a;
 304: {
 305:     REG INT     r;
 306: 
 307:     var[2]=var[1];
 308:     r = a&07; a &= 070;
 309: 
 310:     printf(s);
 311:     IF r==7 ANDF a&020
 312:     THEN IF a&010 THEN printc('*'); FI
 313:          IF a&040
 314:          THEN IF space==NSP
 315:           THEN printc('?');
 316:           ELSE  var[1]=chkget(inkdot(incp),space) + shorten(inkdot(incp+2));
 317:                psymoff(var[1],(a&010?DSYM:type),"");
 318:           FI
 319:          ELSE printc('$');
 320:           IF space==NSP
 321:           THEN printc('?');
 322:           ELSE var[1]=chkget(inkdot(incp), space);
 323:             psymoff(var[1], (a&010?type:NSYM), "");
 324:           FI
 325:          FI
 326:          incp += 2;
 327:          return;
 328:     FI
 329:     r = regname[r];
 330:     switch (a) {
 331:         /* r */
 332:         case 000:
 333:         prints(r);
 334:         return;
 335: 
 336:         /* (r) */
 337:         case 010:
 338:         printf("(%s)", r);
 339:         return;
 340: 
 341:         /* *(r)+ */
 342:         case 030:
 343:         printc('*');
 344: 
 345:         /* (r)+ */
 346:         case 020:
 347:         printf("(%s)+", r);
 348:         return;
 349: 
 350:         /* *-(r) */
 351:         case 050:
 352:         printc('*');
 353: 
 354:         /* -(r) */
 355:         case 040:
 356:         printf("-(%s)", r);
 357:         return;
 358: 
 359:         /* *x(r) */
 360:         case 070:
 361:         printc('*');
 362: 
 363:         /* x(r) */
 364:         case 060:
 365:         IF space==NSP
 366:         THEN printc('?');
 367:         ELSE    var[1]=chkget(inkdot(incp), space);
 368:             psymoff(var[1], (a==070?type:NSYM), "");
 369:         FI
 370:         incp += 2;
 371:         printf("(%s)", r);
 372:         return;
 373:     }
 374: }

Defined functions

Defined variables

Defined struct's

Defined macros