Return to trace4.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / db

Annotation of coherent/d/bin/db/trace4.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * A debugger.
        !             3:  * Command analyser.
        !             4:  */
        !             5: #include <stdio.h>
        !             6: #include "trace.h"
        !             7: 
        !             8: 
        !             9: /*
        !            10:  * Execute a command.
        !            11:  * Return true if more commands may be read.
        !            12:  */
        !            13: command(vp)
        !            14: register VAL *vp;
        !            15: {
        !            16:        register int c;
        !            17:        register int n;
        !            18: 
        !            19:        switch (c=getn()) {
        !            20:        case '=':
        !            21:                if (newline() == 0)
        !            22:                        break;
        !            23:                printx("%lo\n", rvalue(&vp[0], (long)dot));
        !            24:                return (1);
        !            25:        case '?':
        !            26:                if (newline() == 0)
        !            27:                        break;
        !            28:                if (errrstr != NULL)
        !            29:                        printx("%s\n", errrstr);
        !            30:                return (1);
        !            31:        case 'a':
        !            32:                if (newline() == 0)
        !            33:                        break;
        !            34:                putaddr(vsegno(&vp[0], -1), lvalue(&vp[0], (long)dot), I);
        !            35:                putx('\n');
        !            36:                return (1);
        !            37:        case 'b':
        !            38:                if (objflag == 0)
        !            39:                        break;
        !            40:                if ((c=getn()) != 'r') {
        !            41:                        ungetn(c);
        !            42:                        c = 'b';
        !            43:                }
        !            44:                getline("i+.:a\ni+.?i\n:x");
        !            45:                n = setubpt(c, (vaddr_t)lvalue(&vp[0], (long)dot), miscbuf);
        !            46:                if (n == 0)
        !            47:                        printe("Cannot set breakpoint");
        !            48:                return (1);
        !            49:        case 'c':
        !            50:                if (newline() == 0)
        !            51:                        break;
        !            52:                else
        !            53:                        c = '\n';
        !            54:                if (excflag == 0)
        !            55:                        break;
        !            56:                if (nvalue(&vp[0]) == 0)
        !            57:                        setpc((vaddr_t)lvalue(&vp[0], (long)0));
        !            58:                sinmode = SNULL;
        !            59:                return (0);
        !            60:        case 'd':
        !            61:                if (objflag == 0)
        !            62:                        break;
        !            63:                if ((c=getn())!='r' && c!='s' && c!='a') {
        !            64:                        ungetn(c);
        !            65:                        c = 'b';
        !            66:                }
        !            67:                if (newline() == 0)
        !            68:                        break;
        !            69:                if( c == 'a') {
        !            70:                        bptinit();
        !            71:                        return( 1);
        !            72:                }
        !            73:                if (delubpt(c, (vaddr_t)lvalue(&vp[0], (long)dot)) == 0)
        !            74:                        printe("Cannot delete breakpoint");
        !            75:                return (1);
        !            76:        case 'e':
        !            77:                if (nvalue(&vp[0]) == 0)
        !            78:                        setpc((vaddr_t)lvalue(&vp[0], (long)0));
        !            79:                getline("");
        !            80:                return(runfile());
        !            81:        case 'f':
        !            82:                if (newline() == 0)
        !            83:                        break;
        !            84:                printx("%s\n", trapstr!=NULL ? trapstr : "No fault");
        !            85:                return (1);
        !            86:        case 'k':
        !            87:                if (excflag == 0)
        !            88:                        break;
        !            89:                if (newline() == 0)
        !            90:                        break;
        !            91:                if (nvalue(&vp[0]) != 0) {
        !            92:                        printe("No signal specified");
        !            93:                        return (1);
        !            94:                }
        !            95:                printr("Cannot send %d", (int)rvalue(&vp[0], (long)0));
        !            96:                return (1);
        !            97:        case 'm':
        !            98:                if (newline() == 0)
        !            99:                        break;
        !           100:                dispmap();
        !           101:                return (1);
        !           102:        case 'n':
        !           103:                if( ( c = getn()) == 'o')
        !           104:                        dbase = 8;
        !           105:                else if( c == 'd')
        !           106:                        dbase = 10;
        !           107:                else if( c == 'x')
        !           108:                        dbase = 16;
        !           109:                else
        !           110:                        break;
        !           111:                if( newline() == 0)
        !           112:                        break;
        !           113:                return( 1);
        !           114:        case 'o':
        !           115:                if (newline() == 0)
        !           116:                        break;
        !           117:                cantype = rvalue(&vp[0], (long)0);
        !           118:                return (1);
        !           119:        case 'p':
        !           120:                if (newline() == 0)
        !           121:                        break;
        !           122:                dispbpt();
        !           123:                return (1);
        !           124:        case 'q':
        !           125:                if (newline() == 0)
        !           126:                        break;
        !           127:                if (rvalue(&vp[0], (long)1))
        !           128:                        leave();
        !           129:                return (1);
        !           130:        case 'r':
        !           131:                if (newline() == 0)
        !           132:                        break;
        !           133:                else
        !           134:                        c = '\n';
        !           135:                if (regflag == 0)
        !           136:                        break;
        !           137:                dispreg();
        !           138:                return (1);
        !           139:        case 's':
        !           140:                if (excflag == 0)
        !           141:                        break;
        !           142:                if (nvalue(&vp[0]) == 0)
        !           143:                        setpc((vaddr_t)lvalue(&vp[0], (long)0));
        !           144:                sindecr = rvalue(&vp[1], (long)1);
        !           145:                sinmode = SCONT;
        !           146:                if ((c=getn()) != 'c') {
        !           147:                        sinmode = SSTEP;
        !           148:                        ungetn(c);
        !           149:                }
        !           150:                getline("i+.?i");
        !           151:                sinp = savecom(sinp, miscbuf);
        !           152:                return (0);
        !           153:        case 't':
        !           154:                if (newline() == 0)
        !           155:                        break;
        !           156:                else
        !           157:                        c = '\n';
        !           158:                if (regflag == 0)
        !           159:                        break;
        !           160:                dispsbt((int)rvalue(&vp[0], (long)0));
        !           161:                return (1);
        !           162:        case 'x':
        !           163:                if (newline() == 0)
        !           164:                        break;
        !           165:                if (rvalue(&vp[0], (long)1) != 0) {
        !           166:                        sincmod = sinmode;
        !           167:                        sinmode = SNULL;
        !           168:                        addfilp(stdin);
        !           169:                }
        !           170:                return (1);
        !           171:        }
        !           172:        printe("Illegal command");
        !           173:        while (c != '\n')
        !           174:                c = getn();
        !           175:        return (1);
        !           176: }
        !           177: 
        !           178: /*
        !           179:  * If the next character is a newline, return 1, else 0.
        !           180:  */
        !           181: newline()
        !           182: {
        !           183:        return (getn()=='\n');
        !           184: }
        !           185: 
        !           186: /*
        !           187:  * Given a pointer to an allocated buffer and a pointer to a
        !           188:  * command string, copy the command string in the allocated
        !           189:  * buffer.  If the allocated buffer hasn't been allocated,
        !           190:  * allocate it.
        !           191:  */
        !           192: char *
        !           193: savecom(bp, sp)
        !           194: register char *bp;
        !           195: register char *sp;
        !           196: {
        !           197:        register char *cp;
        !           198: 
        !           199:        if (bp == NULL)
        !           200:                bp = nalloc(COMSIZE);
        !           201:        cp = bp;
        !           202:        while (*sp) {
        !           203:                if (cp >= &bp[COMSIZE-1])
        !           204:                        break;
        !           205:                *cp++ = *sp++;
        !           206:        }
        !           207:        *cp++ = '\0';
        !           208:        return (bp);
        !           209: }
        !           210: 
        !           211: /*
        !           212:  * Initialise breakpoint table.
        !           213:  */
        !           214: bptinit()
        !           215: {
        !           216:        register BPT *bp;
        !           217:        register int n;
        !           218: 
        !           219:        for (n=NBPT, bp=&bpt[0]; --n; bp++) {
        !           220:                bp->b_flag = 0;
        !           221:                bp->b_bcom = NULL;
        !           222:                bp->b_rcom = NULL;
        !           223:        }
        !           224: }
        !           225: 
        !           226: /*
        !           227:  * Set a breakpoint (user callable).  If the type is 'b', a regular
        !           228:  * breakpoint.  If it is 'r', a return breakpoint.
        !           229:  */
        !           230: setubpt(t, a, cp)
        !           231: vaddr_t a;
        !           232: char *cp;
        !           233: {
        !           234:        register unsigned n;
        !           235:        vaddr_t pc;
        !           236:        vaddr_t fp;
        !           237: 
        !           238:        if (t == 'b')
        !           239:                n = setibpt(BBPT, a, (vaddr_t)0, cp);
        !           240:        else {
        !           241:                setretf(&pc, &fp);
        !           242:                n = setibpt(BRET, pc, fp, cp);
        !           243:        }
        !           244:        return (n);
        !           245: }
        !           246: 
        !           247: /*
        !           248:  * Set a breakpoint (internal routine).
        !           249:  */
        !           250: setibpt(f, a, fp, cp)
        !           251: register vaddr_t a;
        !           252: vaddr_t fp;
        !           253: char *cp;
        !           254: {
        !           255:        register BPT *bp;
        !           256:        register int n;
        !           257:        int w;
        !           258: 
        !           259: #if FORZ8001
        !           260:        a &= 0x7F00FFFFL;
        !           261: #endif
        !           262:        add = (long)a;
        !           263:        if (getb(1, (char *)&w, sizeof(w)) == 0)
        !           264:                return (0);
        !           265:        for (n=NBPT, bp=&bpt[0]; --n; bp++) {
        !           266:                if (bp->b_flag!=0 && bp->b_badd==a)
        !           267:                        goto out;
        !           268:        }
        !           269:        for (n=NBPT, bp=&bpt[0]; --n; bp++) {
        !           270:                if (bp->b_flag == 0)
        !           271:                        goto out;
        !           272:        }
        !           273:        return (0);
        !           274: out:
        !           275:        if (f!=BBPT && (bp->b_flag&f)!=0)
        !           276:                return (0);
        !           277:        bp->b_flag |= f;
        !           278:        bp->b_badd = a;
        !           279:        switch (f) {
        !           280:        case BBPT:
        !           281:                bp->b_bcom = savecom(bp->b_bcom, cp);
        !           282:                break;
        !           283:        case BRET:
        !           284:                bp->b_rfpt = fp;
        !           285:                bp->b_rcom = savecom(bp->b_rcom, cp);
        !           286:                break;
        !           287:        case BSIN:
        !           288:                bp->b_sfpt = fp;
        !           289:                break;
        !           290:        }
        !           291:        return (1);
        !           292: }
        !           293: 
        !           294: /*
        !           295:  * Delete a breakpoint.  (user callable)
        !           296:  * If `r' is set, it is a return breakpoint.
        !           297:  */
        !           298: delubpt(t, a)
        !           299: vaddr_t a;
        !           300: {
        !           301:        register int f;
        !           302: 
        !           303:        switch (t) {
        !           304:        case 'b':
        !           305:                f = BBPT;
        !           306:                break;
        !           307:        case 'r':
        !           308:                f = BRET;
        !           309:                break;
        !           310:        case 's':
        !           311:                f = BSIN;
        !           312:                break;
        !           313:        }
        !           314:        return (delibpt(f, a));
        !           315: }
        !           316: 
        !           317: /*
        !           318:  * Delete a breakpoint.  (internal routine)
        !           319:  */
        !           320: delibpt(f, a)
        !           321: register int f;
        !           322: vaddr_t a;
        !           323: {
        !           324:        register BPT *bp;
        !           325:        register int n;
        !           326: 
        !           327:        for (n=NBPT, bp=&bpt[0]; --n; bp++) {
        !           328:                if ((bp->b_flag&f)==0 || bp->b_badd!=a)
        !           329:                        continue;
        !           330:                bp->b_flag &= ~f;
        !           331:                return (1);
        !           332:        }
        !           333:        return (0);
        !           334: }
        !           335: 
        !           336: /*
        !           337:  * Display breakpoints.
        !           338:  */
        !           339: dispbpt()
        !           340: {
        !           341:        register BPT *bp;
        !           342:        register int n;
        !           343: 
        !           344:        for (n=NBPT, bp=&bpt[0]; --n; bp++) {
        !           345:                if (testint())
        !           346:                        return;
        !           347:                if ((bp->b_flag&BBPT) != 0)
        !           348:                        putlbpt(' ', bp->b_badd, bp->b_bcom);
        !           349:                if (testint())
        !           350:                        return;
        !           351:                if ((bp->b_flag&BRET) != 0)
        !           352:                        putlbpt('r', bp->b_badd, bp->b_rcom);
        !           353:                if (testint())
        !           354:                        return;
        !           355:                if ((bp->b_flag&BSIN) != 0)
        !           356:                        putlbpt('s', bp->b_badd, "");
        !           357:        }
        !           358: }
        !           359: 
        !           360: /*
        !           361:  * Print out a breakpoint address, type and command.
        !           362:  */
        !           363: putlbpt(t, a, cp)
        !           364: vaddr_t        a;
        !           365: register char *cp;
        !           366: {
        !           367:        register int c;
        !           368: 
        !           369:        printx(DAFMT, (long)a);
        !           370:        printx("%c (", t);
        !           371:        putaddr(1, (long)a, I);
        !           372:        printx(") ");
        !           373:        while ((c=*cp++) != '\0') {
        !           374:                if (c == '\n') {
        !           375:                        printx("\\n");
        !           376:                        continue;
        !           377:                }
        !           378:                if (c == '\\') {
        !           379:                        printx("\\\\");
        !           380:                        continue;
        !           381:                }
        !           382:                putx(c);
        !           383:        }
        !           384:        putx('\n');
        !           385: }
        !           386: 
        !           387: /*
        !           388:  * Print out segmentation map.
        !           389:  */
        !           390: dispmap()
        !           391: {
        !           392:        register MAP *mp;
        !           393:        register int n;
        !           394: 
        !           395:        for (n=0; n<NSEGM; n++) {
        !           396:                if ((mp=segmapl[n]) == NULL)
        !           397:                        continue;
        !           398:                printx("%s", segname[n]);
        !           399:                while (n<NSEGM-1 && segmapl[n+1]==mp)
        !           400:                        printx(" == %s", segname[++n]);
        !           401:                printx("\n");
        !           402:                for (; mp!=NULL; mp=mp->m_next) {
        !           403:                        printx("[");
        !           404:                        putmadd(mp->m_base);
        !           405:                        printx(", ");
        !           406:                        putmadd(mp->m_bend);
        !           407:                        printx("] => ");
        !           408:                        putmadd(mp->m_offt);
        !           409:                        printx(" (%d)\n", mp->m_segi);
        !           410:                        if (testint())
        !           411:                                return;
        !           412:                }
        !           413:        }
        !           414: }
        !           415: 
        !           416: /*
        !           417:  * Print out a long address for segmentation map.
        !           418:  */
        !           419: putmadd(l)
        !           420: fsize_t l;
        !           421: {
        !           422:        register int c, n;
        !           423: 
        !           424:        if (l!=MLI && l!=LI) {
        !           425:                printx(VAFMT, l);
        !           426:                return;
        !           427:        }
        !           428:        c = l==MLI ? '-' : '+';
        !           429:        n = VAWID;
        !           430:        while (n--)
        !           431:                putchar(c);
        !           432: }

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