Return to kdb_print.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / sys / kdb

Annotation of 43BSDTahoe/sys/kdb/kdb_print.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)kdb_print.c 7.5 (Berkeley) 12/15/86
        !             7:  */
        !             8: 
        !             9: #include "../kdb/defs.h"
        !            10: 
        !            11: char   *BADRAD;
        !            12: 
        !            13: ADDR   lastframe;
        !            14: ADDR   callpc;
        !            15: 
        !            16: char   *BADMOD;
        !            17: char   *lp;
        !            18: long   maxpos;
        !            19: int    radix;
        !            20: char   lastc;
        !            21: 
        !            22: /* breakpoints */
        !            23: BKPTR  bkpthead;
        !            24: 
        !            25: extern REGLIST reglist[];
        !            26: 
        !            27: /* general printing routines ($) */
        !            28: 
        !            29: printtrace(modif)
        !            30: {
        !            31:        register narg, i;
        !            32:        register BKPTR bkptr;
        !            33:        register ADDR word;
        !            34:        register char *comptr;
        !            35:        register ADDR argp, frame;
        !            36:        register struct nlist *sp;
        !            37:        int ntramp;
        !            38:        register struct  proc *p;
        !            39:        extern struct proc *allproc;
        !            40: 
        !            41:        if (cntflg==0)
        !            42:                cntval = -1;
        !            43:        switch (modif) {
        !            44: 
        !            45:        case 'd':
        !            46:                if (adrflg) {
        !            47:                        if (adrval < 2 || adrval > 16)
        !            48:                                error(BADRAD);
        !            49:                        radix = adrval;
        !            50:                }
        !            51:                printf("radix=%d base ten", radix);
        !            52:                break;
        !            53: 
        !            54:        case 'w': case 'W':
        !            55:                printf("maxpos=%d", maxpos=(adrflg?adrval:MAXPOS));
        !            56:                break;
        !            57: 
        !            58:        case 's': case 'S':
        !            59:                printf("maxoff=%d", maxoff=(adrflg?adrval:MAXOFF));
        !            60:                break;
        !            61: 
        !            62:        case 'v': case 'V':
        !            63:                printf("variables\n");
        !            64:                for (i=0;i<=35;i++)
        !            65:                        if (var[i]) {
        !            66:                                printc((i<=9 ? '0' : 'a'-10) + i);
        !            67:                                printf(" = %R\n",var[i]);
        !            68:                        }
        !            69:                break;
        !            70: 
        !            71:        case 0: case '?':
        !            72:                if (p = (struct proc *)var[varchk('p')])
        !            73:                        printf("pid = %d\n", p->p_pid);
        !            74:                else
        !            75:                        printf("in idle loop\n");
        !            76:                printtrap(var[varchk('t')], var[varchk('c')]);
        !            77:                /* fall thru... */
        !            78:        case 'r': case 'R':
        !            79:                printregs(modif);
        !            80:                return;
        !            81: 
        !            82:        case 'c': case 'C':
        !            83:                if (adrflg) {
        !            84:                        frame = adrval;
        !            85:                        callpc = getprevpc(frame);
        !            86:                } else {
        !            87:                        frame = pcb.pcb_fp;
        !            88:                        callpc = pcb.pcb_pc;
        !            89:                }
        !            90:                lastframe = NOFRAME;
        !            91:                ntramp = 0;
        !            92:                while (cntval-- && frame != NOFRAME) {
        !            93:                        char *name;
        !            94: 
        !            95:                        chkerr();
        !            96:                        /* check for pc in pcb (signal trampoline code) */
        !            97:                        if (issignalpc(callpc)) {
        !            98:                                name = "sigtramp";
        !            99:                                ntramp++;
        !           100:                        } else {
        !           101:                                ntramp = 0;
        !           102:                                (void) findsym((long)callpc, ISYM);
        !           103:                                if (cursym)
        !           104:                                        name = cursym->n_un.n_name;
        !           105:                                else
        !           106:                                        name = "?";
        !           107:                        }
        !           108:                        printf("%s(", name);
        !           109:                        narg = getnargs(frame);
        !           110:                        argp = frame;
        !           111:                        if (ntramp != 1)
        !           112:                                while (narg) {
        !           113:                                        printf("%R",
        !           114:                                            get((off_t)(argp = nextarg(argp)),
        !           115:                                                DSP));
        !           116:                                        if (--narg != 0)
        !           117:                                                printc(',');
        !           118:                                }
        !           119:                        printf(") at ");
        !           120:                        psymoff((long)callpc, ISYM, "\n");
        !           121: 
        !           122:                        if (modif=='C') {
        !           123:                                while (localsym((long)frame)) {
        !           124:                                        word = get((off_t)localval, DSP);
        !           125:                                        printf("%8t%s:%10t",
        !           126:                                            cursym->n_un.n_name);
        !           127:                                        if (errflg) {
        !           128:                                                printf("?\n");
        !           129:                                                errflg = 0;
        !           130:                                        } else
        !           131:                                                printf("%R\n", word);
        !           132:                                }
        !           133:                        }
        !           134:                        if (ntramp != 1) {
        !           135:                                callpc = getprevpc(frame);
        !           136:                                lastframe = frame;
        !           137:                                frame = getprevframe(frame);
        !           138:                        } else
        !           139:                                callpc = getsignalpc(lastframe);
        !           140:                        if (!adrflg && !INSTACK(frame))
        !           141:                                break;
        !           142:                }
        !           143:                break;
        !           144: 
        !           145:                /*print externals*/
        !           146:        case 'e': case 'E':
        !           147:                for (sp = symtab; sp < esymtab; sp++)
        !           148:                        if (sp->n_type==(N_DATA|N_EXT) ||
        !           149:                            sp->n_type==(N_BSS|N_EXT))
        !           150:                                printf("%s:%12t%R\n", sp->n_un.n_name,
        !           151:                                        get((off_t)sp->n_value, DSP));
        !           152:                break;
        !           153: 
        !           154:                /*print breakpoints*/
        !           155:        case 'b': case 'B':
        !           156:                printf("breakpoints\ncount%8tbkpt%24tcommand\n");
        !           157:                for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
        !           158:                        if (bkptr->flag) {
        !           159:                                printf("%-8.8d",bkptr->count);
        !           160:                                psymoff((long)bkptr->loc,ISYM,"%24t");
        !           161:                                comptr=bkptr->comm;
        !           162:                                while (*comptr)
        !           163:                                        printc(*comptr++);
        !           164:                        }
        !           165:                break;
        !           166: 
        !           167:        case 'l':
        !           168:                for (p = allproc; p; p = p->p_nxt) {
        !           169:                        printf("%X pid %5d %c", p, p->p_pid,
        !           170:                                p->p_stat == SSLEEP ? 'S' :
        !           171:                                p->p_stat == SRUN ? 'R':
        !           172:                                p->p_stat == SIDL ? 'I':
        !           173:                                p->p_stat == SSTOP ? 'T' : '?');
        !           174:                        if (p->p_wchan) {
        !           175:                                printf(" wait ");
        !           176:                                psymoff((long)p->p_wchan, ISYM, "");
        !           177:                        }
        !           178:                        printc(EOR);
        !           179:                }
        !           180:                break;
        !           181: 
        !           182:        default:
        !           183:                error(BADMOD);
        !           184:        }
        !           185: }
        !           186: 
        !           187: static
        !           188: printregs(c)
        !           189: {
        !           190:        register REGPTR p;
        !           191:        ADDR v;
        !           192: 
        !           193:        for (p = reglist; p->rname; p++) {
        !           194:                if (c != 'R' && ishiddenreg(p))
        !           195:                        continue;
        !           196:                v = *p->rkern;
        !           197:                printf("%s%6t%R %16t", p->rname, v);
        !           198:                valpr((long)v, p->rkern == &pcb.pcb_pc ? ISYM : DSYM);
        !           199:                printc(EOR);
        !           200:        }
        !           201:        printpc();
        !           202: }
        !           203: 
        !           204: getreg(regnam)
        !           205: {
        !           206:        register REGPTR p;
        !           207:        register char *regptr;
        !           208:        char *olp;
        !           209: 
        !           210:        olp = lp;
        !           211:        for (p = reglist; p->rname; p++) {
        !           212:                regptr = p->rname;
        !           213:                if (regnam == *regptr++) {
        !           214:                        while (*regptr)
        !           215:                                if (readchar() != *regptr++) {
        !           216:                                        --regptr;
        !           217:                                        break;
        !           218:                                }
        !           219:                        if (*regptr)
        !           220:                                lp = olp;
        !           221:                        else
        !           222:                                return ((int)p->rkern);
        !           223:                }
        !           224:        }
        !           225:        lp = olp;
        !           226:        return (-1);
        !           227: }
        !           228: 
        !           229: printpc()
        !           230: {
        !           231: 
        !           232:        psymoff((long)pcb.pcb_pc, ISYM, ":%16t");
        !           233:        printins(ISP, (long)chkget((off_t)pcb.pcb_pc, ISP));
        !           234:        printc(EOR);
        !           235: }

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