dsmlib.c

Vxworks 的源代码 C语言编写

    {"STI", itSti,       	OP1,0,
    				0xfb, 0x00, 0x00,	/* opcode */
				0xff, 0x00, 0x00},	/* mask */

    {"WAIT", itWait,     	OP1,0,
    				0x9b, 0x00, 0x00,	/* opcode */
				0xff, 0x00, 0x00},	/* mask */

    {"XLAT", itXlat,     	OP1|WFUL,0,
    				0xd7, 0x00, 0x00,	/* opcode */
				0xff, 0x00, 0x00},	/* mask */

    /* 7 bits mask */

    {"ADC", itAdcItoA,   	SF|WFUL|IMM|AX,0,
    				0x14, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"ADD", itAddItoA,   	SF|WFUL|IMM|AX,0,
    				0x04, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"AND", itAndItoA,   	SF|WFUL|IMM|AX,0,
    				0x24, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"CMP", itCmpIwiA,   	SF|WFUL|IMM|AX,0,
    				0x3c, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"CMPS", itCmps,     	OP1|WFUL,0,
    				0xa6, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"IMUL", itImulRMwiI, 	OP1|SEXT|MODRM|REG|IMM,0,
    				0x69, 0x00, 0x00,	/* opcode */
				0xfd, 0x00, 0x00},	/* mask */

    {"IN", itInF,        	OP1|WFUL|PORT|AX,0,
    				0xe4, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"IN", itInV,        	OP1|WFUL|AX,0,
    				0xec, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"INS", itIns,       	OP1|WFUL,0,
    				0x6c, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"LODS", itLods,     	OP1|WFUL,0,
    				0xac, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"MOV", itMovRMtoS,  	OP1|DISR|MODRM|SREG3,0,
    				0x8c, 0x00, 0x00,	/* opcode */
				0xfd, 0x00, 0x00},	/* mask */

    {"MOVS", itMovs,     	OP1|WFUL,0,
    				0xa4, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"OR", itOrItoA,     	SF|WFUL|IMM|AX,0,
    				0x0c, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"OUT", itOutF,      	OP1|WFUL|PORT|AX,0,
    				0xe6, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"OUT", itOutV,      	OP1|WFUL|AX,0,
    				0xee, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"OUTS", itOuts,     	OP1|WFUL,0,
    				0x6e, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"PUSH", itPushI,    	OP1|SEXT|IMM,0,
    				0x68, 0x00, 0x00,	/* opcode */
				0xfd, 0x00, 0x00},	/* mask */

    {"SBB", itSbbIfrA,   	SF|WFUL|IMM|AX,0,
    				0x1c, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"SCAS", itScas,     	OP1|WFUL,0,
    				0xae, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"SHRO", itRolRMby1, 	OP1|WFUL|MODRM|TTT,0,
    				0xd0, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"SHRO", itRolRMbyCL, 	OP1|WFUL|MODRM|TTT|CL,0,
    				0xd2, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"SHRO", itRolRMbyI, 	OP1|WFUL|MODRM|TTT|I8,0,
    				0xc0, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"STOS", itStos,     	OP1|WFUL,0,
    				0xaa, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"SUB", itSubIfrA,   	SF|WFUL|IMM|AX,0,
    				0x2c, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"TEST", itTestRManR, 	OP1|WFUL|MODRM|REG,0,
    				0x84, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"TEST", itTestIanA, 	SF|WFUL|IMM|AX,0,
    				0xa8, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"XCHG", itXchgRM,   	OP1|WFUL|MODRM|REG,0,
    				0x86, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    {"XOR", itXorItoA,    	SF|WFUL|IMM|AX,0,
    				0x34, 0x00, 0x00,	/* opcode */
				0xfe, 0x00, 0x00},	/* mask */

    /* 6 bits mask */

    {"ADC", itAdcRMtoRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x10, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"ADD", itAddRMtoRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x00, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"AND", itAndRMtoRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x20, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"CMP", itCmpRMwiRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x38, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"MOV", itMovRMtoMR, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x88, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"MOV", itMovAMtoMA, 	SF|DISR|WFUL|DIS|AX,0,	
    				0xa0, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"OR", itOrRMtoRM,   	OP1|DISR|WFUL|MODRM|REG,0,
    				0x08, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"POP", itPopS,      	OP1|REG,0,
    				0x07, 0x00, 0x00,	/* opcode */
				0xe7, 0x00, 0x00},	/* mask */

    {"PUSH", itPushS,    	OP1|SREG2,0,
    				0x06, 0x00, 0x00,	/* opcode */
				0xe7, 0x00, 0x00},	/* mask */

    {"SBB", itSbbRMfrRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x18, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"SUB", itSubRMfrRM, 	OP1|DISR|WFUL|MODRM|REG,0,
    				0x28, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    {"XOR", itXorRMtoRM,  	OP1|DISR|WFUL|MODRM|REG,0,
    				0x30, 0x00, 0x00,	/* opcode */
				0xfc, 0x00, 0x00},	/* mask */

    /* 5 bits mask */

    {"DEC", itDecR,      	SF|REG,0,
    				0x48, 0x00, 0x00,	/* opcode */
				0xf8, 0x00, 0x00},	/* mask */

    {"INC", itIncR,      	SF|REG,0,
    				0x40, 0x00, 0x00,	/* opcode */
				0xf8, 0x00, 0x00},	/* mask */

    {"POP", itPopR,      	SF|REG,0,
    				0x58, 0x00, 0x00,	/* opcode */
				0xf8, 0x00, 0x00},	/* mask */

    {"PUSH", itPushR,    	SF|REG,0,
    				0x50, 0x00, 0x00,	/* opcode */
				0xf8, 0x00, 0x00},	/* mask */

    {"XCHG", itXchgA,    	SF|REG|AX,0,
    				0x90, 0x00, 0x00,	/* opcode */
				0xf8, 0x00, 0x00},	/* mask */

    /* 4 bits mask */

    {"CJMPS", itCjmp,    	OP1|TTTN|D8,0,
    				0x70, 0x00, 0x00,	/* opcode */
				0xf0, 0x00, 0x00},	/* mask */

    {"MOV", itMovItoR,   	SF|WFUL|REG|IMM,0,
    				0xb0, 0x00, 0x00,	/* opcode */
				0xf0, 0x00, 0x00},	/* mask */


    {NULL, 0,			0,0,
    				0x00, 0x00, 0x00,	/* opcode */
				0x00, 0x00, 0x00},	/* mask */

    };

/* 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 * regxmm[8] =	/* XMM registers */
    {
    "XMM0", "XMM1", "XMM2", "XMM3", "XMM4", "XMM5", "XMM6", "XMM7"
    };    

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", "---" };

/* CMPSS variations */
LOCAL char *cmpss[8] = { "CMPEQSS",            /* imm = 0 */
                         "CMPLTSS",            /* imm = 1 */
                         "CMPLESS",            /* imm = 2 */
                         "CMPUNORDSS",         /* imm = 3 */
                         "CMPNEQSS",           /* imm = 4 */
                         "CMPNLTSS",           /* imm = 5 */
                         "CMPNLESS",           /* imm = 6 */
                         "CMPORDSS" };         /* imm = 7 */

LOCAL char *cmpps[8] = { "CMPEQPS",            /* imm = 0 */
                         "CMPLTPS",            /* imm = 1 */
                         "CMPLEPS",            /* imm = 2 */
                         "CMPUNORDPS",         /* imm = 3 */
                         "CMPNEQPS",           /* imm = 4 */
                         "CMPNLTPS",           /* imm = 5 */
                         "CMPNLEPS",           /* imm = 6 */
                         "CMPORDPS" };         /* imm = 7 */

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;
    
    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]; pI->mask0 != 0; pI++)
        {
        if ((pI->op0 == (*pD & pI->mask0)) &&
    	    (pI->op1 == (*(pD + 1) & pI->mask1)) &&
    	    (pI->op2 == (*(pD + 2) & pI->mask2)))
    	    {
	    break;
    	    }
	}
    
    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 ("        d32, a32 = %d, %d\n", pX->d32, pX->a32);
        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);