internal MethodIL/*?*/ GetMethodIL(
uint methodDefRowId
) {
MethodRow methodRow = this.MethodTable[methodDefRowId];
if (
(methodRow.ImplFlags & MethodImplFlags.CodeTypeMask) != MethodImplFlags.ILCodeType
|| methodRow.RVA == 0
) {
return null;
}
MemoryBlock memBlock = this.RVAToMemoryBlock(methodRow.RVA);
// Error need to check if the Memory Block is empty. This is calse for all the calls...
MemoryReader memReader = new MemoryReader(memBlock);
byte headByte = memReader.ReadByte();
if ((headByte & CILMethodFlags.ILFormatMask) == CILMethodFlags.ILTinyFormat) {
int size = headByte >> CILMethodFlags.ILTinyFormatSizeShift;
return new MethodIL(
true,
8,
0x00000000,
memReader.GetMemoryBlockAt(0, size),
null
);
} else if ((headByte & CILMethodFlags.ILFormatMask) != CILMethodFlags.ILFatFormat) {
// PEFileFormat Error...
return null;
}
// FatILFormat
byte headByte2 = memReader.ReadByte();
if ((headByte2 >> CILMethodFlags.ILFatFormatHeaderSizeShift) != CILMethodFlags.ILFatFormatHeaderSize) {
// PEFile Format Error...
return null;
}
bool localVarInited = (headByte & CILMethodFlags.ILInitLocals) == CILMethodFlags.ILInitLocals;
bool moreSectsPresent = (headByte & CILMethodFlags.ILMoreSects) == CILMethodFlags.ILMoreSects;
ushort maxStack = memReader.ReadUInt16();
int codeSize = memReader.ReadInt32();
uint localSignatureToken = memReader.ReadUInt32();
MemoryBlock ilCodeMemBlock = memReader.GetMemoryBlockAt(0, codeSize);
SEHTableEntry[]/*?*/ sehTableEntries = null;
if (moreSectsPresent) {
memReader.SkipBytes(codeSize);
memReader.Align(4);
byte sectHeader = memReader.ReadByte();
if ((sectHeader & CILMethodFlags.SectEHTable) != CILMethodFlags.SectEHTable) {
// PEFile Format Error...
return null;
}
bool sectFatFormat = (sectHeader & CILMethodFlags.SectFatFormat) == CILMethodFlags.SectFatFormat;
int dataSize = memReader.ReadByte();
if (sectFatFormat) {
dataSize += (int)memReader.ReadUInt16() << 8;
sehTableEntries = PEFileReader.GetFatSEHEntries(memReader, dataSize / 24);
} else {
memReader.SkipBytes(2); //skip over reserved field
sehTableEntries = PEFileReader.GetSmallSEHEntries(memReader, dataSize / 12);
}
}
return new MethodIL(
localVarInited,
maxStack,
localSignatureToken,
ilCodeMemBlock,
sehTableEntries
);
}
bool PopulateCilInstructions() {
MethodBodyDocument document = new MethodBodyDocument(this.MethodDefinition);
MemoryReader memReader = new MemoryReader(this.MethodIL.EncodedILMemoryBlock);
var numInstructions = CountCilInstructions(memReader);
if (numInstructions == 0) return true;
CilInstruction[] instrList = new CilInstruction[numInstructions];
int instructionNumber = 0;
while (memReader.NotEndOfBytes) {
object/*?*/ value = null;
uint offset = (uint)memReader.Offset;
OperationCode cilOpCode = memReader.ReadOpcode();
switch (cilOpCode) {
case OperationCode.Nop:
case OperationCode.Break:
break;
case OperationCode.Ldarg_0:
case OperationCode.Ldarg_1:
case OperationCode.Ldarg_2:
case OperationCode.Ldarg_3:
value = this.GetParameter((uint)(cilOpCode - OperationCode.Ldarg_0));
break;
case OperationCode.Ldloc_0:
case OperationCode.Ldloc_1:
case OperationCode.Ldloc_2:
case OperationCode.Ldloc_3:
value = this.GetLocal((uint)(cilOpCode - OperationCode.Ldloc_0));
break;
case OperationCode.Stloc_0:
case OperationCode.Stloc_1:
case OperationCode.Stloc_2:
case OperationCode.Stloc_3:
value = this.GetLocal((uint)(cilOpCode - OperationCode.Stloc_0));
break;
case OperationCode.Ldarg_S:
case OperationCode.Ldarga_S:
case OperationCode.Starg_S:
value = this.GetParameter(memReader.ReadByte());
break;
case OperationCode.Ldloc_S:
case OperationCode.Ldloca_S:
case OperationCode.Stloc_S:
value = this.GetLocal(memReader.ReadByte());
break;
case OperationCode.Ldnull:
case OperationCode.Ldc_I4_M1:
case OperationCode.Ldc_I4_0:
case OperationCode.Ldc_I4_1:
case OperationCode.Ldc_I4_2:
case OperationCode.Ldc_I4_3:
case OperationCode.Ldc_I4_4:
case OperationCode.Ldc_I4_5:
case OperationCode.Ldc_I4_6:
case OperationCode.Ldc_I4_7:
case OperationCode.Ldc_I4_8:
break;
case OperationCode.Ldc_I4_S:
value = (int)memReader.ReadSByte();
break;
case OperationCode.Ldc_I4:
value = memReader.ReadInt32();
break;
case OperationCode.Ldc_I8:
value = memReader.ReadInt64();
break;
case OperationCode.Ldc_R4:
value = memReader.ReadSingle();
break;
case OperationCode.Ldc_R8:
value = memReader.ReadDouble();
break;
case OperationCode.Dup:
case OperationCode.Pop:
break;
case OperationCode.Jmp:
value = this.GetMethod(memReader.ReadUInt32());
break;
case OperationCode.Call: {
IMethodReference methodReference = this.GetMethod(memReader.ReadUInt32());
IArrayTypeReference/*?*/ arrayType = methodReference.ContainingType as IArrayTypeReference;
if (arrayType != null) {
// For Get(), Set() and Address() on arrays, the runtime provides method implementations.
// Hence, CCI2 replaces these with pseudo instrcutions Array_Set, Array_Get and Array_Addr.
// All other methods on arrays will not use pseudo instruction and will have methodReference as their operand.
if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Set.UniqueKey) {
cilOpCode = OperationCode.Array_Set;
value = arrayType;
} else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Get.UniqueKey) {
cilOpCode = OperationCode.Array_Get;
value = arrayType;
} else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Address.UniqueKey) {
cilOpCode = OperationCode.Array_Addr;
value = arrayType;
} else {
value = methodReference;
}
} else {
value = methodReference;
}
}
break;
case OperationCode.Calli:
value = this.GetFunctionPointerType(memReader.ReadUInt32());
break;
case OperationCode.Ret:
break;
case OperationCode.Br_S:
case OperationCode.Brfalse_S:
case OperationCode.Brtrue_S:
case OperationCode.Beq_S:
case OperationCode.Bge_S:
case OperationCode.Bgt_S:
case OperationCode.Ble_S:
case OperationCode.Blt_S:
case OperationCode.Bne_Un_S:
case OperationCode.Bge_Un_S:
case OperationCode.Bgt_Un_S:
case OperationCode.Ble_Un_S:
case OperationCode.Blt_Un_S: {
uint jumpOffset = (uint)(memReader.Offset + 1 + memReader.ReadSByte());
if (jumpOffset >= this.EndOfMethodOffset) {
// Error...
}
value = jumpOffset;
}
break;
case OperationCode.Br:
case OperationCode.Brfalse:
case OperationCode.Brtrue:
case OperationCode.Beq:
case OperationCode.Bge:
case OperationCode.Bgt:
case OperationCode.Ble:
case OperationCode.Blt:
case OperationCode.Bne_Un:
case OperationCode.Bge_Un:
case OperationCode.Bgt_Un:
case OperationCode.Ble_Un:
case OperationCode.Blt_Un: {
uint jumpOffset = (uint)(memReader.Offset + 4 + memReader.ReadInt32());
if (jumpOffset >= this.EndOfMethodOffset) {
// Error...
}
value = jumpOffset;
}
break;
case OperationCode.Switch: {
uint numTargets = memReader.ReadUInt32();
uint[] result = new uint[numTargets];
uint asOffset = memReader.Offset + numTargets * 4;
for (int i = 0; i < numTargets; i++) {
uint targetAddress = memReader.ReadUInt32() + asOffset;
if (targetAddress >= this.EndOfMethodOffset) {
// Error...
}
result[i] = targetAddress;
}
value = result;
}
break;
case OperationCode.Ldind_I1:
case OperationCode.Ldind_U1:
case OperationCode.Ldind_I2:
case OperationCode.Ldind_U2:
case OperationCode.Ldind_I4:
case OperationCode.Ldind_U4:
case OperationCode.Ldind_I8:
case OperationCode.Ldind_I:
case OperationCode.Ldind_R4:
case OperationCode.Ldind_R8:
case OperationCode.Ldind_Ref:
case OperationCode.Stind_Ref:
case OperationCode.Stind_I1:
case OperationCode.Stind_I2:
case OperationCode.Stind_I4:
case OperationCode.Stind_I8:
case OperationCode.Stind_R4:
case OperationCode.Stind_R8:
case OperationCode.Add:
case OperationCode.Sub:
case OperationCode.Mul:
case OperationCode.Div:
case OperationCode.Div_Un:
case OperationCode.Rem:
case OperationCode.Rem_Un:
case OperationCode.And:
case OperationCode.Or:
case OperationCode.Xor:
case OperationCode.Shl:
case OperationCode.Shr:
case OperationCode.Shr_Un:
case OperationCode.Neg:
case OperationCode.Not:
case OperationCode.Conv_I1:
case OperationCode.Conv_I2:
case OperationCode.Conv_I4:
case OperationCode.Conv_I8:
case OperationCode.Conv_R4:
case OperationCode.Conv_R8:
case OperationCode.Conv_U4:
case OperationCode.Conv_U8:
break;
case OperationCode.Callvirt: {
IMethodReference methodReference = this.GetMethod(memReader.ReadUInt32());
IArrayTypeReference/*?*/ arrayType = methodReference.ContainingType as IArrayTypeReference;
if (arrayType != null) {
// For Get(), Set() and Address() on arrays, the runtime provides method implementations.
// Hence, CCI2 replaces these with pseudo instructions Array_Set, Array_Get and Array_Addr.
// All other methods on arrays will not use pseudo instruction and will have methodReference as their operand.
if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Set.UniqueKey) {
cilOpCode = OperationCode.Array_Set;
value = arrayType;
} else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Get.UniqueKey) {
cilOpCode = OperationCode.Array_Get;
value = arrayType;
} else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Address.UniqueKey) {
cilOpCode = OperationCode.Array_Addr;
value = arrayType;
} else {
value = methodReference;
}
} else {
value = methodReference;
}
}
break;
case OperationCode.Cpobj:
case OperationCode.Ldobj:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Ldstr:
value = this.GetUserStringForToken(memReader.ReadUInt32());
break;
case OperationCode.Newobj: {
IMethodReference methodReference = this.GetMethod(memReader.ReadUInt32());
IArrayTypeReference/*?*/ arrayType = methodReference.ContainingType as IArrayTypeReference;
if (arrayType != null && !arrayType.IsVector) {
uint numParam = IteratorHelper.EnumerableCount(methodReference.Parameters);
if (numParam != arrayType.Rank)
cilOpCode = OperationCode.Array_Create_WithLowerBound;
else
cilOpCode = OperationCode.Array_Create;
value = arrayType;
} else {
value = methodReference;
}
}
break;
case OperationCode.Castclass:
case OperationCode.Isinst:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Conv_R_Un:
break;
case OperationCode.Unbox:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Throw:
break;
case OperationCode.Ldfld:
case OperationCode.Ldflda:
case OperationCode.Stfld:
value = this.GetField(memReader.ReadUInt32());
break;
case OperationCode.Ldsfld:
case OperationCode.Ldsflda:
case OperationCode.Stsfld:
value = this.GetField(memReader.ReadUInt32());
var fieldRef = value as FieldReference;
if (fieldRef != null) fieldRef.isStatic = true;
break;
case OperationCode.Stobj:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Conv_Ovf_I1_Un:
case OperationCode.Conv_Ovf_I2_Un:
case OperationCode.Conv_Ovf_I4_Un:
case OperationCode.Conv_Ovf_I8_Un:
case OperationCode.Conv_Ovf_U1_Un:
case OperationCode.Conv_Ovf_U2_Un:
case OperationCode.Conv_Ovf_U4_Un:
case OperationCode.Conv_Ovf_U8_Un:
case OperationCode.Conv_Ovf_I_Un:
case OperationCode.Conv_Ovf_U_Un:
break;
case OperationCode.Box:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Newarr: {
var elementType = this.GetType(memReader.ReadUInt32());
if (elementType != null)
value = Vector.GetVector(elementType, PEFileToObjectModel.InternFactory);
else
value = Dummy.ArrayType;
}
break;
case OperationCode.Ldlen:
break;
case OperationCode.Ldelema:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Ldelem_I1:
case OperationCode.Ldelem_U1:
case OperationCode.Ldelem_I2:
case OperationCode.Ldelem_U2:
case OperationCode.Ldelem_I4:
case OperationCode.Ldelem_U4:
case OperationCode.Ldelem_I8:
case OperationCode.Ldelem_I:
case OperationCode.Ldelem_R4:
case OperationCode.Ldelem_R8:
case OperationCode.Ldelem_Ref:
case OperationCode.Stelem_I:
case OperationCode.Stelem_I1:
case OperationCode.Stelem_I2:
case OperationCode.Stelem_I4:
case OperationCode.Stelem_I8:
case OperationCode.Stelem_R4:
case OperationCode.Stelem_R8:
case OperationCode.Stelem_Ref:
break;
case OperationCode.Ldelem:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Stelem:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Unbox_Any:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Conv_Ovf_I1:
case OperationCode.Conv_Ovf_U1:
case OperationCode.Conv_Ovf_I2:
case OperationCode.Conv_Ovf_U2:
case OperationCode.Conv_Ovf_I4:
case OperationCode.Conv_Ovf_U4:
case OperationCode.Conv_Ovf_I8:
case OperationCode.Conv_Ovf_U8:
break;
case OperationCode.Refanyval:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Ckfinite:
break;
case OperationCode.Mkrefany:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Ldtoken:
value = this.GetRuntimeHandleFromToken(memReader.ReadUInt32());
break;
case OperationCode.Conv_U2:
case OperationCode.Conv_U1:
case OperationCode.Conv_I:
case OperationCode.Conv_Ovf_I:
case OperationCode.Conv_Ovf_U:
case OperationCode.Add_Ovf:
case OperationCode.Add_Ovf_Un:
case OperationCode.Mul_Ovf:
case OperationCode.Mul_Ovf_Un:
case OperationCode.Sub_Ovf:
case OperationCode.Sub_Ovf_Un:
case OperationCode.Endfinally:
break;
case OperationCode.Leave: {
uint leaveOffset = (uint)(memReader.Offset + 4 + memReader.ReadInt32());
if (leaveOffset >= this.EndOfMethodOffset) {
// Error...
}
value = leaveOffset;
}
break;
case OperationCode.Leave_S: {
uint leaveOffset = (uint)(memReader.Offset + 1 + memReader.ReadSByte());
if (leaveOffset >= this.EndOfMethodOffset) {
// Error...
}
value = leaveOffset;
}
break;
case OperationCode.Stind_I:
case OperationCode.Conv_U:
case OperationCode.Arglist:
case OperationCode.Ceq:
case OperationCode.Cgt:
case OperationCode.Cgt_Un:
case OperationCode.Clt:
case OperationCode.Clt_Un:
break;
case OperationCode.Ldftn:
case OperationCode.Ldvirtftn:
value = this.GetMethod(memReader.ReadUInt32());
break;
case OperationCode.Ldarg:
case OperationCode.Ldarga:
case OperationCode.Starg:
value = this.GetParameter(memReader.ReadUInt16());
break;
case OperationCode.Ldloc:
case OperationCode.Ldloca:
case OperationCode.Stloc:
value = this.GetLocal(memReader.ReadUInt16());
break;
case OperationCode.Localloc:
value = PointerType.GetPointerType(this.PEFileToObjectModel.PlatformType.SystemVoid, this.PEFileToObjectModel.InternFactory);
break;
case OperationCode.Endfilter:
break;
case OperationCode.Unaligned_:
value = memReader.ReadByte();
break;
case OperationCode.Volatile_:
case OperationCode.Tail_:
break;
case OperationCode.Initobj:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Constrained_:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Cpblk:
case OperationCode.Initblk:
break;
case OperationCode.No_:
value = (OperationCheckFlags)memReader.ReadByte();
break;
case OperationCode.Rethrow:
break;
case OperationCode.Sizeof:
value = this.GetType(memReader.ReadUInt32());
break;
case OperationCode.Refanytype:
case OperationCode.Readonly_:
break;
default:
this.PEFileToObjectModel.PEFileReader.ErrorContainer.AddILError(this.MethodDefinition, offset, MetadataReaderErrorKind.UnknownILInstruction);
break;
}
instrList[instructionNumber++] = new CilInstruction(cilOpCode, document, offset, value);
}
this.MethodBody.SetCilInstructions(instrList);
return true;
}
bool ReadMetadataHeader(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.PEFile;
{
if (memReader.RemainingBytes < COR20Constants.MinimumSizeofMetadataHeader) {
this.ErrorContainer.AddDirectoryError(Directories.Cor20HeaderMetaData, 0, MetadataReaderErrorKind.MetadataHeaderTooSmall);
return false;
}
this.MetadataHeader.Signature = memReader.ReadUInt32();
if (this.MetadataHeader.Signature != COR20Constants.COR20MetadataSignature) {
this.ErrorContainer.AddDirectoryError(Directories.Cor20HeaderMetaData, memReader.Offset - sizeof(uint), MetadataReaderErrorKind.MetadataSignature);
return false;
}
this.MetadataHeader.MajorVersion = memReader.ReadUInt16();
this.MetadataHeader.MinorVersion = memReader.ReadUInt16();
this.MetadataHeader.ExtraData = memReader.ReadUInt32();
this.MetadataHeader.VersionStringSize = memReader.ReadInt32();
if (memReader.RemainingBytes < this.MetadataHeader.VersionStringSize) {
this.ErrorContainer.AddDirectoryError(Directories.Cor20HeaderMetaData, memReader.Offset, MetadataReaderErrorKind.NotEnoughSpaceForVersionString);
return false;
}
int numberOfBytesRead;
this.MetadataHeader.VersionString = memReader.PeekUTF8NullTerminated(0, out numberOfBytesRead);
memReader.SkipBytes(this.MetadataHeader.VersionStringSize);
return true;
}
bool ReadStreamHeaders(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.PEFile;
{
int numberOfStreams = this.StorageHeader.NumberOfStreams;
this.StreamHeaders = new StreamHeader[numberOfStreams];
StreamHeader[] streamHeaders = this.StreamHeaders;
for (int i = 0; i < numberOfStreams; ++i) {
if (memReader.RemainingBytes < COR20Constants.MinimumSizeofStreamHeader) {
this.ErrorContainer.AddDirectoryError(Directories.Cor20HeaderMetaData, memReader.Offset, MetadataReaderErrorKind.StreamHeaderTooSmall);
return false;
}
streamHeaders[i].Offset = memReader.ReadUInt32();
streamHeaders[i].Size = memReader.ReadInt32();
// Review: Oh well there is no way i can test if we will read correctly. However we can check it after reading and aligning...
streamHeaders[i].Name = memReader.ReadASCIINullTerminated();
memReader.Align(4);
if (memReader.RemainingBytes < 0) {
this.ErrorContainer.AddDirectoryError(Directories.Cor20HeaderMetaData, memReader.Offset, MetadataReaderErrorKind.NotEnoughSpaceForStreamHeaderName);
return false;
}
}
return true;
}
bool ReadSectionHeaders(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.Initialized;
{
int numberOfSections = this.COFFFileHeader.NumberOfSections;
if (memReader.RemainingBytes < numberOfSections * PEFileConstants.SizeofSectionHeader) {
this.ErrorContainer.AddBinaryError(memReader.Offset, MetadataReaderErrorKind.SectionHeadersTooSmall);
return false;
}
this.SectionHeaders = new SectionHeader[numberOfSections];
SectionHeader[] sectionHeaderArray = this.SectionHeaders;
for (int i = 0; i < numberOfSections; ++i) {
sectionHeaderArray[i].Name = memReader.ReadASCIIWithSize(PEFileConstants.SizeofSectionName);
sectionHeaderArray[i].VirtualSize = memReader.ReadInt32();
sectionHeaderArray[i].VirtualAddress = memReader.ReadInt32();
sectionHeaderArray[i].SizeOfRawData = memReader.ReadInt32();
sectionHeaderArray[i].OffsetToRawData = memReader.ReadInt32();
sectionHeaderArray[i].RVAToRelocations = memReader.ReadInt32();
sectionHeaderArray[i].PointerToLineNumbers = memReader.ReadInt32();
sectionHeaderArray[i].NumberOfRelocations = memReader.ReadUInt16();
sectionHeaderArray[i].NumberOfLineNumbers = memReader.ReadUInt16();
sectionHeaderArray[i].SectionCharacteristics = (SectionCharacteristics)memReader.ReadUInt32();
}
return true;
}
bool ReadCOR20Header()
//^ requires this.ReaderState >= ReaderState.PEFile;
{
MemoryBlock memBlock = this.DirectoryToMemoryBlock(this.OptionalHeaderDirectoryEntries.COR20HeaderTableDirectory);
if (memBlock.Length < this.OptionalHeaderDirectoryEntries.COR20HeaderTableDirectory.Size) {
this.ErrorContainer.AddDirectoryError(Directories.COR20Header, 0, MetadataReaderErrorKind.NotEnoughSpaceForCOR20HeaderTableDirectory);
return false;
}
MemoryReader memReader = new MemoryReader(memBlock);
if (memReader.RemainingBytes < COR20Constants.SizeOfCOR20Header) {
this.ErrorContainer.AddDirectoryError(Directories.COR20Header, 0, MetadataReaderErrorKind.COR20HeaderTooSmall);
return false;
}
this.COR20Header.CountBytes = memReader.ReadInt32();
this.COR20Header.MajorRuntimeVersion = memReader.ReadUInt16();
this.COR20Header.MinorRuntimeVersion = memReader.ReadUInt16();
this.COR20Header.MetaDataDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.MetaDataDirectory.Size = memReader.ReadUInt32();
this.COR20Header.COR20Flags = (COR20Flags)memReader.ReadUInt32();
this.COR20Header.EntryPointTokenOrRVA = memReader.ReadUInt32();
this.COR20Header.ResourcesDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.ResourcesDirectory.Size = memReader.ReadUInt32();
this.COR20Header.StrongNameSignatureDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.StrongNameSignatureDirectory.Size = memReader.ReadUInt32();
this.COR20Header.CodeManagerTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.CodeManagerTableDirectory.Size = memReader.ReadUInt32();
this.COR20Header.VtableFixupsDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.ExportAddressTableJumpsDirectory.Size = memReader.ReadUInt32();
this.COR20Header.ExportAddressTableJumpsDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.ExportAddressTableJumpsDirectory.Size = memReader.ReadUInt32();
this.COR20Header.ManagedNativeHeaderDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.COR20Header.ManagedNativeHeaderDirectory.Size = memReader.ReadUInt32();
return true;
}
bool ReadOptionalHeaderDirectoryEntries(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.Initialized;
{
if (memReader.RemainingBytes < PEFileConstants.SizeofOptionalHeaderDirectoriesEntries) {
this.ErrorContainer.AddBinaryError(memReader.Offset, MetadataReaderErrorKind.OptionalHeaderDirectoryEntriesTooSmall);
return false;
}
this.OptionalHeaderDirectoryEntries.ExportTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ExportTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ImportTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ImportTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ResourceTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ResourceTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ExceptionTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ExceptionTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.CertificateTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.CertificateTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.BaseRelocationTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.BaseRelocationTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.DebugTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.DebugTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.CopyrightTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.CopyrightTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.GlobalPointerTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.GlobalPointerTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ThreadLocalStorageTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ThreadLocalStorageTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.LoadConfigTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.LoadConfigTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.BoundImportTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.BoundImportTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ImportAddressTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ImportAddressTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.DelayImportTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.DelayImportTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.COR20HeaderTableDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.COR20HeaderTableDirectory.Size = memReader.ReadUInt32();
this.OptionalHeaderDirectoryEntries.ReservedDirectory.RelativeVirtualAddress = memReader.ReadInt32();
this.OptionalHeaderDirectoryEntries.ReservedDirectory.Size = memReader.ReadUInt32();
return true;
}
bool ReadOptionalHeaderNTAdditionalFields64(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.Initialized;
{
if (memReader.RemainingBytes < PEFileConstants.SizeofOptionalHeaderNTAdditionalFields64) {
this.ErrorContainer.AddBinaryError(memReader.Offset, MetadataReaderErrorKind.OptionalHeaderNTAdditionalFields64TooSmall);
return false;
}
this.OptionalHeaderNTAdditionalFields.ImageBase = memReader.ReadUInt64();
this.OptionalHeaderNTAdditionalFields.SectionAlignment = memReader.ReadInt32();
this.OptionalHeaderNTAdditionalFields.FileAlignment = memReader.ReadUInt32();
this.OptionalHeaderNTAdditionalFields.MajorOperatingSystemVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.MinorOperatingSystemVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.MajorImageVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.MinorImageVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.MajorSubsystemVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.MinorSubsystemVersion = memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.Win32VersionValue = memReader.ReadUInt32();
this.OptionalHeaderNTAdditionalFields.SizeOfImage = memReader.ReadInt32();
this.OptionalHeaderNTAdditionalFields.SizeOfHeaders = memReader.ReadInt32();
this.OptionalHeaderNTAdditionalFields.CheckSum = memReader.ReadUInt32();
this.OptionalHeaderNTAdditionalFields.Subsystem = (Subsystem)memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.DllCharacteristics = (DllCharacteristics)memReader.ReadUInt16();
this.OptionalHeaderNTAdditionalFields.SizeOfStackReserve = memReader.ReadUInt64();
this.OptionalHeaderNTAdditionalFields.SizeOfStackCommit = memReader.ReadUInt64();
this.OptionalHeaderNTAdditionalFields.SizeOfHeapReserve = memReader.ReadUInt64();
this.OptionalHeaderNTAdditionalFields.SizeOfHeapCommit = memReader.ReadUInt64();
this.OptionalHeaderNTAdditionalFields.LoaderFlags = memReader.ReadUInt32();
this.OptionalHeaderNTAdditionalFields.NumberOfRvaAndSizes = memReader.ReadInt32();
return true;
}
bool ReadOptionalHeaderStandardFields64(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.Initialized;
{
if (memReader.RemainingBytes < PEFileConstants.SizeofOptionalHeaderStandardFields64) {
this.ErrorContainer.AddBinaryError(memReader.Offset, MetadataReaderErrorKind.OptionalHeaderStandardFields64TooSmall);
return false;
}
this.OptionalHeaderStandardFields.PEMagic = (PEMagic)memReader.ReadUInt16();
this.OptionalHeaderStandardFields.MajorLinkerVersion = memReader.ReadByte();
this.OptionalHeaderStandardFields.MinorLinkerVersion = memReader.ReadByte();
this.OptionalHeaderStandardFields.SizeOfCode = memReader.ReadInt32();
this.OptionalHeaderStandardFields.SizeOfInitializedData = memReader.ReadInt32();
this.OptionalHeaderStandardFields.SizeOfUninitializedData = memReader.ReadInt32();
this.OptionalHeaderStandardFields.RVAOfEntryPoint = memReader.ReadInt32();
this.OptionalHeaderStandardFields.BaseOfCode = memReader.ReadInt32();
return true;
}
bool ReadCOFFFileHeader(
ref MemoryReader memReader
)
//^ requires this.ReaderState >= ReaderState.Initialized;
{
if (memReader.RemainingBytes < PEFileConstants.SizeofCOFFFileHeader) {
this.ErrorContainer.AddBinaryError(memReader.Offset, MetadataReaderErrorKind.COFFHeaderTooSmall);
return false;
}
this.COFFFileHeader.Machine = (Machine)memReader.ReadUInt16();
this.COFFFileHeader.NumberOfSections = memReader.ReadInt16();
this.COFFFileHeader.TimeDateStamp = memReader.ReadInt32();
this.COFFFileHeader.PointerToSymbolTable = memReader.ReadInt32();
this.COFFFileHeader.NumberOfSymbols = memReader.ReadInt32();
this.COFFFileHeader.SizeOfOptionalHeader = memReader.ReadInt16();
this.COFFFileHeader.Characteristics = (Characteristics)memReader.ReadUInt16();
return true;
}
internal IMetadataConstant GetDefaultValue(
MetadataObject metadataObject
) {
uint constRowId = this.PEFileReader.ConstantTable.GetConstantRowId(metadataObject.TokenValue);
if (constRowId == 0)
return Dummy.Constant;
ConstantRow constRow = this.PEFileReader.ConstantTable[constRowId];
MemoryBlock constValueMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(constRow.Value);
MemoryReader memoryReader = new MemoryReader(constValueMemoryBlock);
switch (constRow.Type) {
case ElementType.Boolean: {
byte val = memoryReader.ReadByte();
return new ConstantExpression(this.PlatformType.SystemBoolean, val != 0);
}
case ElementType.Char:
return new ConstantExpression(this.PlatformType.SystemChar, memoryReader.ReadChar());
case ElementType.Int8:
return new ConstantExpression(this.PlatformType.SystemInt8, memoryReader.ReadSByte());
case ElementType.Int16:
return new ConstantExpression(this.PlatformType.SystemInt16, memoryReader.ReadInt16());
case ElementType.Int32:
return new ConstantExpression(this.PlatformType.SystemInt32, memoryReader.ReadInt32());
case ElementType.Int64:
return new ConstantExpression(this.PlatformType.SystemInt64, memoryReader.ReadInt64());
case ElementType.UInt8:
return new ConstantExpression(this.PlatformType.SystemUInt8, memoryReader.ReadByte());
case ElementType.UInt16:
return new ConstantExpression(this.PlatformType.SystemUInt16, memoryReader.ReadUInt16());
case ElementType.UInt32:
return new ConstantExpression(this.PlatformType.SystemUInt32, memoryReader.ReadUInt32());
case ElementType.UInt64:
return new ConstantExpression(this.PlatformType.SystemUInt64, memoryReader.ReadUInt64());
case ElementType.Single:
return new ConstantExpression(this.PlatformType.SystemFloat32, memoryReader.ReadSingle());
case ElementType.Double:
return new ConstantExpression(this.PlatformType.SystemFloat64, memoryReader.ReadDouble());
case ElementType.String: {
int byteLen = memoryReader.Length;
string/*?*/ value;
if (byteLen == -1) {
value = null;
} else if (byteLen == 0) {
value = string.Empty;
} else {
value = memoryReader.ReadUTF16WithSize(byteLen);
}
return new ConstantExpression(this.PlatformType.SystemString, value);
}
case ElementType.Class:
return new ConstantExpression(this.PlatformType.SystemObject, null);
}
// MDError...
return Dummy.Constant;
}