Compartilhar via

DisassemblyData

Descreve uma instrução de desmontagem para que o IDE (ambiente de desenvolvimento integrado) seja exibido.

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
A constante DISASSEMBLY_STREAM_FIELDS que especifica quais campos são preenchidos.

bstrAddress
O endereço como um deslocamento de um ponto inicial específico (geralmente o início da função associada).

bstrCodeBytes
Os bytes de código para esta instrução.

bstrOpcode
O código de operação para esta instrução.

bstrOperands
Os operandos para esta instrução.

bstrSymbol
O nome do símbolo, se houver, associado ao endereço (símbolo público, rótulo e assim por diante).

uCodeLocationId
O identificador de localização do código para esta linha desmontada. Se o endereço de contexto de código de uma linha for maior que o endereço de contexto de código de outra, o identificador de local de código desmontado do primeiro também será maior que o identificador de local de código do segundo.

posBeg
O TEXT_POSITION que corresponde à posição em um documento onde os dados de desassemblagem começam.

posEnd
O TEXT_POSITION que corresponde à posição em um documento em que os dados de desmontagem terminam.

bstrDocumentUrl
Para documentos de texto que podem ser representados como nomes de arquivo, o bstrDocumentUrl campo é preenchido com o nome do arquivo em que a origem pode ser encontrada, usando o formato file://file name.

Para documentos de texto que não podem ser representados como nomes de arquivo, bstrDocumentUrl é um identificador exclusivo para o documento e o mecanismo de depuração deve implementar o método GetDocument .

Esse campo também pode conter informações adicionais sobre somas de verificação. Consulte Comentários para obter detalhes.

dwByteOffset
O número de bytes que a instrução é desde o início da linha de código.

dwFlags
A constante DISASSEMBLY_FLAGS que especifica quais sinalizadores estão ativos.

Remarks

Cada DisassemblyData estrutura descreve uma instrução de desmontagem. Uma matriz dessas estruturas é retornada do método Read .

A estrutura TEXT_POSITION é usada somente para documentos baseados em texto. O intervalo de código-fonte para esta instrução é preenchido apenas para a primeira instrução gerada a partir de uma instrução ou linha, por exemplo, quando dwByteOffset == 0.

Para documentos que não são textuais, um contexto de documento pode ser obtido do código e o bstrDocumentUrl campo deve ser um valor nulo. Se o bstrDocumentUrl campo for o mesmo que o bstrDocumentUrl campo no elemento de matriz anterior DisassemblyData , defina-o bstrDocumentUrl como um valor nulo.

Se o campo dwFlags tiver o sinalizador DF_DOCUMENT_CHECKSUM ativado, as informações adicionais da soma de verificação seguirão a cadeia de caracteres apontada pelo campo bstrDocumentUrl. Especificamente, após o terminador de string nulo, segue um GUID que identifica o algoritmo de checksum, seguido por um valor de 4 bytes que indica a quantidade de bytes no checksum, e depois vêm os bytes do checksum. Consulte o exemplo neste tópico sobre como codificar e decodificar esse campo no Visual C#.

Example

O bstrDocumentUrl campo pode conter informações adicionais diferentes de uma cadeia de caracteres se o DF_DOCUMENT_CHECKSUM sinalizador estiver definido. O processo de criação e leitura dessa cadeia de caracteres codificada é simples no Visual C++. No entanto, no Visual C#, é outra questão. Para aqueles curiosos, o exemplo a seguir mostra uma maneira de criar a cadeia de caracteres codificada do Visual C# e uma maneira de decodificar a cadeia de caracteres codificada no 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 também

  • Last updated on