/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
setOffsetCalled = true;
this.offset = offset;
this.rva = rva;
tinyMethodsDict = null;
fatMethodsDict = null;
var rva2 = rva;
foreach (var mb in tinyMethods) {
mb.SetOffset(offset, rva2);
uint len = mb.GetFileLength();
rva2 += len;
offset += len;
}
foreach (var mb in fatMethods) {
if (alignFatBodies) {
uint padding = (uint)rva2.AlignUp(FAT_BODY_ALIGNMENT) - (uint)rva2;
rva2 += padding;
offset += padding;
}
mb.SetOffset(offset, rva2);
uint len = mb.GetFileLength();
rva2 += len;
offset += len;
}
length = (uint)rva2 - (uint)rva;
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
this.offset = offset;
this.rva = rva;
padding = rva.AlignUp(4) - rva + 2;
length = padding + 6;
}
/// <summary>
/// Returns the first <see cref="ImageSectionHeader"/> that has data at RVA
/// <paramref name="rva"/>
/// </summary>
/// <param name="rva">The RVA</param>
/// <returns></returns>
public ImageSectionHeader ToImageSectionHeader(RVA rva) {
foreach (var section in imageSectionHeaders) {
if (rva >= section.VirtualAddress && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
return section;
}
return null;
}
public ImageSectionHeader FindSection(RVA rva) {
foreach (var section in peImage.ImageSectionHeaders) {
if (section.VirtualAddress <= rva && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
return section;
}
return null;
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
this.offset = offset;
this.rva = rva;
length = HEADER_SIZE;
if (data != null) // Could be null if dontWriteAnything is true
length += (uint)data.Length;
}
/// <summary>
/// Converts an <see cref="RVA"/> to a <see cref="FileOffset"/>
/// </summary>
/// <param name="rva">The RVA to convert</param>
/// <returns>The file offset</returns>
public FileOffset ToFileOffset(RVA rva)
{
var section = ToImageSectionHeader(rva);
if (!(section is null))
{
return((FileOffset)(rva - section.VirtualAddress + section.PointerToRawData));
}
return((FileOffset)rva);
}
/// <inheritdoc/>
public void WriteTo(BinaryWriter writer)
{
writer.Write(code);
if (HasExtraSections)
{
RVA rva2 = rva + (uint)code.Length;
writer.WriteZeros((int)rva2.AlignUp(EXTRA_SECTIONS_ALIGNMENT) - (int)rva2);
writer.Write(extraSections);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="totalSize">Total size of this optional header (from the file header)</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public ImageOptionalHeader64(ref DataReader reader, uint totalSize, bool verify)
{
if (totalSize < 0x70)
{
throw new BadImageFormatException("Invalid optional header size");
}
if (verify && (ulong)reader.Position + totalSize > reader.Length)
{
throw new BadImageFormatException("Invalid optional header size");
}
SetStartOffset(ref reader);
magic = reader.ReadUInt16();
majorLinkerVersion = reader.ReadByte();
minorLinkerVersion = reader.ReadByte();
sizeOfCode = reader.ReadUInt32();
sizeOfInitializedData = reader.ReadUInt32();
sizeOfUninitializedData = reader.ReadUInt32();
addressOfEntryPoint = (RVA)reader.ReadUInt32();
baseOfCode = (RVA)reader.ReadUInt32();
imageBase = reader.ReadUInt64();
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 = (Subsystem)reader.ReadUInt16();
dllCharacteristics = (DllCharacteristics)reader.ReadUInt16();
sizeOfStackReserve = reader.ReadUInt64();
sizeOfStackCommit = reader.ReadUInt64();
sizeOfHeapReserve = reader.ReadUInt64();
sizeOfHeapCommit = reader.ReadUInt64();
loaderFlags = reader.ReadUInt32();
numberOfRvaAndSizes = reader.ReadUInt32();
for (int i = 0; i < dataDirectories.Length; i++)
{
uint len = reader.Position - (uint)startOffset;
if (len + 8 <= totalSize)
{
dataDirectories[i] = new ImageDataDirectory(ref reader, verify);
}
else
{
dataDirectories[i] = new ImageDataDirectory();
}
}
reader.Position = (uint)startOffset + totalSize;
SetEndoffset(ref reader);
}
internal IBinaryReader CreateDataReader_NoLock(RVA rva, uint size)
{
var reader = dataReader.Create(rvaConverter.ToFileOffset(rva), size);
if (reader.Length == size)
{
return(reader);
}
reader.Dispose();
return(MemoryImageStream.CreateEmpty());
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva)
{
this.offset = offset;
this.rva = rva;
length = HEADER_SIZE;
if (data != null) // Could be null if dontWriteAnything is true
{
length += (uint)data.Length;
}
}
public ImageSectionHeader FindSection(RVA rva)
{
foreach (var section in peImage.ImageSectionHeaders)
{
if (section.VirtualAddress <= rva && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
{
return(section);
}
}
return(null);
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
setOffsetCalled = true;
this.offset = offset;
this.rva = rva;
foreach (var resource in resources) {
resource.SetOffset(offset + 4, rva + 4);
uint len = 4 + resource.GetFileLength();
offset = (offset + len).AlignUp(alignment);
rva = (rva + len).AlignUp(alignment);
}
}
public FOA ToFOA(RVA rva)
{
foreach (SectionHeader sectionHeader in _sectionHeaders)
{
if (rva >= sectionHeader.VirtualAddress && rva < sectionHeader.VirtualAddress + Math.Max(sectionHeader.VirtualSize, sectionHeader.RawSize))
{
return(rva - sectionHeader.VirtualAddress + sectionHeader.RawAddress);
}
}
return((FOA)rva);
}
/// <summary>
/// Returns the first <see cref="ImageSectionHeader"/> that has data at RVA
/// <paramref name="rva"/>
/// </summary>
/// <param name="rva">The RVA</param>
/// <returns></returns>
public ImageSectionHeader ToImageSectionHeader(RVA rva)
{
foreach (var section in imageSectionHeaders)
{
if (rva >= section.VirtualAddress && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
{
return(section);
}
}
return(null);
}
public FieldDefOptions(FieldDef field) {
this.Attributes = field.Attributes;
this.Name = field.Name;
this.FieldSig = field.FieldSig;
this.FieldOffset = field.FieldOffset;
this.MarshalType = field.MarshalType;
this.RVA = field.RVA;
this.InitialValue = field.InitialValue;
this.ImplMap = field.ImplMap;
this.Constant = field.Constant;
this.CustomAttributes.AddRange(field.CustomAttributes);
}
public bool GetMethodBody(uint rid, RVA rva, IList <Parameter> parameters, GenericParamContext gpContext, out MethodBody methodBody)
{
var dm = GetDumpedMethod(rid);
if (dm == null)
{
methodBody = null;
return(false);
}
methodBody = MethodBodyReader.CreateCilBody(module, dm.code, dm.extraSections, parameters, dm.mhFlags, dm.mhMaxStack, dm.mhCodeSize, dm.mhLocalVarSigTok, gpContext);
return(true);
}
public MethodRow CreateMethodRow(RVA _rVA, MethodImplAttributes _implFlags, MethodAttributes _flags, uint _name, uint _signature, uint _paramList)
{
MethodRow row = new MethodRow();
row.RVA = _rVA;
row.ImplFlags = _implFlags;
row.Flags = _flags;
row.Name = _name;
row.Signature = _signature;
row.ParamList = _paramList;
return(row);
}
/// <summary>
/// Creates a new data reader
/// </summary>
/// <param name="rva">RVA of data</param>
/// <param name="size">Size of data</param>
/// <returns>A new <see cref="IBinaryReader"/> for this data</returns>
public IBinaryReader CreateDataReader(RVA rva, uint size)
{
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
return(CreateDataReader_NoLock(rva, size));
#if THREAD_SAFE
}
finally { theLock.ExitWriteLock(); }
#endif
}
public FieldDefOptions(FieldDef field) {
Attributes = field.Attributes;
Name = field.Name;
FieldSig = field.FieldSig;
FieldOffset = field.FieldOffset;
MarshalType = field.MarshalType;
RVA = field.RVA;
InitialValue = field.InitialValue;
ImplMap = field.ImplMap;
Constant = field.Constant;
CustomAttributes.AddRange(field.CustomAttributes);
}
public RVA WriteMethodBody(MethodDefinition meth)
{
if (meth.Body == null)
{
return(RVA.Zero);
}
RVA ret = m_reflectWriter.MetadataWriter.GetDataCursor();
meth.Body.Accept(this);
return(ret);
}
/// <summary>
/// Returns the <see cref="FileOffset"/> and <see cref="RVA"/> of a
/// <see cref="ResourceDirectoryEntry"/>. <see cref="SetOffset"/> must have been called.
/// </summary>
/// <param name="dirEntry">A <see cref="ResourceDirectoryEntry"/></param>
/// <param name="fileOffset">Updated with the file offset</param>
/// <param name="rva">Updated with the RVA</param>
/// <returns><c>true</c> if <paramref name="dirEntry"/> is valid and
/// <paramref name="fileOffset"/> and <paramref name="rva"/> have been updated. <c>false</c>
/// if <paramref name="dirEntry"/> is not part of the Win32 resources.</returns>
public bool GetFileOffsetAndRvaOf(ResourceDirectoryEntry dirEntry, out FileOffset fileOffset, out RVA rva) {
var dir = dirEntry as ResourceDirectory;
if (dir != null)
return GetFileOffsetAndRvaOf(dir, out fileOffset, out rva);
var dataHeader = dirEntry as ResourceData;
if (dataHeader != null)
return GetFileOffsetAndRvaOf(dataHeader, out fileOffset, out rva);
fileOffset = 0;
rva = 0;
return false;
}
public CilBodyOptions(CilBody body, RVA rva, FileOffset fileOffset)
{
this.KeepOldMaxStack = body.KeepOldMaxStack;
this.InitLocals = body.InitLocals;
this.MaxStack = body.MaxStack;
this.LocalVarSigTok = body.LocalVarSigTok;
this.RVA = rva;
this.FileOffset = fileOffset;
this.Instructions.AddRange(body.Instructions);
this.ExceptionHandlers.AddRange(body.ExceptionHandlers);
this.Locals.AddRange(body.Variables);
this.Scope = body.Scope;
}
public CilBodyOptions(CilBody body, RVA rva, FileOffset fileOffset)
{
this.KeepOldMaxStack = body.KeepOldMaxStack;
this.InitLocals = body.InitLocals;
this.MaxStack = body.MaxStack;
this.LocalVarSigTok = body.LocalVarSigTok;
this.RVA = rva;
this.FileOffset = fileOffset;
this.Instructions.AddRange(body.Instructions);
this.ExceptionHandlers.AddRange(body.ExceptionHandlers);
this.Locals.AddRange(body.Variables);
this.Scope = body.Scope;
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva)
{
this.offset = offset;
this.rva = rva;
length = HEADER_SIZE * (uint)entries.Count;
foreach (var entry in entries)
{
length = Utils.AlignUp(length, DEFAULT_DEBUGDIRECTORY_ALIGNMENT);
entry.Chunk.SetOffset(offset + length, rva + length);
length += entry.Chunk.GetFileLength();
}
}
public FieldDefOptions(FieldDef field)
{
this.Attributes = field.Attributes;
this.Name = field.Name;
this.FieldSig = field.FieldSig;
this.FieldOffset = field.FieldOffset;
this.MarshalType = field.MarshalType;
this.RVA = field.RVA;
this.InitialValue = field.InitialValue;
this.ImplMap = field.ImplMap;
this.Constant = field.Constant;
this.CustomAttributes.AddRange(field.CustomAttributes);
}
public FieldDefOptions(FieldDef field)
{
Attributes = field.Attributes;
Name = field.Name;
FieldSig = field.FieldSig;
FieldOffset = field.FieldOffset;
MarshalType = field.MarshalType;
RVA = field.RVA;
InitialValue = field.InitialValue;
ImplMap = field.ImplMap;
Constant = field.Constant;
CustomAttributes.AddRange(field.CustomAttributes);
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva)
{
setOffsetCalled = true;
this.offset = offset;
this.rva = rva;
foreach (var resource in resources)
{
resource.SetOffset(offset + 4, rva + 4);
uint len = 4 + resource.GetFileLength();
offset = (offset + len).AlignUp(alignment);
rva = (rva + len).AlignUp(alignment);
}
}
/// <summary>
/// Returns the first <see cref="ImageSectionHeader"/> that has data at RVA
/// <paramref name="rva"/>
/// </summary>
/// <param name="rva">The RVA</param>
/// <returns></returns>
public ImageSectionHeader ToImageSectionHeader(RVA rva)
{
uint alignment = imageNTHeaders.OptionalHeader.SectionAlignment;
foreach (var section in imageSectionHeaders)
{
if (rva >= section.VirtualAddress && rva < section.VirtualAddress + DotNet.Utils.AlignUp(section.VirtualSize, alignment))
{
return(section);
}
}
return(null);
}
byte[] ReadInitialValue_NoLock(RVA rva)
{
uint size;
if (!GetFieldSize(declaringType2, signature as FieldSig, out size))
{
return(null);
}
if (size >= int.MaxValue)
{
return(null);
}
return(readerModule.ReadDataAt(rva, (int)size));
}
public MethodDefinition(string name, RVA rva,
MethodAttributes attrs, MethodImplAttributes implAttrs,
bool hasThis, bool explicitThis, MethodCallingConvention callConv) :
base(name, hasThis, explicitThis, callConv)
{
m_rva = rva;
m_attributes = attrs;
m_implAttrs = implAttrs;
if (!IsStatic)
{
m_this = new ParameterDefinition("this", 0, (ParameterAttributes)0, null);
}
}
public MethodDefOptions(MethodDef method) {
ImplAttributes = method.ImplAttributes;
Attributes = method.Attributes;
SemanticsAttributes = method.SemanticsAttributes;
RVA = method.RVA;
Name = method.Name;
MethodSig = method.MethodSig;
ImplMap = method.ImplMap;
CustomAttributes.AddRange(method.CustomAttributes);
DeclSecurities.AddRange(method.DeclSecurities);
ParamDefs.AddRange(method.ParamDefs);
GenericParameters.AddRange(method.GenericParameters);
Overrides.AddRange(method.Overrides);
}
byte[] ReadInitialValue(RVA rva)
{
uint size;
if (!GetFieldSize(out size))
{
return(null);
}
if (size >= int.MaxValue)
{
return(null);
}
return(readerModule.ReadDataAt(rva, (int)size));
}
/// <inheritdoc/>
public void WriteTo(BinaryWriter writer)
{
RVA rva2 = rva;
foreach (var resourceData in resources)
{
writer.Write(resourceData.GetFileLength());
resourceData.VerifyWriteTo(writer);
rva2 += 4 + resourceData.GetFileLength();
int padding = (int)rva2.AlignUp(alignment) - (int)rva2;
writer.WriteZeros(padding);
rva2 += (uint)padding;
}
}
/// <summary>
/// Converts an <see cref="RVA"/> to a <see cref="FileOffset"/>
/// </summary>
/// <param name="rva">The RVA to convert</param>
/// <returns>The file offset</returns>
public FileOffset?ToFileOffset(RVA rva)
{
var section = ToImageSectionHeader(rva);
if (section is not null)
{
uint offset = rva - section.VirtualAddress + section.PointerToRawData;
if (section.PointerToRawData <= offset && offset < section.PointerToRawData + section.SizeOfRawData)
{
return((FileOffset)offset);
}
}
return(null);
}
public MethodDefOptions(MethodDef method)
{
this.ImplAttributes = method.ImplAttributes;
this.Attributes = method.Attributes;
this.SemanticsAttributes = method.SemanticsAttributes;
this.RVA = method.RVA;
this.Name = method.Name;
this.MethodSig = method.MethodSig;
this.ImplMap = method.ImplMap;
this.CustomAttributes.AddRange(method.CustomAttributes);
this.DeclSecurities.AddRange(method.DeclSecurities);
this.ParamDefs.AddRange(method.ParamDefs);
this.GenericParameters.AddRange(method.GenericParameters);
this.Overrides.AddRange(method.Overrides);
}
public CilBodyOptions(CilBody body, RVA headerRva, FileOffset headerFileOffset, RVA rva, FileOffset fileOffset) {
KeepOldMaxStack = body.KeepOldMaxStack;
InitLocals = body.InitLocals;
HeaderSize = body.HeaderSize;
MaxStack = body.MaxStack;
LocalVarSigTok = body.LocalVarSigTok;
HeaderRVA = headerRva;
HeaderFileOffset = headerFileOffset;
RVA = rva;
FileOffset = fileOffset;
Instructions.AddRange(body.Instructions);
ExceptionHandlers.AddRange(body.ExceptionHandlers);
Locals.AddRange(body.Variables);
PdbMethod = body.PdbMethod;
}
public MethodDefOptions(MethodDef method)
{
ImplAttributes = method.ImplAttributes;
Attributes = method.Attributes;
SemanticsAttributes = method.SemanticsAttributes;
RVA = method.RVA;
Name = method.Name;
MethodSig = method.MethodSig;
ImplMap = method.ImplMap;
CustomAttributes.AddRange(method.CustomAttributes);
DeclSecurities.AddRange(method.DeclSecurities);
ParamDefs.AddRange(method.ParamDefs);
GenericParameters.AddRange(method.GenericParameters);
Overrides.AddRange(method.Overrides);
}
public CilBodyOptions(CilBody body, RVA headerRva, FileOffset headerFileOffset, RVA rva, FileOffset fileOffset) {
KeepOldMaxStack = body.KeepOldMaxStack;
InitLocals = body.InitLocals;
HeaderSize = body.HeaderSize;
MaxStack = body.MaxStack;
LocalVarSigTok = body.LocalVarSigTok;
HeaderRVA = headerRva;
HeaderFileOffset = headerFileOffset;
RVA = rva;
FileOffset = fileOffset;
Instructions.AddRange(body.Instructions);
ExceptionHandlers.AddRange(body.ExceptionHandlers);
Locals.AddRange(body.Variables);
Scope = body.Scope;
}
/// <summary>
/// Returns the <see cref="FileOffset"/> and <see cref="RVA"/> of the raw data
/// owned by a <see cref="ResourceData"/>. <see cref="SetOffset"/> must have been called.
/// </summary>
/// <param name="data">A <see cref="ResourceData"/>'s <see cref="IBinaryReader"/></param>
/// <param name="fileOffset">Updated with the file offset</param>
/// <param name="rva">Updated with the RVA</param>
/// <returns><c>true</c> if <paramref name="data"/> is valid and
/// <paramref name="fileOffset"/> and <paramref name="rva"/> have been updated. <c>false</c>
/// if <paramref name="data"/> is not part of the Win32 resources.</returns>
public bool GetFileOffsetAndRvaOf(IBinaryReader data, out FileOffset fileOffset, out RVA rva)
{
uint offs;
if (data == null || !dataDict.TryGetValue(data, out offs))
{
fileOffset = 0;
rva = 0;
return(false);
}
fileOffset = offset + offs;
rva = this.rva + offs;
return(true);
}
/// <summary>
/// Returns the <see cref="FileOffset"/> and <see cref="RVA"/> of a
/// <see cref="ResourceDirectoryEntry"/>'s name. <see cref="SetOffset"/> must have been
/// called.
/// </summary>
/// <param name="name">The name of a <see cref="ResourceDirectoryEntry"/></param>
/// <param name="fileOffset">Updated with the file offset</param>
/// <param name="rva">Updated with the RVA</param>
/// <returns><c>true</c> if <paramref name="name"/> is valid and
/// <paramref name="fileOffset"/> and <paramref name="rva"/> have been updated. <c>false</c>
/// if <paramref name="name"/> is not part of the Win32 resources.</returns>
public bool GetFileOffsetAndRvaOf(string name, out FileOffset fileOffset, out RVA rva)
{
uint offs;
if (name == null || !stringsDict.TryGetValue(name, out offs))
{
fileOffset = 0;
rva = 0;
return(false);
}
fileOffset = offset + offs;
rva = this.rva + offs;
return(true);
}
/// <summary>
/// Returns the <see cref="FileOffset"/> and <see cref="RVA"/> of a
/// <see cref="ResourceData"/>. <see cref="SetOffset"/> must have been called.
/// </summary>
/// <param name="dataHeader">A <see cref="ResourceData"/></param>
/// <param name="fileOffset">Updated with the file offset</param>
/// <param name="rva">Updated with the RVA</param>
/// <returns><c>true</c> if <paramref name="dataHeader"/> is valid and
/// <paramref name="fileOffset"/> and <paramref name="rva"/> have been updated. <c>false</c>
/// if <paramref name="dataHeader"/> is not part of the Win32 resources.</returns>
public bool GetFileOffsetAndRvaOf(ResourceData dataHeader, out FileOffset fileOffset, out RVA rva)
{
uint offs;
if (dataHeader == null || !dataHeaderDict.TryGetValue(dataHeader, out offs))
{
fileOffset = 0;
rva = 0;
return(false);
}
fileOffset = offset + offs;
rva = this.rva + offs;
return(true);
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
this.offset = offset;
this.rva = rva;
length = 0x28;
importLookupTableRVA = rva + length;
length += 8;
stringsPadding = (int)(rva.AlignUp(STRINGS_ALIGNMENT) - rva);
length += (uint)stringsPadding;
corXxxMainRVA = rva + length;
length += 0xE;
mscoreeDllRVA = rva + length;
length += 0xC;
length++;
}
/// <inheritdoc />
public void SetOffset(FileOffset offset, RVA rva)
{
FileOffset = offset;
RVA = rva;
if (HasExtraSections)
{
var rva2 = rva + (uint)Code.Length;
rva2 = rva2.AlignUp(EXTRA_SECTIONS_ALIGNMENT);
rva2 += (uint)ExtraSections.Length;
length = (uint)rva2 - (uint)rva;
}
else
{
length = (uint)Code.Length;
}
}
public ModuleOptions(ModuleDef module) {
Mvid = module.Mvid;
EncId = module.EncId;
EncBaseId = module.EncBaseId;
Name = module.Name;
Kind = module.Kind;
Characteristics = module.Characteristics;
DllCharacteristics = module.DllCharacteristics;
RuntimeVersion = module.RuntimeVersion;
Machine = module.Machine;
Cor20HeaderFlags = module.Cor20HeaderFlags;
Cor20HeaderRuntimeVersion = module.Cor20HeaderRuntimeVersion;
TablesHeaderVersion = module.TablesHeaderVersion;
ManagedEntryPoint = module.ManagedEntryPoint;
NativeEntryPoint = module.NativeEntryPoint;
CustomAttributes.AddRange(module.CustomAttributes);
}
static void Align(ref FileOffset offset, ref RVA rva) {
offset = offset.AlignUp(HH_ALIGNMENT);
rva = rva.AlignUp(HH_ALIGNMENT);
}
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
this.offset = offset;
this.rva = rva;
//TODO:
}
/// <inheritdoc/>
public override void SetOffset(FileOffset offset, RVA rva) {
base.SetOffset(offset, rva);
uint startOffs = (uint)offset;
offset += HOT_HEAP_DIR_SIZE;
rva += HOT_HEAP_DIR_SIZE;
foreach (var header in headers) {
if (header == null)
continue;
header.SetOffset(offset, rva);
uint len = header.GetFileLength();
offset += len;
rva += len;
Align(ref offset, ref rva);
}
foreach (var hotPool in hotPools) {
Align(ref offset, ref rva);
hotPool.SetOffset(offset, rva);
uint len = hotPool.GetFileLength();
offset += len;
rva += len;
}
Align(ref offset, ref rva);
offset += hotPools.Count * 8;
rva += (uint)hotPools.Count * 8;
offset += 8;
rva += 8;
totalLength = (uint)offset - startOffs;
}
/// <inheritdoc/>
public FileOffset ToFileOffset(PEInfo peInfo, RVA rva) {
return (FileOffset)rva;
}
byte[] ReadInitialValue_NoLock(RVA rva) {
uint size;
if (!GetFieldSize(declaringType2, signature as FieldSig, out size))
return null;
if (size >= int.MaxValue)
return null;
return readerModule.ReadDataAt(rva, (int)size);
}
void InitializeRVA() {
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
if (rva_isInitialized)
return;
rva = GetRVA_NoLock();
rva_isInitialized = true;
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
}
/// <summary>
/// Reads a method body
/// </summary>
/// <param name="method">Method</param>
/// <param name="rva">Method RVA</param>
/// <param name="implAttrs">Method impl attrs</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="MethodBody"/> or <c>null</c> if none</returns>
internal MethodBody ReadMethodBody(MethodDefMD method, RVA rva, MethodImplAttributes implAttrs, GenericParamContext gpContext)
{
MethodBody mb;
var mDec = methodDecrypter;
if (mDec != null && mDec.GetMethodBody(method.OrigRid, rva, method.Parameters, gpContext, out mb)) {
var cilBody = mb as CilBody;
if (cilBody != null)
return InitializeBodyFromPdb(cilBody, method.OrigRid);
return mb;
}
if (rva == 0)
return null;
var codeType = implAttrs & MethodImplAttributes.CodeTypeMask;
if (codeType == MethodImplAttributes.IL)
return InitializeBodyFromPdb(ReadCilBody(method.Parameters, rva, gpContext), method.OrigRid);
if (codeType == MethodImplAttributes.Native)
return new NativeMethodBody(rva);
return null;
}
/// <summary>
/// Converts <paramref name="rva"/> to a file offset in the destination stream
/// </summary>
/// <param name="rva">RVA</param>
long ToWriterOffset(RVA rva) {
if (rva == 0)
return 0;
foreach (var sect in origSections) {
var section = sect.peSection;
if (section.VirtualAddress <= rva && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
return destStreamBaseOffset + (long)sect.chunk.FileOffset + (rva - section.VirtualAddress);
}
return 0;
}
/// <inheritdoc/>
public FileOffset ToFileOffset(RVA rva) {
return peType.ToFileOffset(peInfo, rva);
}
/// <summary>
/// Calculates <see cref="RVA"/> and <see cref="FileOffset"/> of all <see cref="IChunk"/>s
/// </summary>
/// <param name="chunks">All chunks</param>
/// <param name="offset">Starting file offset</param>
/// <param name="rva">Starting RVA</param>
/// <param name="fileAlignment">File alignment</param>
/// <param name="sectionAlignment">Section alignment</param>
protected void CalculateRvasAndFileOffsets(List<IChunk> chunks, FileOffset offset, RVA rva, uint fileAlignment, uint sectionAlignment) {
foreach (var chunk in chunks) {
chunk.SetOffset(offset, rva);
offset += chunk.GetFileLength();
rva += chunk.GetVirtualSize();
offset = offset.AlignUp(fileAlignment);
rva = rva.AlignUp(sectionAlignment);
}
}
/// <summary>
/// Reads a CIL method body
/// </summary>
/// <param name="parameters">Method parameters</param>
/// <param name="rva">RVA</param>
/// <returns>A new <see cref="CilBody"/> instance. It's empty if RVA is invalid (eg. 0 or
/// it doesn't point to a CIL method body)</returns>
public CilBody ReadCilBody(IList<Parameter> parameters, RVA rva)
{
return ReadCilBody(parameters, rva, new GenericParamContext());
}
/// <summary>
/// Reads a CIL method body
/// </summary>
/// <param name="parameters">Method parameters</param>
/// <param name="rva">RVA</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CilBody"/> instance. It's empty if RVA is invalid (eg. 0 or
/// it doesn't point to a CIL method body)</returns>
public CilBody ReadCilBody(IList<Parameter> parameters, RVA rva, GenericParamContext gpContext)
{
if (rva == 0)
return new CilBody();
// Create a full stream so position will be the real position in the file. This
// is important when reading exception handlers since those must be 4-byte aligned.
// If we create a partial stream starting from rva, then position will be 0 and always
// 4-byte aligned. All fat method bodies should be 4-byte aligned, but the CLR doesn't
// seem to verify it. We must parse the method exactly the way the CLR parses it.
using (var reader = metaData.PEImage.CreateFullStream()) {
reader.Position = (long)metaData.PEImage.ToFileOffset(rva);
return MethodBodyReader.CreateCilBody(this, reader, parameters, gpContext);
}
}
bool GetFieldRVA_NoLock(out RVA rva) {
if ((origAttributes & FieldAttributes.HasFieldRVA) == 0) {
rva = 0;
return false;
}
return readerModule.TablesStream.ReadFieldRVARow(readerModule.MetaData.GetFieldRVARid(origRid), out rva);
}
/// <summary>
/// Reads data somewhere in the address space of the image
/// </summary>
/// <param name="rva">RVA of data</param>
/// <param name="size">Size of data</param>
/// <returns>All the data or <c>null</c> if <paramref name="rva"/> or <paramref name="size"/>
/// is invalid</returns>
public byte[] ReadDataAt(RVA rva, int size)
{
if (size < 0)
return null;
var peImage = MetaData.PEImage;
using (var reader = peImage.CreateStream(rva, size)) {
if (reader.Length < size)
return null;
return reader.ReadBytes(size);
}
}
/// <summary>
/// Creates a new data reader
/// </summary>
/// <param name="rva">RVA of data</param>
/// <param name="size">Size of data</param>
/// <returns>A new <see cref="IBinaryReader"/> for this data</returns>
public IBinaryReader CreateDataReader(RVA rva, uint size) {
var reader = dataReader.Create(rvaConverter.ToFileOffset(rva), size);
if (reader.Length == size)
return reader;
reader.Dispose();
return MemoryImageStream.CreateEmpty();
}
/// <inheritdoc/>
public FileOffset ToFileOffset(PEInfo peInfo, RVA rva) {
return peInfo.ToFileOffset(rva);
}
