Return to opset.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / 11v

Annotation of researchv10no/cmd/adb/11v/opset.c, revision 1.1

1.1     ! root        1: #
        !             2: /*
        !             3:  *
        !             4:  *     UNIX debugger
        !             5:  *
        !             6:  */
        !             7: 
        !             8: #include "defs.h"
        !             9: #include "space.h"
        !            10: 
        !            11: #undef SINGLE          /* hack */
        !            12: 
        !            13: /* instruction printing */
        !            14: 
        !            15: #define        DOUBLE  0
        !            16: #define DOUBLW 1
        !            17: #define        SINGLE  2
        !            18: #define SINGLW 3
        !            19: #define        REVERS  4
        !            20: #define        BRANCH  5
        !            21: #define        NOADDR  6
        !            22: #define        DFAULT  7
        !            23: #define        TRAP    8
        !            24: #define        SYS     9
        !            25: #define        SOB     10
        !            26: #define JMP    11
        !            27: #define JSR    12
        !            28: 
        !            29: #define        LOBYTE  0377
        !            30: 
        !            31: 
        !            32: typedef        struct optab    *OPTAB;
        !            33: struct optab {
        !            34:        short   mask;
        !            35:        short   val;
        !            36:        char    itype;
        !            37:        char    *iname;
        !            38: } optab[] = {
        !            39:        0107777, 0010000, DOUBLE, "mov",
        !            40:        0107777, 0020000, DOUBLE, "cmp",
        !            41:        0107777, 0030000, DOUBLE, "bit",
        !            42:        0107777, 0040000, DOUBLE, "bic",
        !            43:        0107777, 0050000, DOUBLE, "bis",
        !            44:        0007777, 0060000, DOUBLE, "add",
        !            45:        0007777, 0160000, DOUBLE, "su",
        !            46:        0100077, 0005000, SINGLE, "clr",
        !            47:        0100077, 0005100, SINGLE, "com",
        !            48:        0100077, 0005200, SINGLE, "inc",
        !            49:        0100077, 0005300, SINGLE, "dec",
        !            50:        0100077, 0005400, SINGLE, "neg",
        !            51:        0100077, 0005500, SINGLE, "adc",
        !            52:        0100077, 0005600, SINGLE, "sbc",
        !            53:        0100077, 0005700, SINGLE, "tst",
        !            54:        0100077, 0006000, SINGLE, "ror",
        !            55:        0100077, 0006100, SINGLE, "rol",
        !            56:        0100077, 0006200, SINGLE, "asr",
        !            57:        0100077, 0006300, SINGLE, "asl",
        !            58:        0000077, 0000100, JMP,    "jmp",
        !            59:        0000077, 0000300, SINGLE, "swab",
        !            60:        0000077, 0170100, SINGLW, "ldfps",
        !            61:        0000077, 0170200, SINGLW, "stfps",
        !            62:        0000077, 0170300, SINGLW, "stst",
        !            63:        0000077, 0170400, SINGLW, "clrf",
        !            64:        0000077, 0170500, SINGLW, "tstf",
        !            65:        0000077, 0170600, SINGLW, "absf",
        !            66:        0000077, 0170700, SINGLW, "negf",
        !            67:        0000077, 0006700, SINGLW, "sxt",
        !            68:        0000077, 0006600, SINGLW, "mtpi",
        !            69:        0000077, 0106600, SINGLW, "mtpd",
        !            70:        0000077, 0006500, SINGLW, "mfpi",
        !            71:        0000077, 0106500, SINGLW, "mfpd",
        !            72:        0000077, 0106700, SINGLW, "mfps",
        !            73:        0000077, 0106400, SINGLW, "mtps",
        !            74:        0000777, 0070000, REVERS, "mul",
        !            75:        0000777, 0071000, REVERS, "div",
        !            76:        0000777, 0072000, REVERS, "ash",
        !            77:        0000777, 0073000, REVERS, "ashc",
        !            78:        LOBYTE,  0000400, BRANCH, "br",
        !            79:        LOBYTE,  0001000, BRANCH, "bne",
        !            80:        LOBYTE,  0001400, BRANCH, "beq",
        !            81:        LOBYTE,  0002000, BRANCH, "bge",
        !            82:        LOBYTE,  0002400, BRANCH, "blt",
        !            83:        LOBYTE,  0003000, BRANCH, "bgt",
        !            84:        LOBYTE,  0003400, BRANCH, "ble",
        !            85:        LOBYTE,  0100000, BRANCH, "bpl",
        !            86:        LOBYTE,  0100400, BRANCH, "bmi",
        !            87:        LOBYTE,  0101000, BRANCH, "bhi",
        !            88:        LOBYTE,  0101400, BRANCH, "blos",
        !            89:        LOBYTE,  0102000, BRANCH, "bvc",
        !            90:        LOBYTE,  0102400, BRANCH, "bvs",
        !            91:        LOBYTE,  0103000, BRANCH, "bcc",
        !            92:        LOBYTE,  0103400, BRANCH, "bcs",
        !            93:        0000000, 0000000, NOADDR, "halt",
        !            94:        0000000, 0000001, NOADDR, "wait",
        !            95:        0000000, 0000002, NOADDR, "rti",
        !            96:        0000000, 0000003, NOADDR, "bpt",
        !            97:        0000000, 0000004, NOADDR, "iot",
        !            98:        0000000, 0000005, NOADDR, "reset",
        !            99:        LOBYTE,  0171000, REVERS, "mulf",
        !           100:        LOBYTE,  0171400, REVERS, "modf",
        !           101:        LOBYTE,  0172000, REVERS, "addf",
        !           102:        LOBYTE,  0172400, REVERS, "movf",
        !           103:        LOBYTE,  0173000, REVERS, "subf",
        !           104:        LOBYTE,  0173400, REVERS, "cmpf",
        !           105:        LOBYTE,  0174000, DOUBLW, "movf",
        !           106:        LOBYTE,  0174400, REVERS, "divf",
        !           107:        LOBYTE,  0175000, DOUBLW, "movei",
        !           108:        LOBYTE,  0175400, DOUBLW, "movfi",
        !           109:        LOBYTE,  0176000, DOUBLW, "movfo",
        !           110:        LOBYTE,  0176400, REVERS, "movie",
        !           111:        LOBYTE,  0177000, REVERS, "movif",
        !           112:        LOBYTE,  0177400, REVERS, "movof",
        !           113:        0000000, 0170000, NOADDR, "cfcc",
        !           114:        0000000, 0170001, NOADDR, "setf",
        !           115:        0000000, 0170002, NOADDR, "seti",
        !           116:        0000000, 0170011, NOADDR, "setd",
        !           117:        0000000, 0170012, NOADDR, "setl",
        !           118:        0000777, 0004000, JSR,    "jsr",
        !           119:        0000777, 0074000, DOUBLE, "xor",
        !           120:        0000007, 0000200, SINGLE, "rts",
        !           121:        0000017, 0000240, DFAULT, "cflg",
        !           122:        0000017, 0000260, DFAULT, "sflg",
        !           123:        LOBYTE,  0104000, TRAP,   "emt",
        !           124: #if NOTDEF
        !           125:        LOBYTE,  0104400, SYS,    "sys",
        !           126: #else
        !           127:        LOBYTE,  0104400, TRAP,   "trap",
        !           128: #endif
        !           129:        0000077, 0006400, TRAP,   "mark",
        !           130:        0000777, 0077000, SOB,    "sob",
        !           131:        0000007, 0000230, TRAP,   "spl",
        !           132:        0177777, 0000000, DFAULT, "",
        !           133: };
        !           134: 
        !           135: #ifdef NOTDEF
        !           136: #define SYSTAB struct systab
        !           137: SYSTAB {
        !           138:        int     argc;
        !           139:        char    *sname;
        !           140: } systab[] = {
        !           141:        1, "indir",
        !           142:        0, "exit",
        !           143:        0, "fork",
        !           144:        2, "read",
        !           145:        2, "write",
        !           146:        2, "open",
        !           147:        0, "close",
        !           148:        0, "wait",
        !           149:        2, "creat",
        !           150:        2, "link",
        !           151:        1, "unlink",
        !           152:        2, "exec",
        !           153:        1, "chdir",
        !           154:        0, "time",
        !           155:        3, "mknod",
        !           156:        2, "chmod",
        !           157:        2, "chown",
        !           158:        1, "break",
        !           159:        2, "stat",
        !           160:        2, "seek",
        !           161:        0, "getpid",
        !           162:        3, "mount",
        !           163:        1, "umount",
        !           164:        0, "setuid",
        !           165:        0, "getuid",
        !           166:        0, "stime",
        !           167:        3, "ptrace",
        !           168:        0, "alarm",
        !           169:        1, "fstat",
        !           170:        0, "pause",
        !           171:        1, "30",
        !           172:        1, "stty",
        !           173:        1, "gtty",
        !           174:        0, "access",
        !           175:        0, "nice",
        !           176:        0, "sleep",
        !           177:        0, "sync",
        !           178:        1, "kill",
        !           179:        0, "csw",
        !           180:        0, "setpgrp",
        !           181:        0, "tell",
        !           182:        0, "dup",
        !           183:        0, "pipe",
        !           184:        1, "times",
        !           185:        4, "profil",
        !           186:        0, "tiu",
        !           187:        0, "setgid",
        !           188:        0, "getgid",
        !           189:        2, "signal",
        !           190:        0, "49",
        !           191:        0, "50",
        !           192:        0, "51",
        !           193:        0, "52",
        !           194:        0, "53",
        !           195:        0, "54",
        !           196:        0, "55",
        !           197:        0, "56",
        !           198:        0, "57",
        !           199:        0, "58",
        !           200:        0, "59",
        !           201:        0, "60",
        !           202:        0, "61",
        !           203:        0, "62",
        !           204:        0, "63",
        !           205: };
        !           206: #endif
        !           207: 
        !           208: char *regname[] = { "r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc"};
        !           209: 
        !           210: static int type, space, incp;
        !           211: 
        !           212: printins(idsp)
        !           213: {
        !           214:        int             byte;
        !           215:        register OPTAB  p;
        !           216:        register short ins;
        !           217: 
        !           218:        ins = sget(dot, idsp);
        !           219:        type=DATASP; space=idsp; incp=2;
        !           220:        for (p=optab;; p++)
        !           221:                if ((ins & ~p->mask) == p->val)
        !           222:                        break;
        !           223:        prints(p->iname);
        !           224:        byte=ins&0100000;
        !           225:        ins &= p->mask;
        !           226:        switch (p->itype) {
        !           227: 
        !           228:            case JMP:
        !           229:                type=INSTSP;
        !           230: 
        !           231:            case SINGLE:
        !           232:                if (byte)
        !           233:                        printc('b');
        !           234:            case SINGLW:
        !           235:                paddr("%8t",ins);
        !           236:                break;
        !           237: 
        !           238:            case REVERS:
        !           239:                doubl(ins&077,(ins>>6)&07);
        !           240:                break;
        !           241: 
        !           242:            case JSR:
        !           243:                type=INSTSP;
        !           244: 
        !           245:            case DOUBLE:
        !           246:                if (byte)
        !           247:                        printc('b');
        !           248:            case DOUBLW:
        !           249:                doubl(ins>>6,ins);
        !           250: 
        !           251:            case NOADDR:
        !           252:                break;
        !           253: 
        !           254:            case SOB:
        !           255:                paddr("%8t",(ins>>6)&07);
        !           256:                branch(",",-(ins&077));
        !           257:                break;
        !           258: 
        !           259:            case BRANCH:
        !           260:                branch("%8t",ins);
        !           261:                break;
        !           262: 
        !           263: #if NOTDEF
        !           264:            case SYS:
        !           265:                BEGIN
        !           266:                   INT          indir;
        !           267:                   REG INT      w;
        !           268:                   printf("%8t%s", systab[ins &= 077].sname);
        !           269:                   IF ins==0 ANDF f==0 ANDF idsp!=NSP   /* indir */
        !           270:                   THEN w=dot; dot=chkget(inkdot(2),idsp);
        !           271:                        prints(" {");
        !           272:                        indir=get(dot,DSP);
        !           273:                        IF errflg
        !           274:                        THEN errflg=0; printc('?');
        !           275:                        ELSE printins(1,DSP,indir);
        !           276:                        FI
        !           277:                        printc('}');
        !           278:                        dot=w; incp=4;
        !           279:                   ELSE w = systab[ins].argc;
        !           280:                        WHILE w-- ANDF idsp!=NSP
        !           281:                        DO prints("; ");
        !           282:                           psymoff(leng(get(inkdot(incp),idsp)), NSYM, "");
        !           283:                           incp += 2;
        !           284:                        OD
        !           285:                   FI
        !           286:                END
        !           287:                break;
        !           288: #endif
        !           289: 
        !           290:            case TRAP:
        !           291:            case DFAULT:
        !           292:            default:
        !           293:                printf("%8t%o", ins);
        !           294:        }
        !           295:        dotinc=incp;
        !           296: }
        !           297: 
        !           298: static
        !           299: doubl(a,b)
        !           300: {
        !           301:        paddr("%8t",a);
        !           302:        paddr(",",b);
        !           303: }
        !           304: 
        !           305: static
        !           306: branch(s,ins)
        !           307: char *s;
        !           308: register WORD ins;
        !           309: {
        !           310:        printf(s);
        !           311:        if (ins&0200)
        !           312:                ins = (char) ins;               /* sign extend byte */
        !           313:        ins = dot + (ins<<1) + 2;
        !           314:        psymoff(ins,INSTSP,"");
        !           315: }
        !           316: 
        !           317: static
        !           318: paddr(s, a)
        !           319: char *s;
        !           320: register int a;
        !           321: {
        !           322:        register int r;
        !           323:        register char *rn;
        !           324: 
        !           325:        var[2]=var[1];
        !           326:        r = a&07; a &= 070;
        !           327: 
        !           328:        printf(s);
        !           329:        if (r==7 && a&020) {
        !           330:                if (a&010)
        !           331:                        printc('*');
        !           332:                if (a&040) {
        !           333:                        if (space==NOSP)
        !           334:                                printc('?');
        !           335:                        else {
        !           336:                                var[1]=stow(sget(inkdot(incp),space)) + inkdot(incp+2);
        !           337:                                chkerr();
        !           338:                                var[1] &= 0177777;
        !           339:                                psymoff(var[1],(a&010?DATASP:type),"");
        !           340:                        }
        !           341:                }
        !           342:                else {
        !           343:                        printc('$');
        !           344:                        if (space==NOSP)
        !           345:                                printc('?');
        !           346:                        else {
        !           347:                                var[1]=stow(sget(inkdot(incp), space));
        !           348:                                chkerr();
        !           349:                                psymoff(var[1], type, "");
        !           350:                        }
        !           351:                }
        !           352:                incp += 2;
        !           353:                return;
        !           354:        }
        !           355:        rn = regname[r];
        !           356:        switch (a) {
        !           357:            /* r */
        !           358:            case 000:
        !           359:                prints(rn);
        !           360:                return;
        !           361: 
        !           362:            /* (r) */
        !           363:            case 010:
        !           364:                printf("(%s)", rn);
        !           365:                return;
        !           366: 
        !           367:            /* *(r)+ */
        !           368:            case 030:
        !           369:                printc('*');
        !           370: 
        !           371:            /* (r)+ */
        !           372:            case 020:
        !           373:                printf("(%s)+", rn);
        !           374:                return;
        !           375: 
        !           376:            /* *-(r) */
        !           377:            case 050:
        !           378:                printc('*');
        !           379: 
        !           380:            /* -(r) */
        !           381:            case 040:
        !           382:                printf("-(%s)", rn);
        !           383:                return;
        !           384: 
        !           385:            /* *x(r) */
        !           386:            case 070:
        !           387:                printc('*');
        !           388: 
        !           389:            /* x(r) */
        !           390:            case 060:
        !           391:                if (space==NOSP)
        !           392:                        printc('?');
        !           393:                else {
        !           394:                        var[1]=stow(sget(inkdot(incp), space));
        !           395:                        chkerr();
        !           396:                        psymoff(var[1], type, "");
        !           397:                }
        !           398:                incp += 2;
        !           399:                printf("(%s)", rn);
        !           400:                return;
        !           401:        }
        !           402: }
        !           403: 
        !           404: 
        !           405: 

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