dis_cf.c

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

    {
        case SIZE_BYTE:
            data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
            inc_disasm_pc(2);
            append_value(dstr,data,8);
            break;
        case SIZE_WORD:
            data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
            inc_disasm_pc(2);
            append_value(dstr,data,16);
            break;
        case SIZE_LONG:
            data = (int)((LONG)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, WORD 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, WORD opword)
{
    /* MOVE .b,.w,.l */
    int opw1, opw2;
#ifdef MCF5200
    int sea;
#endif

    /* 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 = opword | opw2;         /* swapped mode */
    opw2 = (opw1 & 0x0E00) >> 3;    /* reg */
    opword = opword | opw2;         /* swapped reg */

    append_size2(dstr,opword,13,TRUE);
#ifndef MCF5200
    append_ea(dstr,opword,5,EA_ALL);
    append_string(dstr,",");
    append_ea(dstr,opword,11,isa[index].ea_mask);
#endif

#ifdef MCF5200
    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:
            append_ea(dstr,opword,11,
                (DRD | ARD | ARI | ARIPO | ARIPR | ARID));
            break;
        case ARII8:
        case PCII8:
        case AS:
        case AL:
        case IM:
            append_ea(dstr,opword,11,
                (DRD | ARD | ARI | ARIPO | ARIPR));
            break;
        default:
            valid_instruction = FALSE;
            break;
    }
#endif

}

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

static void
func10 (int index, WORD 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, WORD opword)
{
    /* MOVE from CCR */
    append_string(dstr,"CCR,");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}

static void
func12 (int index, WORD 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, WORD opword)
{
    /* SWAP EXT EXTB */
    (void)index;
    append_register(dstr,opword,DATA_REGISTER,2);
}

static void
func14 (int index, WORD 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, WORD 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, WORD opword)
{
    /* LINK word */
    int disp;
    char buffer[20];

    (void)index;
    disp = (int)((SWORD)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, WORD opword)
{
    /* RTE HALT RTS NOP */
    /* instruction printed by calling routine */
    (void)index;
    (void)opword;
}

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

#ifndef MCF5200
static void
func19 (int index, WORD opword)
{
    /* CMP2 and CHK2 */
    int opword2;

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

    /* both instruction have same EA mask */
    if (opword2 & 0x000800)
    {
        append_instruction(dstr,"CHK2");
    }
    else
    {
        append_instruction(dstr,"CMP2");
    }
    append_size(dstr,opword,10,TRUE);
    append_ea(dstr,opword,5,isa[index].ea_mask);
    append_string(dstr,",");
    append_register(dstr,opword2,15,14);
}
#if 0
static void
func20 (int index, WORD opword)
{
    int data;

    (void)index;

    append_string(dstr,"#");
    data = opword & 0x0007;
    append_value(dstr,data,8);
}
#endif
#endif /* MCF5200 */

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

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

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

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

static void
func24 (int index, WORD 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, WORD opword)
{
    /* Bcc */
    int disp, target;
#ifdef SYMBOL_TABLE
    char tstr[100];
#endif

    (void)index;
    disp = opword & 0x00FF;
    if (disp == 0)
    {
        /* 16 bit disp */
        disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
        target = (int)disasm_pc + disp;
        inc_disasm_pc(2);
    }
    else
    {
        if (disp == 0x00FF)
        {
            /* 32 bit disp */
            valid_instruction = FALSE;
            return;
        }
        else
        {
            /* 8 bit disp */
            disp = (int)((SBYTE)disp);
            target = (int)disasm_pc + disp;
        }
    }
#ifdef 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, WORD 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);
}

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:
                    mask = 0x8000;
                    break;
            }
            reg = regD;
        }
        else
        {
            switch (dir)
            {
                case 1:
                    mask = 0x0100;
                    break;
                case -1:
                    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;
                        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);