DisassemblyData
Popisuje jednu pokyn k zpětnému překladu pro zobrazení integrovaného vývojového prostředí (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;
};
Členové
dwFields
Konstanta DISASSEMBLY_STREAM_FIELDS , která určuje, která pole jsou vyplněna.
bstrAddress
Adresa jako posun od počátečního bodu (obvykle začátek přidružené funkce).
bstrCodeBytes
Bajty kódu pro tuto instrukci
bstrOpcode
Opcode pro tuto instrukci.
bstrOperands
Operandy pro tuto instrukci.
bstrSymbol
Název symbolu, pokud existuje, přidružený k adrese (veřejný symbol, popisek atd.).
uCodeLocationId
Identifikátor umístění kódu pro tento rozebraný řádek. Pokud je kontextová adresa kódu jednoho řádku větší než kontextová adresa kódu jiného, pak rozebráný identifikátor umístění kódu prvního bude také větší než identifikátor umístění kódu druhého.
posBeg
TEXT_POSITION, která odpovídá pozici v dokumentu, kde začínají data zpětného překladu.
posEnd
TEXT_POSITION, která odpovídá pozici v dokumentu, kde končí data zpětného překladu.
bstrDocumentUrl
U textových dokumentů, které mohou být reprezentovány jako názvy souborů, bstrDocumentUrl je pole vyplněno názvem souboru, kde lze najít zdroj pomocí formátu file://file name.
U textových dokumentů, které nelze reprezentovat jako názvy souborů, bstrDocumentUrl je jedinečný identifikátor dokumentu a ladicí modul musí implementovat Metodu GetDocument .
Toto pole může také obsahovat další informace o kontrolních součtech. Podrobnosti najdete v poznámkách.
dwByteOffset
Počet bajtů, které instrukce spouští, je od začátku řádku kódu.
dwFlags
Konstanta DISASSEMBLY_FLAGS , která určuje, které příznaky jsou aktivní.
Poznámky
Každá DisassemblyData struktura popisuje jednu instrukci zpětného překladu. Z metody Read se vrátí pole těchto struktur.
Struktura TEXT_POSITION se používá pouze pro textové dokumenty. Oblast zdrojového kódu pro tuto instrukci je vyplněna pouze pro první instrukce vygenerované z příkazu nebo řádku, například když dwByteOffset == 0.
U dokumentů, které nejsou textové, lze z kódu získat kontext dokumentu a bstrDocumentUrl pole by mělo mít hodnotu null. bstrDocumentUrl Pokud je pole stejné jako bstrDocumentUrl pole v předchozím DisassemblyData prvku pole, nastavte bstrDocumentUrl hodnotu null.
Pokud má dwFlags DF_DOCUMENT_CHECKSUM pole nastavený příznak, další informace kontrolního součtu bstrDocumentUrl se řídí řetězcem, na který odkazuje dané pole. Konkrétně po ukončení řetězce s hodnotou null následuje identifikátor GUID identifikující algoritmus kontrolního součtu, za kterým následuje 4 bajtová hodnota označující počet bajtů v kontrolním součtu a za ním následuje bajty kontrolního součtu. Podívejte se na příklad v tomto tématu o kódování a dekódování tohoto pole v jazyce Visual C#.
Příklad
Pole bstrDocumentUrl může obsahovat jiné informace než řetězec, pokud DF_DOCUMENT_CHECKSUM je příznak nastaven. Proces vytváření a čtení tohoto zakódovaného řetězce je v jazyce Visual C++ jednoduchý. V jazyce Visual C# je to ale další věc. Pro ty, kteří jsou zvědaví, následující příklad ukazuje jeden ze způsobů, jak vytvořit kódovaný řetězec z Visual C# a jedním ze způsobů, jak dekódovat kódovaný řetězec v jazyce 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);
}
}
}
}
}