DisassemblyData
Descrive un'istruzione disassembly per l'ambiente di sviluppo integrato (IDE) da visualizzare.
Sintassi
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;
};
Membri
dwFields
Costante DISAS edizione StandardMBLY_STREAM_FIELDS che specifica i campi compilati.
bstrAddress
Indirizzo come offset da un punto iniziale (in genere l'inizio della funzione associata).
bstrCodeBytes
Byte di codice per questa istruzione.
bstrOpcode
Codice operativo per questa istruzione.
bstrOperands
Operandi per questa istruzione.
bstrSymbol
Nome del simbolo, se presente, associato all'indirizzo (simbolo pubblico, etichetta e così via).
uCodeLocationId
Identificatore del percorso del codice per questa riga disassemblata. Se l'indirizzo del contesto di codice di una riga è maggiore dell'indirizzo del contesto di codice di un altro, l'identificatore del percorso del codice disassemblato del primo sarà maggiore dell'identificatore del percorso del codice del secondo.
posBeg
Il TEXT_POSITION che corrisponde alla posizione in un documento in cui iniziano i dati del disassembly.
posEnd
Il TEXT_POSITION che corrisponde alla posizione in un documento in cui terminano i dati disassembly.
bstrDocumentUrl
Per i documenti di testo che possono essere rappresentati come nomi di file, il bstrDocumentUrl campo viene compilato con il nome del file in cui è possibile trovare l'origine, usando il formato file://file name.
Per i documenti di testo che non possono essere rappresentati come nomi di file, bstrDocumentUrl è un identificatore univoco per il documento e il motore di debug deve implementare il metodo GetDocument .
Questo campo può contenere anche informazioni aggiuntive sui checksum. Pe altri dettagli, vedere la sezione Osservazioni.
dwByteOffset
Il numero di byte che l'istruzione proviene dall'inizio della riga di codice.
dwFlags
Costante DISAS edizione StandardMBLY_FLAGS che specifica quali flag sono attivi.
Osservazioni:
Ogni DisassemblyData struttura descrive un'istruzione di disassembly. Una matrice di queste strutture viene restituita dal metodo Read .
La struttura TEXT_POSITION viene utilizzata solo per i documenti basati su testo. L'intervallo di codice sorgente per questa istruzione viene compilato solo per la prima istruzione generata da un'istruzione o da una riga, ad esempio quando dwByteOffset == 0.
Per i documenti non testuali, è possibile ottenere un contesto di documento dal codice e il bstrDocumentUrl campo deve essere un valore Null. Se il bstrDocumentUrl campo è uguale al bstrDocumentUrl campo nell'elemento della matrice precedente DisassemblyData , impostare su bstrDocumentUrl un valore Null.
Se il dwFlags campo ha il DF_DOCUMENT_CHECKSUM flag impostato, le informazioni aggiuntive sul checksum seguono la stringa a cui punta il bstrDocumentUrl campo. In particolare, dopo il carattere di terminazione della stringa Null, viene seguito un GUID che identifica l'algoritmo checksum seguito da un valore di 4 byte che indica il numero di byte nel checksum e che a sua volta è seguito dai byte di checksum. Vedere l'esempio in questo argomento su come codificare e decodificare questo campo in Visual C#.
Esempio
Il bstrDocumentUrl campo può contenere informazioni aggiuntive diverse da una stringa se il DF_DOCUMENT_CHECKSUM flag è impostato. Il processo di creazione e lettura di questa stringa codificata è semplice in Visual C++. Tuttavia, in Visual C#, è un'altra questione. Per coloro che sono curiosi, l'esempio seguente illustra un modo per creare la stringa codificata da Visual C# e un modo per decodificare la stringa codificata in 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);
}
}
}
}
}