Bagikan melalui

DisassemblyData

Menjelaskan satu instruksi pembongkaran yang harus ditampilkan oleh lingkungan pengembangan terintegrasi (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
Konstanta DISASSEMBLY_STREAM_FIELDS yang menentukan bidang mana yang diisi.

bstrAddress
Alamat sebagai offset dari beberapa titik awal (biasanya awal fungsi terkait).

bstrCodeBytes
Kode byte untuk instruksi ini.

bstrOpcode
Opcode untuk instruksi ini.

bstrOperands
Operand untuk instruksi ini.

bstrSymbol
Nama simbol, jika ada, yang terkait dengan alamat (simbol publik, label, dan sebagainya).

uCodeLocationId
Pengidentifikasi lokasi kode untuk baris yang dibongkar ini. Jika alamat konteks kode dari satu baris lebih besar dari alamat konteks kode dari baris lain, maka pengidentifikasi lokasi kode yang dibongkar dari baris pertama juga akan lebih besar dari pengidentifikasi lokasi kode yang kedua.

posBeg
TEXT_POSITION yang menunjukkan posisi dalam dokumen di mana data pembongkaran dimulai.

posEnd
TEXT_POSITION yang sesuai dengan posisi dalam dokumen tempat data pembongkaran berakhir.

bstrDocumentUrl
Untuk dokumen teks yang dapat direpresentasikan sebagai nama file, bstrDocumentUrl bidang diisi dengan nama file tempat sumber dapat ditemukan, menggunakan format file://file name.

Untuk dokumen teks yang tidak dapat direpresentasikan sebagai nama file, bstrDocumentUrl adalah pengidentifikasi unik untuk dokumen, dan mesin debug harus menerapkan metode GetDocument .

Bidang ini juga dapat berisi informasi tambahan tentang checksum. Lihat Keterangan untuk detailnya.

dwByteOffset
Jumlah byte instruksi berasal dari awal baris kode.

dwFlags
Konstanta DISASSEMBLY_FLAGS yang menentukan bendera mana yang aktif.

Remarks

Setiap DisassemblyData struktur menjelaskan satu instruksi pembongkaran. Sekumpulan struktur ini dikembalikan dari fungsi Read.

Struktur TEXT_POSITION hanya digunakan untuk dokumen berbasis teks. Rentang kode sumber untuk instruksi ini diisi hanya untuk instruksi pertama yang dihasilkan dari pernyataan atau baris, misalnya, ketika dwByteOffset == 0.

Untuk dokumen yang non-tekstual, konteks dokumen dapat diperoleh dari kode, dan bstrDocumentUrl bidang harus berupa nilai null. Jika bidang bstrDocumentUrl sama dengan bidang bstrDocumentUrl di elemen array sebelumnya DisassemblyData, maka atur bstrDocumentUrl ke nilai null.

dwFlags Jika bidang memiliki bendera DF_DOCUMENT_CHECKSUM diatur, maka informasi checksum tambahan mengikuti string yang ditunjukkan oleh bidang bstrDocumentUrl . Secara khusus, setelah terminator string null, diikuti oleh GUID yang mengidentifikasi algoritma checksum, kemudian diikuti oleh nilai 4 byte yang menunjukkan jumlah byte dalam checksum, dan akhirnya diikuti oleh byte checksum. Lihat Contoh dalam topik ini tentang cara mengodekan dan mendekode bidang ini di Visual C#.

Example

Bidang bstrDocumentUrl dapat berisi informasi tambahan selain tipe data string jika flag DF_DOCUMENT_CHECKSUM diatur. Proses pembuatan dan pembacaan string yang dikodekan ini sangat mudah di Visual C++. Namun, di Visual C#, itu adalah masalah lain. Bagi mereka yang ingin tahu, contoh berikut menunjukkan salah satu cara untuk membuat string yang dikodekan dari Visual C# dan salah satu cara untuk mendekode string yang dikodekan di 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);
                }
            }
        }
    }
}

Lihat juga

  • Last updated on