disasm.c

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

}

/********************************************************************/
static void
func23 (int index, uint16 opword)
{
    /* STOP RTD */
    int data;

    (void)index;
    (void)opword;
    append_string(dstr,"#");
    data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);
    append_value(dstr,data,16);
}

/********************************************************************/
static void
func24 (int index, uint16 opword)
{
    /* MOVEQ */
    int data;

    (void)index;
    append_string(dstr,"#");
    data = opword & 0x00FF;
    append_value(dstr,data,8);
    append_string(dstr,",");
    append_register(dstr,opword,DATA_REGISTER,11);
}

/********************************************************************/
static void
func25 (int index, uint16 opword)
{
    /* Bcc */
    int disp, target;
#if (defined(SYMBOL_TABLE))
    char tstr[100];
#endif

    (void)index;
    disp = opword & 0x00FF;
    if (disp == 0)
    {
        /* 16 bit disp */
        disp = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
        target = (int)disasm_pc + disp;
        inc_disasm_pc(2);
    }
    else if (disp == 0x00FF)
    {
        #if (defined(CPU_MCF5407))
            /* 32 bit disp */
            disp = (int)((int32)cpu_read_data((ADDRESS)disasm_pc,32));
            target = (int)disasm_pc + disp;
            inc_disasm_pc(4);
        #else
            /* 32 bit disp */ 
            valid_instruction = FALSE;
            return;
        #endif
    }
    else
    {
        /* 8 bit disp */
        disp = (int)((int8)disp);
        target = (int)disasm_pc + disp;
    }

#if (defined(SYMBOL_TABLE))
    if (symtab_convert_address((ADDRESS)target,tstr))
    {
        append_string(dstr,tstr);
    }
    else
        append_value(dstr,target,32);
#else
    append_value(dstr,target,32);
#endif
}

/********************************************************************/
static void
func26 (int index, uint16 opword)
{
    /* MOVEA */

    append_size2(dstr,opword,13,TRUE);
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");
    append_register(dstr,opword,ADDRESS_REGISTER,11);
}

/********************************************************************/
static int
more_bits_set (int cm, int cc, int dir, int reg_mask)
{
    /* cm = current mask, cc = current count */
    switch (dir)
    {
        case 1:
            cm = cm << 1;
            break;
        case -1:
            cm = cm >> 1;
            break;
    }
    ++cc;
    while (cc < 8)
    {
        if (cm & reg_mask)
        {
            return TRUE;
        }
        switch (dir)
        {
            case 1:
                cm = cm << 1;
                break;
            case -1:
                cm = cm >> 1;
                break;
        }
        ++cc;
    }
    return FALSE;
}

/********************************************************************/
static void
append_reg_list (int reg_mask, int opword)
{
    int mask, i, j, first, need_slash, dir, next_set, some_set;
    char buffer[9];
    char *reg;
    char regA[] = "A";
    char regD[] = "D";

    /* Check for predecrement mode */
    if ((opword & 0x0038) == 0x0020)
    {
        /* predecrement */
        dir = -1;
    }
    else
    {
        dir = 1;
    }

    need_slash = FALSE;
    for (j = 0; j < 2; j++)
    {
        if (j == 0)
        {
            switch (dir)
            {
                case 1:
                    mask = 0x0001;
                    break;
                case -1:
                default:
                    mask = 0x8000;
                    break;
            }
            reg = regD;
        }
        else
        {
            switch (dir)
            {
                case 1:
                    mask = 0x0100;
                    break;
                case -1:
                default:
                    mask = 0x0080;
                    break;
            }
            reg = regA;
            if (need_slash)
                append_string(dstr,"/");
        }

        some_set = FALSE;
        first = TRUE;
        need_slash = FALSE;

        for (i = 0; i < 8; i++)
        {
            if (reg_mask & mask)
            {
                some_set = TRUE;
                if (first)
                {
                    /* first one in subrange */
                    if (need_slash)
                    {
                        append_string(dstr,"/");
                        need_slash = FALSE;
                    }
                    append_string(dstr,reg);
                    sprintf(buffer,"%d",i);
                    append_string(dstr,buffer);
                    if (!more_bits_set(mask,i,dir,reg_mask))
                        need_slash = TRUE;
                    first = FALSE;
                }
                else
                {
                    /* check to see if next set */
                    switch (dir)
                    {
                        case 1:
                            next_set = (((reg_mask & (mask << 1))) &&
                                (i != 7));
                            break;
                        default:
                        case -1:
                            next_set = (((reg_mask & (mask >> 1))) &&
                                (i != 7));
                            break;
                    }
                    if (!next_set)
                    {
                        /* the next isn't set, so display */
                        append_string(dstr,"-");
                        append_string(dstr,reg);
                        sprintf(buffer,"%d",i);
                        append_string(dstr,buffer);
                            need_slash = TRUE;
                        first = TRUE;
                    }
                }
            }
            else first = TRUE;
            switch (dir)
            {
                case 1:
                    mask = mask << 1;
                    break;
                case -1:
                    mask = mask >> 1;
                    break;
            }
        }
        if ((i == 8) && (j == 0) && some_set)
        {
            switch (dir)
            {
                case 1:
                    need_slash = more_bits_set(0x0080,-1,dir,reg_mask);
                    break;
                case -1:
                    need_slash = more_bits_set(0x0100,-1,dir,reg_mask);
                    break;
                default:
                    break;
            }
        }
    }
}

/********************************************************************/
static void
func27 (int index, uint16 opword)
{
    /* MOVEM */
    int mask;

    mask = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);

    if (opword & 0x0040)
    {
        /* long */
        append_size(dstr,0x0002,1,TRUE);
    }
    else
    {
        /* word */
        append_size(dstr,0x0002,2,TRUE);
    }

    if (opword & 0x0400)
    {
        /* memory to register */
        append_ea(dstr,opword,5,isa[index].ea_mask);
        append_string(dstr,",");
        append_reg_list(mask,opword);
    }
    else
    {
        /* register to memory */
        append_reg_list(mask,opword);
        append_string(dstr,",");
        append_ea(dstr,opword,5,isa[index].ea_mask);
    }
}

/********************************************************************/
static void
func28 (int index, uint16 opword)
{
    /* CMPA ADDA SUBA */

    if (opword & 0x0100)
    {
        /* long */
        append_size(dstr,0x0002,1,TRUE);
    }
    else
    {
        /* word */
        append_size(dstr,0x0002,2,TRUE);
    }
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");
    append_register(dstr,opword,ADDRESS_REGISTER,11);
}

/********************************************************************/
static void
func29 (int index, uint16 opword)
{
    /* SUBQ ADDQ */
    int data;

    data = ((opword & 0x0E00) >> 9);
    if (data == 0)
        data = 8;

    append_size(dstr,opword,7,TRUE);
    append_string(dstr,"#");
    append_value(dstr,data,8);
    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func31 (int index, uint16 opword)
{
    /* AND OR EOR */
    append_size(dstr,opword,7,TRUE);
    append_register(dstr,opword,DATA_REGISTER,11);
    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func32 (int index, uint16 opword)
{
    /* LEA */
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");
    append_register(dstr,opword,ADDRESS_REGISTER,11);
}

/********************************************************************/
static void
func33 (int index, uint16 opword)
{
    /* SUB AND ADD OR CMP */
    append_size(dstr,opword,7,TRUE);
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");
    append_register(dstr,opword,DATA_REGISTER,11);
}

/********************************************************************/
static void
func34 (int index, uint16 opword)
{
    /* LSL,LSR,ROL,ROR,ROXL,ROXR,ASL,ASR #<data> */
    int data;

    (void)index;
    data = ((opword & 0x0E00) >> 9);
    if (data == 0)
        data = 8;
    append_size(dstr,opword,7,TRUE);
    append_string(dstr,"#");
    append_value(dstr,data,8);
    append_string(dstr,",");
    append_register(dstr,opword,DATA_REGISTER,2);
}

/********************************************************************/
static void
func35 (int index, uint16 opword)
{
    /* LSL,LSR,ROL,ROR,ROXL,ROXR,ASL,ASR Dx */

    (void)index;
    append_size(dstr,opword,7,TRUE);
    append_register(dstr,opword,DATA_REGISTER,11);
    append_string(dstr,",");
    append_register(dstr,opword,DATA_REGISTER,2);
}

/********************************************************************/
static void
func36 (int index, uint16 opword)
{
    /* MOVEC */
    extern const int RCSIZE;
    int opword2, success, i;
    char buffer[9];

    (void)index;
    opword2 = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);

    if (opword & 0x0001)
    {
        append_register(dstr,opword2,15,14);
        append_string(dstr,",");
    }

    success = FALSE;
    for (i=0; i<RCSIZE; i++)
    {
        if ((opword2 & 0x0FFF) == rc[i].code)
        {
            append_string(dstr,rc[i].name);
            success = TRUE;
            break;
        }
    }

    if (!success)
    {
        sprintf(buffer,"Rc%03X",opword2);
        append_string(dstr,buffer);
    }

    if (!(opword & 0x0001))
    {
        append_string(dstr,",");
        append_register(dstr,opword2,15,14);
    }
}

/********************************************************************/
static void
func37 (int index, uint16 opword)
{
    /* WDEBUG */
    int opword2;

    opword2 = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);

    if (opword2 & 0x0003)
    {
        append_ea(dstr,opword,5,isa[index].ea_mask);
    }
    else
    {
        valid_instruction = FALSE;
    }
}

/********************************************************************/
static void
func38 (int index, uint16 opword)
{