dis_arm_instr.c

完整的Bell实验室的嵌入式文件系统TFS

                                    /* Immediate.  */
                                    int offset = ((given & 0xf00) >> 4) 
                                        | (given & 0xf);
                                    if (offset)
                                        func (stream, ", %s#%d",
                                              (((given & 0x00800000) == 0)
                                               ? "-" : ""), offset);
                                } else {
                                    /* Register.  */
                                    func (stream, ", %s%s",
                                          (((given & 0x00800000) == 0)
                                           ? "-" : ""),
                                          arm_regnames[given & 0xf]);
                                }

                                func (stream, "]%s", 
                                      ((given & 0x00200000) != 0) ? "!" : "");
                            } else {
                                /* Post-indexed.  */
                                if ((given & 0x00400000) == 0x00400000) {
                                    /* Immediate.  */
                                    int offset = ((given & 0xf00) >> 4) 
                                        | (given & 0xf);
                                    if (offset)
                                        func (stream, "], %s#%d",
                                              (((given & 0x00800000) == 0)
                                               ? "-" : ""), offset);
                                    else 
                                        func (stream, "]");
                                } else {
                                    /* Register.  */
                                    func (stream, "], %s%s",
                                          (((given & 0x00800000) == 0)
                                           ? "-" : ""),
                                          arm_regnames[given & 0xf]);
                                }
                            }
                        }
                        break;
              
                    case 'b':
#if 0
                        (*info->print_address_func)
                            (BDISP (given) * 4 + pc + 8, info);
#else
                        func (stream, "0x%x", BDISP (given) * 4 + pc + 8);
#endif
                        break;

                    case 'c':
                        func (stream, "%s",
                              arm_conditional [(given >> 28) & 0xf]);
                        break;

                    case 'm':
                    {
                        int started = 0;
                        int reg;

                        func (stream, "{");
                        for (reg = 0; reg < 16; reg++)
                            if ((given & (1 << reg)) != 0) {
                                if (started)
                                    func (stream, ", ");
                                started = 1;
                                func (stream, "%s", arm_regnames[reg]);
                            }
                        func (stream, "}");
                    }
                    break;

                    case 'o':
                        if ((given & 0x02000000) != 0) {
                            int rotate = (given & 0xf00) >> 7;
                            int immed = (given & 0xff);

                            immed = (((immed << (32 - rotate))
                                      | (immed >> rotate)) & 0xffffffff);
                            func (stream, "#%d ; 0x%x", immed, immed);
                        } else
                            arm_decode_shift (given, func, stream);
                        break;

                    case 'p':
                        if ((given & 0x0000f000) == 0x0000f000)
                            func (stream, "p");
                        break;

                    case 't':
                        if ((given & 0x01200000) == 0x00200000)
                            func (stream, "t");
                        break;

                    case 'h':
                        if ((given & 0x00000020) == 0x00000020)
                            func (stream, "h");
                        else
                            func (stream, "b");
                        break;

                    case 'A':
                        func (stream, "[%s", 
                              arm_regnames [(given >> 16) & 0xf]);
                        if ((given & 0x01000000) != 0) {
                            int offset = given & 0xff;
                            if (offset)
                                func (stream, ", %s#%d]%s",
                                      ((given & 0x00800000) == 0 ? "-" : ""),
                                      offset * 4,
                                      ((given & 0x00200000) != 0 ? "!" : ""));
                            else
                                func (stream, "]");
                        } else {
                            int offset = given & 0xff;
                            if (offset)
                                func (stream, "], %s#%d",
                                      ((given & 0x00800000) == 0 ? "-" : ""),
                                      offset * 4);
                            else
                                func (stream, "]");
                        }
                        break;

                    case 'C':
                        switch (given & 0x000f0000)
                        {
                        default:
                            func (stream, "_???");
                            break;
                        case 0x90000:
                            func (stream, "_all");
                            break;
                        case 0x10000:
                            func (stream, "_c");
                            break;
                        case 0x20000:
                            func (stream, "_x");
                            break;
                        case 0x40000:
                            func (stream, "_s");
                            break;
                        case 0x80000:
                            func (stream, "_f");
                            break;
                        }
                        break;

                    case 'F':
                        switch (given & 0x00408000) {
                        case 0:
                            func (stream, "4");
                            break;
                        case 0x8000:
                            func (stream, "1");
                            break;
                        case 0x00400000:
                            func (stream, "2");
                            break;
                        default:
                            func (stream, "3");
                        }
                        break;
            
                    case 'P':
                        switch (given & 0x00080080) {
                        case 0:
                            func (stream, "s");
                            break;
                        case 0x80:
                            func (stream, "d");
                            break;
                        case 0x00080000:
                            func (stream, "e");
                            break;
                        default:
                            func (stream, "<illegal precision>");
                            break;
                        }
                        break;
                    case 'Q':
                        switch (given & 0x00408000) {
                        case 0:
                            func (stream, "s");
                            break;
                        case 0x8000:
                            func (stream, "d");
                            break;
                        case 0x00400000:
                            func (stream, "e");
                            break;
                        default:
                            func (stream, "p");
                            break;
                        }
                        break;
                    case 'R':
                        switch (given & 0x60) {
                        case 0:
                            break;
                        case 0x20:
                            func (stream, "p");
                            break;
                        case 0x40:
                            func (stream, "m");
                            break;
                        default:
                            func (stream, "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) {
                        case '-':
                            c++;
                          
                            while (*c >= '0' && *c <= '9')
                                bitend = (bitend * 10) + *c++ - '0';
                          
                            if (!bitend) {
                                func (stream, "***OOPS!***");
                                return 4;
                            }
                          
                            switch (*c) {
                            case 'r':
                            {
                                long reg;
                  
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                  
                                func (stream, "%s", arm_regnames[reg]);
                            }
                            break;
                            case 'd':
                            {
                                long reg;
                  
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                  
                                func (stream, "%d", reg);
                            }
                            break;

                            case 'x':
                            {
                                long reg;
                              
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                  
                                func (stream, "0x%08x", reg);
                  
                                /* Some SWI instructions have special
                                   meanings.  */
                                if ((given & 0x0fffffff) == 0x0FF00000)
                                    func (stream, " ; IMB");
                                else if ((given & 0x0fffffff) == 0x0FF00001)
                                    func (stream, " ; IMBRange");
                            }
                            break;

                            case 'X':
                            {
                                long reg;
                  
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                  
                                func (stream, "%01x", reg & 0xf);
                            }
                            break;

                            case 'f':
                            {
                                long reg;
                  
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                              
                                if (reg > 7)