dis_arm_instr.c

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

                                    func (stream, "#%s",
                                          arm_fp_const[reg & 7]);
                                else
                                    func (stream, "f%d", reg);
                            }
                            break;

                            default:
                                func (stream, "***OOPS!***");
                                return 4;
                            }
                            break;
                          
                        case '`':
                            c++;
                            if ((given & (1 << bitstart)) == 0)
                                func (stream, "%c", *c);
                            break;
                        case '\'':
                            c++;
                            if ((given & (1 << bitstart)) != 0)
                                func (stream, "%c", *c);
                            break;
                        case '?':
                            ++c;
                            if ((given & (1 << bitstart)) != 0)
                                func (stream, "%c", *c++);
                            else
                                func (stream, "%c", *++c);
                            break;
                        default:
                            func (stream, "***OOPS!***");
                            return 4;
                        }
                        break;
                      
                    default:
                        func (stream, "***OOPS!***");
                        return 4;
                    }
                    }
#ifdef NOTABS
                } else if (*c == '\t') {
                    func (stream, "%c", ' ');
#endif
                } else {
                    func (stream, "%c", *c);
                }
            }
            return 4;
        }
    }
    func (stream, "***OOPS!***");
    return 4;
}

/*************************************************************************/

int
disarm_print_thumb_instr (unsigned long pc, long given,
                          void *funcA, void *stream) 
{
    int (*func)() = funcA;
    struct thumb_opcode * insn;

    for (insn = thumb_opcodes; insn->assembler; insn++) {
        if ((given & insn->mask) == insn->value) {
            char * c = insn->assembler;

            /* Special processing for Thumb 2 instruction BL sequence:  */
            if (!*c) { /* Check for empty (not NULL) assembler string.  */
                func (stream, "bl\t");
        
#if 0
                info->print_address_func (BDISP23 (given) * 2 + pc + 4, info);
#else
                func (stream, "0x%x", BDISP23 (given) * 2 + pc + 4);
#endif
                return 4;
            } else {
                given &= 0xffff;
          
                for (; *c; c++) {
                    if (*c == '%') {
                        int domaskpc = 0;
                        int domasklr = 0;
              
                        switch (*++c) {
                        case '%':
                            func (stream, "%%");
                            break;
                            
                        case 'S':
                        {
                            long reg;
                
                            reg = (given >> 3) & 0x7;
                            if (given & (1 << 6))
                                reg += 8;
                
                            func (stream, "%s", arm_regnames[reg]);
                        }
                        break;

                        case 'D':
                        {
                            long reg;
                            
                            reg = given & 0x7;
                            if (given & (1 << 7))
                                reg += 8;
                
                            func (stream, "%s", arm_regnames[reg]);
                        }
                        break;

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

                        case 'N':
                            if (given & (1 << 8))
                                domasklr = 1;
                            /* Fall through.  */
                        case 'O':
                            if (*c == 'O' && (given & (1 << 8)))
                                domaskpc = 1;
                            /* Fall through.  */
                        case 'M':
                        {
                            int started = 0;
                            int reg;
                
                            func (stream, "{");
                
                            /* It would be nice if we could spot
                               ranges, and generate the rS-rE format: */
                            for (reg = 0; (reg < 8); reg++)
                                if ((given & (1 << reg)) != 0) {
                                    if (started)
                                        func (stream, ", ");
                                    started = 1;
                                    func (stream, "%s", arm_regnames[reg]);
                                }

                            if (domasklr) {
                                if (started)
                                    func (stream, ", ");
                                started = 1;
                                func (stream, arm_regnames[14] /* "lr" */);
                            }

                            if (domaskpc) {
                                if (started)
                                    func (stream, ", ");
                                func (stream, arm_regnames[15] /* "pc" */);
                            }

                            func (stream, "}");
                        }
                        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 '-':
                            {
                                long reg;
                                
                                c++;
                                while (*c >= '0' && *c <= '9')
                                    bitend = (bitend * 10) + *c++ - '0';
                                if (!bitend) {
                                    func (stream, "***OOPS!***");
                                    return 2;
                                }
                                reg = given >> bitstart;
                                reg &= (2 << (bitend - bitstart)) - 1;
                                switch (*c) {
                                case 'r':
                                    func (stream, "%s", arm_regnames[reg]);
                                    break;
                                    
                                case 'd':
                                    func (stream, "%d", reg);
                                    break;

                                case 'H':
                                    func (stream, "%d", reg << 1);
                                    break;
                                    
                                case 'W':
                                    func (stream, "%d", reg << 2);
                                    break;
                                    
                                case 'a':
                                    /* PC-relative address -- the bottom two
                                       bits of the address are dropped
                                       before the calculation.  */
#if 0
                                    info->print_address_func
                                        (((pc + 4) & ~3) + (reg << 2), info);
#else
                                    func (stream, "0x%x", 
                                          ((pc + 4) & ~3) + (reg << 2));
#endif
                                    break;

                                case 'x':
                                    func (stream, "0x%04x", reg);
                                    break;

                                case 'I':
                                    reg = ((reg ^ (1 << bitend)) 
                                           - (1 << bitend));
                                    func (stream, "%d", reg);
                                    break;

                                case 'B':
                                    reg = ((reg ^ (1 << bitend)) 
                                           - (1 << bitend));
#if 0
                                    (*info->print_address_func)
                                        (reg * 2 + pc + 4, info);
#else
                                    func(stream, "0x%x", reg * 2 + pc + 4);
#endif
                                    break;

                                default:
                                    func (stream, "***OOPS!***");
                                    return 2;
                                }
                            }
                            break;

                            case '\'':
                                c++;
                                if ((given & (1 << bitstart)) != 0)
                                    func (stream, "%c", *c);
                                break;

                            case '?':
                                ++c;
                                if ((given & (1 << bitstart)) != 0)
                                    func (stream, "%c", *c++);
                                else
                                    func (stream, "%c", *++c);
                                break;

                            default:
                                func (stream, "***OOPS!***");
                                return 2;
                            }
                        }
                        break;

                        default:
                            func (stream, "***OOPS!***");
                            return 2;
                        }
#ifdef NOTABS
                } else if (*c == '\t') {
                    func (stream, "%c", ' ');
#endif
                } else
                    func (stream, "%c", *c);
                }
            }
            return 2;
        }
    }

    /* No match.  */
    func (stream, "***OOPS!***");
    return 2;
}

/*************************************************************************/

#endif /* of INCLUDE_DISASSEMBLER */