Return to print.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb

Annotation of cci/usr/src/bin/adb/print.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *
        !             3:  *     UNIX debugger
        !             4:  *
        !             5:  */
        !             6: #include "defs.h"
        !             7: 
        !             8: MSG            LONGFIL;
        !             9: MSG            NOTOPEN;
        !            10: MSG            BADMOD;
        !            11: 
        !            12: MAP            txtmap;
        !            13: MAP            datmap;
        !            14: 
        !            15: ADDR           lastframe;
        !            16: ADDR           callpc;
        !            17: 
        !            18: INT            infile;
        !            19: INT            outfile;
        !            20: CHAR           *lp;
        !            21: L_INT          maxoff;
        !            22: L_INT          maxpos;
        !            23: INT            radix;
        !            24: 
        !            25: /* symbol management */
        !            26: L_INT          localval;
        !            27: 
        !            28: /* breakpoints */
        !            29: BKPTR          bkpthead;
        !            30: 
        !            31: REGLIST reglist [] = {
        !            32:                "p2lr", P2LR,
        !            33:                "p2br",P2BR,
        !            34:                "p0lr", P0LR,
        !            35:                "p0br",P0BR,
        !            36:                "ksp",KSP,
        !            37:                "hfs", HFS,
        !            38:                "psl", PSL,
        !            39:                "pc", PC,
        !            40:                "ach", ACHI,
        !            41:                "acl", ACLO,
        !            42:                "usp",USP,
        !            43:                "fp", FP,
        !            44:                "r12", R12,
        !            45:                "r11", R11,
        !            46:                "r10", R10,
        !            47:                "r9", R9,
        !            48:                "r8", R8,
        !            49:                "r7", R7,
        !            50:                "r6", R6,
        !            51:                "r5", R5,
        !            52:                "r4", R4,
        !            53:                "r3", R3,
        !            54:                "r2", R2,
        !            55:                "r1", R1,
        !            56:                "r0", R0,
        !            57:                0
        !            58: };
        !            59: 
        !            60: char           lastc;
        !            61: 
        !            62: INT            fcor;
        !            63: STRING         errflg;
        !            64: INT            signo;
        !            65: INT            sigcode;
        !            66: 
        !            67: 
        !            68: L_INT          dot;
        !            69: L_INT          var[];
        !            70: STRING         symfil;
        !            71: STRING         corfil;
        !            72: L_INT          pid;
        !            73: L_INT          adrval;
        !            74: INT            adrflg;
        !            75: L_INT          cntval;
        !            76: INT            cntflg;
        !            77: 
        !            78: STRING         signals[] = {
        !            79:                "",
        !            80:                "hangup",
        !            81:                "interrupt",
        !            82:                "quit",
        !            83:                "illegal instruction",
        !            84:                "trace/BPT",
        !            85:                "IOT",
        !            86:                "EMT",
        !            87:                "floating exception",
        !            88:                "killed",
        !            89:                "bus error",
        !            90:                "memory fault",
        !            91:                "bad system call",
        !            92:                "broken pipe",
        !            93:                "alarm call",
        !            94:                "terminated",
        !            95:                "signal 16",
        !            96:                "stop (signal)",
        !            97:                "stop (tty)",
        !            98:                "continue (signal)",
        !            99:                "child termination",
        !           100:                "stop (tty input)",
        !           101:                "stop (tty output)",
        !           102:                "input available (signal)",
        !           103:                "cpu timelimit",
        !           104:                "file sizelimit",
        !           105:                "signal 26",
        !           106:                "signal 27",
        !           107:                "signal 28",
        !           108:                "signal 29",
        !           109:                "signal 30",
        !           110:                "signal 31",
        !           111: };
        !           112: 
        !           113: /* general printing routines ($) */
        !           114: 
        !           115: printtrace(modif)
        !           116: {
        !           117:        REG             narg, i;
        !           118:        REG BKPTR       bkptr;
        !           119:        REG     ADDR    word;
        !           120:        REG     STRING  comptr;
        !           121:        REG     ADDR    argp, frame;
        !           122:        register struct nlist *sp;
        !           123: 
        !           124:        IF cntflg==0 THEN cntval = -1; FI
        !           125: 
        !           126:        switch (modif) {
        !           127: 
        !           128:            case '<':
        !           129:                IF cntval == 0
        !           130:                THEN    WHILE readchar() != EOR
        !           131:                        DO OD
        !           132:                        lp--;
        !           133:                        break;
        !           134:                FI
        !           135:                                                        /* fall through */
        !           136:            case '>':
        !           137:                {CHAR           file[64];
        !           138:                INT             index;
        !           139: 
        !           140:                index=0;
        !           141:                IF modif=='<'
        !           142:                THEN    iclose();
        !           143:                ELSE    oclose();
        !           144:                FI
        !           145:                IF rdc()!=EOR
        !           146:                THEN    REP file[index++]=lastc;
        !           147:                            IF index>=63 THEN error(LONGFIL); FI
        !           148:                        PER readchar()!=EOR DONE
        !           149:                        file[index]=0;
        !           150:                        IF modif=='<'
        !           151:                        THEN    infile=open(file,0);
        !           152:                                IF infile<0
        !           153:                                THEN    infile=0; error(NOTOPEN);
        !           154:                                ELSE    IF cntflg
        !           155:                                        THEN    var[9] = cntval;
        !           156:                                        ELSE    var[9] = 1;
        !           157:                                        FI
        !           158:                                FI
        !           159:                        ELSE    outfile=open(file,1);
        !           160:                                IF outfile<0
        !           161:                                THEN    outfile=creat(file,0644);
        !           162: #ifndef EDDT
        !           163:                                ELSE    lseek(outfile,0L,2);
        !           164: #endif
        !           165:                                FI
        !           166:                        FI
        !           167: 
        !           168:                ELSE    IF modif == '<'
        !           169:                        THEN    iclose();
        !           170:                        FI
        !           171:                FI
        !           172:                lp--;
        !           173:                }
        !           174:                break;
        !           175: 
        !           176:            case 'd':
        !           177:                if (adrflg) {
        !           178:                        if (!(adrval>=2 && adrval<=16 || adrval<=-2 && adrval>=-16)) {
        !           179:                                printf("illegal radix %d base ten",radix);
        !           180:                                break;
        !           181:                        }
        !           182:                        radix=adrval;
        !           183:                }
        !           184:                printf("radix=%d base ten",radix);
        !           185:                break;
        !           186: 
        !           187:            case 'q': case 'Q': case '%':
        !           188:                done();
        !           189: 
        !           190:            case 'w': case 'W':
        !           191:                maxpos=(adrflg?adrval:MAXPOS);
        !           192:                break;
        !           193: 
        !           194:            case 's': case 'S':
        !           195:                maxoff=(adrflg?adrval:MAXOFF);
        !           196:                break;
        !           197: 
        !           198:            case 'v': case 'V':
        !           199:                printf("variables\n");
        !           200:                FOR i=0;i<=35;i++
        !           201:                DO IF var[i]
        !           202:                   THEN printc((i<=9 ? '0' : 'a'-10) + i);
        !           203:                        printf(" = %R\n",var[i]);
        !           204:                   FI
        !           205:                OD
        !           206:                break;
        !           207: 
        !           208:            case 'm': case 'M':
        !           209:                printmap("? map",&txtmap);
        !           210:                printmap("/ map",&datmap);
        !           211:                break;
        !           212: 
        !           213:            case 0: case '?':
        !           214:                IF pid
        !           215:                THEN printf("pcs id = %d\n",pid);
        !           216:                ELSE printf("no process\n");
        !           217:                FI
        !           218:                sigprint(); flushbuf();
        !           219: 
        !           220:            case 'r': case 'R':
        !           221:                printregs(modif);
        !           222:                return;
        !           223: 
        !           224:            case 'c': case 'C':
        !           225:                IF adrflg
        !           226:                THEN frame=adrval;
        !           227:                        callpc=get(frame-8,DSP);
        !           228:                ELSE
        !           229:                        frame= uw[FP];
        !           230:                        callpc= uw[PC];
        !           231:                FI
        !           232:                lastframe=0;
        !           233:                WHILE cntval-- ANDF frame!=0 ANDF frame>lastframe ANDF (adrflg ORF INSTACK(frame))
        !           234:                DO      char *name;
        !           235:                        chkerr();
        !           236:                        findsym(callpc,ISYM);
        !           237:                        if (cursym &&
        !           238:                            !strcmp(cursym->n_un.n_name, "start"))
        !           239:                                break;
        !           240:                        if (cursym)
        !           241:                                name = cursym->n_un.n_name;
        !           242:                        else
        !           243:                                name = "?";
        !           244:                        printf("%s(", name);
        !           245:                        narg = ((get(frame-4, DSP)&0xffff)-4)/4;
        !           246:                        argp = frame;
        !           247:                        LOOP IF narg<=0 THEN break; FI
        !           248:                                printf("%R", get(argp += 4, DSP));
        !           249:                                IF --narg>0 THEN printc(','); FI
        !           250:                        POOL
        !           251:                        printf(") at ");
        !           252:                        psymoff(callpc, ISYM, "\n");
        !           253: 
        !           254:                        IF modif=='C'
        !           255:                        THEN WHILE localsym(frame)
        !           256:                             DO word=get(localval,DSP);
        !           257:                                printf("%8t%s:%10t", cursym->n_un.n_name);
        !           258:                                IF errflg THEN printf("?\n"); errflg=0; ELSE printf("%R\n",word); FI
        !           259:                             OD
        !           260:                        FI
        !           261: 
        !           262:                        callpc=get(frame-8, DSP);
        !           263:                        if (callpc > USRSTACK) {
        !           264:                                printf("sigtramp()\n");
        !           265:                                callpc=get(frame+44, DSP);
        !           266:                        }
        !           267:                        lastframe=frame;
        !           268:                        frame=get(frame, DSP)&ALIGN;
        !           269:                OD
        !           270:                break;
        !           271: 
        !           272:            /*print externals*/
        !           273:            case 'e': case 'E':
        !           274:                for (sp = symtab; sp < esymtab; sp++) {
        !           275:                   if (sp->n_type==(N_DATA|N_EXT) ORF sp->n_type==(N_BSS|N_EXT))
        !           276:                        printf("%s:%12t%R\n", sp->n_un.n_name, get(sp->n_value,DSP));
        !           277:                }
        !           278:                break;
        !           279: 
        !           280:            /*print breakpoints*/
        !           281:            case 'b': case 'B':
        !           282:                printf("breakpoints\ncount%8tbkpt%24tcommand\n");
        !           283:                for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
        !           284:                        if (bkptr->flag) {
        !           285:                                printf("%-8.8d",bkptr->count);
        !           286:                                psymoff(bkptr->loc,ISYM,"%24t");
        !           287:                                comptr=bkptr->comm;
        !           288:                                WHILE *comptr DO printc(*comptr++); OD
        !           289:                        }
        !           290:                break;
        !           291: 
        !           292:            default: error(BADMOD);
        !           293:        }
        !           294: 
        !           295: }
        !           296: 
        !           297: printmap(s,amap)
        !           298: STRING s; REG  MAP *amap;
        !           299: {
        !           300:        int file;
        !           301:        file=amap->ufd;
        !           302:        printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
        !           303:        printf("b1 = %-16R",amap->b1);
        !           304:        printf("e1 = %-16R",amap->e1);
        !           305:        printf("f1 = %-16R",amap->f1);
        !           306:        printf("\nb2 = %-16R",amap->b2);
        !           307:        printf("e2 = %-16R",amap->e2);
        !           308:        printf("f2 = %-16R",amap->f2);
        !           309:        printc(EOR);
        !           310: }
        !           311: 
        !           312: printregs(c)
        !           313: {
        !           314:        REG REGPTR      p;
        !           315:        L_INT           v;
        !           316: 
        !           317:        FOR p=reglist; p->rname; p++
        !           318:        DO
        !           319:                if(c!='R' && p->roffs!=PSL)
        !           320:                        continue;
        !           321:                c = 'R';
        !           322:                printf("%s%6t%R %16t", p->rname, v= uw[p->roffs]);
        !           323:                valpr(v,(p->roffs==PC?ISYM:DSYM));
        !           324:                printc(EOR);
        !           325:        OD
        !           326:        printpc();
        !           327: }
        !           328: 
        !           329: getreg(regnam)
        !           330: {
        !           331:        REG REGPTR      p;
        !           332:        REG STRING      regptr;
        !           333:        CHAR    *olp;
        !           334: 
        !           335:        olp=lp;
        !           336:        FOR p=reglist; p->rname; p++
        !           337:        DO      regptr=p->rname;
        !           338:                IF (regnam == *regptr++)
        !           339:                THEN
        !           340:                        WHILE *regptr
        !           341:                        DO IF readchar() != *regptr++
        !           342:                                THEN --regptr; break;
        !           343:                                FI
        !           344:                        OD
        !           345:                        IF *regptr
        !           346:                        THEN lp=olp;
        !           347:                        ELSE return(p->roffs);
        !           348:                        FI
        !           349:                FI
        !           350:        OD
        !           351:        lp=olp;
        !           352:        return(0);
        !           353: }
        !           354: 
        !           355: printpc()
        !           356: {
        !           357:        dot= uw[PC];
        !           358:        psymoff(dot,ISYM,":%16t"); printins(ISP,chkget(dot,ISP));
        !           359:        printc(EOR);
        !           360: }
        !           361: 
        !           362: char   *illinames[] = {
        !           363:        "reserved addressing fault",
        !           364:        "priviliged instruction fault",
        !           365:        "reserved operand fault"
        !           366: };
        !           367: char   *fpenames[] = {
        !           368:        0,
        !           369:        "integer overflow trap",
        !           370:        "integer divide by zero trap",
        !           371: /* not valid
        !           372:        "floating overflow trap",
        !           373:        "floating/decimal divide by zero trap",
        !           374:        "floating underflow trap",
        !           375:        "decimal overflow trap",
        !           376:        "subscript out of range trap",
        !           377:        "floating overflow fault",
        !           378:        "floating divide by zero fault",
        !           379:        "floating undeflow fault"
        !           380: */
        !           381: };
        !           382: 
        !           383: sigprint()
        !           384: {
        !           385:        IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
        !           386:        THEN printf(signals[signo]); FI
        !           387:        switch (signo) {
        !           388: 
        !           389:        case SIGFPE:
        !           390:                IF (sigcode > 0 &&
        !           391:                    sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
        !           392:                        printf(" ("); printf(fpenames[sigcode]); printc(')');
        !           393:                FI
        !           394:                break;
        !           395: 
        !           396:        case SIGILL:
        !           397:                IF (sigcode >= 0 &&
        !           398:                    sigcode < sizeof illinames / sizeof illinames[0]) THEN
        !           399:                        printf(" ("); printf(illinames[sigcode]); printc(')');
        !           400:                FI
        !           401:                break;
        !           402:        }
        !           403: }

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