Return to bpact.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / breakpoint

Annotation of 43BSD/ucb/pascal/pdx/breakpoint/bpact.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 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: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)bpact.c    5.1 (Berkeley) 6/5/85";
        !             9: #endif not lint
        !            10: /*
        !            11:  * Routines for doing the right thing when a breakpoint is reached.
        !            12:  */
        !            13: 
        !            14: #include "defs.h"
        !            15: #include "breakpoint.h"
        !            16: #include "sym.h"
        !            17: #include "tree.h"
        !            18: #include "source.h"
        !            19: #include "mappings.h"
        !            20: #include "runtime.h"
        !            21: #include "process.h"
        !            22: #include "machine.h"
        !            23: #include "main.h"
        !            24: #include "bp.rep"
        !            25: #include "tree/tree.rep"
        !            26: 
        !            27: typedef enum { SAVE, NOSAVE } SAVEBP;
        !            28: 
        !            29: LOCAL SAVEBP handlebp();
        !            30: 
        !            31: /*
        !            32:  * A "delayed" breakpoint is one that has an action involving execution
        !            33:  * of code, e.g. at a CALL we want to step from the beginning of the
        !            34:  * procedure to the first line before printing parameters.
        !            35:  */
        !            36: 
        !            37: LOCAL short delayed;
        !            38: 
        !            39: #define NONE 0
        !            40: #define DELAY_CALL 1
        !            41: #define DELAY_STOP 2
        !            42: 
        !            43: /*
        !            44:  * Take action at a breakpoint; if it's not a breakpoint return FALSE.
        !            45:  *
        !            46:  * As we go through the list of breakpoints, we have to remember
        !            47:  * the previous one so that "handlebp" can delete breakpoints on
        !            48:  * the fly if necessary.
        !            49:  *
        !            50:  * If the breakpoint is a STOP_BP, handlebp will set "isstopped".  After
        !            51:  * going through the loop, bpact checks if "isstopped" is set and calls
        !            52:  * printstatus if it is.  This is so multiple breakpoints at the same
        !            53:  * address, one of which is a STOP_BP, still work.
        !            54:  */
        !            55: 
        !            56: #define isswitch(bptype) ( \
        !            57:        bptype == ALL_ON || bptype == ALL_OFF || \
        !            58:        bptype == TERM_ON || bptype == TERM_OFF || \
        !            59:        bptype == BLOCK_ON || bptype == BLOCK_OFF || \
        !            60:        bptype == STOP_ON || bptype == STOP_OFF \
        !            61: )
        !            62: 
        !            63: BOOLEAN bpact()
        !            64: {
        !            65:        register BPINFO *p;
        !            66:        BPINFO *prev, *next;
        !            67:        BOOLEAN found;
        !            68:        ADDRESS oldpc;
        !            69: 
        !            70:        delayed = NONE;
        !            71:        found = FALSE;
        !            72:        prev = NIL;
        !            73:        for (p = bphead; p != NIL; p = next) {
        !            74:                next = p->bpnext;
        !            75:                if (p->bpaddr == pc) {
        !            76:                        prbpfound(p);
        !            77:                        found = TRUE;
        !            78:                        if (p->bpcond == NIL || isswitch(p->bptype) || cond(p->bpcond)) {
        !            79:                                prbphandled();
        !            80:                                if (handlebp(p) == NOSAVE) {
        !            81:                                        prbpnosave();
        !            82:                                        if (prev == NIL) {
        !            83:                                                bphead = next;
        !            84:                                        } else {
        !            85:                                                prev->bpnext = next;
        !            86:                                        }
        !            87:                                        dispose(p);
        !            88:                                } else {
        !            89:                                        prbpsave();
        !            90:                                        prev = p;
        !            91:                                }
        !            92:                        } else {
        !            93:                                prev = p;
        !            94:                        }
        !            95:                } else {
        !            96:                        prev = p;
        !            97:                }
        !            98:        }
        !            99:        if (delayed != NONE) {
        !           100:                oldpc = pc;
        !           101:                runtofirst();
        !           102:                if ((delayed&DELAY_CALL) == DELAY_CALL) {
        !           103:                        SYM *s, *t;
        !           104: 
        !           105:                        s = curfunc;
        !           106:                        t = whatblock(return_addr());
        !           107:                        if (t == NIL) {
        !           108:                                panic("can't find block for caller addr %d", caller_addr());
        !           109:                        }
        !           110:                        printcall(s, t);
        !           111:                        addbp(return_addr(), RETURN, s, NIL, NIL, 0);
        !           112:                }
        !           113:                if (pc != oldpc) {
        !           114:                        bpact();
        !           115:                }
        !           116:                if (isstopped) {
        !           117:                        printstatus();
        !           118:                }
        !           119:        } else {
        !           120:                if (isstopped) {
        !           121:                        printstatus();
        !           122:                }
        !           123:        }
        !           124:        fflush(stdout);
        !           125:        return(found);
        !           126: }
        !           127: 
        !           128: /*
        !           129:  * Handle an expected breakpoint appropriately, return whether
        !           130:  * or not to save the breakpoint.
        !           131:  */
        !           132: 
        !           133: LOCAL SAVEBP handlebp(p)
        !           134: BPINFO *p;
        !           135: {
        !           136:        register SYM *s, *t;
        !           137:        SAVEBP r;
        !           138: 
        !           139:        r = SAVE;
        !           140:        switch(p->bptype) {
        !           141:                case ALL_ON:
        !           142:                        curfunc = p->bpblock;
        !           143:                        addcond(TRPRINT, p->bpcond);
        !           144:                        if (p->bpline >= 0) {
        !           145:                                tracing++;
        !           146:                        } else {
        !           147:                                inst_tracing++;
        !           148:                        }
        !           149:                        addbp(return_addr(), ALL_OFF, curfunc, p->bpcond, NIL, 0);
        !           150:                        break;
        !           151: 
        !           152:                case ALL_OFF:
        !           153:                        r = NOSAVE;
        !           154:                        if (p->bpline >= 0) {
        !           155:                                tracing--;
        !           156:                        } else {
        !           157:                                inst_tracing--;
        !           158:                        }
        !           159:                        delcond(TRPRINT, p->bpcond);
        !           160:                        curfunc = p->bpblock;
        !           161:                        break;
        !           162: 
        !           163:                case STOP_ON:
        !           164:                        var_tracing++;
        !           165:                        curfunc = p->bpblock;
        !           166:                        if (p->bpnode != NIL) {
        !           167:                                addvar(TRSTOP, p->bpnode, p->bpcond);
        !           168:                        } else if (p->bpcond != NIL) {
        !           169:                                addcond(TRSTOP, p->bpcond);
        !           170:                        }
        !           171:                        addbp(return_addr(), STOP_OFF, curfunc, p->bpcond, p->bpnode, 0);
        !           172:                        break;
        !           173: 
        !           174:                case STOP_OFF:
        !           175:                        r = NOSAVE;
        !           176:                        delcond(TRSTOP, p->bpcond);
        !           177:                        var_tracing--;
        !           178:                        curfunc = p->bpblock;
        !           179:                        break;
        !           180: 
        !           181:                case INST:
        !           182:                        curline = p->bpline;
        !           183:                        if (curline > 0) {
        !           184:                                printf("trace:  ");
        !           185:                                printlines(curline, curline);
        !           186:                        } else {
        !           187:                                printf("inst trace:     ");
        !           188:                                printinst(pc, pc);
        !           189:                        }
        !           190:                        break;
        !           191: 
        !           192:                case STOP_BP:
        !           193:                        if (p->bpblock != NIL) {
        !           194:                                delayed |= DELAY_STOP;
        !           195:                                curfunc = p->bpblock;
        !           196:                        }
        !           197:                        curline = p->bpline;
        !           198:                        isstopped = TRUE;
        !           199:                        break;
        !           200: 
        !           201:                case BLOCK_ON: {
        !           202:                        BPINFO *nbp;
        !           203: 
        !           204:                        s = p->bpblock;
        !           205:                        t = p->bpnode->nameval;
        !           206:                        nbp = newbp(codeloc(t), CALL, t, p->bpcond, NIL, 0);
        !           207:                        addbp(return_addr(), BLOCK_OFF, (SYM *) nbp, NIL, NIL, 0);
        !           208:                        break;
        !           209:                }
        !           210: 
        !           211:                case BLOCK_OFF: {
        !           212:                        BPINFO *oldbp;
        !           213: 
        !           214:                        r = NOSAVE;
        !           215:                        oldbp = (BPINFO *) p->bpblock;
        !           216:                        delbp(oldbp->bpid);
        !           217:                        break;
        !           218:                }
        !           219: 
        !           220:                case CALL:
        !           221:                        delayed |= DELAY_CALL;
        !           222:                        curfunc = p->bpblock;
        !           223:                        break;
        !           224: 
        !           225:                case RETURN:
        !           226:                        r = NOSAVE;
        !           227:                        s = p->bpblock;
        !           228:                        printrtn(s);
        !           229:                        break;
        !           230: 
        !           231:                case TERM_ON: {
        !           232:                        ADDRESS addr;
        !           233: 
        !           234:                        curfunc = p->bpblock;
        !           235:                        addvar(TRPRINT, p->bpnode, p->bpcond);
        !           236:                        addr = return_addr();
        !           237:                        addbp(addr, TERM_OFF, curfunc, p->bpcond, p->bpnode, 0);
        !           238:                        var_tracing++;
        !           239:                        break;
        !           240:                }
        !           241: 
        !           242:                case TERM_OFF:
        !           243:                        r = NOSAVE;
        !           244:                        var_tracing--;
        !           245:                        delvar(TRPRINT, p->bpnode, p->bpcond);
        !           246:                        curfunc = p->bpblock;
        !           247:                        break;
        !           248: 
        !           249:                case AT_BP:
        !           250:                        printf("at line %d: ", p->bpline);
        !           251:                        eval(p->bpnode);
        !           252:                        prtree(p->bpnode);
        !           253:                        printf(" = ");
        !           254:                        printval(p->bpnode->nodetype);
        !           255:                        putchar('\n');
        !           256:                        break;
        !           257: 
        !           258:                /*
        !           259:                 * Returning from a called procedure.
        !           260:                 * Further breakpoint processing is not done, since if
        !           261:                 * there were any it wouldn't be associated with the call.
        !           262:                 */
        !           263:                case CALLPROC:
        !           264:                        procreturn(p->bpblock);
        !           265:                        delbp(p->bpid);
        !           266:                        erecover();
        !           267:                        /* NOTREACHED */
        !           268: 
        !           269:                case END_BP:
        !           270:                        r = NOSAVE;
        !           271:                        endprogram();
        !           272: 
        !           273:                default:
        !           274:                        panic("unknown bptype %d in cont", p->bptype);
        !           275:                        /* NOTREACHED */
        !           276:        }
        !           277:        return(r);
        !           278: }
        !           279: 
        !           280: /*
        !           281:  * Internal trace routines.
        !           282:  */
        !           283: 
        !           284: LOCAL char *prbptype[] ={
        !           285:        "ALL_ON", "ALL_OFF", "INST", "CALL", "RETURN", "BLOCK_ON", "BLOCK_OFF",
        !           286:        "TERM_ON", "TERM_OFF", "AT_BP", "STOP_BP", "CALLPROC", "END_BP",
        !           287:        "STOP_ON", "STOP_OFF",
        !           288: };
        !           289: 
        !           290: LOCAL prbpfound(p)
        !           291: BPINFO *p;
        !           292: {
        !           293:        if (option('b')) {
        !           294:                printf("%s breakpoint found at pc %d, line %d -- ",
        !           295:                        prbptype[(int) p->bptype], p->bpaddr, p->bpline);
        !           296:        }
        !           297: }
        !           298: 
        !           299: LOCAL prbphandled()
        !           300: {
        !           301:        if (option('b')) {
        !           302:                printf("handled, ");
        !           303:        }
        !           304: }
        !           305: 
        !           306: LOCAL prbpnosave()
        !           307: {
        !           308:        if (option('b')) {
        !           309:                printf("not saved\n");
        !           310:                fflush(stdout);
        !           311:        }
        !           312: }
        !           313: 
        !           314: LOCAL prbpsave()
        !           315: {
        !           316:        if (option('b')) {
        !           317:                printf("saved\n");
        !           318:                fflush(stdout);
        !           319:        }
        !           320: }

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