Return to opset.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb

Annotation of cci/usr/src/bin/adb/opset.c, revision 1.1

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

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