dsmlib.c

vxworks源码源码解读是学习vxworks的最佳途径

    {"SBB", itSbbIfrA,		SF|WFUL|IMM|AX,		0x1c, 0x00, 0xfe, 0x00},
    {"SCAS", itScas,		OP1|WFUL,		0xae, 0x00, 0xfe, 0x00},
    {"SHRO", itRolRMby1,	OP1|WFUL|MODRM|TTT,	0xd0, 0x00, 0xfe, 0x00},
    {"SHRO", itRolRMbyCL,	OP1|WFUL|MODRM|TTT|CL,	0xd2, 0x00, 0xfe, 0x00},
    {"SHRO", itRolRMbyI,	OP1|WFUL|MODRM|TTT|I8,	0xc0, 0x00, 0xfe, 0x00},
    {"STOS", itStos,		OP1|WFUL,		0xaa, 0x00, 0xfe, 0x00},
    {"SUB", itSubIfrA,		SF|WFUL|IMM|AX,		0x2c, 0x00, 0xfe, 0x00},
    {"TEST", itTestRManR,	OP1|WFUL|MODRM|REG,	0x84, 0x00, 0xfe, 0x00},
    {"TEST", itTestIanA,	SF|WFUL|IMM|AX,		0xa8, 0x00, 0xfe, 0x00},
    {"XCHG", itXchgRM,		OP1|WFUL|MODRM|REG,	0x86, 0x00, 0xfe, 0x00},
    {"XOR", itXorItoA,		SF|WFUL|IMM|AX,		0x34, 0x00, 0xfe, 0x00},

    /* 6 bits mask */
    {"ADC", itAdcRMtoRM,	OP1|DISR|WFUL|MODRM|REG,0x10, 0x00, 0xfc, 0x00},
    {"ADD", itAddRMtoRM,	OP1|DISR|WFUL|MODRM|REG,0x00, 0x00, 0xfc, 0x00},
    {"AND", itAndRMtoRM,	OP1|DISR|WFUL|MODRM|REG,0x20, 0x00, 0xfc, 0x00},
    {"CMP", itCmpRMwiRM,	OP1|DISR|WFUL|MODRM|REG,0x38, 0x00, 0xfc, 0x00},
    {"MOV", itMovRMtoMR,	OP1|DISR|WFUL|MODRM|REG,0x88, 0x00, 0xfc, 0x00},
    {"MOV", itMovAMtoMA,	SF|DISR|WFUL|DIS|AX,	0xa0, 0x00, 0xfc, 0x00},
    {"OR", itOrRMtoRM,		OP1|DISR|WFUL|MODRM|REG,0x08, 0x00, 0xfc, 0x00},
    {"POP", itPopS,		OP1|REG,		0x07, 0x00, 0xe7, 0x00},
    {"PUSH", itPushS,		OP1|SREG2,		0x06, 0x00, 0xe7, 0x00},
    {"SBB", itSbbRMfrRM,	OP1|DISR|WFUL|MODRM|REG,0x18, 0x00, 0xfc, 0x00},
    {"SUB", itSubRMfrRM,	OP1|DISR|WFUL|MODRM|REG,0x28, 0x00, 0xfc, 0x00},
    {"XOR", itXorRMtoRM,	OP1|DISR|WFUL|MODRM|REG,0x30, 0x00, 0xfc, 0x00},

    /* 5 bits mask */
    {"DEC", itDecR,		SF|REG,			0x48, 0x00, 0xf8, 0x00},
    {"INC", itIncR,		SF|REG,			0x40, 0x00, 0xf8, 0x00},
    {"POP", itPopR,		SF|REG,			0x58, 0x00, 0xf8, 0x00},
    {"PUSH", itPushR,		SF|REG,			0x50, 0x00, 0xf8, 0x00},
    {"XCHG", itXchgA,		SF|REG|AX,		0x90, 0x00, 0xf8, 0x00},

    /* 4 bits mask */
    {"CJMPS", itCjmp,		OP1|TTTN|D8,		0x70, 0x00, 0xf0, 0x00},
    {"MOV", itMovItoR,		SF|WFUL|REG|IMM,	0xb0, 0x00, 0xf0, 0x00},

    {NULL, 0,			0,			0x00, 0x00, 0x00, 0x00},
    };

/* reg[d32=0,1][reg field=0 - 7] */
LOCAL char *reg[2][8] = 
    {
    {"AX",  "CX",  "DX",  "BX",  "SP",  "BP",  "SI",  "DI"},
    {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"},
    };

/* regw[d32=0,1][w bit=0,1][reg field=0 - 7] */
LOCAL char *regw[2][2][8] = 
    {
    {{"AL",  "CL",  "DL",  "BL",  "AH",  "CH",  "DH",  "BH"},
     {"AX",  "CX",  "DX",  "BX",  "SP",  "BP",  "SI",  "DI"}},
    {{"AL",  "CL",  "DL",  "BL",  "AH",  "CH",  "DH",  "BH"},
     {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"}},
    };

LOCAL char * regmmx[8] =	/* MMX registers */
    {
    "MM0", "MM1", "MM2", "MM3", "MM4", "MM5", "MM6", "MM7"
    };

LOCAL char * gg[4] =		/* MMX instructions packed granularities */
    {
    "B",			/* packed bytes                          */
    "W",			/* packed words                          */
    "D",			/* packed double words                   */
    "Q"				/* packed quad words                     */
    };

/* immL[d32=0,1][w bit=0,1] */
LOCAL char immL[2][2] = { {1,2},{1,4} };

/* segment registers, sreg3[sreg3=0-7] */
LOCAL char *sreg3[8] = { "ES","CS","SS","DS","FS","GS","--","--" };

/* segment registers, sreg2[sreg2=0-3] */
LOCAL char *sreg2[4] = { "ES","CS","SS","DS" };

/* shift rotate opecodes, ttt[ttt=0-7] */
LOCAL char *ttt[8] = { "ROL","ROR","RCL","RCR","SHL","SHR","---","SAR" };

/* conditional jump opecodes, tttn[tttn=0-15] */
LOCAL char *tttn[16] = 
    { 
    "O","NO","B","NB","E","NE","BE","NBE",
    "S","NS","P","NP","L","NL","LE","NLE"
    };

/* control registers, */
LOCAL char *eeec[8] = { "CR0","---","CR2","CR3","CR4","---","---","---" };

/* debug registers, */
LOCAL char *eeed[8] = { "DR0","DR1","DR2","DR3","DR4","DR5","DR6","DR7" };

/* test registers, */
LOCAL char *eeet[8] = { "---","---","---","---","---","---","TR6","TR7" };

/* modrm format */
LOCAL char *modrm[2][3][8] = 
    {
    {{"[BX+SI]",		"[BX+DI]",
      "[BP+SI]",		"[BP+DI]",
      "[SI]",			"[DI]",
      "0x%04x",			"[BX]"},
     {"[BX+SI+%d]",		"[BX+DI+%d]", 
      "[BX+SI+%d]",		"[BX+DI+%d]", 
      "[SI+%d]",		"[DI+%d]", 
      "[BP+%d]",		"[BX+%d]"},
     {"[BX+SI+%d]",		"[BX+DI+%d]", 
      "[BX+SI+%d]",		"[BX+DI+%d]",
      "[SI+%d]",		"[DI+%d]", 
      "[BP+%d]",		"[BX+%d]"}},
    {{"[EAX]",			"[ECX]", 
      "[EDX]",			"[EBX]",
      "sib",			"0x%08x", 
      "[ESI]",			"[EDI]"},
     {"[EAX+%d]",		"[ECX+%d]", 
      "[EDX+%d]",		"[EBX+%d]",
      "sib",			"[EBP+%d]", 
      "[ESI+%d]",		"[EDI+%d]"},
     {"[EAX+%d]",		"[ECX+%d]", 
      "[EDX+%d]",		"[EBX+%d]",
      "sib",			"[EBP+%d]", 
      "[ESI+%d]",		"[EDI+%d]"}}
    };

/* sib format */
LOCAL char *sib[3][8] = 
    {
    {"[EAX+(%3s%2s)]",		"[ECX+(%3s%2s)]", 
     "[EDX+(%3s%2s)]",		"[EBX+(%3s%2s)]",
     "[ESP+(%3s%2s)]",		"[0x%08x+(%3s%2s)]",
     "[ESI+(%3s%2s)]",		"[EDI+(%3s%2s)]"},
    {"[EAX+(%3s%2s)+%d]",	"[ECX+(%3s%2s)+%d]",
     "[EDX+(%3s%2s)+%d]",	"[EBX+(%3s%2s)+%d]",
     "[ESP+(%3s%2s)+%d]",	"[EBP+(%3s%2s)+%d]",
     "[ESI+(%3s%2s)+%d]",	"[EDI+(%3s%2s)+%d]"},
    {"[EAX+(%3s%2s)+%d]",	"[ECX+(%3s%2s)+%d]",
     "[EDX+(%3s%2s)+%d]",	"[EBX+(%3s%2s)+%d]",
     "[ESP+(%3s%2s)+%d]",	"[EBP+(%3s%2s)+%d]",
     "[ESI+(%3s%2s)+%d]",	"[EDI+(%3s%2s)+%d]"}
    };

/* scale */
LOCAL char *scale[4] = { "x1","x2","x4","x8" };

/* indexR */
LOCAL char *indexR[8] = { "EAX","ECX","EDX","EBX","no-","EBP","ESI","EDI" };

/* st */
LOCAL char *st = "ST(%d)";

/* mf */
LOCAL char *mf[4] = { "r32", "---", "r64", "---" };

LOCAL int prefixAsize = 0;		/* prefix Address Size, 0x67 */
LOCAL int prefixOsize = 0;		/* prefix Operand Size, 0x66 */

int dsmAsize = 1;			/* 32 bits address size */
int dsmDsize = 1;			/* 32 bits data size */
int dsmDebug = 0;			/* debug flag */

char * instKeeper = NULL;		/* keeps instruction string */

/* forward declarations */

LOCAL void dsmPass1 (FORMAT_X *pX, FORMAT_Y *pY);
LOCAL void dsmPass2 (FORMAT_X *pX, FORMAT_Y *pY);

/*******************************************************************************
*
* dsmFind - disassemble one instruction
*
* This routine figures out which instruction is pointed to by pD.
*
* RETURNS: N/A
*/

LOCAL void dsmFind
    (
    FAST UCHAR *pD,		/* Pointer to the instruction	*/
    FORMAT_X *pX,		/* Pointer to the FORMAT_X	*/
    FORMAT_Y *pY 		/* Pointer to the FORMAT_Y	*/
    )
    {
    INST *pI;
    OP3MASK *pOp3;

    pX->pD = (char *)pD;

    if (prefixAsize)
        pX->a32 = ~dsmAsize & 0x1;
    else
        pX->a32 = dsmAsize;

    if (prefixOsize)
        pX->d32 = ~dsmDsize & 0x1;
    else
        pX->d32 = dsmDsize;

    pX->w = 1;

    for (pI = &inst[0], pOp3 = &op3[0]; pI->mask0 != 0; pI++)
        {
        if ((pI->op0 == (*pD & pI->mask0)) &&
    	    (pI->op1 == (*(pD + 1) & pI->mask1)))
    	    {
            if (pI->flag & OP3)
		{
    	        if (pOp3->op2 == (*(pD + 2) & pOp3->mask2))
    	            break;
		}
    	    else
    	        break;
    	    }
	if ( (pOp3->mask2 != 0) && (pI->flag & OP3))
	    pOp3++;
        }
    
    if (pI->mask0 == 0)
	{
        errnoSet (S_dsmLib_UNKNOWN_INSTRUCTION);
	if (dsmDebug)
            printf ("unknown instruction.  pD = 0x%x %x %x %x\n",(UCHAR)*pD,
                (UCHAR)*(pD + 1), (UCHAR)*(pD + 2), (UCHAR)*(pD + 3));
        return;
	}
    
    pX->pI = pI;
    
    dsmPass1 (pX, pY);

    if (pX->pI->type == itAsize)	/* set prefixAsize for next inst. */
	prefixAsize = 1;
    else
	prefixAsize = 0;

    if (pX->pI->type == itOsize)	/* set prefixOsize for next inst. */
	prefixOsize = 1;
    else
	prefixOsize = 0;

    if (dsmDebug)
	{
        printf ("FORMAT_X INST   pOpc = %s\n", pX->pI->pOpc);
        printf ("                type = 0x%x\n", pX->pI->type);
        printf ("                flag = 0x%x\n", pX->pI->flag);
        printf ("        pD = 0x%x %x %x %x\n", (UCHAR)*pX->pD,
            (UCHAR)*(pX->pD + 1), (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
        printf ("        lenO, lenD, lenI = %d, %d, %d\n", pX->lenO,
            pX->lenD, pX->lenI);
        printf ("        modrm, sib = %d, %d\n", pX->modrm, pX->sib);
        printf ("        w s d = %d %d %d\n", pX->w, pX->s, pX->d);
        printf ("        mod reg rm = %d %d %d\n", pX->mod, pX->reg, pX->rm);
        printf ("        ss index base = %d %d %d\n", pX->ss, pX->index,
	    pX->base);
	}
    
    dsmPass2 (pX, pY);
    
    if (dsmDebug)
	{
        printf ("FORMAT_Y len = %d\n", pY->len);
        printf ("        obuf = %s\n", pY->obuf);
        printf ("        rbuf = %s\n", pY->rbuf);
        printf ("        mbuf = %s\n", pY->mbuf);
        printf ("        ibuf = %s\n", pY->ibuf);
        printf ("        dbuf = %s\n", pY->dbuf);
	}

    return;
    }

/*******************************************************************************
*
* dsmPass1 - fill FORMAT_X structure.
*
* RETURNS: N/A
*/

LOCAL void dsmPass1
    (
    FORMAT_X *pX,
    FORMAT_Y *pY 
    )
    {
    char *pS;

    /* get a size of Opecode, 1, 2 */

    if ((pX->pI->flag & SF) || (pX->pI->flag & OP1))
	pX->lenO = 1;
    else if ((pX->pI->flag & OP2) || (pX->pI->flag & OP3))
	pX->lenO = 2;
    else
	printf ("dsmPass1 error 0\n");

    /* get a Opecode */

    if (pX->pI->flag & TTTN)
	{
	instKeeper = pX->pI->pOpc;
	pS = tttn[*(pX->pD + pX->lenO - 1) & 0x0f];
	if (pX->pI->type == itCjmp)
	    {
	    bcopy ("J  ", pY->obuf, 3);
	    bcopy (pS, &pY->obuf[1], strlen (pS));
	    }
	if (pX->pI->type == itCset)
	    {
	    bcopy ("SET", pY->obuf, 3);
	    bcopy (pS, &pY->obuf[3], strlen (pS));
	    }
	if (pX->pI->type == itCmovcc)
	    {
	    bcopy ("CMOV", pY->obuf, 4);
	    bcopy (pS, &pY->obuf[4], strlen (pS));
	    }
	pX->pI->pOpc = pY->obuf;
	}

    if (pX->pI->flag & TTT)
	pX->pI->pOpc = ttt[(*(pX->pD + pX->lenO) & 0x38) >> 3];

    /* get an MMX granularity */

    if (pX->pI->flag & GG)
	{
	instKeeper = pX->pI->pOpc;
	pS = gg[*(pX->pD + pX->lenO - 1) & 0x03];
	bcopy (pX->pI->pOpc, pY->obuf, strlen (pX->pI->pOpc));
	bcopy (pS, &pY->obuf[strlen (pX->pI->pOpc)], strlen (pS));
	pX->pI->pOpc = pY->obuf;
	}

    /* get a W */

    if (pX->pI->flag & WFUL)
	{
	pX->w = *(pX->pD + pX->lenO - 1) & 0x01;
	if (pX->pI->type == itMovItoR)
	    pX->w = (*pX->pD & 0x08) >> 3;
	}

    /* get a S */

    if (pX->pI->flag & SEXT)
	pX->s = (*(pX->pD + pX->lenO - 1) & 0x02) >> 1;

    /* get a D */

    if (pX->pI->flag & DISR)
	pX->d = (*(pX->pD + pX->lenO - 1) & 0x02) >> 1;

    /* get D for MMX registers */

    if ( ( (pX->pI->flag & MMXRM) && (! pX->pI->flag & MMXREG)) ||
	 ( (pX->pI->flag & MMXREG) && (! pX->pI->flag & MMXRM)))
	pX->d = (*(pX->pD + pX->lenO - 1) & 0x10) >> 4;

    /* get a REG */

    if (pX->pI->flag & SREG2)
        pX->reg = (*pX->pD & 0x18) >> 3;
    if (pX->pI->flag & SREG3)
        pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;
    if ( (pX->pI->flag & REG) || (pX->pI->flag & MMXREG))
	{
	if (pX->pI->flag & SF)
	    pX->reg = *pX->pD & 0x07;
	else if (pX->pI->flag & MODRM)
	    pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;
	else
	    printf ("dsmPass1 error 1\n");
	}
    if (pX->pI->flag & EEE)
        pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;

    /* get a ST for 387*/

    if (pX->pI->flag & ST)
	pX->st = *(pX->pD + pX->lenO - 1) & 0x07;

    /* get a MF for 387*/

    if (pX->pI->flag & MF)
	pX->mf = (*pX->pD & 0x06) >> 1;

    /* get a FD for 387 */

    if (pX->pI->flag & FD)
	pX->fd = *pX->pD & 0x04;

    /* get a size of Immediate, 0, 1, 2, 4 */

    if ((pX->pI->flag & I8) || (pX->pI->flag & TYPE))
	pX->lenI = 1;

    if (pX->pI->flag & IMM)
	{
	if (pX->s)
	    pX->lenI = 1;