Return to m98k-check.c CVS log

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

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

1.1     ! root        1: #include <stdio.h>
        !             2: #include "m98k-opcode.h"
        !             3: 
        !             4: static int bits(
        !             5:     unsigned long width);
        !             6: 
        !             7: static char *cond[] = { "lt", "gt", "eq", "un"};
        !             8: static char *pred[] = { "+", "-" };
        !             9: 
        !            10: void
        !            11: main(
        !            12: int argc,
        !            13: char *argv[],
        !            14: char *envp[])
        !            15: {
        !            16:     long i, j, x, d, p;
        !            17: 
        !            18:        for(i = 0; *(m98k_opcodes[i].name) != '\0'; i++){
        !            19:            printf("\t%s", m98k_opcodes[i].name);
        !            20:            if(IS_BRANCH_CONDITIONAL(m98k_opcodes[i].opcode)){
        !            21:                p = bits(5) & 1;
        !            22:                printf("%s", pred[p]);
        !            23:            }
        !            24:            if(m98k_opcodes[i].ops[0].type == NONE)
        !            25:                printf("\n");
        !            26:            else
        !            27:                printf("\t");
        !            28:            d = 0;
        !            29:            for(j = 0; j < 5 && m98k_opcodes[i].ops[j].type != NONE; j++){
        !            30:                switch(m98k_opcodes[i].ops[j].type){
        !            31:                case PCREL:
        !            32:                    printf("_relitive");
        !            33:                    break;
        !            34:                case BADDR:
        !            35:                    printf("_absolute");
        !            36:                    break;
        !            37:                case D:
        !            38:                    printf("0x%04x(", bits(16));
        !            39:                    d = 1;
        !            40:                    break;
        !            41:                case DS:
        !            42:                    printf("0x%04x(", bits(14) << 2);
        !            43:                    d = 1;
        !            44:                    break;
        !            45:                case SI:
        !            46:                case UI:
        !            47:                    printf("0x%04x", bits(16));
        !            48:                    break;
        !            49:                case GREG:
        !            50:                    printf("r%d", bits(5) );
        !            51:                    break;
        !            52:                case G0REG:
        !            53:                    printf("r%d", bits(5) | 0x1 );
        !            54:                    break;
        !            55:                case FREG:
        !            56:                    printf("f%d", bits(5) );
        !            57:                    break;
        !            58:                case SGREG:
        !            59:                    printf("sr%d", bits(4) );
        !            60:                    break;
        !            61:                case SPREG:
        !            62:                    printf("%d", bits(10) );
        !            63:                    break;
        !            64:                case BCND:
        !            65:                    printf("cr%d+%s", bits(3), cond[bits(2)] );
        !            66:                    break;
        !            67:                case CRF:
        !            68:                case CRFONLY:
        !            69:                    x = bits(3);
        !            70:                    printf("cr%d", x == 0 ? 1 : x);
        !            71:                    break;
        !            72:                case sh:
        !            73:                    printf("%d", bits(6) );
        !            74:                    break;
        !            75:                case mb:
        !            76:                    printf("%d", bits(6) );
        !            77:                    break;
        !            78:                case NUM0:
        !            79:                case NUM:
        !            80:                    if(j == 0 &&
        !            81:                       IS_BRANCH_CONDITIONAL(m98k_opcodes[i].opcode)){
        !            82:                        x = bits(m98k_opcodes[i].ops[j].width);
        !            83:                        if(m98k_opcodes[i].ops[2].type == PCREL)
        !            84:                            if(p == 0) /* + with negative disp */
        !            85:                                x &= 0xfffffffe; 
        !            86:                            else
        !            87:                                x |= 1; 
        !            88:                        else
        !            89:                            if(p == 0) /* + with positive disp */
        !            90:                                x |= 1; 
        !            91:                            else
        !            92:                                x &= 0xfffffffe; 
        !            93:                        if(x == 20)
        !            94:                            x = 0;
        !            95:                        printf("%d", x);
        !            96:                    }
        !            97:                    else
        !            98:                        printf("%d", bits(m98k_opcodes[i].ops[j].width) );
        !            99:                    break;
        !           100:                case NONE:
        !           101:                    break;
        !           102:                }
        !           103:                if(j == 5 || m98k_opcodes[i].ops[j+1].type == NONE){
        !           104:                    if(d == 1)
        !           105:                        printf(")\n");
        !           106:                    else
        !           107:                        printf("\n");
        !           108:                }
        !           109:                else{
        !           110:                    if(m98k_opcodes[i].ops[j].type != D &&
        !           111:                       m98k_opcodes[i].ops[j].type != DS)
        !           112:                        printf(",");
        !           113:                }
        !           114:            }
        !           115:        }
        !           116:        exit(0);
        !           117: }
        !           118: 
        !           119: static
        !           120: int
        !           121: bits(
        !           122: unsigned long width)
        !           123: {
        !           124:      static int x = 1;
        !           125: 
        !           126:        x = (x + 1) & ((1 << width) - 1);
        !           127:        return(x);
        !           128: }

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