DisassemblyData
Décrit une instruction de désassemblement pour l’affichage de l’environnement de développement intégré (IDE).
Syntaxe
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;
};
Membres
dwFields
Constante DISASSE MoLY_STREAM_FIELDS qui spécifie les champs à remplir.
bstrAddress
Adresse en tant que décalage par rapport à un point de départ (généralement le début de la fonction associée).
bstrCodeBytes
Octets de code pour cette instruction.
bstrOpcode
Opcode pour cette instruction.
bstrOperands
Opérandes pour cette instruction.
bstrSymbol
Nom du symbole, le cas échéant, associé à l’adresse (symbole public, étiquette, etc.).
uCodeLocationId
Identificateur d’emplacement du code pour cette ligne désassemblé. Si l’adresse du contexte de code d’une ligne est supérieure à l’adresse du contexte de code d’une autre, l’identificateur d’emplacement de code désassemblé du premier est également supérieur à l’identificateur d’emplacement du code du second.
posBeg
Le TEXT_POSITION qui correspond à la position dans un document où commencent les données désassemblantes.
posEnd
Le TEXT_POSITION qui correspond à la position dans un document où se terminent les données désassemblantes.
bstrDocumentUrl
Pour les documents texte qui peuvent être représentés en tant que noms de fichiers, le bstrDocumentUrl champ est renseigné avec le nom de fichier où la source est trouvée, à l’aide du format file://file name.
Pour les documents texte qui ne peuvent pas être représentés en tant que noms de fichiers, bstrDocumentUrl il s’agit d’un identificateur unique pour le document, et le moteur de débogage doit implémenter la méthode GetDocument .
Ce champ peut également contenir des informations supplémentaires sur les case activée sums. Pour plus d’informations, consultez Remarques.
dwByteOffset
Le nombre d’octets que l’instruction est à partir du début de la ligne de code.
dwFlags
Constante DISASSE MoLY_FLAGS qui spécifie les indicateurs actifs.
Notes
Chaque DisassemblyData structure décrit une instruction de désassemblement. Un tableau de ces structures est retourné par la méthode Read .
La structure TEXT_POSITION est utilisée uniquement pour les documents textuels. La plage de code source de cette instruction est remplie uniquement pour la première instruction générée à partir d’une instruction ou d’une ligne, par exemple, quand dwByteOffset == 0.
Pour les documents qui ne sont pas textuels, un contexte de document peut être obtenu à partir du code et le bstrDocumentUrl champ doit être une valeur Null. Si le bstrDocumentUrl champ est identique bstrDocumentUrl au champ de l’élément de tableau précédent DisassemblyData , définissez la bstrDocumentUrl valeur null.
Si le dwFlags champ a le jeu d’indicateursDF_DOCUMENT_CHECKSUM, des informations supplémentaires case activée sum suivent la chaîne pointée par le bstrDocumentUrl champ. Plus précisément, après la fin de chaîne null, il suit un GUID identifiant l’algorithme de case activée sum qui est à son tour suivi d’une valeur de 4 octets indiquant le nombre d’octets dans le case activée sum et qui à son tour est suivi des octets de case activée sum. Consultez l’exemple de cette rubrique sur l’encodage et le décodage de ce champ en Visual C#.
Exemple
Le bstrDocumentUrl champ peut contenir des informations supplémentaires autres qu’une chaîne si l’indicateur DF_DOCUMENT_CHECKSUM est défini. Le processus de création et de lecture de cette chaîne encodée est simple dans Visual C++. Toutefois, dans Visual C#, il s’agit d’une autre question. Pour ceux qui sont curieux, l’exemple suivant montre une façon de créer la chaîne encodée à partir de Visual C# et d’une façon de décoder la chaîne encodée 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);
}
}
}
}
}