public override IEnumerable GetValues()
{
yield return TokenString("Name", row.NameString);
yield return Value("Flags", row.Flags.ToString());
yield return Value("ImplFlags", row.ImplFlags.ToString());
yield return Value("ParamList", row.ParamList);
yield return Value("Rva", row.Rva.ToString());
MethodSignature signature = new MethodSignature(Metadata, row.SignatureBlob);
yield return Value("Signature", signature.ToString());
if (row.Rva != 0)
{
var code = MetadataModule.GetInstructionStream((long)row.Rva);
var codeReader = new EndianAwareBinaryReader(code, Endianness.Little);
var header = new MethodHeader(codeReader);
if (header.LocalVarSigTok.RID != 0)
{
yield return Value("LocalVarSigTok", header.LocalVarSigTok.ToString());
StandAloneSigRow standAlongSigRow = Metadata.ReadStandAloneSigRow(header.LocalVarSigTok);
var local = new LocalVariableSignature(Metadata, standAlongSigRow.SignatureBlob);
yield return Value("Method Header", local.ToString());
}
}
}
/// <summary>
/// Loads and validates the image file header.
/// </summary>
/// <param name="reader">The reader, to read From.</param>
public void Read(EndianAwareBinaryReader reader)
{
this.Signature = reader.ReadUInt32();
if (this.Signature != PE_SIGNATURE)
throw new BadImageFormatException();
this.FileHeader.Read(reader);
this.OptionalHeader.Read(reader);
}
/// <summary>
/// Loads the CLI_HEADER from the reader.
/// </summary>
/// <param name="reader">The reader.</param>
public void Read(EndianAwareBinaryReader reader)
{
Cb = reader.ReadUInt32();
MajorRuntimeVersion = reader.ReadUInt16();
MinorRuntimeVersion = reader.ReadUInt16();
Metadata.Read(reader);
Flags = (RuntimeImageFlags)reader.ReadUInt32();
EntryPointToken = reader.ReadUInt32();
Resources.Read(reader);
StrongNameSignature.Read(reader);
CodeManagerTable.Read(reader);
VTableFixups.Read(reader);
ExportAddressTableJumps.Read(reader);
ManagedNativeHeader.Read(reader);
}
/// <summary>
/// Loads and validates the DOS header.
/// </summary>
public void Read(EndianAwareBinaryReader reader)
{
e_magic = reader.ReadUInt16();
e_cblp = reader.ReadUInt16();
e_cp = reader.ReadUInt16();
e_crlc = reader.ReadUInt16();
e_cparhdr = reader.ReadUInt16();
e_minalloc = reader.ReadUInt16();
e_maxalloc = reader.ReadUInt16();
e_ss = reader.ReadUInt16();
e_sp = reader.ReadUInt16();
e_csum = reader.ReadUInt16();
e_ip = reader.ReadUInt16();
e_cs = reader.ReadUInt16();
e_lfarlc = reader.ReadUInt16();
e_ovno = reader.ReadUInt16();
e_res00 = reader.ReadUInt16();
e_res01 = reader.ReadUInt16();
e_res02 = reader.ReadUInt16();
e_res03 = reader.ReadUInt16();
e_oemid = reader.ReadUInt16();
e_oeminfo = reader.ReadUInt16();
e_res20 = reader.ReadUInt16();
e_res21 = reader.ReadUInt16();
e_res22 = reader.ReadUInt16();
e_res23 = reader.ReadUInt16();
e_res24 = reader.ReadUInt16();
e_res25 = reader.ReadUInt16();
e_res26 = reader.ReadUInt16();
e_res27 = reader.ReadUInt16();
e_res28 = reader.ReadUInt16();
e_res29 = reader.ReadUInt16();
e_lfanew = reader.ReadUInt32();
if (DOS_HEADER_MAGIC != e_magic)
throw new BadImageFormatException();
}
/// <summary>
/// Loads the header from the reader.
/// </summary>
/// <param name="reader">The reader.</param>
public void Read(EndianAwareBinaryReader reader)
{
Magic = reader.ReadUInt16();
if (IMAGE_OPTIONAL_HEADER_MAGIC != Magic)
throw new BadImageFormatException();
MajorLinkerVersion = reader.ReadByte();
MinorLinkerVersion = reader.ReadByte();
SizeOfCode = reader.ReadUInt32();
SizeOfInitializedData = reader.ReadUInt32();
SizeOfUninitializedData = reader.ReadUInt32();
AddressOfEntryPoint = reader.ReadUInt32();
BaseOfCode = reader.ReadUInt32();
BaseOfData = reader.ReadUInt32();
ImageBase = reader.ReadUInt32();
SectionAlignment = reader.ReadUInt32();
FileAlignment = reader.ReadUInt32();
MajorOperatingSystemVersion = reader.ReadUInt16();
MinorOperatingSystemVersion = reader.ReadUInt16();
MajorImageVersion = reader.ReadUInt16();
MinorImageVersion = reader.ReadUInt16();
MajorSubsystemVersion = reader.ReadUInt16();
MinorSubsystemVersion = reader.ReadUInt16();
Win32VersionValue = reader.ReadUInt32();
SizeOfImage = reader.ReadUInt32();
SizeOfHeaders = reader.ReadUInt32();
CheckSum = reader.ReadUInt32();
Subsystem = reader.ReadUInt16();
DllCharacteristics = reader.ReadUInt16();
SizeOfStackReserve = reader.ReadUInt32();
SizeOfStackCommit = reader.ReadUInt32();
SizeOfHeapReserve = reader.ReadUInt32();
SizeOfHeapCommit = reader.ReadUInt32();
LoaderFlags = reader.ReadUInt32();
NumberOfRvaAndSizes = reader.ReadUInt32();
DataDirectory = new ImageDataDirectory[NumberOfRvaAndSizes];
for (int i = 0; i < NumberOfRvaAndSizes; i++)
{
DataDirectory[i].Read(reader);
}
}
/// <summary>
/// Loads the IMAGE_DATA_DIRECTORY from the reader.
/// </summary>
/// <param name="reader">The reader.</param>
public void Read(EndianAwareBinaryReader reader)
{
VirtualAddress = reader.ReadUInt32();
Size = reader.ReadInt32();
}
/// <summary>
/// Reads the method header from the instruction stream.
/// </summary>
/// <param name="reader">The reader used to decode the instruction stream.</param>
/// <returns></returns>
public MethodHeader(EndianAwareBinaryReader reader)
{
Clauses = new List<ExceptionHandlingClause>();
// Read first byte
Flags = (MethodFlags)reader.ReadByte();
// Check least significant 2 bits
switch (Flags & MethodFlags.HeaderMask)
{
case MethodFlags.TinyFormat:
CodeSize = ((int)(Flags & MethodFlags.TinyCodeSizeMask) >> 2);
Flags &= MethodFlags.HeaderMask;
break;
case MethodFlags.FatFormat:
// Read second byte of flags
Flags = (MethodFlags)(reader.ReadByte() << 8 | (byte)Flags);
if (MethodFlags.ValidHeader != (Flags & MethodFlags.HeaderSizeMask))
throw new CompilerException("Invalid method ");
MaxStack = reader.ReadUInt16();
CodeSize = reader.ReadInt32();
LocalVarSigTok = new Token(reader.ReadUInt32()); // ReadStandAloneSigRow
break;
default:
throw new CompilerException("Invalid method header");
}
// Are there sections following the code?
if (MethodFlags.MoreSections != (Flags & MethodFlags.MoreSections))
return;
// Yes, seek to them and process those sections
long codepos = reader.BaseStream.Position;
// Seek to the end of the code...
long dataSectPos = codepos + CodeSize;
if (0 != (dataSectPos & 3))
dataSectPos += (4 - (dataSectPos % 4));
reader.BaseStream.Position = dataSectPos;
// Read all headers, so the IL decoder knows how to handle these...
byte flags;
do
{
flags = reader.ReadByte();
bool isFat = (0x40 == (flags & 0x40));
int length;
int blocks;
if (isFat)
{
byte a = reader.ReadByte();
byte b = reader.ReadByte();
byte c = reader.ReadByte();
length = (c << 24) | (b << 16) | a;
blocks = (length - 4) / 24;
}
else
{
length = reader.ReadByte();
blocks = (length - 4) / 12;
/* Read & skip the padding. */
reader.ReadInt16();
}
Debug.Assert(0x01 == (flags & 0x3F), "Unsupported method data section.");
// Read the clause
for (int i = 0; i < blocks; i++)
{
ExceptionHandlingClause clause = new ExceptionHandlingClause();
clause.Read(reader, isFat);
Clauses.Add(clause);
}
}
while (0x80 == (flags & 0x80));
reader.BaseStream.Position = codepos;
}
