dsmlib.c

Vxworks 的源代码 C语言编写

    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;

    /* pX->lenO = size of Opcode in bytes = 1, 2, or 3 */

    if (pX->pI->flag & OP3)
        pX->lenO = 3;
    else if (pX->pI->flag & OP2) 
	pX->lenO = 2;
    else
	pX->lenO = 1;

    /* 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 
     *
     * jhw - for our representation of data direction:
     *           pX->d = 0 is an r/m -> reg transfer 
     *           pX->d = 1 is a  reg -> r/m transfer
     */

    if (pX->pI->flag & DISR)
        {

        /* 
	 * MMX instructions reference least significant opcode byte bit 4 for 
         * data direction information.
         *
         * for Intel's representation:
         *    D bit = 0 is an r/m -> reg transfer 
         *    D bit = 1 is a  reg -> r/m transfer 
         */
						               
        if (pX->pI->flag & (MMXREG|MMXRM))
            pX->d = (*(pX->pD + pX->lenO - 1) & 0x10) >> 4;

        /* 
	 * XMM instructions reference least significant opcode byte bit 0 for 
         * data direction information.
         *
         * for Intel's representation:
         *    D bit = 0 is an r/m -> reg transfer 
         *    D bit = 1 is a  reg -> r/m transfer 
         */
      
        else if (pX->pI->flag2 & (XMMREG|XMMRM))
             pX->d = (*(pX->pD + pX->lenO - 1) & 0x01);

        /* 
	 * all others use least significant byte bit 1 for 
         * data direction information.
         * 
         * BUT... all other instructions use the opposite representation!
         *
	 * for Intel's representation:
         *    D bit = 1 is an r/m -> reg transfer 
         *    D bit = 0 is a  reg -> r/m transfer 
         */

        else
            /* invert the state */
            pX->d = (*(pX->pD + pX->lenO - 1) & 0x02) ? 0 : 1;

	/* evaluate the special case instructions! */

	/*
	 * PEXTRW is a SIMD instruction, but it operates on MMX
	 * register. Therefore it deviates from the above rules.
	 * The DISR flag is included in the definition because
	 * the data dir is reg -> r/m regardless.
	 */

	if (pX->pI->type == itPextrw)
            pX->d = 1;
	}

    /* 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) ||
	 (pX->pI->flag2 & XMMREG))    
	{
	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 ("dsmLib.c error 0: Invalid opcode flag definition.\n");
            printf ("\top = 0x%02x 0x%02x 0x%02x 0x%02x\n",
                    (UCHAR)*pX->pD, (UCHAR)*(pX->pD + 1),
                    (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
            }
	}
    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->lenI = 1;

    if (pX->pI->flag & IMM)
	{
	if (pX->s)
	    pX->lenI = 1;
	else
	    pX->lenI = immL[(int)pX->d32][(int)pX->w];
	}

    if (pX->pI->flag & OFFSEL)
	{

	/* 
	 * CALL/JMP ptr16:16/32
	 * The operand size attribute determines the size of offset (16/32).
	 * The operand size attribute is the D flag in the segment desc.
	 * The instruction prefix 0x66 can be used to select an operand
	 * size other than the default.
	 */

	if (pX->d32)
	    pX->lenI = 4;
	else
	    pX->lenI = 2;
	}

    if ((pX->pI->flag & D16L8) || (pX->pI->flag & PORT))
	pX->lenI = 2;

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

    if (pX->pI->flag & D8)
	pX->lenD = 1;

    if (pX->pI->flag & (DIS|D16))
	{
	if (pX->pI->flag & WFUL)
	    {
	    if (pX->pI->type == itMovAMtoMA)
		pX->lenD = immL[(int)pX->a32][(int)pX->w];
	    else
		pX->lenD = immL[(int)pX->d32][(int)pX->w];
	    }
	else
	    pX->lenD = immL[(int)pX->d32][(int)pX->w];
	}

    if (pX->pI->flag & OFFSEL)
	pX->lenD = 2;

    if (pX->pI->flag & D16L8)
	pX->lenD = 1;

    if (pX->pI->flag & MODRM)
	{
	pX->modrm = 1;
	pY->pD = pX->pD + pX->lenO;
	pX->mod = (*pY->pD & 0xc0) >> 6;
	pX->rm = *pY->pD & 0x07;
	if ((pX->a32 == 0) && (pX->mod != 3))
	    {
	    if (pX->mod == 1)
		pX->lenD = 1;
	    else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->rm == 6)))
		pX->lenD = 2;
	    }
	if ((pX->a32 == 1) && (pX->mod != 3))
	    {
	    if (pX->rm == 4)
		{
	        pX->sib = 1;
	        pY->pD = pX->pD + pX->lenO + pX->modrm;
	        pX->ss = (*pY->pD & 0xc0) >> 6;
	        pX->index = (*pY->pD & 0x38) >> 3;
	        pX->base = *pY->pD & 0x07;
	        if (pX->mod == 1)
		    pX->lenD = 1;
	        else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->base == 5)))
		    pX->lenD = 4;
		}
	    else
		{
	        if (pX->mod == 1)
		    pX->lenD = 1;
	        else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->rm == 5)))
		    pX->lenD = 4;
		}
	    }
	}
    }
    
/*******************************************************************************
*
* dsmPass2 - fill FORMAT_Y structure.
*
* RETURNS: N/A
*/

LOCAL void dsmPass2
    (
    FORMAT_X *pX,
    FORMAT_Y *pY 
    )
    {
    FAST char *pS = 0;

    /* get an instruction length, pY->len */

    pY->len = pX->lenO + pX->modrm + pX->sib + pX->lenD + pX->lenI;

    /* get an opecode pointer, pY->pOpc */

    pY->pOpc = pX->pI->pOpc;

    if (pX->pI->flag & MF)
        {
        pS = pY->obuf;
        if (pX->mf & 1)
	    {
	    bcopy (pX->pI->pOpc, pS + 1, strlen (pX->pI->pOpc));
	    bcopy ("FI", pS, 2);
	    }
        else
	    {
	    bcopy (pX->pI->pOpc, pS, strlen (pX->pI->pOpc));
	    strcat (pS, mf[(int)pX->mf]);
	    }
        pY->pOpc = pY->obuf;
        }

    if (pX->pI->flag & POP)
        {
        bcopy (pX->pI->pOpc, pY->obuf, strlen (pX->pI->pOpc));
        strcat (pY->obuf, "P");
        pY->pOpc = pY->obuf;
        }

    /* get a register operand buffer, pY->rbuf */

    if (pX->pI->flag & SREG2)
        bcopy (sreg2[(int)pX->reg], pY->rbuf, strlen (sreg2[(int)pX->reg]));

    if (pX->pI->flag & SREG3)
        bcopy (sreg3[(int)pX->reg], pY->rbuf, strlen (sreg3[(int)pX->reg]));

    /* get register number */

    if (pX->pI->flag & REG)
        {
        if (pX->pI->flag & WFUL)
	    pS = regw[(int)pX->d32][(int)pX->w][(int)pX->reg];
        else
	    pS = reg[(int)pX->d32][(int)pX->reg];
        bcopy (pS, pY->rbuf, strlen (pS));
        }

    /* get MMX register number */

    if (pX->pI->flag & MMXREG)
	{
	pS = regmmx[ (int) pX->reg];
	bcopy (pS, pY->rbuf, strlen (pS));
	}

    /* XMM register */

    if (pX->pI->flag2 & XMMREG)
        {
	pS = regxmm[ (int) pX->reg];
	memcpy ((void *) pY->rbuf, (void *) pS, strlen (pS));
        }


    if (pX->pI->flag & EEE)
        {
        if (pX->pI->type == itMovC)
            pS = eeec[(int)pX->reg];
        else if (pX->pI->type == itMovD)
            pS = eeed[(int)pX->reg];
        else if (pX->pI->type == itMovT)
            pS = eeet[(int)pX->reg];
        bcopy (pS, pY->rbuf, strlen (pS));
        pS = reg[(int)pX->d32][(int)pX->rm];
        bcopy (pS, pY->mbuf, strlen (pS));
        }

    if (pX->pI->flag & AX)
        {
        if (pX->pI->flag & WFUL)
	    {
	    if (pX->pI->type == itMovAMtoMA)
	        pS = regw[(int)pX->a32][(int)pX->w][0];
	    else
	        pS = regw[(int)pX->d32][(int)pX->w][0];
	    }
        else
	    pS = reg[(int)pX->d32][0];

        if (pX->pI->flag & REG)
            bcopy (pS, pY->ibuf, strlen (pS));
	else
            bcopy (pS, pY->rbuf, strlen (pS));
        }

    if (pX->pI->flag & ST)
        sprintf (pY->rbuf, st, pX->st);
    
    /* get a displacement operand buffer, pY->dbuf */

    if (pX->pI->flag & (D8|D16|DIS))
        {
        pY->pD = pX->pD + pX->lenO + pX->modrm + pX->sib;
        if (pX->lenD == 1)
	    pY->addr = *(pY->pD);
        else if (pX->lenD == 2)
	    pY->addr = *(short *)pY->pD;
        else if (pX->lenD == 4)
	    {
	    if (pX->pI->flag & D16)
	        pY->addr = *(int *)pY->pD & 0x0000ffff;
	    else
	        pY->addr = *(int *)pY->pD;
	    }
	sprintf (pY->dbuf, "0x%x", pY->addr);
        }

    if (pX->pI->flag & OFFSEL)
        sprintf (pY->dbuf, "0x%x", *(USHORT *)(pX->pD + pX->lenO + pX->lenI));
    
    if (pX->pI->flag & D16L8)
        sprintf (pY->dbuf, "0x%x", *(UCHAR *)(pX->pD + pX->lenO + pX->lenI));

    /* get an immediate operand buffer, pY->ibuf */

    if (pX->pI->flag & (IMM|I8))
        {
        pY->pD = pX->pD + pX->lenO + pX->modrm + pX->sib + pX->lenD;
        if (pX->lenI == 1)
	    {
	    if (pX->s)
	        sprintf (pY->ibuf, "%d", *pY->pD);
	    else
	        sprintf (pY->ibuf, "0x%x", *(UCHAR *)pY->pD);
	    }
        if (pX->lenI == 2)
	    sprintf (pY->ibuf, "0x%x", *(USHORT *)pY->pD);
        if (pX->lenI == 4)
	    sprintf (pY->ibuf, "0x%x", *(UINT *)pY->pD);
       
        /* 
         * CMPSS and CMPPS opcode string is modified based on 
	 * the imm value.
	 */

	if ((pX->pI->type == itCmpps) || (pX->pI->type == itCmpss))
            {

            /* verify that (0 < imm < 8) */

            if (*(UCHAR *)pY->pD < 8)
                {
                if (pX->pI->type == itCmpps)
                    pY->pOpc = cmpps[*(UCHAR *)pY->pD];
                else 
                    pY->pOpc = cmpss[*(UCHAR *)pY->pD];
                }
            }
	}

    if (pX->pI->fla