dis_cf.c

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

    mask = 0x3; /* 2 bits */
    for (i = 1; i < disp_offset; i++)
        mask = mask << 1;
    i = (extension & mask) >> (disp_offset - 1);

    switch (i)
    {
        case 0:
        case 1:
            break;
        case 2:
            disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
            inc_disasm_pc(2);
            append_value(buf,disp,16);
            break;
        case 3:
            disp = (int)((SLONG)cpu_read_data((ADDRESS)disasm_pc,32));
            inc_disasm_pc(4);
            append_value(buf,disp,32);
            break;
    }
}

static void
append_size_scale (char *buf, int extension, int size_offset, int scale_offset)
{
    /*
     * This function determines the size and scale information
     * for addressing modes that require it.
     * 
     * The `offsets' are given by the bit number as listed in the
     * M68000 Family Programmer's Reference, Chapter 2. [15 .. 0]
     */
    int i, mask, size, scale;

    mask = 0x1; /* 1 bits */
    for (i = 0; i < size_offset; i++)
        mask = mask << 1;
    size = (extension & mask) >> size_offset;

    mask = 0x3; /* 2 bits */
    for (i = 1; i < scale_offset; i++)
        mask = mask << 1;
    scale = (extension & mask) >> (scale_offset - 1);

    if (size)
        append_string(buf,".L");
    else
        append_string(buf,".W");

    switch (scale)
    {
        case 0:
            append_string(buf,"*1");
            break;
        case 1:
            append_string(buf,"*2");
            break;
        case 2:
            append_string(buf,"*4");
            break;
        case 3:
            /* valid_instruction = FALSE; */
            append_string(buf,"*8");
            break;
    }
}

static int
append_ea (char *buf, int opword, int offset, int ea_mask)
{
    /*
     * This routine creates the addressing mode.  The
     * extensions for the addressing mode, if necessary,
     * start at disasm_pc
     */
    int i, mask, mode, reg, ea;
    char buffer[9];
#ifdef SYMBOL_TABLE
    char tstr[100];
#endif

    ea = EA_NONE;

    /* get addressing mode */
    mask = 0x7; /* 3 bits */
    for (i = 2; i < offset; i++)
        mask = mask << 1;
    mode = (opword & mask) >> (offset - 2);

    /* get register */
    mask = 0x7; /* 3 bits */
    for (i = 2; i < (offset - 3); i++)
        mask = mask << 1;
    reg = (opword & mask) >> (offset -3 - 2);

    switch (mode)
    {
        case 0: /* data register direct mode */
            append_register(buf,reg,DATA_REGISTER,2);
            ea = DRD;
            break;
        case 1: /* address register direct mode */
            append_register(buf,reg,ADDRESS_REGISTER,2);
            ea = ARD;
            break;
        case 2: /* address register indirect mode (ARI) */
            append_string(buf,"(");
            append_register(buf,reg,ADDRESS_REGISTER,2);
            append_string(buf,")");
            ea = ARI;
            break;
        case 3: /* ARI with postincrement mode */
            append_string(buf,"(");
            append_register(buf,reg,ADDRESS_REGISTER,2);
            append_string(buf,")+");
            ea = ARIPO;
            break;
        case 4: /* ARI with predecrement mode */
            append_string(buf,"-(");
            append_register(buf,reg,ADDRESS_REGISTER,2);
            append_string(buf,")");
            ea = ARIPR;
            break;
        case 5: /* ARI with displacement mode */
            {
                int disp;
                disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
                inc_disasm_pc(2);
                sprintf(buffer,"%d",disp);
                append_string(buf,buffer);
                append_string(buf,"(");
                append_register(buf,reg,ADDRESS_REGISTER,2);
                append_string(buf,")");
                ea = ARID;
            }
            break;
        case 6:
            {
                /* this mode is overloaded.  the encoding in the */
                /* extension byte indicate which of the 4 modes  */
                /*                                               */
                /* [xxxxxxx0xxxx0000] ARI 8bit displacement      */
                /* [xxxxxxx1xxxx0000] ARI base displacement      */
                /* [xxxxxxx1xxxx00xx] memory indirect pre index  */
                /* [xxxxxxx1xxxx01xx] memory indirect post index */
                /*                                               */

                int extension;

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

                if (extension & 0x0100)
                {
                    /* ARI base or memory indirects */
                    if (extension & 0x0007)
                    {
                        /* memory indirects */
                        if (extension & 0x0004)
                        {
                            /* memory indirect post index */
                            append_string(buf,"(");
                            append_string(buf,"[");
                            append_displacement(buf,extension,5);
                            append_string(buf,",");
                            append_register(buf,reg,ADDRESS_REGISTER,2);
                            append_string(buf,"]");
                            append_string(buf,",");
                            append_register(buf,extension,15,14);
                            append_size_scale(buf,extension,11,10);
                            append_string(buf,",");
                            append_displacement(buf,extension,1);
                            ea = MIPO;
                        }
                        else
                        {
                            /* memory indirect pre index */
                            append_string(buf,"(");
                            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);
                            append_string(buf,"]");
                            append_string(buf,",");
                            append_displacement(buf,extension,1);
                            ea = MIPR;
                        }
                    }
                    else
                    {
                        /* 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
                {
                    SBYTE disp8;

                    disp8 = (SBYTE)(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)((SWORD)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)((SLONG)cpu_read_data((ADDRESS)disasm_pc,32));
                        inc_disasm_pc(4);

#ifdef 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)((SWORD)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)*(WORD *)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)((SBYTE)(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)((WORD)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)((WORD)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)((LONG)cpu_read_data((ADDRESS)disasm_pc,32));
                                inc_disasm_pc(4);
                                append_string(buf,"#");
#ifdef 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, WORD opword)
{
    sprintf(dstr,"%s -- ??????",isa[index].instruction);
}
#endif

static void
func1 (int index, WORD opword)
{
    /* BTST, BCLR, BCHG, BSET statics */
    int data;
    data = (int)((WORD)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);
}

#ifndef MCF5200
static void
func2 (int index, WORD opword)
{
    /* ORI ANDI EORI to CCR */
    int data;

    (void)index;
    (void)opword;

    data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);
    append_string(dstr,"#");
    append_value(dstr,data,8);
    append_string(dstr,",CCR");
}

static void
func3 (int index, WORD opword)
{
    /* ORI ANDI EORI to SR */
    int data;

    (void)index;
    (void)opword;

    data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);
    append_string(dstr,"#");
    append_value(dstr,data,16);
    append_string(dstr,",SR");
}

static void
func4 (int index, WORD opword)
{
    /* RTM */

    (void)index;
    (void)opword;

    append_register(dstr,opword,3,2);
}

static void
func5 (int index, WORD opword)
{
    /* CALLM */
    int data;

    data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
    inc_disasm_pc(2);
    append_string(dstr,"#");
    append_value(dstr,data,8);
    append_string(dstr,",");
    append_ea(dstr,opword,5,isa[index].ea_mask);
}
#endif /* MCF5200 */

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

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

    switch (disasm_op_size)