Return to m88k-check.c CVS log

Up to [Apple XNU] / GNUtools / cctools / as

Annotation of GNUtools/cctools/as/m88k-check.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "m88k-opcode.h"
        !             3: 
        !             4: static int reg(void);
        !             5: static int creg(void);
        !             6: static int cnst(void);
        !             7: static void print_cond(void);
        !             8: static void print_cmp(void);
        !             9: 
        !            10: void
        !            11: main(
        !            12: int argc,
        !            13: char *argv[],
        !            14: char *envp[])
        !            15: {
        !            16:     long i, j;
        !            17: 
        !            18:        for(i = 0; i < NUMOPCODES - 1; i++){
        !            19:            printf("\t%s\t", m88k_opcodes[i].name);
        !            20:            if(m88k_opcodes[i].op[0].type == NIL)
        !            21:                printf("\n");
        !            22:            for(j = 0; j < 3 && m88k_opcodes[i].op[j].type != NIL; j++){
        !            23:                switch(m88k_opcodes[i].op[j].type){
        !            24:                case CNST:
        !            25: #ifdef SIGNED_IMMEDIATES
        !            26:                case SCNST:
        !            27: #endif
        !            28:                    printf("0x%04x", cnst() );
        !            29:                    break;
        !            30:                case REG:
        !            31:                    printf("r%d", reg() );
        !            32:                    break;
        !            33:                case BF:
        !            34:                    printf("%d<%d>", reg(), reg() );
        !            35:                    break;
        !            36:                case REGSC:
        !            37:                    printf("[r%d]", reg() );
        !            38:                    break;
        !            39:                case CRREG:
        !            40:                    printf("cr%d", creg() );
        !            41:                    break;
        !            42:                case FCRREG:
        !            43:                    printf("fcr%d", creg() );
        !            44:                    break;
        !            45:                case PCREL:
        !            46:                    printf("undef");
        !            47:                    break;
        !            48:                case CONDMASK:
        !            49:                    print_cond();
        !            50:                    break;
        !            51:                case CMPRSLT:
        !            52:                    print_cmp();
        !            53:                    break;
        !            54:                case ROT:
        !            55:                    printf("<%d>", reg() );
        !            56:                    break;
        !            57:                case E4ROT:
        !            58:                    printf("<%d>", creg() & ~0x3);
        !            59:                    break;
        !            60:                case EREG:
        !            61:                    printf("r%d", reg() & ~0x1);
        !            62:                    break;
        !            63:                case XREG:
        !            64:                    printf("x%d", reg());
        !            65:                    break;
        !            66:                }
        !            67:                if(j == 2 || m88k_opcodes[i].op[j+1].type == NIL)
        !            68:                    printf("\n");
        !            69:                else if(m88k_opcodes[i].op[j+1].type != REGSC)
        !            70:                    printf(",");
        !            71:            }
        !            72:        }
        !            73: }
        !            74: 
        !            75: static
        !            76: int
        !            77: reg(void)
        !            78: {
        !            79:      static int x = 1;
        !            80: 
        !            81:        x = (x + 1) & 0x1f;
        !            82:        return(x);
        !            83: }
        !            84: 
        !            85: static
        !            86: int
        !            87: creg(void)
        !            88: {
        !            89:      static int x = 1;
        !            90: 
        !            91:        x = (x + 1) & 0x3f;
        !            92:        return(x);
        !            93: }
        !            94: 
        !            95: static
        !            96: int
        !            97: cnst(void)
        !            98: {
        !            99:      static int x = 1;
        !           100: 
        !           101:        x = (x + 1) & 0xffff;
        !           102:        return(x);
        !           103: }
        !           104: 
        !           105: static
        !           106: void
        !           107: print_cond(void)
        !           108: {
        !           109:      static int x = 1;
        !           110: 
        !           111:        x = (x + 1) & 0x1f;
        !           112:        switch(x){
        !           113:        case 0x02:
        !           114:            printf("eq0");
        !           115:            break;
        !           116:        case 0x0d:
        !           117:            printf("ne0");
        !           118:            break;
        !           119:        case 0x01:
        !           120:            printf("gt0");
        !           121:            break;
        !           122:        case 0x0c:
        !           123:            printf("lt0");
        !           124:            break;
        !           125:        case 0x03:
        !           126:            printf("ge0");
        !           127:            break;
        !           128:        case 0x0e:
        !           129:            printf("le0");
        !           130:            break;
        !           131:        default:
        !           132:            printf("%d", x);
        !           133:        }
        !           134: }
        !           135: 
        !           136: static
        !           137: char *cmpslot[] = { "**", "**", "eq", "ne", "gt", "le", "lt", "ge",
        !           138:                    "hi", "ls", "lo", "hs", "be", "nb", "he", "nh" };
        !           139: static
        !           140: void
        !           141: print_cmp(void)
        !           142: {
        !           143:      static int x = 1;
        !           144: 
        !           145:        x = (x + 1) & 0x1f;
        !           146:        if(x < 2 || x > 15)
        !           147:            printf("%d", x);
        !           148:        else
        !           149:            printf("%s", cmpslot[x]);
        !           150: }

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