internal static CallSite LoadCallSite(IBinaryAccessor accessor, Module module)
{
byte sigType = accessor.ReadByte();
return(LoadCallSite(accessor, module, sigType));
}
internal BamlImageLoader(IBinaryAccessor accessor)
{
_accessor = accessor;
}
public static IBinaryAccessor Map(this IBinaryAccessor accessor)
{
return(accessor.Map(0, accessor.Length));
}
internal void Write(IBinaryAccessor accessor, ProjectWriteState state)
{
accessor.Write7BitEncodedInt(state.SetString(ProjectHelper.MakeRelativePath(_filePath, state.BasePath)));
accessor.Write7BitEncodedInt(state.SetString(ProjectHelper.MakeRelativePath(_outputPath, state.BasePath)));
accessor.Write((int)_flags);
accessor.Write((int)_flags2);
accessor.Write((int)_flags3);
if (NameChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_name));
}
if (CultureChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_culture));
}
if (VersionChanged)
{
accessor.Write((ushort)_version.Major);
accessor.Write((ushort)_version.Minor);
accessor.Write((ushort)_version.Build);
accessor.Write((ushort)_version.Revision);
}
if (TitleChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_title));
}
if (DescriptionChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_description));
}
if (CompanyChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_company));
}
if (ProductChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_product));
}
if (CopyrightChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_copyright));
}
if (TrademarkChanged)
{
accessor.Write7BitEncodedInt(state.SetString(_trademark));
}
if (_sign != null)
{
accessor.Write(true);
_sign.Write(accessor, state);
}
else
{
accessor.Write(false);
}
WriteModules(accessor, state);
WriteResources(accessor, state);
}
internal ProjectType(IBinaryAccessor accessor, ProjectReadState state)
{
Read(accessor, state);
}
protected unsafe void Read(IBinaryAccessor accessor)
{
// DOS
DOSHeader dosHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.DosHeaderSize))
{
dosHeader = *(DOSHeader *)pBuff;
}
if (dosHeader.Signature != PEConstants.DosSignature)
{
throw new BadImageFormatException(SR.DOSHeaderSignatureNotValid);
}
accessor.Position = dosHeader.Lfanew;
// NT Signature
if (accessor.ReadUInt32() != PEConstants.NTSignature)
{
throw new BadImageFormatException(SR.PESignatureNotValid);
}
// COFF
COFFHeader coffHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.COFFHeaderSize))
{
coffHeader = *(COFFHeader *)pBuff;
}
_characteristics = coffHeader.Characteristics;
_machine = coffHeader.Machine;
// PE
ushort peMagic = accessor.ReadUInt16();
accessor.Position -= 2;
if (peMagic == PEConstants.PEMagic32)
{
_is32Bits = true;
PEHeader peHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.PEHeaderSize))
{
peHeader = *(PEHeader *)pBuff;
}
_addressOfEntryPoint = peHeader.AddressOfEntryPoint;
_imageBase = peHeader.ImageBase;
_sectionAlignment = peHeader.SectionAlignment;
_fileAlignment = peHeader.FileAlignment;
_subsystem = peHeader.Subsystem;
_dllCharacteristics = peHeader.DllCharacteristics;
_sizeOfStackReserve = peHeader.SizeOfStackReserve;
}
else if (peMagic == 0x20b)
{
_is32Bits = false;
PEHeader64 peHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.PEHeader64Size))
{
peHeader = *(PEHeader64 *)pBuff;
}
_addressOfEntryPoint = peHeader.AddressOfEntryPoint;
_imageBase = peHeader.ImageBase;
_sectionAlignment = peHeader.SectionAlignment;
_fileAlignment = peHeader.FileAlignment;
_subsystem = peHeader.Subsystem;
_dllCharacteristics = peHeader.DllCharacteristics;
_sizeOfStackReserve = peHeader.SizeOfStackReserve;
}
else
{
throw new BadImageFormatException(SR.PEHeaderSignatureNotValid);
}
// Directories
for (int i = 0; i < PEConstants.NumberOfRvaAndSizes; i++)
{
fixed(byte *pBuff = accessor.ReadBytes(8))
{
_directories[i] = *(DataDirectory *)pBuff;
}
}
// Sections
_sections = new PESection[coffHeader.NumberOfSections];
for (int i = 0; i < coffHeader.NumberOfSections; i++)
{
_sections[i] = PESection.Read(accessor);
}
}
internal ProjectAssembly(IBinaryAccessor accessor, ProjectReadState state)
{
Read(accessor, state);
}
public static void Write(this IBinaryAccessor accessor, DataDirectory dd)
{
accessor.Write((uint)dd.RVA);
accessor.Write((int)dd.Size);
}
internal ModuleObjectState(ModuleState state, IBinaryAccessor accessor)
{
_state = state;
Deserialize(accessor);
}
internal static FunctionPointer LoadFnPtr(IBinaryAccessor accessor, Module module)
{
var callSite = CallSite.LoadCallSite(accessor, module);
return(new FunctionPointer(callSite));
}
public static DataDirectory ReadDataDirectory(this IBinaryAccessor accessor)
{
return(new DataDirectory(accessor.ReadUInt32(), accessor.ReadInt32()));
}
public StringSerializer(IBinaryAccessor accessor, IEqualityComparer <string> comparer)
: base(accessor, comparer)
{
}
public StringSerializer(IBinaryAccessor accessor)
: base(accessor, StringComparer.Ordinal)
{
}
internal void Load(IBinaryAccessor accessor)
{
int count = accessor.ReadUInt16();
Load(accessor, count);
}
public override void Deserialize(IBinaryAccessor accessor)
{
_debuggingModes = accessor.Read7BitEncodedInt();
}
public void Save(IBinaryAccessor accessor)
{
if (accessor == null)
{
throw new ArgumentNullException("accessor");
}
// DOS
accessor.Write((ushort)PEConstants.DosSignature);
accessor.Write((ushort)0x90); // BytesInLastBlock
accessor.Write((ushort)3); // BlocksInFile
accessor.Write((ushort)0); // NumRelocs
accessor.Write((ushort)4); // HeaderParagraphs
accessor.Write((ushort)0); // MinExtraParagraphs
accessor.Write((ushort)0xFFFF); // MaxExtraParagraphs
accessor.Write((ushort)0); // SS
accessor.Write((ushort)0xB8); // SP
accessor.Write((ushort)0); // Checksum
accessor.Write((ushort)0); // IP
accessor.Write((ushort)0); // CS
accessor.Write((ushort)0x40); // RelocTableOffset
accessor.Write((ushort)0); // OverlayNumber
accessor.Write(0, 32); // Reserved
if ((_characteristics & ImageCharacteristics.EXECUTABLE_IMAGE) != 0)
{
accessor.Write((uint)(PEConstants.DosHeaderSize + PEConstants.DosX86Stub.Length)); // Lfanew
}
else
{
accessor.Write((uint)0); // Image file is not valid
}
accessor.Write(PEConstants.DosX86Stub);
// NT Signature
accessor.Write((uint)PEConstants.NTSignature);
// COFF
accessor.Write((ushort)Machine);
accessor.Write((ushort)_sections.Count); // NumberOfSections
accessor.Write((uint)TimeDateStamp.To_time_t());
accessor.Write((uint)0); // PointerToSymbolTable
accessor.Write((uint)0); // NumberOfSymbols
accessor.Write((ushort)(Is32Bits ? 0xE0 : 0xF0)); // SizeOfOptionalHeader
accessor.Write((ushort)Characteristics);
// PE Standard
if (Is32Bits)
{
accessor.Write((ushort)PEConstants.PEMagic32);
}
else
{
accessor.Write((ushort)PEConstants.PEMagic64);
}
accessor.Write((byte)MajorLinkerVersion);
accessor.Write((byte)MinorLinkerVersion);
accessor.Write((uint)SizeOfCode);
accessor.Write((uint)SizeOfInitializedData);
accessor.Write((uint)SizeOfUninitializedData);
accessor.Write((uint)AddressOfEntryPoint);
accessor.Write((uint)BaseOfCode);
if (Is32Bits)
{
accessor.Write((uint)BaseOfData);
}
// NT Specific
if (Is32Bits)
{
accessor.Write((uint)ImageBase);
}
else
{
accessor.Write((ulong)ImageBase);
}
accessor.Write((uint)SectionAlignment);
accessor.Write((uint)FileAlignment);
accessor.Write((ushort)MajorOperatingSystemVersion);
accessor.Write((ushort)MinorOperatingSystemVersion);
accessor.Write((ushort)MajorImageVersion);
accessor.Write((ushort)MinorImageVersion);
accessor.Write((ushort)MajorSubsystemVersion);
accessor.Write((ushort)MinorSubsystemVersion);
accessor.Write((uint)0); // Win32VersionValue
accessor.Write((uint)SizeOfImage);
accessor.Write((uint)SizeOfHeaders);
accessor.Write((uint)0); // CheckSum
accessor.Write((ushort)Subsystem);
accessor.Write((ushort)DllCharacteristics);
if (Is32Bits)
{
accessor.Write((uint)SizeOfStackReserve);
}
else
{
accessor.Write((ulong)SizeOfStackReserve);
}
if (Is32Bits)
{
accessor.Write((uint)SizeOfStackCommit);
}
else
{
accessor.Write((ulong)SizeOfStackCommit);
}
if (Is32Bits)
{
accessor.Write((uint)SizeOfHeapReserve);
}
else
{
accessor.Write((ulong)SizeOfHeapReserve);
}
if (Is32Bits)
{
accessor.Write((uint)SizeOfHeapCommit);
}
else
{
accessor.Write((ulong)SizeOfHeapCommit);
}
accessor.Write((uint)0); // LoaderFlags (reserved)
accessor.Write((uint)PEConstants.NumberOfRvaAndSizes);
// Directories
for (int i = 0; i < PEConstants.NumberOfRvaAndSizes; i++)
{
accessor.Write(_directories[i]);
}
// Write section headers
foreach (var section in _sections)
{
string sectionName = section.Name.PadRight(8, '\0');
accessor.Write(sectionName, Encoding.ASCII);
accessor.Write((uint)section.VirtualSize);
accessor.Write((uint)section.RVA);
accessor.Write((uint)section.SizeOfRawData);
accessor.Write((uint)section.PointerToRawData);
accessor.Write((uint)0); // PointerToRelocations
accessor.Write((uint)0); // PointerToLinenumbers
accessor.Write((ushort)0); // NumberOfRelocations
accessor.Write((ushort)0); // NumberOfLinenumbers
accessor.Write((uint)section.Characteristics);
}
accessor.Write(0, (int)(SizeOfHeaders - accessor.Position));
// Write section data
foreach (var section in _sections)
{
int blobLength = 0;
foreach (var blob in section.Blobs)
{
if (blob.OffsetAlignment > 0)
{
int alignCount = blobLength.Align(blob.OffsetAlignment) - blobLength;
if (alignCount > 0)
{
accessor.Write(new byte[alignCount]);
blobLength += alignCount;
}
}
accessor.Write(blob.GetBuffer(), 0, blob.Length);
blobLength += blob.Length;
}
accessor.Write(0, (int)(section.SizeOfRawData - blobLength));
}
}
public bool TryOpenImageToSectionData(uint rva, out IBinaryAccessor accessor)
{
PESection section;
return(TryOpenImageToSectionData(rva, out accessor, out section));
}
public override void Deserialize(IBinaryAccessor accessor)
{
_assemblyIsPrivate = accessor.ReadBoolean();
_stripAfterObfuscation = accessor.ReadBoolean();
}
internal static ArrayType LoadSzArray(IBinaryAccessor accessor, Module module)
{
var elementType = Load(accessor, module);
return(new ArrayType(elementType));
}
public override void Serialize(IBinaryAccessor accessor)
{
accessor.Write((bool)_assemblyIsPrivate);
accessor.Write((bool)_stripAfterObfuscation);
}
internal void Read(IBinaryAccessor accessor, ProjectReadState state)
{
_filePath = ProjectHelper.MakeAbsolutePath(state.GetString(accessor.Read7BitEncodedInt()), state.BasePath);
_outputPath = ProjectHelper.MakeAbsolutePath(state.GetString(accessor.Read7BitEncodedInt()), state.BasePath);
_flags = accessor.ReadInt32();
_flags2 = accessor.ReadInt32();
_flags3 = accessor.ReadInt32();
if (NameChanged)
{
_name = state.GetString(accessor.Read7BitEncodedInt());
}
if (CultureChanged)
{
_culture = state.GetString(accessor.Read7BitEncodedInt());
}
if (VersionChanged)
{
_version = new Version(accessor.ReadUInt16(), accessor.ReadUInt16(), accessor.ReadUInt16(), accessor.ReadUInt16());
}
if (TitleChanged)
{
_title = state.GetString(accessor.Read7BitEncodedInt());
}
if (DescriptionChanged)
{
_description = state.GetString(accessor.Read7BitEncodedInt());
}
if (CompanyChanged)
{
_company = state.GetString(accessor.Read7BitEncodedInt());
}
if (ProductChanged)
{
_product = state.GetString(accessor.Read7BitEncodedInt());
}
if (CopyrightChanged)
{
_copyright = state.GetString(accessor.Read7BitEncodedInt());
}
if (TrademarkChanged)
{
_trademark = state.GetString(accessor.Read7BitEncodedInt());
}
if (accessor.ReadBoolean())
{
_sign = new ProjectAssemblySign(accessor, state);
}
ReadModules(accessor, state);
ReadResources(accessor, state);
}
private void LoadInstructions(IBinaryAccessor accessor, Module module, int codeSize)
{
long startOffset = accessor.Position;
var image = module.Image;
_instructions = new List <Instruction>();
while (accessor.Position < startOffset + codeSize)
{
OpCode opCode;
byte opByte = accessor.ReadByte();
if (opByte == 0xFE)
{
opByte = accessor.ReadByte();
opCode = OpCodes.OpCodeArray[256 + opByte];
}
else
{
opCode = OpCodes.OpCodeArray[opByte];
}
if (opCode == null)
{
throw new CodeModelException(string.Format(SR.AssemblyLoadError, module.Location));
}
object value;
switch (opCode.OperandType)
{
case OperandType.InlineBrTarget:
{
value = accessor.ReadInt32();
}
break;
case OperandType.InlineField:
{
int token = accessor.ReadInt32();
value = FieldReference.Load(module, token);
}
break;
case OperandType.InlineI:
{
value = accessor.ReadInt32();
}
break;
case OperandType.InlineI8:
{
value = accessor.ReadInt64();
}
break;
case OperandType.InlineMethod:
{
int token = accessor.ReadInt32();
value = MethodReference.Load(module, token);
}
break;
case OperandType.InlineR:
{
value = accessor.ReadDouble();
}
break;
case OperandType.InlineSig:
{
int token = accessor.ReadInt32();
if (MetadataToken.GetType(token) == MetadataTokenType.Signature)
{
int rid = MetadataToken.GetRID(token);
value = CallSite.LoadStandAloneSig(module, rid);
}
else
{
throw new CodeModelException(SR.MethodBodyBlobNotValid);
}
}
break;
case OperandType.InlineString:
{
// Token of a userdefined string, whose RID portion is actually an offset in the #US blob stream.
uint token = accessor.ReadUInt32();
int rid = (int)(token & 0x00ffffff);
value = image.GetUserString(rid);
}
break;
case OperandType.InlineSwitch:
{
int count = accessor.ReadInt32();
int[] targets = new int[count];
for (int i = 0; i < count; i++)
{
targets[i] = accessor.ReadInt32();
}
value = targets;
}
break;
case OperandType.InlineTok:
{
int token = accessor.ReadInt32();
int rid = MetadataToken.GetRID(token);
switch (MetadataToken.GetType(token))
{
case MetadataTokenType.Method:
value = MethodReference.LoadMethodDef(module, rid);
break;
case MetadataTokenType.MethodSpec:
value = GenericMethodReference.LoadMethodSpec(module, rid);
break;
case MetadataTokenType.MemberRef:
value = MethodReference.LoadMemberRef(module, rid);
break;
case MetadataTokenType.Field:
value = FieldReference.LoadFieldDef(module, rid);
break;
case MetadataTokenType.TypeDef:
value = TypeReference.LoadTypeDef(module, rid);
break;
case MetadataTokenType.TypeRef:
value = TypeReference.LoadTypeRef(module, rid);
break;
case MetadataTokenType.TypeSpec:
value = TypeSignature.LoadTypeSpec(module, rid);
break;
default:
throw new CodeModelException(SR.MethodBodyBlobNotValid);
}
}
break;
case OperandType.InlineType:
{
int token = accessor.ReadInt32();
value = TypeSignature.Load(module, token);
}
break;
case OperandType.InlineVar:
{
value = accessor.ReadInt16();
}
break;
case OperandType.ShortInlineBrTarget:
{
value = accessor.ReadSByte();
}
break;
case OperandType.ShortInlineI:
{
value = accessor.ReadByte();
}
break;
case OperandType.ShortInlineR:
{
value = accessor.ReadSingle();
}
break;
case OperandType.ShortInlineVar:
{
value = accessor.ReadByte();
}
break;
default:
{
value = null;
}
break;
}
_instructions.Add(new Instruction(opCode, value));
}
}
private void ReadStreams(IBinaryAccessor accessor, long metadataOffset)
{
int numberOfStream = accessor.ReadUInt16();
int[] offsets = new int[numberOfStream];
int[] sizes = new int[numberOfStream];
string[] names = new string[numberOfStream];
for (int i = 0; i < numberOfStream; i++)
{
offsets[i] = accessor.ReadInt32();
sizes[i] = accessor.ReadInt32();
// Name of the stream; a zero-terminated ASCII string no longer than 31 characters (plus zero terminator).
// The name might be shorter, in which case the size of the stream header is correspondingly reduced,
// padded to the 4-byte boundary.
long startPos = accessor.Position;
names[i] = accessor.ReadNullTerminatedString(Encoding.ASCII);
accessor.Align(startPos, 4);
}
int tableIndex = -1;
for (int i = 0; i < numberOfStream; i++)
{
int offset = offsets[i];
int size = sizes[i];
string name = names[i];
if (name == MetadataConstants.StreamTable)
{
tableIndex = i;
_tables.IsOptimized = true;
}
else if (name == MetadataConstants.StreamTableUnoptimized)
{
tableIndex = i;
_tables.IsOptimized = false;
}
else if (name == MetadataConstants.StreamStrings)
{
accessor.Position = offset + metadataOffset;
_strings.Blob = new Blob(accessor.ReadBytes(size));
}
else if (name == MetadataConstants.StreamUserStrings)
{
accessor.Position = offset + metadataOffset;
_userStrings.Blob = new Blob(accessor.ReadBytes(size));
}
else if (name == MetadataConstants.StreamGuid)
{
accessor.Position = offset + metadataOffset;
_guids.Blob = new Blob(accessor.ReadBytes(size));
}
else if (name == MetadataConstants.StreamBlob)
{
accessor.Position = offset + metadataOffset;
_blobs.Blob = new Blob(accessor.ReadBytes(size));
}
else
{
accessor.Position = offset + metadataOffset;
var stream = new MetadataExternalStream(name, new Blob(accessor.ReadBytes(size)));
ExternalStreams.Add(stream);
}
}
if (tableIndex >= 0)
{
// Read table last as it relies on heaps.
accessor.Position = offsets[tableIndex] + metadataOffset;
_tables.Read(accessor);
}
}
private void StateLoadInstructions(IBinaryAccessor accessor, Module module)
{
int instructionCount = accessor.Read7BitEncodedInt();
_instructions = new List <Instruction>(instructionCount);
for (int i = 0; i < instructionCount; i++)
{
OpCode opCode;
byte opByte = accessor.ReadByte();
if (opByte == 0xFE)
{
opByte = accessor.ReadByte();
opCode = OpCodes.OpCodeArray[256 + opByte];
}
else
{
opCode = OpCodes.OpCodeArray[opByte];
}
object value;
switch (opCode.OperandType)
{
case OperandType.InlineBrTarget:
{
value = accessor.ReadInt32();
}
break;
case OperandType.InlineField:
{
int token = accessor.ReadInt32();
value = module.GetSignature <Signature>(token);
}
break;
case OperandType.InlineI:
{
value = accessor.ReadInt32();
}
break;
case OperandType.InlineI8:
{
value = accessor.ReadInt64();
}
break;
case OperandType.InlineMethod:
{
int token = accessor.ReadInt32();
value = module.GetSignature <Signature>(token);
}
break;
case OperandType.InlineR:
{
value = accessor.ReadDouble();
}
break;
case OperandType.InlineSig:
{
int token = accessor.ReadInt32();
value = module.GetSignature <Signature>(token);
}
break;
case OperandType.InlineString:
{
// Token of a userdefined string, whose RID portion is actually an offset in the #US blob stream.
value = accessor.ReadLengthPrefixedString(Encoding.Unicode);
}
break;
case OperandType.InlineSwitch:
{
int count = accessor.ReadInt32();
int[] targets = new int[count];
for (int j = 0; j < count; j++)
{
targets[j] = accessor.ReadInt32();
}
value = targets;
}
break;
case OperandType.InlineTok:
{
int token = accessor.ReadInt32();
value = module.GetSignature <Signature>(token);
}
break;
case OperandType.InlineType:
{
int token = accessor.ReadInt32();
value = module.GetSignature <Signature>(token);
}
break;
case OperandType.InlineVar:
{
value = accessor.ReadInt16();
}
break;
case OperandType.ShortInlineBrTarget:
{
value = accessor.ReadSByte();
}
break;
case OperandType.ShortInlineI:
{
value = accessor.ReadByte();
}
break;
case OperandType.ShortInlineR:
{
value = accessor.ReadSingle();
}
break;
case OperandType.ShortInlineVar:
{
value = accessor.ReadByte();
}
break;
default:
{
value = null;
}
break;
}
_instructions.Add(new Instruction(opCode, value));
}
}
internal static PinnedType LoadPinned(IBinaryAccessor accessor, Module module)
{
var elementType = Load(accessor, module);
return(new PinnedType(elementType));
}
public abstract void Deserialize(IBinaryAccessor accessor);
public static void Align(this IBinaryAccessor accessor, int align)
{
Align(accessor, 0, align);
}
public override void Serialize(IBinaryAccessor accessor)
{
accessor.Write7BitEncodedInt(_debuggingModes);
}
public static Guid ReadGuid(this IBinaryAccessor accessor)
{
return(new Guid(accessor.ReadBytes(16)));
}
public SignatureSerializer(IBinaryAccessor accessor)
: base(accessor, SignatureComparer.Default)
{
}
