dsmlib.c

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

	else
	    pX->lenI = immL[(int)pX->d32][(int)pX->w];
	}

    if (pX->pI->flag & OFFSEL)
	{
	if (pX->d)
	    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));
	}

    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);
        }

    if (pX->pI->flag & TYPE)
        sprintf (pY->ibuf, "0x%x", *(UCHAR *)(pX->pD + pX->lenO));

    if (pX->pI->flag & PORT)
        sprintf (pY->ibuf, "0x%04x", *(USHORT *)(pX->pD + pX->lenO));

    if (pX->pI->flag & OFFSEL)
        {
        if (pX->lenI == 2)
            sprintf (pY->ibuf, "0x%x", *(USHORT *)(pX->pD + pX->lenO));
        else
            sprintf (pY->ibuf, "0x%x", *(UINT *)(pX->pD + pX->lenO));
        }

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

    if (pX->pI->type == itRolRMby1)		
        sprintf (pY->ibuf, "0x1");

    /* get a memory operand buffer, pY->mbuf */

    if (pX->modrm) 
	{
	if (pX->mod == 3)
            {
            if (pX->pI->flag & WFUL)
	        pS = regw[(int)pX->d32][(int)pX->w][(int)pX->rm];
	    else if (pX->pI->flag & MMXRM)
		pS = regmmx[(int)pX->rm];
            else
	        pS = reg[(int)pX->d32][(int)pX->rm];
            bcopy (pS, pY->mbuf, strlen (pS));
            }
	else
	    {
	    if (pX->a32 == 0)
                {
                pY->pD = pX->pD + pX->lenO + pX->modrm;
	        pS = modrm[(int)pX->a32][(int)pX->mod][(int)pX->rm];
                if (pX->mod == 0)
	            {
	            if (pX->rm == 6)
	                sprintf (pY->mbuf, pS, *(USHORT *)pY->pD);
		        /* see 01e, pY->addr = *(USHORT *)pY->pD; */
	            else
	                sprintf (pY->mbuf, pS);
	            }
                else if (pX->mod == 1)
	            sprintf (pY->mbuf, pS, *pY->pD);
                else if (pX->mod == 2)
	            sprintf (pY->mbuf, pS, *(USHORT *)pY->pD);
                }
	    else
                {
                pY->pD = pX->pD + pX->lenO + pX->modrm;
	        pS = modrm[(int)pX->a32][(int)pX->mod][(int)pX->rm];
                if ((pX->sib) && (pX->rm == 4))
	            {
                    pY->pD += pX->sib;
	            pS = sib[(int)pX->mod][(int)pX->base];
	            if (pX->mod == 0)
		        {
		        if (pX->base == 5)
	                    sprintf (pY->mbuf, pS, *(int *)pY->pD, 
				     indexR[(int)pX->index],
				     scale[(int)pX->ss]);
	                else
	                    sprintf (pY->mbuf, pS, indexR[(int)pX->index], 
				     scale[(int)pX->ss]);
		        }
	            else if (pX->mod == 1)
	                sprintf (pY->mbuf, pS, indexR[(int)pX->index],
				 scale[(int)pX->ss], *pY->pD);
	            else if (pX->mod == 2)
	                sprintf (pY->mbuf, pS, indexR[(int)pX->index],
				 scale[(int)pX->ss], *(int *)pY->pD);
	            }
                else 
	            {
                    if (pX->mod == 0)
	                {
                        if (pX->rm == 5)
	                    sprintf (pY->mbuf, pS, *(int *)pY->pD);
		            /* see 01e, pY->addr = *(int *)pY->pD; */
	                else
	                    sprintf (pY->mbuf, pS);
	                }
                    else if (pX->mod == 1)
	                sprintf (pY->mbuf, pS, *pY->pD);
	            else if (pX->mod == 2)
	                sprintf (pY->mbuf, pS, *(int *)pY->pD);
	            }
                }
            }
        }
    }

/*******************************************************************************
*
* dsmPrint - print FORMAT_Y structure.
*
* RETUERNS: N/A
*/

LOCAL void dsmPrint
    (
    FORMAT_X *pX,		/* Pointer to the FORMAT_X	*/
    FORMAT_Y *pY,		/* Pointer to the FORMAT_Y	*/
    VOIDFUNCPTR prtAddress 	/* Address printing function	*/
    )
    {
    int flag;
    char *pS;
    char *pD = pX->pD;
    int bytesToPrint;
    int ix;

    if (pY->len == 0)
        pY->len = 1;

    bytesToPrint = (((pY->len - 1) >> 3) + 1) << 3;

    /* print out an address */

    printf ("%08x  ", (UINT)pX->pD);

    /* print out a data */

    for (ix=0; ix < bytesToPrint; ix++)
	{
	if ((ix & ~0x07) && ((ix & 0x07) == 0))
	    printf ("\n          ");
	printf ((ix < pY->len) ? "%02x " : "   ", (UCHAR)*pD++);
	}

    /* print out the unknown instruction */

    if (pX->pI == NULL)
	{
	printf (".BYTE          0x%02x\n", (UCHAR)*pX->pD);
	return;
	}

    /* set the operand pointers */

    flag = pX->pI->flag & 0xfffff;

    switch (flag)
        {
        case REG:
        case SREG3:
        case SREG2:
        case ST:
            pY->pOpr0 = pY->rbuf;
	    break;

        case MODRM:
            pY->pOpr0 = pY->mbuf;
	    if (pX->pI->type == itRolRMby1)
		pY->pOpr1 = pY->ibuf;
	    break;

        case TYPE:
        case IMM:
            pY->pOpr0 = pY->ibuf;
	    break;

        case D8:
        case DIS:
            pY->pOpr0 = (char *)&pY->addr;
	    break;

        case D16:
            pY->pOpr0 = pY->dbuf;