DisassemblyData
Descreve uma instrução de desmontagem para o ambiente de desenvolvimento integrado (IDE) a ser exibido.
Sintaxe
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;
};
Membros
dwFields
A constante DISASSEMBLY_STREAM_FIELDS que especifica quais campos são preenchidos.
bstrAddress
O endereço como um deslocamento de algum ponto de partida (geralmente o início da função associada).
bstrCodeBytes
Os bytes de código para esta instrução.
bstrOpcode
O opcode 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 local de código para essa linha desmontada. Se o endereço de contexto de código de uma linha for maior do que o endereço de contexto de código de outra, o identificador de local de código desmontado da primeira também será maior do que o identificador de local de código da segunda.
posBeg
O TEXT_POSITION que corresponde à posição em um documento onde os dados de desmontagem começam.
posEnd
O TEXT_POSITION que corresponde à posição em um documento onde os dados de desmontagem terminam.
bstrDocumentUrl
Para documentos de texto que podem ser representados como nomes de arquivo, o campo é preenchido com o nome do arquivo onde a fonte pode ser encontrada, usando o bstrDocumentUrl formato file://file name.
Para documentos de texto que não podem ser representados como nomes de arquivo, é um identificador exclusivo para o documento, bstrDocumentUrl 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 é do início da linha de código.
dwFlags
A constante DISASSEMBLY_FLAGS que especifica quais sinalizadores estão ativos.
Comentários
Cada DisassemblyData estrutura descreve uma instrução de desmontagem. Uma matriz dessas estruturas é retornada do método Read .
A estrutura TEXT_POSITION é usada apenas 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 a partir do código, e o bstrDocumentUrl campo deve ser um valor nulo. Se o campo for igual ao bstrDocumentUrl campo no elemento de matriz anteriorDisassemblyData, defina o bstrDocumentUrl bstrDocumentUrl como um valor nulo.
Se o campo tiver o dwFlags DF_DOCUMENT_CHECKSUM sinalizador definido, as informações adicionais de soma de verificação seguirão a cadeia de caracteres apontada bstrDocumentUrl pelo campo. Especificamente, após o terminador de cadeia de caracteres nulo, segue-se um GUID identificando o algoritmo de soma de verificação que, por sua vez, é seguido por um valor de 4 bytes indicando o número de bytes na soma de verificação e que, por sua vez, é seguido pelos bytes de soma de verificação. Consulte o exemplo neste tópico sobre como codificar e decodificar esse campo no Visual C#.
Exemplo
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 que estão 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);
}
}
}
}
}