disasm.c

ucos on sa1200 from ixp1200 EB

                            int offset = ((given & 0xf00) >> 4) | (given & 0xf);
                            if ((given & 0x00800000) == 0)
                                offset = -offset;
                            /* +++ */
                            printf("\t; 2. 0x%08x", offset + pc + 8);
                        }
                        else
                        {
                            printf("[%s", 
                                arm_regnames[(given >> 16) & 0xf]);
                            if ((given & 0x01000000) != 0)
                            {
                                /* pre-indexed */
                                if ((given & 0x00400000) == 0x00400000)
                                {
                                    /* immediate */
                                    int offset = ((given & 0xf00) >> 4) | (given & 0xf);
                                    if (offset)
                                        printf(", %s#0x%x",
                                        (((given & 0x00800000) == 0)
                                        ? "-" : ""), offset);
                                }
                                else
                                {
                                    /* register */
                                    printf(", %s%s",
                                        (((given & 0x00800000) == 0)
                                        ? "-" : ""),
                                        arm_regnames[given & 0xf]);
                                }
                                
                                printf("]%s", 
                                    ((given & 0x00200000) != 0) ? "!" : "");
                            }
                            else
                            {
                                /* post-indexed */
                                if ((given & 0x00400000) == 0x00400000)
                                {
                                    /* immediate */
                                    int offset = ((given & 0xf00) >> 4) | (given & 0xf);
                                    if (offset)
                                        printf("], %s#0x%x",
                                        (((given & 0x00800000) == 0)
                                        ? "-" : ""), offset);
                                    else 
                                        printf("]");
                                }
                                else
                                {
                                    /* register */
                                    printf("], %s%s",
                                        (((given & 0x00800000) == 0)
                                        ? "-" : ""),
                                        arm_regnames[given & 0xf]);
                                }
                            }
                        }
                        break;
                        
                    case 'b':
                        /* +++ */
                        /* printf("\t; 3. 0x%08x", BDISP (given) * 4 + pc + 8); */
                        printf("0x%08x", BDISP (given) * 4 + pc + 8);
                        break;
                        
                    case 'c':
                        printf("%s",
                            arm_conditional [(given >> 28) & 0xf]);
                        break;
                        
                    case 'm':
                        {
                            int started = 0;
                            int reg;
                            
                            printf("{");
                            for (reg = 0; reg < 16; reg++)
                                if ((given & (1 << reg)) != 0)
                                {
                                    if (started)
                                        printf(", ");
                                    started = 1;
                                    printf("%s", arm_regnames[reg]);
                                }
                                printf("}");
                        }
                        break;
                        
                    case 'o':
                        if ((given & 0x02000000) != 0)
                        {
                            int rotate = (given & 0xf00) >> 7;
                            int immed = (given & 0xff);
                            printf("#0x%x",
                                ((immed << (32 - rotate))
                                | (immed >> rotate)) & 0xffffffff);
                        }
                        else
                            arm_decode_shift(given);
                        break;
                        
                    case 'p':
                        if ((given & 0x0000f000) == 0x0000f000)
                            printf("p");
                        break;
                        
                    case 't':
                        if ((given & 0x01200000) == 0x00200000)
                            printf("t");
                        break;
                        
                    case 'h':
                        if ((given & 0x00000020) == 0x00000020)
                            printf("h");
                        else
                            printf("b");
                        break;
                        
                    case 'A':
                        printf("[%s", arm_regnames [(given >> 16) & 0xf]);
                        if ((given & 0x01000000) != 0)
                        {
                            int offset = given & 0xff;
                            if (offset)
                                printf(", %s#0x%x]%s",
                                ((given & 0x00800000) == 0 ? "-" : ""),
                                offset * 4,
                                ((given & 0x00200000) != 0 ? "!" : ""));
                            else
                                printf("]");
                        }
                        else
                        {
                            int offset = given & 0xff;
                            if (offset)
                                printf("], %s#0x%x",
                                ((given & 0x00800000) == 0 ? "-" : ""),
                                offset * 4);
                            else
                                printf("]");
                        }
                        break;
                        
                    case 'C':
                        switch (given & 0x00090000)
                        {
                        default:
                            printf("_???");
                            break;
                        case 0x90000:
                            printf("_all");
                            break;
                        case 0x10000:
                            printf("_ctl");
                            break;
                        case 0x80000:
                            printf("_flg");
                            break;
                        }
                        break;
                        
                    case 'F':
                        switch (given & 0x00408000)
                        {
                        case 0:
                            printf("4");
                            break;
                        case 0x8000:
                            printf("1");
                            break;
                        case 0x00400000:
                            printf("2");
                            break;
                        default:
                            printf("3");
                        }
                        break;
                        
                    case 'P':
                        switch (given & 0x00080080)
                        {
                        case 0:
                            printf("s");
                            break;
                        case 0x80:
                            printf("d");
                            break;
                        case 0x00080000:
                            printf("e");
                            break;
                        default:
                            printf("<illegal precision>");
                            break;
                        }
                        break;

                    case 'Q':
                        switch (given & 0x00408000)
                        {
                        case 0:
                            printf("s");
                            break;
                        case 0x8000:
                            printf("d");
                            break;
                        case 0x00400000:
                            printf("e");
                            break;
                        default:
                            printf("p");
                            break;
                        }
                        break;

                    case 'R':
                        switch (given & 0x60)
                        {
                        case 0:
                            break;
                        case 0x20:
                            printf("p");
                            break;
                        case 0x40:
                            printf("m");
                            break;
                        default:
                            printf("z");
                            break;
                        }
                        break;
                        
                    case '0': case '1': case '2': case '3': case '4': 
                    case '5': case '6': case '7': case '8': case '9':
                    {
                        int bitstart = *c++ - '0';
                        int bitend = 0;
                        while (*c >= '0' && *c <= '9')
                            bitstart = (bitstart * 10) + *c++ - '0';

                        switch (*c) /* switch (*c) -- 1 */
                        {
                        case '-':
                            c++;
                            while (*c >= '0' && *c <= '9')
                                bitend = (bitend * 10) + *c++ - '0';
                            if (!bitend)
                            {
                                printf(" !!!abort!!!\n");
                                return;
                            }

                            switch (*c) /* switch (*c) -- 2 */
                            {
                            case 'r':
                                {
                                    long reg;
                                    reg = given >> bitstart;
                                    reg &= (2 << (bitend - bitstart)) - 1;
                                    printf("%s", arm_regnames[reg]);
                                }
                                break;
                            case 'd':
                                {
                                    long reg;
                                    reg = given >> bitstart;
                                    reg &= (2 << (bitend - bitstart)) - 1;
                                    printf("%d", reg);
                                }
                                break;
                            case 'x':
                                {
                                    long reg;
                                    reg = given >> bitstart;
                                    reg &= (2 << (bitend - bitstart)) - 1;
                                    printf("0x%08x", reg);
                                }
                                break;
                            case 'f':
                                {
                                    long reg;
                                    reg = given >> bitstart;
                                    reg &= (2 << (bitend - bitstart)) - 1;
                                    if (reg > 7)
                                        printf("#%s", arm_fp_const[reg & 7]);
                                    else
                                        printf("f%d", reg);
                                }
                                break;
                            default:
                                printf("!!!abort!!!\n");
                                return;
                            } /* switch (*c) -- 2 */
                            break; /* case '-': */

                        case '`':
                            c++;
                            if ((given & (1 << bitstart)) == 0)
                                printf("%c", *c);
                            break;
                        case '\'':
                            c++;
                            if ((given & (1 << bitstart)) != 0)
                                printf("%c", *c);
                            break;
                        case '?':
                            ++c;
                            if ((given & (1 << bitstart)) != 0)
                                printf("%c", *c++);
                            else
                                printf("%c", *++c);
                            break;
                        default:
                            printf("!!!abort!!!\n");
                            return;
                        } /* switch (*c) -- 1 */
                    }
                    break; /* case '0' - '9' */
                    default:
                        printf("!!!abort!!!\n");
                        return;
                    } /* switch (*++c) */
                }
                else /* if (*c == '%') */
                    printf("%c", *c);
            }
            return; /* last statement in "if ((given & insn->mask) == insn->value)" */
        }
    }

    printf("!!!abort!!!\n");
    return;
}

/* end of file */