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

   1: #
   2: /*
   3:  *
   4:  *	UNIX debugger
   5:  *
   6:  */
   7: 
   8: #include "defs.h"
   9: 
  10: 
  11: MSG     LONGFIL;
  12: MSG     NOTOPEN;
  13: MSG     A68BAD;
  14: MSG     A68LNK;
  15: MSG     BADMOD;
  16: 
  17: MAP     txtmap;
  18: MAP     datmap;
  19: 
  20: SYMTAB      symbol;
  21: INT     lastframe;
  22: INT     callpc;
  23: 
  24: INT     infile;
  25: INT     outfile;
  26: CHAR        *lp;
  27: INT     maxoff;
  28: INT     maxpos;
  29: INT     octal;
  30: 
  31: /* symbol management */
  32: L_INT       localval;
  33: 
  34: /* breakpoints */
  35: BKPTR       bkpthead;
  36: 
  37: REGLIST reglist [] {
  38:         "ps", ps,
  39:         "pc", pc,
  40:         "sp", sp,
  41:         "r5", r5,
  42:         "r4", r4,
  43:         "r3", r3,
  44:         "r2", r2,
  45:         "r1", r1,
  46:         "r0", r0,
  47: };
  48: 
  49: INT     frnames[] { 0, 3, 4, 5, 1, 2 };
  50: 
  51: char        lastc;
  52: POS     corhdr[];
  53: POS     *endhdr;
  54: 
  55: INT     fcor;
  56: STRING      errflg;
  57: INT     signo;
  58: 
  59: 
  60: L_INT       dot;
  61: L_INT       var[];
  62: STRING      symfil;
  63: STRING      corfil;
  64: INT     pid;
  65: L_INT       adrval;
  66: INT     adrflg;
  67: L_INT       cntval;
  68: INT     cntflg;
  69: 
  70: STRING      signals[] {
  71:         "",
  72:         "hangup",
  73:         "interrupt",
  74:         "quit",
  75:         "illegal instruction",
  76:         "trace/BPT",
  77:         "IOT",
  78:         "EMT",
  79:         "floating exception",
  80:         "killed",
  81:         "bus error",
  82:         "memory fault",
  83:         "bad system call",
  84:         "broken pipe",
  85:         "alarm call",
  86:         "terminated",
  87: };
  88: 
  89: 
  90: 
  91: 
  92: /* general printing routines ($) */
  93: 
  94: printtrace(modif)
  95: {
  96:     INT     narg, i, stat, name, limit;
  97:     POS     dynam;
  98:     REG BKPTR   bkptr;
  99:     CHAR        hi, lo;
 100:     INT     word;
 101:     STRING      comptr;
 102:     L_INT       argp, frame, link;
 103:     SYMPTR      symp;
 104: 
 105:     IF cntflg==0 THEN cntval = -1; FI
 106: 
 107:     switch (modif) {
 108: 
 109:         case '<':
 110:         case '>':
 111:         {CHAR       file[64];
 112:         INT     index;
 113: 
 114:         index=0;
 115:         IF modif=='<'
 116:         THEN    iclose();
 117:         ELSE    oclose();
 118:         FI
 119:         IF rdc()!=EOR
 120:         THEN    REP file[index++]=lastc;
 121:                 IF index>=63 THEN error(LONGFIL); FI
 122:             PER readchar()!=EOR DONE
 123:             file[index]=0;
 124:             IF modif=='<'
 125:             THEN    infile=open(file,0);
 126:                 IF infile<0
 127:                 THEN    infile=0; error(NOTOPEN);
 128:                 FI
 129:             ELSE    outfile=open(file,1);
 130:                 IF outfile<0
 131:                 THEN    outfile=creat(file,0644);
 132:                 ELSE    lseek(outfile,0L,2);
 133:                 FI
 134:             FI
 135: 
 136:         FI
 137:         lp--;
 138:         }
 139:         break;
 140: 
 141:         case 'o':
 142:         octal = TRUE; break;
 143: 
 144:         case 'd':
 145:         octal = FALSE; break;
 146: 
 147:         case 'q': case 'Q': case '%':
 148:         done();
 149: 
 150:         case 'w': case 'W':
 151:         maxpos=(adrflg?adrval:MAXPOS);
 152:         break;
 153: 
 154:         case 's': case 'S':
 155:         maxoff=(adrflg?adrval:MAXOFF);
 156:         break;
 157: 
 158:         case 'v': case 'V':
 159:         prints("variables\n");
 160:         FOR i=0;i<=35;i++
 161:         DO IF var[i]
 162:            THEN printc((i<=9 ? '0' : 'a'-10) + i);
 163:             printf(" = %Q\n",var[i]);
 164:            FI
 165:         OD
 166:         break;
 167: 
 168:         case 'm': case 'M':
 169:         printmap("? map",&txtmap);
 170:         printmap("/ map",&datmap);
 171:         break;
 172: 
 173:         case 0: case '?':
 174:         IF pid
 175:         THEN printf("pcs id = %d\n",pid);
 176:         ELSE prints("no process\n");
 177:         FI
 178:         sigprint(); flushbuf();
 179: 
 180:         case 'r': case 'R':
 181:         printregs();
 182:         return;
 183: 
 184:         case 'f': case 'F':
 185:         printfregs(modif=='F');
 186:         return;
 187: 
 188:         case 'c': case 'C':
 189:         frame=(adrflg?adrval:endhdr[r5])&EVEN; lastframe=0;
 190:         callpc=(adrflg?get(frame+2,DSP):endhdr[pc]);
 191:         WHILE cntval--
 192:         DO  chkerr();
 193:             narg = findroutine(frame);
 194:             printf("%.8s(", symbol.symc);
 195:             argp = frame+4;
 196:             IF --narg >= 0
 197:             THEN    printf("%o", get(argp, DSP));
 198:             FI
 199:             WHILE --narg >= 0
 200:             DO  argp += 2;
 201:                 printf(",%o", get(argp, DSP));
 202:             OD
 203:             prints(")\n");
 204: 
 205:             IF modif=='C'
 206:             THEN WHILE localsym(frame)
 207:                  DO word=get(localval,DSP);
 208:                 printf("%8t%.8s:%10t", symbol.symc);
 209:                 IF errflg THEN prints("?\n"); errflg=0; ELSE printf("%o\n",word); FI
 210:                  OD
 211:             FI
 212: 
 213:             lastframe=frame;
 214:             frame=get(frame, DSP)&EVEN;
 215:             IF frame==0 THEN break; FI
 216:         OD
 217:         break;
 218: 
 219:         /*print externals*/
 220:         case 'e': case 'E':
 221:         symset();
 222:         WHILE (symp=symget())
 223:         DO chkerr();
 224:            IF (symp->symf)==043 ORF (symp->symf)==044
 225:            THEN printf("%.8s:%12t%o\n", symp->symc, get(leng(symp->symv),DSP));
 226:            FI
 227:         OD
 228:         break;
 229: 
 230:         case 'a': case 'A':
 231:         frame=(adrflg ? adrval : endhdr[r4]);
 232: 
 233:         WHILE cntval--
 234:         DO chkerr();
 235:            stat=get(frame,DSP); dynam=get(frame+2,DSP); link=get(frame+4,DSP);
 236:            IF modif=='A'
 237:            THEN printf("%8O:%8t%-8o,%-8o,%-8o",frame,stat,dynam,link);
 238:            FI
 239:            IF stat==1 THEN break; FI
 240:            IF errflg THEN error(A68BAD); FI
 241: 
 242:            IF get(link-4,ISP)!=04767
 243:            THEN IF get(link-2,ISP)!=04775
 244:             THEN error(A68LNK);
 245:             ELSE /*compute entry point of routine*/
 246:                  prints(" ? ");
 247:             FI
 248:            ELSE printf("%8t");
 249:                 valpr(name=shorten(link)+get(link-2,ISP),ISYM);
 250:             name=get(leng(name-2),ISP);
 251:             printf("%8t\""); limit=8;
 252:             REP word=get(leng(name),DSP); name += 2;
 253:                 lo=word&LOBYTE; hi=(word>>8)&LOBYTE;
 254:                 printc(lo); printc(hi);
 255:             PER lo ANDF hi ANDF limit-- DONE
 256:             printc('"');
 257:            FI
 258:            limit=4; i=6; printf("%24targs:%8t");
 259:            WHILE limit--
 260:            DO printf("%8t%o",get(frame+i,DSP)); i += 2; OD
 261:            printc(EOR);
 262: 
 263:            frame=dynam;
 264:         OD
 265:         errflg=0;
 266:         flushbuf();
 267:         break;
 268: 
 269:         /*set default c frame*/
 270:         /*print breakpoints*/
 271:         case 'b': case 'B':
 272:         printf("breakpoints\ncount%8tbkpt%24tcommand\n");
 273:         FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
 274:         DO IF bkptr->flag
 275:            THEN printf("%-8.8d",bkptr->count);
 276:             psymoff(leng(bkptr->loc),ISYM,"%24t");
 277:             comptr=bkptr->comm;
 278:             WHILE *comptr DO printc(*comptr++); OD
 279:            FI
 280:         OD
 281:         break;
 282: 
 283:         default: error(BADMOD);
 284:     }
 285: 
 286: }
 287: 
 288: printmap(s,amap)
 289: STRING  s; MAP *amap;
 290: {
 291:     int file;
 292:     file=amap->ufd;
 293:     printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
 294:     printf("b1 = %-16Q",amap->b1);
 295:     printf("e1 = %-16Q",amap->e1);
 296:     printf("f1 = %-16Q",amap->f1);
 297:     printf("\nb2 = %-16Q",amap->b2);
 298:     printf("e2 = %-16Q",amap->e2);
 299:     printf("f2 = %-16Q",amap->f2);
 300:     printc(EOR);
 301: }
 302: 
 303: printfregs(longpr)
 304: {
 305:     REG i;
 306:     L_REAL f;
 307: 
 308:     printf("fpsr	%o\n", corhdr[0].fpsr);
 309:     FOR i=0; i<FRMAX; i++
 310:     DO  IF corhdr[0].fpsr&FD ORF longpr /* long mode */
 311:         THEN    f = corhdr[0].Lfr[frnames[i]];
 312:         ELSE    f = corhdr[0].Sfr[frnames[i]];
 313:         FI
 314:         printf("fr%-8d%-32.18f\n", i, f);
 315:     OD
 316: }
 317: 
 318: printregs()
 319: {
 320:     REG REGPTR  p;
 321:     INT     v;
 322: 
 323:     FOR p=reglist; p < &reglist[9]; p++
 324:     DO  printf("%s%8t%o%8t", p->rname, v=endhdr[p->roffs]);
 325:         valpr(v,(p->roffs==pc?ISYM:DSYM));
 326:         printc(EOR);
 327:     OD
 328:     printpc();
 329: }
 330: 
 331: getreg(regnam)
 332: {
 333:     REG REGPTR  p;
 334:     REG STRING  regptr;
 335:     CHAR        regnxt;
 336:     regnxt=readchar();
 337:     FOR p=reglist; p<&reglist[9]; p++
 338:     DO  regptr=p->rname;
 339:         IF (regnam == *regptr++) ANDF (regnxt == *regptr)
 340:         THEN    return(p->roffs);
 341:         FI
 342:     OD
 343:     lp--;
 344:     return(0);
 345: }
 346: 
 347: printpc()
 348: {
 349:     dot=endhdr[pc];
 350:     psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP));
 351:     printc(EOR);
 352: }
 353: 
 354: sigprint()
 355: {
 356:     prints(signals[signo]);
 357: }

Defined functions

Defined variables