Return to tracestop.c CVS log

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

Annotation of 43BSD/ucb/pascal/pdx/tree/tracestop.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[] = "@(#)tracestop.c        5.1 (Berkeley) 6/6/85";
        !             9: #endif not lint
        !            10: 
        !            11: /*
        !            12:  * Handle trace and stop commands.
        !            13:  */
        !            14: 
        !            15: #include "defs.h"
        !            16: #include "breakpoint.h"
        !            17: #include "sym.h"
        !            18: #include "tree.h"
        !            19: #include "runtime.h"
        !            20: #include "source.h"
        !            21: #include "object.h"
        !            22: #include "mappings.h"
        !            23: #include "machine.h"
        !            24: #include "tree.rep"
        !            25: 
        !            26: LOCAL SYM *tcontainer();
        !            27: 
        !            28: /*
        !            29:  * Process a trace/untrace command, basically checking arguments
        !            30:  * and translate to a call of the appropriate routine.
        !            31:  */
        !            32: 
        !            33: trace(cmd, exp, where, cond)
        !            34: int cmd;
        !            35: NODE *exp;
        !            36: NODE *where;
        !            37: NODE *cond;
        !            38: {
        !            39:        if (exp == NIL) {
        !            40:                traceall(cmd, where, cond);
        !            41:        } else if (exp->op == O_LCON || exp->op == O_QLINE) {
        !            42:                traceinst(cmd, exp, where, cond);
        !            43:        } else if (where!=NIL && (where->op==O_QLINE || where->op==O_LCON)) {
        !            44:                traceat(cmd, exp, where, cond);
        !            45:        } else {
        !            46:                tracedata(cmd, exp, where, cond);
        !            47:        }
        !            48:        if (where != NIL) {
        !            49:                tfree(where);
        !            50:        }
        !            51: }
        !            52: 
        !            53: /*
        !            54:  * Set a breakpoint that will turn on tracing.
        !            55:  *
        !            56:  * A line number of 0 in the breakpoint information structure
        !            57:  * means it's a normal trace.
        !            58:  *
        !            59:  * A line number of -1 indicates that we want to trace at the instruction
        !            60:  * rather than source line level.
        !            61:  *
        !            62:  * If location is NIL, turn on tracing because if the user
        !            63:  * has the program stopped somewhere and says "trace",
        !            64:  * he/she wants to see tracing after continuing execution.
        !            65:  */
        !            66: 
        !            67: LOCAL traceall(cmd, where, cond)
        !            68: int cmd;
        !            69: NODE *where;
        !            70: NODE *cond;
        !            71: {
        !            72:        SYM *s;
        !            73:        LINENO line;
        !            74: 
        !            75:        if (where != NIL && where->op != O_NAME) {
        !            76:                error("bad location for trace");
        !            77:        }
        !            78:        if (cmd == O_TRACE) {
        !            79:                line = 0;
        !            80:        } else {
        !            81:                line = -1;
        !            82:        }
        !            83:        if (where == NIL) {
        !            84:                switch (cmd) {
        !            85:                        case O_TRACE:
        !            86:                                if (tracing != 0) {
        !            87:                                        error("already tracing lines");
        !            88:                                }
        !            89:                                tracing++;
        !            90:                                addcond(TRPRINT, cond);
        !            91:                                break;
        !            92: 
        !            93:                        case O_TRACEI:
        !            94:                                if (inst_tracing != 0) {
        !            95:                                        error("already tracing instructions");
        !            96:                                }
        !            97:                                inst_tracing++;
        !            98:                                addcond(TRPRINT, cond);
        !            99:                                break;
        !           100: 
        !           101:                        default:
        !           102:                                panic("bad cmd in traceall");
        !           103:                                break;
        !           104:                }
        !           105:                s = program;
        !           106:        } else if (where->op != O_NAME) {
        !           107:                trerror("found %t, expected procedure or function", where);
        !           108:        } else {
        !           109:                s = where->nameval;
        !           110:                if (!isblock(s)) {
        !           111:                        error("\"%s\" is not a procedure or function", name(s));
        !           112:                }
        !           113:        }
        !           114:        addbp(codeloc(s), ALL_ON, s, cond, NIL, line);
        !           115: }
        !           116: 
        !           117: /*
        !           118:  * Set up the appropriate breakpoint for tracing an instruction.
        !           119:  */
        !           120: 
        !           121: LOCAL traceinst(cmd, exp, where, cond)
        !           122: int cmd;
        !           123: NODE *exp;
        !           124: NODE *where;
        !           125: NODE *cond;
        !           126: {
        !           127:        LINENO line;
        !           128:        ADDRESS addr;
        !           129: 
        !           130:        if (where != NIL) {
        !           131:                error("unexpected \"at\" or \"in\"");
        !           132:        }
        !           133:        if (cmd == O_TRACEI) {
        !           134:                if (exp->op == O_QLINE) {
        !           135:                        addr = (ADDRESS) exp->right->lconval;
        !           136:                } else if (exp->op == O_LCON) {
        !           137:                        addr = (ADDRESS) exp->lconval;
        !           138:                } else {
        !           139:                        trerror("expected integer constant, found %t", exp);
        !           140:                }
        !           141:                line = -1;
        !           142:        } else {
        !           143:                if (exp->op == O_QLINE) {
        !           144:                        line = (LINENO) exp->right->lconval;
        !           145:                        addr = objaddr(line, exp->left->sconval);
        !           146:                } else {
        !           147:                        line = (LINENO) exp->lconval;
        !           148:                        addr = objaddr(line, cursource);
        !           149:                }
        !           150:                if (addr == (ADDRESS) -1) {
        !           151:                        error("can't trace line %d", line);
        !           152:                }
        !           153:        }
        !           154:        tfree(exp);
        !           155:        addbp(addr, INST, NIL, cond, NIL, line);
        !           156: }
        !           157: 
        !           158: /*
        !           159:  * set a breakpoint to print an expression at a given line or address
        !           160:  */
        !           161: 
        !           162: LOCAL traceat(cmd, exp, where, cond)
        !           163: int cmd;
        !           164: NODE *exp;
        !           165: NODE *where;
        !           166: NODE *cond;
        !           167: {
        !           168:        LINENO line;
        !           169:        ADDRESS addr;
        !           170: 
        !           171:        if (cmd == O_TRACEI) {
        !           172:                if (where->op != O_LCON) {
        !           173:                        trerror("expected integer constant, found %t", where);
        !           174:                }
        !           175:                line = -1;
        !           176:                addr = (ADDRESS) where->lconval;
        !           177:        } else {
        !           178:                line = (LINENO) where->right->lconval;
        !           179:                addr = objaddr(line, where->left->sconval);
        !           180:                if (addr == (ADDRESS) -1) {
        !           181:                        error("can't trace at line %d", line);
        !           182:                }
        !           183:        }
        !           184:        addbp(addr, AT_BP, NIL, cond, exp, line);
        !           185: }
        !           186: 
        !           187: /*
        !           188:  * Set up breakpoint for tracing data.
        !           189:  *
        !           190:  * The tracing of blocks lies somewhere between instruction and data;
        !           191:  * it's here since a block cannot be distinguished from other terms.
        !           192:  *
        !           193:  * As in "traceall", if the "block" is the main program then the
        !           194:  * user didn't actually specify a block.  This means we want to
        !           195:  * turn tracing on ourselves because if the program is stopped
        !           196:  * we want to be on regardless of whether they say "cont" or "run".
        !           197:  */
        !           198: 
        !           199: LOCAL tracedata(cmd, exp, block, cond)
        !           200: int cmd;
        !           201: NODE *exp;
        !           202: NODE *block;
        !           203: NODE *cond;
        !           204: {
        !           205:        SYM *s, *t;
        !           206: 
        !           207:        if (exp->op != O_RVAL && exp->op != O_CALL) {
        !           208:                error("can't trace expressions");
        !           209:        }
        !           210:        if (block == NIL) {
        !           211:                t = tcontainer(exp->left);
        !           212:        } else if (block->op == O_NAME) {
        !           213:                t = block->nameval;
        !           214:        } else {
        !           215:                trerror("found %t, expected procedure or function", block);
        !           216:        }
        !           217:        if (exp->left->op == O_NAME) {
        !           218:                s = exp->left->nameval;
        !           219:                if (isblock(s)) {
        !           220:                        addbp(codeloc(t), BLOCK_ON, t, cond, exp->left, 0);
        !           221:                        if (t == program) {
        !           222:                                addbp(codeloc(s), CALL, s, cond, NIL, 0);
        !           223:                        }
        !           224:                        return;
        !           225:                }
        !           226:        }
        !           227:        addbp(codeloc(t), TERM_ON, t, cond, exp, 0);
        !           228:        if (curfunc == t) {
        !           229:                var_tracing++;
        !           230:                addvar(TRPRINT, exp, cond);
        !           231:                addbp(return_addr(), TERM_OFF, t, cond, exp, 0);
        !           232:        }
        !           233: }
        !           234: 
        !           235: /*
        !           236:  * Setting and unsetting of stops.
        !           237:  */
        !           238: 
        !           239: stop(cmd, exp, where, cond)
        !           240: int cmd;
        !           241: NODE *exp;
        !           242: NODE *where;
        !           243: NODE *cond;
        !           244: {
        !           245:        SYM *s;
        !           246:        LINENO n;
        !           247: 
        !           248:        if (exp != NIL) {
        !           249:                stopvar(cmd, exp, where, cond);
        !           250:        } else if (cond != NIL) {
        !           251:                if (where == NIL) {
        !           252:                        s = program;
        !           253:                } else if (where->op == O_NAME) {
        !           254:                        s = where->nameval;
        !           255:                } else {
        !           256:                        error("bad location for stop");
        !           257:                }
        !           258:                n = codeloc(s);
        !           259:                addbp(n, STOP_ON, s, cond, NIL, n);
        !           260:                addcond(TRSTOP, cond);
        !           261:                var_tracing++;
        !           262:        } else if (where->op == O_NAME) {
        !           263:                s = where->nameval;
        !           264:                if (!isblock(s)) {
        !           265:                        error("\"%s\" is not a procedure or function", name(s));
        !           266:                }
        !           267:                n = codeloc(s);
        !           268:                addbp(n, STOP_BP, s, cond, NIL, srcline(firstline(s)));
        !           269:        } else {
        !           270:                stopinst(cmd, where, cond);
        !           271:        }
        !           272:        if (where != NIL) {
        !           273:                tfree(where);
        !           274:        }
        !           275: }
        !           276: 
        !           277: LOCAL stopinst(cmd, where, cond)
        !           278: int cmd;
        !           279: NODE *where;
        !           280: NODE *cond;
        !           281: {
        !           282:        LINENO line;
        !           283:        ADDRESS addr;
        !           284: 
        !           285:        if (where->op != O_QLINE) {
        !           286:                error("expected line number");
        !           287:        }
        !           288:        if (cmd == O_STOP) {
        !           289:                line = (LINENO) where->right->lconval;
        !           290:                addr = objaddr(line, where->left->sconval);
        !           291:                if (addr == (ADDRESS) -1) {
        !           292:                        error("can't stop at that line");
        !           293:                }
        !           294:        } else {
        !           295:                line = -1;
        !           296:                addr = (ADDRESS) where->right->lconval;
        !           297:        }
        !           298:        addbp(addr, STOP_BP, NIL, cond, NIL, line);
        !           299: }
        !           300: 
        !           301: /*
        !           302:  * Implement stopping on assignment to a variable by adding it to
        !           303:  * the variable list.
        !           304:  */
        !           305: 
        !           306: LOCAL stopvar(cmd, exp, where, cond)
        !           307: int cmd;
        !           308: NODE *exp;
        !           309: NODE *where;
        !           310: NODE *cond;
        !           311: {
        !           312:        SYM *s;
        !           313: 
        !           314:        if (exp->op != O_RVAL) {
        !           315:                trerror("found %t, expected variable", exp);
        !           316:        }
        !           317:        if (cmd == O_STOPI) {
        !           318:                inst_tracing++;
        !           319:        }
        !           320:        var_tracing++;
        !           321:        addvar(TRSTOP, exp, cond);
        !           322:        if (where == NIL) {
        !           323:                s = program;
        !           324:        } else if (where->op == O_NAME) {
        !           325:                s = where->nameval;
        !           326:        } else {
        !           327:                error("bad location for stop");
        !           328:        }
        !           329:        addbp(codeloc(s), STOP_ON, s, cond, exp, 0);
        !           330: }
        !           331: 
        !           332: /*
        !           333:  * Figure out the block that contains the symbols
        !           334:  * in the given variable expression.
        !           335:  */
        !           336: 
        !           337: LOCAL SYM *tcontainer(var)
        !           338: NODE *var;
        !           339: {
        !           340:        NODE *p;
        !           341: 
        !           342:        p = var;
        !           343:        while (p->op != O_NAME) {
        !           344:                if (isleaf(p->op)) {
        !           345:                        panic("unexpected op %d in tcontainer", p->op);
        !           346:                        /* NOTREACHED */
        !           347:                }
        !           348:                p = p->left;
        !           349:        }
        !           350:        return container(p->nameval);
        !           351: }

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