DisassemblyDataDisassemblyData

Décrit une instruction de code machine pour l’environnement de développement intégré (IDE) à afficher.Describes one disassembly instruction for the integrated development environment (IDE) to display.

SyntaxeSyntax

typedef struct tagDisassemblyData {   
   DISASSEMBLY_STREAM_FIELDS dwFields;  
   BSTR                      bstrAddress;  
   BSTR                      bstrAddressOffset;  
   BSTR                      bstrCodeBytes;  
   BSTR                      bstrOpcode;  
   BSTR                      bstrOperands;  
   BSTR                      bstrSymbol;  
   UINT64                    uCodeLocationId;  
   TEXT_POSITION             posBeg;  
   TEXT_POSITION             posEnd;  
   BSTR                      bstrDocumentUrl;  
   DWORD                     dwByteOffset;  
   DISASSEMBLY_FLAGS         dwFlags;  
} DisassemblyData;  
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;  
};  

MembresMembers

dwFields
Le DISASSEMBLY_STREAM_FIELDS constante qui spécifie les champs sont remplis.The DISASSEMBLY_STREAM_FIELDS constant that specifies which fields are filled out.

bstrAddress
L’adresse en tant que décalage à partir d’un point de départ (généralement le début de la fonction associée).The address as an offset from some starting point (usually the beginning of the associated function).

bstrCodeBytes
Les octets de code pour cette instruction.The code bytes for this instruction.

bstrOpcode
Le code d’opération pour cette instruction.The opcode for this instruction.

bstrOperands
Les opérandes pour cette instruction.The operands for this instruction.

bstrSymbol
Le nom du symbole, le cas échéant, liées à l’adresse (symboles publics, étiquette et ainsi de suite).The symbol name, if any, associated with the address (public symbol, label, and so on).

uCodeLocationId
L’identificateur d’emplacement de code pour cette ligne désassemblée.The code location identifier for this disassembled line. Si l’adresse de contexte de code d’une ligne est supérieure à l’adresse du contexte d’un autre code, puis l’identificateur d’emplacement de code désassemblé du premier sera également supérieur à l’identificateur d’emplacement de code de la deuxième.If the code context address of one line is greater than the code context address of another, then the disassembled code location identifier of the first will also be greater than the code location identifier of the second.

posBeg
Le TEXT_POSITION qui correspond à la position d’un document où le code machine de données commence.The TEXT_POSITION that corresponds to the position in a document where the disassembly data begins.

posEnd
Le TEXT_POSITION qui correspond à la position d’un document où les données de désassemblage se terminent.The TEXT_POSITION that corresponds to the position in a document where the disassembly data ends.

bstrDocumentUrl
Pour les documents de texte qui peuvent être représentés en tant que noms de fichiers, le bstrDocumentUrl champ affiche le nom du fichier où se trouve la source, en utilisant le format file://file name.For text documents that can be represented as file names, the bstrDocumentUrl field is filled in with the file name where the source can be found, using the format file://file name.

Pour les documents de texte qui ne peut pas être représentés en tant que noms de fichiers, bstrDocumentUrl est un identificateur unique pour le document, et le moteur de débogage doit implémenter la GetDocument (méthode).For text documents that cannot be represented as file names, bstrDocumentUrl is a unique identifier for the document, and the debug engine must implement the GetDocument method.

Ce champ peut également contenir des informations supplémentaires sur les sommes de contrôle.This field can also contain additional information about checksums. Pour plus d’informations, consultez la section Notes.See Remarks for details.

dwByteOffset
Le nombre d’octets de que l’instruction est au début de la ligne de code.The number of bytes the instruction is from the beginning of the code line.

dwFlags
Le DISASSEMBLY_FLAGS constante qui spécifie les indicateurs sont actifs.The DISASSEMBLY_FLAGS constant that specifies which flags are active.

NotesRemarks

Chaque DisassemblyData structure décrit une instruction de code machine.Each DisassemblyData structure describes one instruction of disassembly. Un tableau de ces structures est retourné à partir de la en lecture (méthode).An array of these structures is returned from the Read method.

Le TEXT_POSITION structure est utilisée pour des documents texte uniquement.The TEXT_POSITION structure is used for text-based documents only. La plage de code source pour cette instruction est remplie uniquement pour la première instruction générée à partir d’une instruction ou d’une ligne, par exemple, lorsque dwByteOffset == 0.The source code range for this instruction is filled out only for the first instruction generated from a statement or line, for example, when dwByteOffset == 0.

Pour les documents non textuelles, un contexte de document peut être obtenu à partir du code et le bstrDocumentUrl champ doit être une valeur null.For documents that are non-textual, a document context can be obtained from the code, and the bstrDocumentUrl field should be a null value. Si le bstrDocumentUrl champ est le même que le bstrDocumentUrl champ précédent DisassemblyData élément du tableau, puis définissez le bstrDocumentUrl à une valeur null.If the bstrDocumentUrl field is the same as the bstrDocumentUrl field in the previous DisassemblyData array element, then set the bstrDocumentUrl to a null value.

Si le dwFlags champ a le DF_DOCUMENT_CHECKSUM l’indicateur, puis les informations de somme de contrôle supplémentaires suivant la chaîne pointée par le bstrDocumentUrl champ.If the dwFlags field has the DF_DOCUMENT_CHECKSUM flag set, then additional checksum information follows the string pointed to by the bstrDocumentUrl field. Plus précisément, après la marque de fin de chaîne null, il suit un GUID qui identifie l’algorithme de somme de contrôle qui est à son tour suivi par une valeur de 4 octets qui indique le nombre d’octets dans la somme de contrôle, qui à son tour est suivi par les octets de la somme de contrôle.Specifically, after the null string terminator, there follows a GUID identifying the checksum algorithm that is in turn followed by a 4 byte value indicating the number of bytes in the checksum and that in turn is followed by the checksum bytes. Consultez l’exemple dans cette rubrique comment encoder et décoder de ce champ dans Visual C#Visual C#.See the Example in this topic on how to encode and decode this field in Visual C#Visual C#.

ExempleExample

Le bstrDocumentUrl champ peut contenir des informations supplémentaires autres que chaîne si le DF_DOCUMENT_CHECKSUM est défini.The bstrDocumentUrl field can contain additional information other than a string if the DF_DOCUMENT_CHECKSUM flag is set. Le processus de création et la lecture de cette chaîne encodée est très simple dans Visual C++Visual C++.The process of creating and reading this encoded string is straightforward in Visual C++Visual C++. Toutefois, dans Visual C#Visual C#, il s’agit d’un autre.However, in Visual C#Visual C#, it is another matter. Pour ceux qui vous intéresse, l’exemple suivant illustre la manière de créer la chaîne encodée à partir de Visual C#Visual C# et une façon de décoder la chaîne encodée dans Visual C#Visual C#.For those who are curious, the following example shows one way to create the encoded string from Visual C#Visual C# and one way to decode the encoded string in Visual C#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 aussiSee Also

Structures et Unions Structures and Unions
En lecture Read
DISASSEMBLY_STREAM_FIELDS DISASSEMBLY_STREAM_FIELDS
IDebugCodeContext2 IDebugCodeContext2
IDebugDocumentContext2 IDebugDocumentContext2
TEXT_POSITION TEXT_POSITION
DISASSEMBLY_FLAGSDISASSEMBLY_FLAGS