// See the comments in Equals - we're doing string comparisons here
// to compare full type names.
public static bool Equals(MiniAssembly assemblyA, PEFileReader peFileB, MetadataToken assemblyRefB)
{
System.Diagnostics.Contracts.Contract.Requires(assemblyA != null);
System.Diagnostics.Contracts.Contract.Requires(peFileB != null);
System.Diagnostics.Contracts.Contract.Requires(assemblyRefB.Table == MDTables.Tables.AssemblyRef);
String nameA, nameRefB;
if (assemblyA.IsReflectionAssembly)
{
nameA = AppDomain.CurrentDomain.ApplyPolicy(assemblyA._reflectionAssembly.FullName);
}
else
{
AssemblyInfo assemblyInfoA = new AssemblyInfo();
assemblyA._peFile.GetAssemblyInfo(ref assemblyInfoA);
nameA = AppDomain.CurrentDomain.ApplyPolicy(assemblyInfoA.ToString());
}
AssemblyInfo assemblyInfoB = ReadAssemblyRef(peFileB, assemblyRefB);
nameRefB = AppDomain.CurrentDomain.ApplyPolicy(assemblyInfoB.ToString());
return(Utils.AssemblyRefEqualsDef(nameRefB, nameA));
}
private static ReadOnlyArray<Module> CreateAssemblyModules(PEFileReader peFileReader, string assemblyResolvedPath, MetadataFileProvider fileProvider)
{
List<Module> modules = new List<Module>();
modules.Add(new Module(peFileReader));
foreach (string moduleFileName in peFileReader.GetMetadataModuleNames())
{
string modulePath;
try
{
modulePath = fileProvider.ProvideModuleFile(assemblyResolvedPath, moduleFileName);
}
catch (Exception e)
{
throw new FileNotFoundException(e.Message, moduleFileName);
}
if (modulePath == null)
{
throw new FileNotFoundException("Module not found", moduleFileName);
}
modules.Add(CreateModuleFromFile(modulePath));
}
return modules.AsReadOnly<Module>();
}
private static AssemblyInfo ReadAssemblyRef(PEFileReader peFile, MetadataToken assemblyRef)
{
System.Diagnostics.Contracts.Contract.Requires(peFile != null);
System.Diagnostics.Contracts.Contract.Requires(assemblyRef.Table == MDTables.Tables.AssemblyRef);
MDTables metaData = peFile.MetaData;
BinaryReader B = metaData.B;
metaData.SeekToMDToken(assemblyRef);
UInt16 major = B.ReadUInt16();
UInt16 minor = B.ReadUInt16();
UInt16 build = B.ReadUInt16();
UInt16 revision = B.ReadUInt16();
Version v = new Version(major, minor, build, revision);
UInt32 assemblyFlags = B.ReadUInt32();
byte[] publicKey = metaData.ReadBlob();
String simpleName = metaData.ReadString();
String culture = metaData.ReadString();
if ((culture != null) && (culture.Length == 0))
{
culture = null;
}
return(new AssemblyInfo(v, assemblyFlags, publicKey, simpleName, culture));
}
protected MiniModule(String peFileName)
{
System.Diagnostics.Contracts.Contract.Requires(peFileName != null);
_peFile = new PEFileReader(peFileName);
_moduleName = Path.GetFileNameWithoutExtension(peFileName);
}
private static ReadOnlyArray <Module> CreateAssemblyModules(PEFileReader peFileReader, string assemblyResolvedPath, MetadataFileProvider fileProvider)
{
List <Module> modules = new List <Module>();
modules.Add(new Module(peFileReader));
foreach (string moduleFileName in peFileReader.GetMetadataModuleNames())
{
string modulePath;
try
{
modulePath = fileProvider.ProvideModuleFile(assemblyResolvedPath, moduleFileName);
}
catch (Exception e)
{
throw new FileNotFoundException(e.Message, moduleFileName);
}
if (modulePath == null)
{
throw new FileNotFoundException("Module not found", moduleFileName);
}
modules.Add(CreateModuleFromFile(modulePath));
}
return(modules.AsReadOnly <Module>());
}
static void Main(string[] args)
{
var reader = new PEFileReader();
var sources =
from file in Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.System))
where ".exe.dll".IndexOf(Path.GetExtension(file), StringComparison.OrdinalIgnoreCase) < 0
select file;
sources = new[] { typeof(Program).Assembly.Location };
foreach (var peFile in sources)
{
Stream stream;
try
{
stream = File.OpenRead(peFile);
}
catch(Exception error)
{
continue;
}
using(stream)
{
var pe = reader.Read(stream);
}
}
}
static void Main(string[] args)
{
var reader = new PEFileReader();
var sources =
from file in Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.System))
where ".exe.dll".IndexOf(Path.GetExtension(file), StringComparison.OrdinalIgnoreCase) < 0
select file;
sources = new[] { typeof(Program).Assembly.Location };
foreach (var peFile in sources)
{
Stream stream;
try
{
stream = File.OpenRead(peFile);
}
catch (Exception error)
{
continue;
}
using (stream)
{
var pe = reader.Read(stream);
}
}
}
// See the ECMA CLI spec, Partition II, section 23.2.1.
private MiniParameterInfo[] ParseSig(byte[] sig)
{
PEFileReader peFile = _assembly.PEFileReader;
peFile.InitMetaData();
MDTables MetaData = peFile.MetaData;
uint i = 0;
// The first byte of the Signature holds bits for HASTHIS, EXPLICITTHIS
// and calling convention (DEFAULT, VARARG, or GENERIC). These are OR'ed
// together.
i++;
uint numParams = DecodeInteger(sig, ref i);
// Skip over return type
// Skip custom modifiers.
do
{
if (sig[i] == (byte)CorElementType.CModOpt)
{
i++;
}
else if (sig[i] == (byte)CorElementType.CModReqd)
{
i++;
}
else
{
break;
}
} while (true);
// Skip return type. Note that for constructors, it should be void.
if (sig[i] == (byte)CorElementType.Void)
{
i++;
}
else if (sig[i] == (byte)CorElementType.TypedByRef)
{
i++;
}
else
{
if (sig[i] == (byte)CorElementType.ByRef)
{
i++;
}
ParseType(sig, ref i, false, true);
}
MiniParameterInfo[] parameters = new MiniParameterInfo[numParams];
for (uint paramNum = 0; paramNum < numParams; paramNum++)
{
parameters[paramNum] = ParseType(sig, ref i, false, false);
//Console.WriteLine("Read a parameter: {0}", parameters[paramNum]);
}
return(parameters);
}
internal static PEFileReader CreatePEFileReaderFromBytes(string uniqueName, byte[] bytes)
{
var binaryDocumentMemoryBlock = new ByteArrayMemoryBlock(uniqueName, bytes);
PEFileReader peFileReader = new PEFileReader(binaryDocumentMemoryBlock);
Contract.ThrowIfTrue(peFileReader.ReaderState < ReaderState.Metadata);
return(peFileReader);
}
/// <summary>
/// Method to open the module in the MetadataReader. This method loads the module and returns the object corresponding to the opened module.
/// Also returns the ModuleIDentifier corresponding to the module as the out parameter. Modules are opened as if they are not contained in any assembly.
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
/// <param name="moduleIdentity">Contains the module identity of the binary document in case it is an module.</param>
/// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
public IModule OpenModule(
IBinaryDocument binaryDocument,
out ModuleIdentity /*?*/ moduleIdentity
)
{
moduleIdentity = null;
lock (GlobalLock.LockingObject)
{
IBinaryDocumentMemoryBlock /*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null)
{
// Error...
return(Dummy.Module);
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata)
{
// Error...
return(Dummy.Module);
}
//^ assert peFileReader.ReaderState >= ReaderState.Metadata;
if (peFileReader.IsAssembly)
{
AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
moduleIdentity = assemblyIdentity;
Assembly /*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null)
{
return(lookupAssembly);
}
}
else
{
moduleIdentity = this.GetModuleIdentifier(peFileReader);
Module /*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
if (lookupModule != null)
{
return(lookupModule);
}
}
try
{
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
this.LoadedModule(peFileToObjectModel.Module);
Assembly /*?*/ assembly = peFileToObjectModel.Module as Assembly;
if (assembly != null)
{
this.OpenMemberModules(binaryDocument, assembly);
}
return(peFileToObjectModel.Module);
}
catch (MetadataReaderException)
{
// Error...
}
}
return(Dummy.Module);
}
/// <summary>
/// Computes the ModuleIdentifier of the PE File as if the module belong to given assembly.
/// </summary>
/// <param name="peFileReader"></param>
/// <param name="containingAssemblyIdentity"></param>
/// <returns></returns>
internal ModuleIdentity GetModuleIdentifier(PEFileReader peFileReader, AssemblyIdentity containingAssemblyIdentity)
//^ requires peFileReader.ReaderState >= ReaderState.Metadata;
//^ ensures (result.Location != null && result.Location.Length != 0);
{
ModuleRow moduleRow = peFileReader.ModuleTable[1];
IName moduleName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[moduleRow.Name]);
return(new ModuleIdentity(moduleName, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location, containingAssemblyIdentity));
}
internal TypeInfo(MetadataToken typeRefToken, MiniAssembly referencingAssembly, bool disambiguatingJunkForTypeRefOverload)
{
System.Diagnostics.Contracts.Contract.Requires(referencingAssembly != null);
System.Diagnostics.Contracts.Contract.Requires(typeRefToken.Table == MDTables.Tables.TypeRef);
_mdToken = typeRefToken;
_assembly = referencingAssembly;
_representation = Representation.TypeRef | Representation.Name;
PEFileReader peFile = referencingAssembly.PEFileReader;
MDTables MetaData = peFile.MetaData;
MetaData.SeekToMDToken(typeRefToken);
MetadataToken assemblyRef = MetaData.ReadMetadataToken(MDTables.Encodings.ResolutionScope);
_typeName = MetaData.ReadString();
_nameSpace = MetaData.ReadString();
// Read assembly information
MetaData.SeekToMDToken(assemblyRef);
UInt16 major = peFile.B.ReadUInt16();
UInt16 minor = peFile.B.ReadUInt16();
UInt16 build = peFile.B.ReadUInt16();
UInt16 revision = peFile.B.ReadUInt16();
peFile.B.ReadUInt32(); // assembly flags
byte[] publicKeyOrToken = MetaData.ReadBlob();
String simpleName = MetaData.ReadString();
String culture = MetaData.ReadString();
// assert so we can get the AssemblyName of mscorlib.dll
FileIOPermission permission = new FileIOPermission(PermissionState.None);
permission.AllLocalFiles = FileIOPermissionAccess.PathDiscovery;
permission.Assert();
System.Reflection.Assembly mscorlib = typeof(Object).Assembly;
if (simpleName == "mscorlib" && (culture.Length == 0) && Utils.PublicKeyMatches(mscorlib.GetName(), publicKeyOrToken))
{
// Upgrade to using a Type!
Type t = mscorlib.GetType(FullName, false);
if (t != null)
{
_reflectionType = t;
_representation |= Representation.ReflectionType;
}
}
String typeRefDefiningAssemblyName = String.Format(CultureInfo.InvariantCulture,
"{0}, Version={1}.{2}.{3}.{4}, Culture={5}, PublicKeyToken={6}",
simpleName, major, minor, build, revision,
(culture.Length == 0 ? "neutral" : culture), Utils.PublicKeyToString(publicKeyOrToken));
_assemblyQualifiedName = FullName + ", " + typeRefDefiningAssemblyName;
_representation |= Representation.AssemblyQualifiedName;
}
protected virtual void Dispose(bool disposing)
{
if (_peFile != null)
{
if (disposing)
{
_peFile.Dispose();
}
_peFile = null;
}
}
internal static Module CreateModuleFromFile(string path)
{
PEFileReader peFileReader = CreatePEFileReaderFromFile(path);
if (peFileReader.IsAssembly)
{
throw new MetadataReaderException(MetadataReaderErrorKind.InvalidPEKind);
}
return(new Module(peFileReader));
}
public WinMDModule(
ModuleMetadata owner,
AbstractMemoryBlock memoryBlock,
PEFileReader peFileReader,
ReadOnlyArray<AssemblyIdentity> referencedAssemblies,
WinMDScenario scenario)
: base(owner, memoryBlock, peFileReader, referencedAssemblies)
{
this.scenario = scenario;
this.winMdStartIndex = (uint)referencedAssemblies.Count - WinMdExtraRefs;
}
internal static PEFileReader CreatePEFileReaderFromFile(string path)
{
using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
{
var binaryDocumentMemoryBlock = MemoryMappedFile.CreateMemoryMappedFile(stream, path);
PEFileReader peFileReader = new PEFileReader(binaryDocumentMemoryBlock);
Contract.ThrowIfTrue(peFileReader.ReaderState < ReaderState.Metadata);
return(peFileReader);
}
}
internal static PEFileReader CreatePEFileReaderFromFile(string path)
{
using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
{
var binaryDocumentMemoryBlock = MemoryMappedFile.CreateMemoryMappedFile(stream, path);
PEFileReader peFileReader = new PEFileReader(binaryDocumentMemoryBlock);
Contract.ThrowIfTrue(peFileReader.ReaderState < ReaderState.Metadata);
return peFileReader;
}
}
public WinMDModule(
ModuleMetadata owner,
AbstractMemoryBlock memoryBlock,
PEFileReader peFileReader,
ReadOnlyArray <AssemblyIdentity> referencedAssemblies,
WinMDScenario scenario)
: base(owner, memoryBlock, peFileReader, referencedAssemblies)
{
this.scenario = scenario;
this.winMdStartIndex = (uint)referencedAssemblies.Count - WinMdExtraRefs;
}
private static Dictionary <string, FieldHandle> GetFieldDefs(PEFileReader reader, TypeHandle typeHandle)
{
var fields = new Dictionary <string, FieldHandle>();
foreach (var fieldHandle in reader.GetTypeDefinition(typeHandle).GetFields())
{
var fieldDef = reader.GetField(fieldHandle);
var name = reader.GetString(fieldDef.Name);
fields.Add(name, fieldHandle);
}
return(fields);
}
private static Dictionary <string, EventHandle> GetEventDefs(PEFileReader reader, TypeHandle typeHandle)
{
var events = new Dictionary <string, EventHandle>();
foreach (var eventHandle in reader.GetTypeDefinition(typeHandle).GetEvents())
{
var eventDef = reader.GetEvent(eventHandle);
var name = reader.GetString(eventDef.Name);
events.Add(name, eventHandle);
}
return(events);
}
private static Dictionary <string, TypeFromMetadata> GetTypeDefinitions(PEFileReader reader)
{
var types = new Dictionary <string, TypeFromMetadata>();
foreach (var typeHandle in reader.TypeDefinitions)
{
var typeDef = reader.GetTypeDefinition(typeHandle);
var name = reader.GetString(typeDef.Name); // TODO: Index by namespace + name. By MetadataTypeName?
types.Add(name, new TypeFromMetadata(reader, typeHandle));
}
return(types);
}
// TODO: Index by signature.
private static Dictionary <string, MethodHandle> GetMethodDefs(PEFileReader reader, TypeHandle typeHandle)
{
var methods = new Dictionary <string, MethodHandle>();
foreach (var methodHandle in reader.GetTypeDefinition(typeHandle).GetMethods())
{
var methodDef = reader.GetMethod(methodHandle);
var name = reader.GetString(methodDef.Name);
methods.Add(name, methodHandle);
}
return(methods);
}
// Return the attributes on this type of the given custom attribute type
internal MiniCustomAttributeInfo[] GetCustomAttributeInfos(Type caReflectedType)
{
List <MiniCustomAttributeInfo> result = new List <MiniCustomAttributeInfo>();
PEFileReader peFile = _assembly.PEFileReader;
peFile.InitMetaData();
MDTables metaData = peFile.MetaData;
uint numRows = metaData.RowsInTable(MDTables.Tables.CustomAttribute);
for (uint i = 0; i < numRows; i++)
{
metaData.SeekToRowOfTable(MDTables.Tables.CustomAttribute, i);
// Format: Parent type token, CA type token (really the constructor method), value (index into blob heap)
MetadataToken targetType = metaData.ReadMetadataToken(MDTables.Encodings.HasCustomAttribute);
MetadataToken caType = metaData.ReadMetadataToken(MDTables.Encodings.CustomAttributeType);
byte[] caBlob = metaData.ReadBlob();
if (targetType.Equals(this._mdToken))
{
//Console.WriteLine("CA - Applied to: {0} CA .ctor: {1} Value: {2}", targetType, caType, value);
//Console.WriteLine("CA MD Tokens Parent: {0} Type: {1}", targetType.ToMDToken(), caType.ToMDToken());
// Ensure the custom attribute type is the type we expect
metaData.SeekToMDToken(caType);
String caTypeName = null, caNameSpace = null;
if (caType.Table != MDTables.Tables.MemberRef)
{
// Custom attribute was defined in the assembly we are currently inspecting?
// Ignore it.
System.Diagnostics.Contracts.Contract.Assert(caType.Table == MDTables.Tables.MethodDef);
continue;
}
MetadataToken customAttributeType = metaData.ReadMetadataToken(MDTables.Encodings.MemberRefParent);
//Console.WriteLine(" MemberRef: {0} Type of MemberRef: {1}", caType.ToMDToken(), customAttributeType.ToMDToken());
metaData.SeekToMDToken(customAttributeType);
MetadataToken resolutionScope = metaData.ReadMetadataToken(MDTables.Encodings.ResolutionScope);
caTypeName = metaData.ReadString();
caNameSpace = metaData.ReadString();
if (caTypeName == caReflectedType.Name && caNameSpace == caReflectedType.Namespace)
{
MiniCustomAttributeInfo customAttributeInfo = ParseCustomAttribute(caBlob, caReflectedType);
result.Add(customAttributeInfo);
}
}
}
return(result.ToArray());
}
internal static Assembly CreateAssemblyFromBytes(AssemblyBytesReference reference)
{
// make a copy of the byte[], so that the user can't change the bytes that the reader consumes:
PEFileReader peFileReader = CreatePEFileReaderFromBytes(reference.UniqueName, (byte[])reference.Bytes.Clone());
if (!peFileReader.IsAssembly)
{
throw new MetadataReaderException(MetadataReaderErrorKind.InvalidPEKind);
}
return(new Assembly(reference.UniqueName, ReadOnlyArray.Singleton(new Module(peFileReader))));
}
private static Dictionary <string, PropertyHandle> GetPropertyDefs(PEFileReader reader, TypeHandle typeHandle)
{
var properties = new Dictionary <string, PropertyHandle>();
foreach (var propertyHandle in reader.GetTypeDefinition(typeHandle).GetProperties())
{
var propertyDef = reader.GetProperty(propertyHandle);
var name = reader.GetString(propertyDef.Name);
properties.Add(name, propertyHandle);
}
return(properties);
}
/// <summary>
/// This method loads a module from a file containing only the metadata section of a PE file. (No headers and no IL.)
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
/// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
public IModule OpenSnapshot(IBinaryDocument binaryDocument)
{
ModuleIdentity moduleIdentity;
lock (GlobalLock.LockingObject) {
IBinaryDocumentMemoryBlock /*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null)
{
// Error...
return(Dummy.Module);
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock, snapshot: true);
if (peFileReader.ReaderState < ReaderState.Metadata)
{
// Error...
return(Dummy.Module);
}
if (peFileReader.IsAssembly)
{
AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
moduleIdentity = assemblyIdentity;
Assembly /*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null)
{
return(lookupAssembly);
}
}
else
{
moduleIdentity = this.GetModuleIdentifier(peFileReader);
Module /*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
if (lookupModule != null)
{
return(lookupModule);
}
}
if (peFileReader.ReaderState < ReaderState.Metadata)
{
// Error...
return(Dummy.Module);
}
try {
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
this.LoadedModule(peFileToObjectModel.Module);
CciEventSource.Log.ModuleOpened(peFileToObjectModel.Module, moduleIdentity, binaryDocument.Length);
return(peFileToObjectModel.Module);
} catch (MetadataReaderException) {
// Error...
}
}
return(Dummy.Module);
}
internal static Assembly CreateAssemblyFromFile(string metadataFile, string resolvedPath, MetadataFileProvider fileProvider)
{
PEFileReader peFileReader = CreatePEFileReaderFromFile(metadataFile);
if (!peFileReader.IsAssembly)
{
throw new MetadataReaderException(MetadataReaderErrorKind.InvalidPEKind);
}
var modules = CreateAssemblyModules(peFileReader, resolvedPath, fileProvider);
return(new Assembly(metadataFile, modules));
}
public MiniAssembly ResolveAssemblyRef(MetadataToken token, bool throwOnError)
{
System.Diagnostics.Contracts.Contract.Requires(token.Table == MDTables.Tables.AssemblyRef);
PEFileReader peFile = this.PEFileReader;
MDTables metaData = peFile.MetaData;
metaData.SeekToMDToken(token);
peFile.B.ReadUInt64(); // Skip 4 parts of the version number.
peFile.B.ReadUInt32(); // AssemblyFlags
byte[] publicKeyOrToken = metaData.ReadBlob(); // Public key or token
String assemblySimpleName = metaData.ReadString(); // simple name
String cultureName = metaData.ReadString(); // assembly culture
if (!String.IsNullOrEmpty(cultureName))
{
throw new BadImageFormatException(Res.UnexpectedlyLoadingASatellite, FullName);
}
if (assemblySimpleName == "mscorlib" && (cultureName.Length == 0 || cultureName == "neutral"))
{
return(new MiniAssembly(typeof(Object).Assembly));
}
MiniAssembly loadedAssembly = Open(assemblySimpleName, _dependencyDirs, throwOnError);
if (loadedAssembly != null)
{
// Check whether the reference to the assembly matches what we actually loaded.
// We don't respect the "throwOnError" parameter here because if someone does
// violate this, they've either severely messed up their deployment, or they're
// attempting a security exploit.
System.Reflection.AssemblyName loadedAssemblyName =
new System.Reflection.AssemblyName(loadedAssembly.FullName);
if (!Utils.PublicKeyMatches(loadedAssemblyName, publicKeyOrToken))
{
throw new FileLoadException(String.Format(CultureInfo.CurrentCulture, Res.AssemblyLoadRefDefMismatch,
assemblySimpleName, publicKeyOrToken, loadedAssemblyName.GetPublicKeyToken()));
}
if (!String.IsNullOrEmpty(loadedAssemblyName.CultureInfo.Name))
{
throw new FileLoadException(String.Format(CultureInfo.CurrentCulture, Res.AssemblyLoadRefDefMismatch,
assemblySimpleName, String.Empty, loadedAssemblyName.CultureInfo.Name));
}
}
return(loadedAssembly);
}
internal TypeInfo(MetadataToken typeDef, MiniAssembly assembly)
{
System.Diagnostics.Contracts.Contract.Requires(assembly != null);
System.Diagnostics.Contracts.Contract.Requires(typeDef.Table == MDTables.Tables.TypeDef);
_mdToken = typeDef;
_assembly = assembly;
_representation = Representation.Token;
PEFileReader peFile = _assembly.PEFileReader;
MDTables mdScope = peFile.MetaData;
mdScope.SeekToMDToken(_mdToken);
peFile.B.ReadUInt32(); // TypeAttributes;
_typeName = mdScope.ReadString(); // this type's name
_nameSpace = mdScope.ReadString(); // this type's namespace
_representation |= Representation.Name;
}
/// <summary>
/// This method is called when an assembly is loaded. This makes sure that all the member modules of the assembly are loaded.
/// </summary>
/// <param name="binaryDocument"></param>
/// <param name="assembly"></param>
private void OpenMemberModules(IBinaryDocument binaryDocument, Assembly assembly)
{
List <Module> memberModuleList = new List <Module>();
AssemblyIdentity assemblyIdentity = assembly.AssemblyIdentity;
foreach (IFileReference fileRef in assembly.PEFileToObjectModel.GetFiles())
{
if (!fileRef.HasMetadata)
{
continue;
}
IBinaryDocumentMemoryBlock /*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument, fileRef.FileName.Value);
if (binaryDocumentMemoryBlock == null)
{
// Error...
continue;
}
try
{
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata)
{
// Error...
continue;
}
if (peFileReader.IsAssembly)
{
// Error...
continue;
}
ModuleIdentity moduleIdentity = this.GetModuleIdentifier(peFileReader, assemblyIdentity);
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, assembly, this.metadataReaderHost.PointerSize);
memberModuleList.Add(peFileToObjectModel.Module);
}
catch (MetadataReaderException)
{
continue;
}
}
if (memberModuleList.Count == 0)
{
return;
}
assembly.SetMemberModules(new EnumerableArrayWrapper <Module, IModule>(memberModuleList.ToArray(), Dummy.Module));
}
// Get the immediate interfaces on this type.
public TypeInfo[] GetInterfaces()
{
List <TypeInfo> interfaces = new List <TypeInfo>();
if (HasReflectionType)
{
foreach (Type interfaceType in _reflectionType.GetInterfaces())
{
interfaces.Add(new TypeInfo(interfaceType));
}
}
else if (HasTypeRef)
{
TypeInfo defInfo = TypeRefToTypeDef(_mdToken, true);
return(defInfo.GetInterfaces());
}
else
{
System.Diagnostics.Contracts.Contract.Assert(_mdToken.Table == MDTables.Tables.TypeDef);
PEFileReader peFile = _assembly.PEFileReader;
MDTables mdScope = peFile.MetaData;
// Walk through all rows of the interface implementation table,
// looking for this _mdToken.
uint numRows = mdScope.RowsInTable(MDTables.Tables.InterfaceImpl);
for (uint i = 0; i < numRows; i++)
{
try
{
mdScope.SeekToRowOfTable(MDTables.Tables.InterfaceImpl, i);
uint typeDefRow = mdScope.ReadRowIndex(MDTables.Tables.TypeDef);
if (typeDefRow == _mdToken.Index)
{
MetadataToken interfaceToken = mdScope.ReadMetadataToken(MDTables.Encodings.TypeDefOrRef);
interfaces.Add(TypeInfoFromTypeDefOrRef(interfaceToken));
}
}
catch (GenericsNotImplementedException) // ignore interfaces such as IComparable<int> that aren't relevant to the addin model
{}
}
}
return(interfaces.ToArray());
}
/// <summary>
/// Method to open the assembly in MetadataReader. This method loads the assembly and returns the object corresponding to the
/// opened assembly. Also returns the AssemblyIdentifier corresponding to the assembly as the out parameter.
/// Only assemblies that unify to themselves can be opened i.e. if the unification policy of the compilation host says that mscorlib 1.0 unifies to mscorlib 2.0
/// then only mscorlib 2.0 can be loaded.
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an assembly.</param>
/// <param name="assemblyIdentity">Contains the assembly identifier of the binary document in case it is an assembly.</param>
/// <returns>Assembly that is loaded or Dummy.Assembly in case assembly could not be loaded.</returns>
public IAssembly OpenAssembly(IBinaryDocument binaryDocument, out AssemblyIdentity /*?*/ assemblyIdentity)
{
Contract.Requires(binaryDocument != null);
Contract.Ensures(Contract.Result <IAssembly>() != null);
assemblyIdentity = null;
lock (GlobalLock.LockingObject) {
IBinaryDocumentMemoryBlock /*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null)
{
// Error...
return(Dummy.Assembly);
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata)
{
// Error...
return(Dummy.Assembly);
}
//^ assert peFileReader.ReaderState >= ReaderState.Metadata;
if (!peFileReader.IsAssembly)
{
// Error...
return(Dummy.Assembly);
}
assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
Assembly /*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null)
{
return(lookupAssembly);
}
try {
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, assemblyIdentity, null, this.metadataReaderHost.PointerSize);
Assembly /*?*/ assembly = peFileToObjectModel.Module as Assembly;
//^ assert assembly != null;
this.LoadedModule(assembly);
CciEventSource.Log.ModuleOpened(assembly, assemblyIdentity, binaryDocument.Length);
this.OpenMemberModules(binaryDocument, assembly);
return(assembly);
} catch (MetadataReaderException) {
return(Dummy.Assembly);
}
}
}
/// <summary>
/// If the given binary document contains a CLR assembly, return the identity of the assembly. Otherwise, return null.
/// </summary>
public AssemblyIdentity /*?*/ GetAssemblyIdentifier(IBinaryDocument binaryDocument)
{
IBinaryDocumentMemoryBlock /*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null)
{
return(null);
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata)
{
return(null);
}
if (!peFileReader.IsAssembly)
{
return(null);
}
return(this.GetAssemblyIdentifier(peFileReader));
}
/// <summary>
/// Computes the AssemblyIdentifier of the PE File. This requires that peFile is an assembly.
/// </summary>
/// <param name="peFileReader"></param>
/// <returns></returns>
internal AssemblyIdentity GetAssemblyIdentifier(PEFileReader peFileReader)
//^ requires peFileReader.ReaderState >= ReaderState.Metadata && peFileReader.IsAssembly;
//^ ensures (result.Location != null && result.Location.Length != 0);
{
AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
IName assemblyName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[assemblyRow.Name]);
string cultureName = peFileReader.StringStream[assemblyRow.Culture];
Version version = new Version(assemblyRow.MajorVersion, assemblyRow.MinorVersion, assemblyRow.BuildNumber, assemblyRow.RevisionNumber);
byte[] publicKeyArray = TypeCache.EmptyByteArray;
byte[] publicKeyTokenArray = TypeCache.EmptyByteArray;
if (assemblyRow.PublicKey != 0)
{
publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
if (publicKeyArray.Length > 0)
{
publicKeyTokenArray = UnitHelper.ComputePublicKeyToken(publicKeyArray);
}
}
return(new AssemblyIdentity(assemblyName, cultureName, version, publicKeyTokenArray, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location));
}
private static Dictionary<string, FieldHandle> GetFieldDefs(PEFileReader reader, TypeHandle typeHandle)
{
var fields = new Dictionary<string, FieldHandle>();
foreach (var fieldHandle in reader.GetTypeDefinition(typeHandle).GetFields())
{
var fieldDef = reader.GetField(fieldHandle);
var name = reader.GetString(fieldDef.Name);
fields.Add(name, fieldHandle);
}
return fields;
}
internal static PEFileReader CreatePEFileReaderFromBytes(string uniqueName, byte[] bytes)
{
var binaryDocumentMemoryBlock = new ByteArrayMemoryBlock(uniqueName, bytes);
PEFileReader peFileReader = new PEFileReader(binaryDocumentMemoryBlock);
Contract.ThrowIfTrue(peFileReader.ReaderState < ReaderState.Metadata);
return peFileReader;
}
private readonly Dictionary<string, TypeFromMetadata> typeDefs; // TODO: Index by namespace + name. By MetadataTypeName?
public InitialPeGeneration(Guid moduleVersionId, PEFileReader reader)
{
this.moduleVersionId = moduleVersionId;
this.reader = reader;
this.typeDefs = GetTypeDefinitions(reader);
}
private static Dictionary<string, TypeFromMetadata> GetTypeDefinitions(PEFileReader reader)
{
var types = new Dictionary<string, TypeFromMetadata>();
foreach (var typeHandle in reader.TypeDefinitions)
{
var typeDef = reader.GetTypeDefinition(typeHandle);
var name = reader.GetString(typeDef.Name); // TODO: Index by namespace + name. By MetadataTypeName?
types.Add(name, new TypeFromMetadata(reader, typeHandle));
}
return types;
}
private static Dictionary<string, EventHandle> GetEventDefs(PEFileReader reader, TypeHandle typeHandle)
{
var events = new Dictionary<string, EventHandle>();
foreach (var eventHandle in reader.GetTypeDefinition(typeHandle).GetEvents())
{
var eventDef = reader.GetEvent(eventHandle);
var name = reader.GetString(eventDef.Name);
events.Add(name, eventHandle);
}
return events;
}
// TODO: Index by signature.
private static Dictionary<string, MethodHandle> GetMethodDefs(PEFileReader reader, TypeHandle typeHandle)
{
var methods = new Dictionary<string, MethodHandle>();
foreach (var methodHandle in reader.GetTypeDefinition(typeHandle).GetMethods())
{
var methodDef = reader.GetMethod(methodHandle);
var name = reader.GetString(methodDef.Name);
methods.Add(name, methodHandle);
}
return methods;
}
private static Dictionary<string, PropertyHandle> GetPropertyDefs(PEFileReader reader, TypeHandle typeHandle)
{
var properties = new Dictionary<string, PropertyHandle>();
foreach (var propertyHandle in reader.GetTypeDefinition(typeHandle).GetProperties())
{
var propertyDef = reader.GetProperty(propertyHandle);
var name = reader.GetString(propertyDef.Name);
properties.Add(name, propertyHandle);
}
return properties;
}
public TypeFromMetadata(PEFileReader reader, TypeHandle typeHandle)
{
this.reader = reader;
this.typeHandle = typeHandle;
}
