Partager via

DésassembleyData

Décrit une instruction de désassemblement pour l’affichage de l’environnement de développement intégré (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 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
L'opcode pour cette instruction.

bstrOperands
Les opérandes pour cette instruction.

bstrSymbol
Nom du symbole, le cas échéant, associé à l’adresse (symbole public, étiquette, etc.).

uCodeLocationId
Identificateur d’emplacement de code pour cette ligne désassemblée. 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
La TEXT_POSITION correspondant à la position dans un document où commencent les données de désassemblage.

posEnd
Le TEXT_POSITION qui correspond à la position dans un document où se terminent les données de désassemblage.

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 sommes de contrôle. Pour plus d’informations, consultez Remarques.

dwByteOffset
Le nombre d’octets entre l’instruction et le début de la ligne de code.

dwFlags
Constante DISASSEMBLY_FLAGS qui spécifie les indicateurs actifs.

Remarks

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 l’indicateur DF_DOCUMENT_CHECKSUM défini, des informations de somme de contrôle supplémentaires 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 somme de contrôle qui est à son tour suivi d’une valeur de 4 octets indiquant le nombre d’octets dans la somme de contrôle et qu’à son tour est suivi par les octets de somme de contrôle. Consultez l’exemple de cette rubrique sur l’encodage et le décodage de ce champ en Visual C#.

Example

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);
                }
            }
        }
    }
}

Voir aussi

  • Last updated on