Return to opset.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / bin / adb / adb.tahoe

Annotation of 43BSDTahoe/bin/adb/adb.tahoe/opset.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)opset.c    1.1 (Berkeley) 2/25/86";
        !             3: #endif
        !             4: /*
        !             5:  *
        !             6:  *     UNIX debugger
        !             7:  *
        !             8:  */
        !             9: 
        !            10: #include "defs.h"
        !            11: #include "optab.h"
        !            12: 
        !            13: STRING         errflg;
        !            14: L_INT          dot;
        !            15: INT            dotinc;
        !            16: L_INT          var[];
        !            17: 
        !            18: 
        !            19: /* instruction printing */
        !            20: 
        !            21: POS    type, space, incp;
        !            22: 
        !            23: OPTAB ioptab[256]; /* index by opcode to optab */
        !            24: 
        !            25: mkioptab() {/* set up ioptab */
        !            26:        REG OPTAB p=optab;
        !            27:        while (p->iname){
        !            28:                ioptab[p->val&LOBYTE]=p;
        !            29:                p++;
        !            30:        }
        !            31: }
        !            32: 
        !            33: printins(idsp,ins)
        !            34:        REG L_INT       ins;
        !            35: {
        !            36:        short   argno;          /* argument index */
        !            37:        REG     mode;           /* mode */
        !            38:        REG     r;              /* register name */
        !            39:        REG     d;              /* assembled byte, word, long or float */
        !            40:        long    snarf();
        !            41:        REG char *      ap;
        !            42:        REG OPTAB       ip;
        !            43: 
        !            44:        type = DSYM;
        !            45:        space = idsp;
        !            46:        ins = byte(ins);
        !            47:        if((ip=ioptab[ins]) == (OPTAB)0) {
        !            48:                printf("?%2x%8t", ins);
        !            49:                dotinc = 1;
        !            50:                return;
        !            51:        }
        !            52:        printf("%s%8t",ip->iname);
        !            53:        incp = 1;
        !            54:        ap = ip->argtype;
        !            55:        for (argno=0; argno<ip->nargs; argno++,ap++) {
        !            56:                var[argno] = 0x80000000;
        !            57:                if (argno!=0) printc(',');
        !            58:          top:
        !            59:                if (*ap&ACCB)
        !            60:                        mode = 0xAF + ((*ap&7)<<5);  /* branch displacement */
        !            61:                else{
        !            62:                        mode = bchkget(inkdot(incp),idsp); ++incp;
        !            63:                }
        !            64:                r = mode&0xF;
        !            65:                mode >>= 4;
        !            66:                switch ((int)mode) {
        !            67:                        case 0:
        !            68:                        case 1:
        !            69:                        case 2:
        !            70:                        case 3:
        !            71:                                /* short literal */
        !            72:                                printc('$');
        !            73:                                d = mode<<4|r;
        !            74:                                goto immed;
        !            75:                        case 4: /* [r] */
        !            76:                                printf("[%s]",regname[r]);
        !            77:                                goto top;
        !            78:                        case 5: /* r */
        !            79:                                printf("%s",regname[r]);
        !            80:                                break;
        !            81:                        case 6: /* (r) */
        !            82:                                printf("(%s)",regname[r]);
        !            83:                                break;
        !            84:                        case 7: /* -(r) */
        !            85:                                printf("-(%s)",regname[r]);
        !            86:                                break;
        !            87:                        case 9: /* *(r)+ */
        !            88:                                printc('*');
        !            89:                        case 8: /* (r)+ */
        !            90:                                if(r==0xF || mode==8 && (r==8 || r==9)) {
        !            91:                                        printc('$');
        !            92:                                        d = snarf((r&03)+1, idsp);
        !            93:                                } else {        /*it's not PC immediate or abs*/
        !            94:                                        printf("(%s)+",regname[r]);
        !            95:                                        break;
        !            96:                                }
        !            97:                        immed:
        !            98:                                if(ins == KCALL && d>=0 && d<SYSSIZ) {
        !            99:                                        if(systab[d])
        !           100:                                                printf(systab[d]);
        !           101:                                        else
        !           102:                                                printf("%R", d);
        !           103:                                        break;
        !           104:                                }
        !           105:                                goto disp;
        !           106:                        case 0xB:       /* byte displacement deferred */
        !           107:                        case 0xD:       /* word displacement deferred */
        !           108:                        case 0xF:       /* long displacement deferred */
        !           109:                                printc('*');
        !           110:                        case 0xA:       /* byte displacement */
        !           111:                        case 0xC:       /* word displacement */
        !           112:                        case 0xE:       /* long displacement */
        !           113:                                d = snarf(1<<((mode>>1&03)-1), idsp);
        !           114:                                if (r==0xF) { /* PC offset addressing */
        !           115:                                        d += dot+incp;
        !           116:                                        psymoff(d,type,"");
        !           117:                                        var[argno]=d;
        !           118:                                        break;
        !           119:                                }
        !           120:                        disp:
        !           121:                                if(d>=0 && d<maxoff)
        !           122:                                        printf("%R", d);
        !           123:                                else
        !           124:                                        psymoff(d,type,"");
        !           125:                                if (mode>=0xA)
        !           126:                                        printf("(%s)",regname[r]);
        !           127:                                var[argno]=d;
        !           128:                                break;
        !           129:                } /* end of the mode switch */
        !           130:        }
        !           131:        if (ins==CASEL) {
        !           132:                if(inkdot(incp)&01)     /* align */
        !           133:                        incp++;
        !           134:                for (argno=0; argno<=var[2]; ++argno) {
        !           135:                        printc(EOR);
        !           136:                        printf("    %R:  ",argno+var[1]);
        !           137:                        d=shorten(get(inkdot(incp+argno+argno),idsp));
        !           138:                        if (d&0x8000) d -= 0x10000;
        !           139:                        psymoff(inkdot(incp)+d,type,"");
        !           140:                }
        !           141:                incp += var[2]+var[2]+2;
        !           142:        }
        !           143:        dotinc=incp;
        !           144: }
        !           145: 
        !           146: long snarf (nbytes, idsp)
        !           147: {
        !           148:        register long value;
        !           149: 
        !           150:        value = chkget(inkdot(incp), idsp);
        !           151:        incp += nbytes;
        !           152:        return(value>>(4-nbytes)*8);
        !           153: }

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