Compartir a través de

DesensambladoData

Describe una instrucción de desensamblaje para que se muestre el entorno de desarrollo integrado (IDE).

Syntax

public struct DisassemblyData { 
    public uint          dwFields;
    public string        bstrAddress;
    public string        bstrAddressOffset;
    public string        bstrCodeBytes;
    public string        bstrOpcode;
    public string        bstrOperands;
    public string        bstrSymbol;
    public ulong         uCodeLocationId;
    public TEXT_POSITION posBeg;
    public TEXT_POSITION posEnd;
    public string        bstrDocumentUrl;
    public uint          dwByteOffset;
    public uint          dwFlags;
};

Members

dwFields
Constante DISASSEMBLY_STREAM_FIELDS que especifica qué campos se rellenan.

bstrAddress
La dirección como un desplazamiento desde algún punto de partida (normalmente al inicio de la función asociada).

bstrCodeBytes
Los bytes de código de esta instrucción.

bstrOpcode
Código de operación para esta instrucción.

bstrOperands
Operandos para esta instrucción.

bstrSymbol
El nombre del símbolo, si existe, asociado a la dirección (símbolo público, etiqueta, etc.).

uCodeLocationId
Identificador de ubicación de código para esta línea desensamblada. Si la dirección de contexto de código de una línea es mayor que la dirección de contexto de código de otra, entonces la identificación de la ubicación de código desensamblado de la primera también será mayor que la identificación de la ubicación de código de la segunda.

posBeg
El TEXT_POSITION que corresponde a la posición de un documento donde comienzan los datos de desensamblaje.

posEnd
El TEXT_POSITION que corresponde a la posición en un documento donde finalizan los datos de desensamblado.

bstrDocumentUrl
Para los documentos de texto que se pueden representar como nombres de archivo, el bstrDocumentUrl campo se rellena con el nombre de archivo donde se puede encontrar el origen, con el formato file://file name.

Para los documentos de texto que no se pueden representar como nombres de archivo, bstrDocumentUrl es un identificador único para el documento y el motor de depuración debe implementar el método GetDocument .

Este campo también puede contener información adicional sobre sumas de comprobación. Consulte Comentarios para obtener más detalles.

dwByteOffset
La cantidad de bytes que hay desde el principio de la línea de código hasta la instrucción.

dwFlags
Constante DISASSEMBLY_FLAGS que especifica qué marcas están activas.

Remarks

Cada DisassemblyData estructura describe una instrucción de desensamblaje. Se devuelve una matriz de estas estructuras desde el método Read .

La estructura TEXT_POSITION solo se usa para documentos basados en texto. El intervalo de código fuente de esta instrucción se rellena solo para la primera instrucción generada a partir de una instrucción o línea, por ejemplo, cuando dwByteOffset == 0.

Para los documentos que no son textuales, se puede obtener un contexto de documento del código y el bstrDocumentUrl campo debe ser un valor NULL. Si el bstrDocumentUrl campo es el mismo que el bstrDocumentUrl campo del elemento de matriz anterior DisassemblyData , establezca en bstrDocumentUrl un valor NULL.

Si el dwFlags campo tiene la DF_DOCUMENT_CHECKSUM marca establecida, la información adicional de suma de comprobación sigue la cadena a la que apunta el bstrDocumentUrl campo. En concreto, después del terminador de cadena NULL, sigue un GUID que identifica el algoritmo de suma de comprobación que, a su vez, va seguido de un valor de 4 bytes que indica el número de bytes de la suma de comprobación y, a su vez, va seguido de los bytes de suma de comprobación. Vea el ejemplo de este tema sobre cómo codificar y descodificar este campo en Visual C#.

Example

El bstrDocumentUrl campo puede contener información adicional distinta de una cadena si se establece la DF_DOCUMENT_CHECKSUM marca. El proceso de creación y lectura de esta cadena codificada es sencillo en Visual C++. Sin embargo, en Visual C#, es otra cuestión. Para aquellos que tienen curiosidad, en el ejemplo siguiente se muestra una manera de crear la cadena codificada desde Visual C# y una manera de descodificar la cadena codificada en Visual C#.

using System;
using System.Runtime.InteropServices;

namespace MyNamespace
{
    class MyClass
    {
        string EncodeData(string documentString,
                          Guid checksumGuid,
                          byte[] checksumData)
        {
            string returnString = documentString;

            if (checksumGuid == null || checksumData == null)
            {
                // Nothing more to do. Just return the string.
                return returnString;
            }

            returnString += '\0'; // separating null value

            // Add checksum GUID to string.
            byte[] guidDataArray  = checksumGuid.ToByteArray();
            int    guidDataLength = guidDataArray.Length;
            IntPtr pBuffer        = Marshal.AllocCoTaskMem(guidDataLength);
            for (int i = 0; i < guidDataLength; i++)
            {
                Marshal.WriteByte(pBuffer, i, guidDataArray[i]);
            }
            // Copy guid data bytes to string as wide characters.
            // Assumption: sizeof(char) == 2.
            for (int i = 0; i < guidDataLength / sizeof(char); i++)
            {
                returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
            }

            // Add checksum count (a 32-bit value).
            Int32 checksumCount = checksumData.Length;
            Marshal.StructureToPtr(checksumCount, pBuffer, true);
            for (int i = 0; i < sizeof(Int32) / sizeof(char); i++)
            {
                returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
            }

            // Add checksum data.
            pBuffer = Marshal.AllocCoTaskMem(checksumCount);
            for (int i = 0; i < checksumCount; i++)
            {
                Marshal.WriteByte(pBuffer, i, checksumData[i]);
            }
            for (int i = 0; i < checksumCount / sizeof(char); i++)
            {
                returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
            }
            Marshal.FreeCoTaskMem(pBuffer);

            return returnString;
        }

        void DecodeData(    string encodedString,
                        out string documentString,
                        out Guid   checksumGuid,
                        out byte[] checksumData)
        {
            documentString = String.Empty;
            checksumGuid = Guid.Empty;
            checksumData = null;

            IntPtr pBuffer = Marshal.StringToBSTR(encodedString);
            if (null != pBuffer)
            {
                int bufferOffset = 0;

                // Parse string out. String is assumed to be Unicode.
                documentString = Marshal.PtrToStringUni(pBuffer);
                bufferOffset += (documentString.Length + 1) * sizeof(char);

                // Parse Guid out.
                // Read guid bytes from buffer and store in temporary
                // buffer that contains only the guid bytes. Then the
                // Marshal.PtrToStructure() can work properly.
                byte[] guidDataArray  = checksumGuid.ToByteArray();
                int    guidDataLength = guidDataArray.Length;
                IntPtr pGuidBuffer    = Marshal.AllocCoTaskMem(guidDataLength);
                for (int i = 0; i < guidDataLength; i++)
                {
                    Marshal.WriteByte(pGuidBuffer, i,
                                      Marshal.ReadByte(pBuffer, bufferOffset + i));
                }
                bufferOffset += guidDataLength;
                checksumGuid = (Guid)Marshal.PtrToStructure(pGuidBuffer, typeof(Guid));
                Marshal.FreeCoTaskMem(pGuidBuffer);

                // Parse out the number of checksum data bytes (always 32-bit value).
                int dataCount = Marshal.ReadInt32(pBuffer, bufferOffset);
                bufferOffset += sizeof(Int32);

                // Parse out the checksum data.
                checksumData = new byte[dataCount];
                for (int i = 0; i < dataCount; i++)
                {
                    checksumData[i] = Marshal.ReadByte(pBuffer, bufferOffset + i);
                }
            }
        }
    }
}

Consulte también

  • Last updated on