disasm.c

motorola 针对coldfire 5275 评估板的Dbug bootloader源程序

                    {
                        /* ARI with BASE displacement */
                        append_string(buf,"(");
                        append_displacement(buf,extension,5);
                        append_string(buf,",");
                        append_register(buf,reg,ADDRESS_REGISTER,2);
                        append_string(buf,",");
                        append_register(buf,extension,15,14);
                        append_size_scale(buf,extension,11,10);
                        ea = ARIIB;
                    }
                }
                else
                {
                    int8 disp8;

                    disp8 = (int8)(extension & 0x00FF);
                    sprintf(buffer,"%d",disp8);
                    append_string(buf,buffer);
                    append_string(buf,"(");
                    append_register(buf,reg,ADDRESS_REGISTER,2);
                    append_string(buf,",");
                    append_register(buf,extension,15,14);
                    append_size_scale(buf,extension,11,10);
                    ea = ARII8;
                }
            append_string(buf,")");
            }
            break;
        case 7:
            switch (reg)
            {
                case 0x0:
                    {
                        int data;
                        data = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
                        inc_disasm_pc(2);
                        append_string(buf,"(");
                        append_value(buf,data,16);
                        append_string(buf,".W");
                        append_string(buf,")");
                    }
                    ea = AS;
                    break;
                case 0x1:
                    {
                        int data;
                        data = (int)((int32)cpu_read_data((ADDRESS)disasm_pc,32));
                        inc_disasm_pc(4);

#if (defined(SYMBOL_TABLE))
                        if (symtab_convert_address((ADDRESS)data,tstr))
                        {
                            append_string(buf,tstr);
                        }
                        else
                        {
                            append_string(buf,"(");
                            append_value(buf,data,32);
                            append_string(buf,".L");
                            append_string(buf,")");
                        }
#else
                        append_string(buf,"(");
                        append_value(buf,data,32);
                        append_string(buf,".L");
                        append_string(buf,")");
#endif
                    }
                    ea = AL;
                    break;
                case 0x2:
                    {
                        int disp;
                        disp = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
                        inc_disasm_pc(2);
                        sprintf(buffer,"%d",disp);
                        append_string(buf,buffer);
                        append_string(buf,"(PC)");
                    }
                    ea = PCID;
                    break;
                case 0x3:
                    {
                        int extension, disp;

                        extension = (int)*(uint16 *)disasm_pc;
                        inc_disasm_pc(2);

                        /* this mode is overloaded.  the encoding in the */
                        /* extension byte indicate which of the 4 modes  */
                        /*                                               */
                        /* [xxxxxxx0xxxx0000] PC  8bit displacement      */
                        /* [xxxxxxx1xxxx0000] PC  base displacement      */
                        /* [xxxxxxx1xxxx00xx] PC mem indirect pre index  */
                        /* [xxxxxxx1xxxx01xx] PC mem indirect post index */
                        /*                                               */

                        if (extension & 0x0100)
                        {
                            /* PC base or PC memory indirects */
                            if (extension & 0x0007)
                            {
                                /* PC memory indirects */
                                if (extension & 0x0004)
                                {
                                    /* memory indirect post index */
                                    append_string(buf,"(");
                                    append_string(buf,"[");
                                    append_displacement(buf,extension,5);
                                    append_string(buf,",PC],");
                                    append_register(buf,extension,15,14);
                                    append_size_scale(buf,extension,11,10);
                                    append_string(buf,",");
                                    append_displacement(buf,extension,1);
                                    ea = PCMIPO;
                                }
                                else
                                {
                                    /* memory indirect pre index */
                                    append_string(buf,"(");
                                    append_string(buf,"[");
                                    append_displacement(buf,extension,5);
                                    append_string(buf,",PC,");
                                    append_register(buf,extension,15,14);
                                    append_size_scale(buf,extension,11,10);
                                    append_string(buf,"]");
                                    append_string(buf,",");
                                    append_displacement(buf,extension,1);
                                    ea = PCMIPR;
                                }
                            }
                            else
                            {
                                /* base disp */
                                append_string(buf,"(");
                                append_displacement(buf,extension,5);
                                append_string(buf,",PC,");
                                append_register(buf,extension,15,14);
                                append_size_scale(buf,extension,11,10);
                                ea = PCIIB;
                            }
                        }
                        else
                        {
                            disp = (int)((int8)(extension & 0x00FF));
                            sprintf(buffer,"%d",disp);
                            append_string(buf,buffer);
                            append_string(buf,"(PC,");
                            append_register(buf,extension,15,14);
                            append_size_scale(buf,extension,11,10);
                            append_string(buf,")");
                            ea = PCII8;
                        }
                    }
                    break;
                case 0x4:
                    {
                        int data;
                        switch (disasm_op_size)
                        {
                            case SIZE_BYTE:
                                data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
                                inc_disasm_pc(2);
                                data = (int)(data & 0x00FF);
                                append_string(buf,"#");
                                append_value(buf,data,8);
                                break;
                            case SIZE_WORD:
                                data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
                                inc_disasm_pc(2);
                                append_string(buf,"#");
                                append_value(buf,data,16);
                                break;
                            case SIZE_LONG:
                                data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,32));
                                inc_disasm_pc(4);
                                append_string(buf,"#");
#if (defined(SYMBOL_TABLE))
                                if (symtab_convert_address((ADDRESS)data,tstr))
                                {
                                    append_string(buf,tstr);
                                }
                                else
                                    append_value(buf,data,32);
#else
                                append_value(buf,data,32);
#endif
                                break;
                            default:
                                break;
                        }
                    }
                    ea = IM;
                    break;
            }
        default:
            break;
    }
    if (!(ea_mask & ea))
    {
        /* EA was not one of ones in mask */
        valid_instruction = FALSE;
    }
    return ea;  /* needed by MOVE */
}

/********************************************************************/
#if 0
static void
func (int index, uint16 opword)
{
    sprintf(dstr,"%s -- ??????",isa[index].instruction);
}
#endif

/********************************************************************/
static void
func1 (int index, uint16 opword)
{
    /* BTST, BCLR, BCHG, BSET statics */
    int data;
    data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);

    if (0xFF00 & data)
    {
        valid_instruction = FALSE;
        return;
    }
    append_string(dstr,"#");
    append_value(dstr,data,8);
    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func6 (int index, uint16 opword)
{
    /* ORI EORI ANDI SUBI ADDI CMPI  */
    int data;

    append_size(dstr,opword,7,TRUE);
    append_string(dstr,"#");

    switch (disasm_op_size)
    {
        case SIZE_BYTE:
            data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
            inc_disasm_pc(2);
            append_value(dstr,data,8);
            break;
        case SIZE_WORD:
            data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
            inc_disasm_pc(2);
            append_value(dstr,data,16);
            break;
        case SIZE_LONG:
            data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,32));
            inc_disasm_pc(4);
            append_value(dstr,data,32);
            break;
    }

    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func7 (int index, uint16 opword)
{
    /* BTST, BCHG, BSET, BCLR reg */
    append_register(dstr,opword,DATA_REGISTER,11);
    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func8 (int index, uint16 opword)
{
    /* MOVE .b,.w,.l */
    int opw1, opw2;
    int sea;

    /* the destination <ea> is swapped from the form expected by */
    /* append_ea().  so make it look right */
    opw1 = opword & 0x0FC0;
    opword = opword & 0xF03F;       /* punch out dest */
    opw2 = (opw1 & 0x01C0) << 3;    /* mode */
    opword = (uint16)(opword | opw2);           /* swapped mode */
    opw2 = (opw1 & 0x0E00) >> 3;    /* reg */
    opword = (uint16)(opword | opw2);           /* swapped reg */

    append_size2(dstr,opword,13,TRUE);

    sea = append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");

    /* NOTE: On Coldfire, not all dest <ea> are possible! */
    /* See MCF5200 Family Programmer's Reference Manual,  */
    /* pages 4-53 thru 4-55 for further information.      */

    switch (sea)
    {
        case DRD:
        case ARD:
        case ARI:
        case ARIPO:
        case ARIPR:
            append_ea(dstr,opword,11,
                (DRD | ARD | ARI | ARIPO | ARIPR | ARID | ARII8 \
                | AS | AL));
            break;
        case ARID:
        case PCID:
        case IM:
            append_ea(dstr,opword,11,
                (DRD | ARD | ARI | ARIPO | ARIPR | ARID));
            break;
        case ARII8:
        case PCII8:
        case AS:
        case AL:
            append_ea(dstr,opword,11,
                (DRD | ARD | ARI | ARIPO | ARIPR));
            break;
        default:
            valid_instruction = FALSE;
            break;
    }
}

/********************************************************************/
static void
func9 (int index, uint16 opword)
{
    /* MOVE from SR */
    append_string(dstr,"SR,");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func10 (int index, uint16 opword)
{
    /* MOVE to SR */
    disasm_op_size = SIZE_WORD;
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",SR");
}

/********************************************************************/
static void
func11 (int index, uint16 opword)
{
    /* MOVE from CCR */
    append_string(dstr,"CCR,");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func12 (int index, uint16 opword)
{
    /* MOVE to CCR */
    disasm_op_size = SIZE_WORD;
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",CCR");
}

/********************************************************************/
static void
func13 (int index, uint16 opword)
{
    /* SWAP EXT EXTB */
    (void)index;
    append_register(dstr,opword,DATA_REGISTER,2);
}

/********************************************************************/
static void
func14 (int index, uint16 opword)
{
    /* ADDX SUBX */
    (void)index;
    append_size(dstr,opword,7,TRUE);

    if (opword & 0x0008)
    {
        /* ADDX/SUBX -(Ax),-(Ay) */
        append_string(dstr,"-(");
        append_register(dstr,opword,ADDRESS_REGISTER,2);
        append_string(dstr,"),-(");
        append_register(dstr,opword,ADDRESS_REGISTER,11);
        append_string(dstr,")");
    }
    else
    {
        /* ADDX/SUBX Dx,Dy */
        append_register(dstr,opword,DATA_REGISTER,2);
        append_string(dstr,",");
        append_register(dstr,opword,DATA_REGISTER,11);
    }
}

/********************************************************************/
static void
func15 (int index, uint16 opword)
{
    /* NEGX NEG NOT CLR WDDATA */
    append_size(dstr,opword,7,TRUE);
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func16 (int index, uint16 opword)
{
    /* LINK word */
    int disp;
    char buffer[20];

    (void)index;
    disp = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);
    append_register(dstr,opword,ADDRESS_REGISTER,2);
    append_string(dstr,",#");
    sprintf(buffer,"%d",disp);
    append_string(dstr,buffer);
}

/********************************************************************/
static void
func17 (int index, uint16 opword)
{
    /* RTE HALT RTS NOP */
    /* instruction printed by calling routine */
    (void)index;
    (void)opword;
}

/********************************************************************/
static void
func18 (int index, uint16 opword)
{
    /* ASL ASR LSL LSR ROR ROL ROXL ROXR NBCD PEA JSR JMP TAS */
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func21 (int index, uint16 opword)
{
    (void)index;
    append_register(dstr,opword,ADDRESS_REGISTER,2);
}

/********************************************************************/
static void
func22 (int index, uint16 opword)
{
    /* TRAP */
    int data;
    (void)index;
    append_string(dstr,"#");
    data = opword & 0x000F;
    append_value(dstr,data,8);