internal static StringTable ReadStringTable(this PeReader reader) { var orgPos = reader.GetPosition(); var table = new StringTable(); reader.ReadFileInfo(table, 8); table.LanguageCode = ulong.Parse(table.Key, NumberStyles.HexNumber); // Read children (Strings, as sz key/value pairs) var children = new Dictionary <string, string>(); while (reader.GetPosition() < orgPos + table.Length) { var child = reader.ReadStringTableString(); children.Add(child.key, child.value); } table.Values = children.ToImmutableDictionary(); // Undocumented reader.ReadPadding(); return(table); }
public HostEnvironment(INameTable table, IEnumerable <String> assemblyPaths, IEnumerable <String> referencedAssemblies) : base(table, new InternFactory(), 4, assemblyPaths, true) { _peReader = new PeReader(this); _assemblyPaths = assemblyPaths; _referencedAssemblies = referencedAssemblies; }
public void Read(BinaryReader reader, bool isRoot, uint parentName) { ResourceDirectoryInfo = PeReader.FromBinaryReader <ImageResourceDirectory>(reader); List <ImageResourceDirectoryEntry> dirs = new List <ImageResourceDirectoryEntry>(); List <ImageResourceDataEntry> entrys = new List <ImageResourceDataEntry>(); for (int i = 0; i <= ResourceDirectoryInfo.NumberOfNamedEntries - 1; i++) { entrys.Add(PeReader.FromBinaryReader <ImageResourceDataEntry>(reader)); } for (int i = 0; i <= ResourceDirectoryInfo.NumberOfIdEntries - 1; i++) { if (isRoot) { ImageResourceDirectoryEntry dirEntry = PeReader.FromBinaryReader <ImageResourceDirectoryEntry>(reader); if (dirEntry.Name == Convert.ToUInt32(Win32ResourceType.RT_ICON) || dirEntry.Name == Convert.ToUInt32(Win32ResourceType.RT_GROUP_ICON)) { dirs.Add(dirEntry); } } else { dirs.Add(PeReader.FromBinaryReader <ImageResourceDirectoryEntry>(reader)); } } foreach (ImageResourceDataEntry e in entrys) { bool isDir = false; uint entryLoc = e.GetOffset(ref isDir); uint entrySize = e.Size; ResourceEntry entryInfo = new ResourceEntry(e, m_Stream, parentName); Entries.Add(entryInfo); } foreach (ImageResourceDirectoryEntry d in dirs) { bool isDir = false; uint dirLoc = d.GetOffset(ref isDir); ResourceDirectory dirInfo = new ResourceDirectory(d, m_Stream, m_BaseAddress); if (isDir) { Directorys.Add(dirInfo); dirInfo.Seek(); dirInfo.Read(reader, false, d.Name != 0 ? d.Name : parentName); } else { dirInfo.Seek(); ImageResourceDataEntry entry = PeReader.FromBinaryReader <ImageResourceDataEntry>(reader); uint entryLoc = entry.GetOffset(ref isDir); uint entrySize = entry.Size; ResourceEntry entryInfo = new ResourceEntry(entry, m_Stream, parentName); entryInfo.Seek(); Entries.Add(entryInfo); } } }
public PeHeader(Stream stream) { Reader = new PeReader(stream); Reader.SetPosition(0); DosHeader = Reader.ReadDosHeader(); if (!DosHeader.IsValid) { return; } Reader.SetPosition(DosHeader.HeaderAddress); CoffHeader = Reader.ReadCoffFileHeader(); OptionalHeader = Reader.ReadOptionalHeader(); HeaderFormat = OptionalHeader?.Magic switch { CoffHeader.Magic.Pe32 => Format.PE32, CoffHeader.Magic.Pe32Plus => Format.PE32_PLUS, _ => Format.UNKNOWN }; Reader.SetPosition(CoffHeader.Location + CoffHeader.Size + CoffHeader.SizeOfOptionalHeader); Sections = Reader.ReadSectionTable(CoffHeader.NumberOfSections); }
private static void ReadMethodLocations(Dictionary <string, string> methodLocations, string pdbFixturePath, string peFixturePath) { var host = new PeReader.DefaultHost(); var pdbFileStream = File.OpenRead(pdbFixturePath); var peReader = new PeReader(host); var pdbReader = new PdbReader(pdbFileStream, host); var assembly = peReader.OpenAssembly( BinaryDocument.GetBinaryDocumentForFile(peFixturePath, host) ); foreach (var type in assembly.GetAllTypes()) { foreach (var member in type.Members) { foreach (var sourceLocation in pdbReader.GetPrimarySourceLocationsFor(member.Locations)) { var memberName = $"{member}"; if (!methodLocations.ContainsKey(memberName)) { methodLocations.Add( memberName, $"{sourceLocation.SourceDocument.Name}:{sourceLocation.StartLine}" ); } } } } }
internal static VarFileInfo ReadVarFileInfo(this PeReader reader) { var orgPos = reader.GetPosition(); var info = new VarFileInfo(); if (!reader.ReadFileInfo(info, "VarFileInfo")) { return(null); } var var = new Var(); if (!reader.ReadFileInfo(var, "Translation")) { return(null); } info.Value = var; var codes = new List <ulong>(); while (reader.GetPosition() < var.Position + var.Length) { ulong code = reader.ReadUInt16(); code = reader.ReadUInt16() | (code << 16); codes.Add(code); } info.Value.LanguageCodes = codes.ToImmutableArray(); return(info); }
public override void Read(PeReader rdr) { rdr.BaseStream.Position = 0; m = rdr.ReadUInt16(); hc = rdr.ReadBytes(0x3a); o = rdr.ReadUInt32(); ds = rdr.ReadBytes((int)(o - 0x40)); }
public void Read(PeReader rdr) { rdr.SetPosition(hdr.DataDirectoriesOffset); for (int i = 0; i < 16; i++) { Items.Add(new DataDirectoryEntry((DataDirectoryType)i, rdr.ReadUInt32(), rdr.ReadUInt32())); } }
/// <summary> /// Allocates a simple host environment using default settings inherited from MetadataReaderHost and that /// uses PeReader as its metadata reader. /// </summary> /// <param name="nameTable"> /// A collection of IName instances that represent names that are commonly used during compilation. /// This is a provided as a parameter to the host environment in order to allow more than one host /// environment to co-exist while agreeing on how to map strings to IName instances. /// </param> public PortableHost(INameTable nameTable) : base(nameTable, new InternFactory(), 0, null, false) { Contract.Requires(nameTable != null); Contract.Ensures(base.NameTable == nameTable); this.peReader = new PeReader(this); }
public void Dispose() { if (Pdb is not null) { Pdb.Dispose(); } PeReader.Dispose(); stream.Dispose(); }
internal MetadataErrorContainer( PeReader metadataReader, IBinaryDocument binaryDocument ) { this.MetadataReader = metadataReader; this.BinaryDocument = binaryDocument; this.ErrorList = new MultiHashtable <MetadataReaderErrorMessage>(); }
internal static (string key, string value) ReadStringTableString(this PeReader reader) { var entry = new StringTable.String(); // Undocumented - StringTable entries are 32-bit aligned reader.ReadPadding(); reader.ReadFileInfo(entry); return(entry.Key, reader.ReadStringZ()); }
internal static void ReadFileInfo(this PeReader reader, FileInfo info, int keyLen) { info.Position = reader.GetPosition(); info.Length = reader.ReadUInt16(); info.ValueLength = reader.ReadUInt16(); info.Type = reader.ReadUInt16(); info.Key = reader.ReadStringZ(keyLen); info.Padding1 = reader.ReadPadding(); }
public void Read(PeReader rdr) { rdr.SetPosition(SectionHeadersOffset); for (int i = 0; i < file.PEHeader.NumberOfSections; i++) { Section sect = new Section(this); sect.Read(rdr); this.Add(sect); } }
public void Read(PeReader rdr) { rdr.SetPosition(StandardFieldsOffset); t = (ExecutableType)rdr.ReadUInt16(); sf = new StandardFieldsHeader(file, this); sf.Read(rdr); wsf = new WindowsSpecificFieldsHeader(file, this); wsf.Read(rdr); dd = new DataDirectoriesHeader(this); dd.Read(rdr); }
internal HostEnvironment() : base(new NameTable(), new InternFactory(), 0, null, false) { this.peReader = new PeReader(this); string /*?*/ loc = typeof(object).Assembly.Location; if (loc == null) { loc = string.Empty; } }
public override void Read(PeReader rdr) { rdr.SetPosition(PEHeaderOffset); m = (MachineType)rdr.ReadUInt16(); noSect = rdr.ReadUInt16(); stamp = rdr.ReadStamp(); ptrSym = rdr.ReadUInt32(); noSym = rdr.ReadUInt32(); sOh = rdr.ReadUInt16(); c = (PeCharacteristics)rdr.ReadUInt16(); }
public override void Read(PeReader rdr) { rdr.SetPosition(hdr.WindowsSpecificFieldsOffset); if (hdr.Type == ExecutableType.PE32Plus) { imgBas = rdr.ReadUInt64(); sectA = rdr.ReadUInt32(); fA = rdr.ReadUInt32(); maOs = rdr.ReadUInt16(); miOs = rdr.ReadUInt16(); maImg = rdr.ReadUInt16(); miImg = rdr.ReadUInt16(); maSs = rdr.ReadUInt16(); miSs = rdr.ReadUInt16(); winVer = rdr.ReadUInt32(); sImg = rdr.ReadUInt32(); sHdr = rdr.ReadUInt32(); cs = rdr.ReadUInt32(); Ss = (WindowsSubsystem)rdr.ReadUInt16(); dll = (DLLCharacteristics)rdr.ReadUInt16(); sSr = rdr.ReadUInt64(); sSc = rdr.ReadUInt64(); sHr = rdr.ReadUInt64(); sHc = rdr.ReadUInt64(); ldrF = rdr.ReadUInt32(); noDd = rdr.ReadUInt32(); } else { imgBas = rdr.ReadUInt32(); sectA = rdr.ReadUInt32(); fA = rdr.ReadUInt32(); maOs = rdr.ReadUInt16(); miOs = rdr.ReadUInt16(); maImg = rdr.ReadUInt16(); miImg = rdr.ReadUInt16(); maSs = rdr.ReadUInt16(); miSs = rdr.ReadUInt16(); winVer = rdr.ReadUInt32(); sImg = rdr.ReadUInt32(); sHdr = rdr.ReadUInt32(); cs = rdr.ReadUInt32(); Ss = (WindowsSubsystem)rdr.ReadUInt16(); dll = (DLLCharacteristics)rdr.ReadUInt16(); sSr = rdr.ReadUInt32(); sSc = rdr.ReadUInt32(); sHr = rdr.ReadUInt32(); sHc = rdr.ReadUInt32(); ldrF = rdr.ReadUInt32(); noDd = rdr.ReadUInt32(); } }
internal HostEnvironment() : base(new NameTable(), new InternFactory(), 0, null, true) { this.peReader = new PeReader(this); string /*?*/ loc = typeof(object).Assembly.Location; if (loc == null) { loc = string.Empty; } var mscoreAssembly = this.peReader.OpenAssembly(BinaryDocument.GetBinaryDocumentForFile(loc, this)); this.mscorlibIdentity = mscoreAssembly.AssemblyIdentity; this.RegisterAsLatest(mscoreAssembly); }
public void Load(PeReader rdr, uint adr) { rdr.SetPosition(adr); uint s = Location.Size; while (rdr.BaseStream.Position - adr < s) { CertificateEntry e = new CertificateEntry(); uint len = rdr.ReadUInt32(); e.Revision = (CertificateRevision)rdr.ReadUInt16(); e.CertificateType = (CertificateType)rdr.ReadUInt16(); e.CertificateData = rdr.ReadBytes((int)len - 8); items.Add(e); } }
internal static bool ReadFileInfo(this PeReader reader, FileInfo info, string expectedKey) { var orgPos = reader.GetPosition(); reader.ReadFileInfo(info, expectedKey.Length); var result = info.Key.Equals(expectedKey, StringComparison.Ordinal); if (!result) { info.Position = 0; reader.SetPosition(orgPos); } return(result); }
public override void Read(PeReader rdr) { rdr.SetPosition(hdr.StandardFieldsOffset); rdr.ReadUInt16(); maL = rdr.ReadByte(); miL = rdr.ReadByte(); sC = rdr.ReadUInt32(); sI = rdr.ReadUInt32(); sU = rdr.ReadUInt32(); entry = rdr.ReadUInt32(); bc = rdr.ReadUInt32(); if (Magic != ExecutableType.PE32Plus) { bd = rdr.ReadUInt32(); } }
internal void Read(PeReader rdr) { n = new string(rdr.ReadChars(8)).Trim('\0'); vSize = rdr.ReadUInt32(); vPtr = rdr.ReadUInt32(); uint rSize = rdr.ReadUInt32(); uint rPtr = rdr.ReadUInt32(); relocPtr = rdr.ReadUInt32(); lnPtr = rdr.ReadUInt32(); relocNo = rdr.ReadUInt16(); lnNo = rdr.ReadUInt16(); c = (SectionFlags)rdr.ReadUInt32(); rdr.SaveLocation(); rdr.SetPosition(rPtr); dat = rdr.ReadBytes((int)rSize); rdr.LoadLocation(); }
internal static VsFixedFileInfo ReadVsFixedFileInfo(this PeReader reader) { return(new() { Signature = reader.ReadUInt32(), StrucVersion = reader.ReadUInt32(), FileVersionMs = reader.ReadUInt32(), FileVersionLs = reader.ReadUInt32(), ProductVersionMs = reader.ReadUInt32(), ProductVersionLs = reader.ReadUInt32(), FileFlagsMask = reader.ReadUInt32(), FileFlags = reader.ReadUInt32(), FileOs = reader.ReadUInt32(), FileType = reader.ReadUInt32(), FileSubtype = reader.ReadUInt32(), FileDateMs = reader.ReadUInt32(), FileDateLs = reader.ReadUInt32() }); }
/// <summary> /// Read icon group from PE file header /// </summary> /// <param name="reader">reader that holds the PE image</param> /// <param name="iconImageData">all the ResourceEntry objects that hold the image data for the icon</param> internal bool Read(BinaryReader reader, List <ResourceEntry> iconImageData) { try { Group = PeReader.FromBinaryReader <GRPICONDIR>(reader); if (Group.idReserved != 0) { return(false); } if (Group.idType != 1) { return(false); } for (int i = 0; i <= Group.idCount - 1; i++) { GRPICONDIRENTRY entry = PeReader.FromBinaryReader <GRPICONDIRENTRY>(reader); IconImage image = new IconImage(); image.Entry = entry; foreach (ResourceEntry bmp in iconImageData) { if (bmp.Name == entry.ID) { image.Resource = bmp; Entries.Add(image); break; } } } return(true); } catch { return(false); } }
internal static StringFileInfo ReadStringFileInfo(this PeReader reader) { var orgPos = reader.GetPosition(); var info = new StringFileInfo(); if (!reader.ReadFileInfo(info, "StringFileInfo")) { return(null); } // Read all children (StringTables) var children = new List <StringTable>(); while (reader.GetPosition() < orgPos + info.Length) { children.Add(reader.ReadStringTable()); } info.Children = children.ToImmutableList(); return(info); }
internal HostEnvironment() : base(new NameTable(), 4) { this.peReader = new PeReader(this); string/*?*/ loc = typeof(object).Assembly.Location; if (loc == null) { loc = string.Empty; } this.mscorlibIdentity = new AssemblyIdentity( this.NameTable.GetNameFor("mscorlib"), string.Empty, new Version(2, 0, 0, 0), new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }, loc ); this.RegisterAsLatest(this.peReader.OpenAssembly(BinaryDocument.GetBinaryDocumentForFile(this.mscorlibIdentity.Location, this))); }
public TestHostEnvironment() { reader = new PeReader(this); }
/// <summary> /// Checks the location against all previously loaded locations. If a unit /// had been loaded from it before and if the last write time is newer, then /// the previously loaded unit, all units dependent on it, and all reference /// assemblies for it are deleted from the cache and a new PeReader is created /// for reading in all future units. /// </summary> /// <returns> /// true iff (unit was unloaded or this is the first time this location has been seen) /// the latter case should be for the first time the unit has been loaded. /// </returns> private bool UnloadPreviouslyLoadedUnitIfLocationIsNewer(string location) { location = Path.GetFullPath(location); var timeOfLastModification = File.GetLastWriteTime(location); DateTime previousTime; if (!this.location2LastModificationTime.TryGetValue(location, out previousTime)) { this.location2LastModificationTime.Add(location, timeOfLastModification); return true; } if (!(previousTime.CompareTo(timeOfLastModification) < 0)) return false; // file has been modified. Need to throw away PeReader because it caches based on identity and // won't actually read in and construct an object model from the file. Even though at this // point we don't even know what assembly is at this location. Maybe it isn't even an updated // version, but instead some completely different assembly? this.peReader = new PeReader(this); IUnit unit; if (this.location2Unit.TryGetValue(location, out unit)) { CleanupStaleUnit(unit); } return true; }
// Caller should lock peFileToObjectModel internal CoreTypes(PEFileToObjectModel peFileToObjectModel) { INameTable nameTable = peFileToObjectModel.NameTable; PEFileReader peFileReader = peFileToObjectModel.PEFileReader; PeReader peReader = peFileToObjectModel.ModuleReader; Module module = peFileToObjectModel.Module; AssemblyIdentity /*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity; int systemName = nameTable.System.UniqueKey; int voidName = nameTable.Void.UniqueKey; int booleanName = nameTable.Boolean.UniqueKey; int charName = nameTable.Char.UniqueKey; int byteName = nameTable.Byte.UniqueKey; int sByteName = nameTable.SByte.UniqueKey; int int16Name = nameTable.Int16.UniqueKey; int uint16Name = nameTable.UInt16.UniqueKey; int int32Name = nameTable.Int32.UniqueKey; int uint32Name = nameTable.UInt32.UniqueKey; int int64Name = nameTable.Int64.UniqueKey; int uint64Name = nameTable.UInt64.UniqueKey; int stringName = nameTable.String.UniqueKey; int intPtrName = nameTable.IntPtr.UniqueKey; int uintPtrName = nameTable.UIntPtr.UniqueKey; int objectName = nameTable.Object.UniqueKey; int singleName = nameTable.Single.UniqueKey; int doubleName = nameTable.Double.UniqueKey; int decimalName = nameTable.Decimal.UniqueKey; int typedReference = nameTable.TypedReference.UniqueKey; int enumName = nameTable.Enum.UniqueKey; int valueTypeName = nameTable.ValueType.UniqueKey; int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey; int typeName = nameTable.Type.UniqueKey; int arrayName = nameTable.Array.UniqueKey; int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey; if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity)) { peReader.RegisterCoreAssembly(module as Assembly); uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows; for (uint i = 1; i <= numberOfTypeDefs; ++i) { TypeDefRow typeDefRow = peFileReader.TypeDefTable[i]; if (!typeDefRow.IsNested) { int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey; if (namespaceName == systemName) { int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey; if (typeDefName == voidName) { this.SystemVoid = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Void); } else if (typeDefName == booleanName) { this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Boolean); } else if (typeDefName == charName) { this.SystemChar = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Char); } else if (typeDefName == byteName) { this.SystemByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Byte); } else if (typeDefName == sByteName) { this.SystemSByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.SByte); } else if (typeDefName == int16Name) { this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int16); } else if (typeDefName == uint16Name) { this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt16); } else if (typeDefName == int32Name) { this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int32); } else if (typeDefName == uint32Name) { this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt32); } else if (typeDefName == int64Name) { this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int64); } else if (typeDefName == uint64Name) { this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt64); } else if (typeDefName == stringName) { this.SystemString = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.String); } else if (typeDefName == intPtrName) { this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.IntPtr); } else if (typeDefName == uintPtrName) { this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr); } else if (typeDefName == objectName) { this.SystemObject = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Object); } else if (typeDefName == singleName) { this.SystemSingle = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Single); } else if (typeDefName == doubleName) { this.SystemDouble = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Double); } else if (typeDefName == decimalName) { this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typedReference) { this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.TypedReference); } else if (typeDefName == enumName) { this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == valueTypeName) { this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == multicastDelegateName) { this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typeName) { this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == arrayName) { this.SystemArray = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == paramArrayAttributeName) { this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } } } } } else { uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows; AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity); if (coreAssemblyRef == null) { // Error... coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 0, peReader.metadataReaderHost.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable); } uint coreAssemblyRefToken = coreAssemblyRef.TokenValue; for (uint i = 1; i <= numberOfTypeRefs; ++i) { TypeRefRow typeRefRow = peFileReader.TypeRefTable[i]; if (typeRefRow.ResolutionScope != coreAssemblyRefToken) { continue; } int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey; if (namespaceName == systemName) { int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey; if (typeDefName == voidName) { this.SystemVoid = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Void); } else if (typeDefName == booleanName) { this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Boolean); } else if (typeDefName == charName) { this.SystemChar = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Char); } else if (typeDefName == byteName) { this.SystemByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Byte); } else if (typeDefName == sByteName) { this.SystemSByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.SByte); } else if (typeDefName == int16Name) { this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int16); } else if (typeDefName == uint16Name) { this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt16); } else if (typeDefName == int32Name) { this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int32); } else if (typeDefName == uint32Name) { this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt32); } else if (typeDefName == int64Name) { this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int64); } else if (typeDefName == uint64Name) { this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt64); } else if (typeDefName == stringName) { this.SystemString = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.String); } else if (typeDefName == intPtrName) { this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.IntPtr); } else if (typeDefName == uintPtrName) { this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr); } else if (typeDefName == objectName) { this.SystemObject = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Object); } else if (typeDefName == singleName) { this.SystemSingle = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Single); } else if (typeDefName == doubleName) { this.SystemDouble = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Double); } else if (typeDefName == decimalName) { this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typedReference) { this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.TypedReference); } else if (typeDefName == enumName) { this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == valueTypeName) { this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == multicastDelegateName) { this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typeName) { this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == arrayName) { this.SystemArray = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == paramArrayAttributeName) { this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive); } } } NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System); if (this.SystemVoid == null) { this.SystemVoid = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Void, ModuleSignatureTypeCode.Void); } if (this.SystemBoolean == null) { this.SystemBoolean = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Boolean, ModuleSignatureTypeCode.Boolean); } if (this.SystemChar == null) { this.SystemChar = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Char, ModuleSignatureTypeCode.Char); } if (this.SystemByte == null) { this.SystemByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Byte, ModuleSignatureTypeCode.Byte); } if (this.SystemSByte == null) { this.SystemSByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.SByte, ModuleSignatureTypeCode.SByte); } if (this.SystemInt16 == null) { this.SystemInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int16, ModuleSignatureTypeCode.Int16); } if (this.SystemUInt16 == null) { this.SystemUInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt16, ModuleSignatureTypeCode.UInt16); } if (this.SystemInt32 == null) { this.SystemInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int32, ModuleSignatureTypeCode.Int32); } if (this.SystemUInt32 == null) { this.SystemUInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt32, ModuleSignatureTypeCode.UInt32); } if (this.SystemInt64 == null) { this.SystemInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int64, ModuleSignatureTypeCode.Int64); } if (this.SystemUInt64 == null) { this.SystemUInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt64, ModuleSignatureTypeCode.UInt64); } if (this.SystemString == null) { this.SystemString = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.String, ModuleSignatureTypeCode.String); } if (this.SystemIntPtr == null) { this.SystemIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.IntPtr, ModuleSignatureTypeCode.IntPtr); } if (this.SystemUIntPtr == null) { this.SystemUIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UIntPtr, ModuleSignatureTypeCode.UIntPtr); } if (this.SystemObject == null) { this.SystemObject = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Object, ModuleSignatureTypeCode.Object); } if (this.SystemSingle == null) { this.SystemSingle = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Single, ModuleSignatureTypeCode.Single); } if (this.SystemDouble == null) { this.SystemDouble = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Double, ModuleSignatureTypeCode.Double); } if (this.SystemDecimal == null) { this.SystemDecimal = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Decimal, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemTypedReference == null) { this.SystemTypedReference = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.TypedReference, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemEnum == null) { this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Enum, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemValueType == null) { this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.ValueType, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemMulticastDelegate == null) { this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemType == null) { this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Type, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemArray == null) { this.SystemArray = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Array, ModuleSignatureTypeCode.NotModulePrimitive); } if (this.SystemParamArrayAttribute == null) { this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, ModuleSignatureTypeCode.NotModulePrimitive); } } }
internal SimpleHostEnvironment(INameTable nameTable, IInternFactory internFactory, bool preserveILLocations) : base(nameTable, internFactory, 0, null, false) { this.preserveILLocations = preserveILLocations; this.peReader = new PeReader(this); }
/*^ #pragma warning disable 2666, 2669, 2677, 2674 ^*/ internal PEFileToObjectModel( PeReader peReader, PEFileReader peFileReader, ModuleIdentity moduleIdentity, Assembly/*?*/ containingAssembly, byte pointerSize ) //^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null; //^ requires peFileReader.IsAssembly ==> containingAssembly == null; //^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0); { this.pointerSize = pointerSize; this.document = new MetadataObjectDocument(this); this.ModuleReader = peReader; this.PEFileReader = peFileReader; this.NameTable = peReader.metadataReaderHost.NameTable; this.InternFactory = peReader.metadataReaderHost.InternFactory; this.StringIndexToNameTable = new Hashtable<IName>(); this.StringIndexToUnmangledNameTable = new Hashtable<IName>(); this.typeCache = new TypeCache(this); uint moduleNameOffset = peFileReader.ModuleTable.GetName(1); IName moduleName = this.GetNameFromOffset(moduleNameOffset); AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity; if (peFileReader.IsAssembly) { //^ assert assemblyIdentity != null; AssemblyRow assemblyRow = peFileReader.AssemblyTable[1]; IName assemblyName = this.GetNameFromOffset(assemblyRow.Name); byte[] publicKeyArray = TypeCache.EmptyByteArray; if (assemblyRow.PublicKey != 0) { publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey]; } uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity); Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray); this.ContainingAssembly = assem; this.Module = assem; } else { uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity); this.ContainingAssembly = containingAssembly; this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity); } this.LoadAssemblyReferences(); this.LoadModuleReferences(); this.RootModuleNamespace = new RootNamespace(this); this.NamespaceINameHashtable = new Hashtable<Namespace>(); this.LoadNamespaces(); this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>(); this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows); this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows); this.PreLoadTypeDefTableLookup(); this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1]; this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1]; this.RedirectedTypeDefArray = new INamedTypeReference/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1]; this.ModuleTypeDefLoadState[0] = LoadState.Loaded; this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1]; this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1]; this.ExportedTypeLoadState[0] = LoadState.Loaded; this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1]; if (peFileReader.MethodSpecTable.NumberOfRows > 0) { this.ModuleMethodSpecHashtable = new DoubleHashtable<IGenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1); } this.ModuleTypeRefReferenceArray = new INamedTypeReference[peFileReader.TypeRefTable.NumberOfRows + 1]; this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1]; this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded; if (peFileReader.TypeSpecTable.NumberOfRows > 0) { this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1); } this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1]; this.ModuleMethodArray = new IMethodDefinition[peFileReader.MethodTable.NumberOfRows + 1]; this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1]; this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1]; this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1]; this.UnspecializedMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1]; this.SpecializedFieldHashtable = new DoubleHashtable<ISpecializedFieldReference>(); this.SpecializedMethodHashtable = new DoubleHashtable<ISpecializedMethodReference>(); this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1]; this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1]; this._Module_ = this.Create_Module_Type(); }
internal MetadataErrorContainer( PeReader metadataReader, IBinaryDocument binaryDocument ) { this.MetadataReader = metadataReader; this.BinaryDocument = binaryDocument; this.ErrorList = new MultiHashtable<MetadataReaderErrorMessage>(); }
internal HostEnvironment() : base(new NameTable(), new InternFactory(), 0, null, true) { this.peReader = new PeReader(this); string/*?*/ loc = typeof(object).Assembly.Location; if (loc == null) loc = ""; System.Reflection.AssemblyName coreAssemblyName = new System.Reflection.AssemblyName(typeof(object).Assembly.FullName); this.coreAssemblySymbolicIdentity = new AssemblyIdentity(this.NameTable.GetNameFor(coreAssemblyName.Name), "", coreAssemblyName.Version, coreAssemblyName.GetPublicKeyToken(), loc); this.RegisterAsLatest(this.peReader.OpenAssembly(BinaryDocument.GetBinaryDocumentForFile(loc, this))); loc = typeof(Microsoft.SmallBasic.Library.ConsoleTextColor).Assembly.Location; if (loc == null) loc = ""; //System.Reflection.AssemblyName runtimeName = new System.Reflection.AssemblyName(typeof(Microsoft.SmallBasic.Library.ConsoleTextColor).Assembly.FullName); //this.smallBasicRuntimeAssemblyIdentity = // new AssemblyIdentity(this.NameTable.GetNameFor(runtimeName.Name), "", runtimeName.Version, runtimeName.GetPublicKeyToken(), loc); this.RegisterAsLatest(this.peReader.OpenAssembly(BinaryDocument.GetBinaryDocumentForFile(loc, this))); }
public void Cleanup() { _reader = null; }
/*^ #pragma warning disable 2674, 2666 ^*/ internal PEFileReader( PeReader moduleReadWriteFactory, IBinaryDocumentMemoryBlock binaryDocumentMemoryBlock ) { this.ErrorContainer = new MetadataErrorContainer(moduleReadWriteFactory, binaryDocumentMemoryBlock.BinaryDocument); this.ReaderState = ReaderState.Initialized; this.BinaryDocumentMemoryBlock = binaryDocumentMemoryBlock; if (!this.ReadPEFileLevelData()) return; if (!this.ReadCORModuleLevelData()) return; if (!this.ReadMetadataLevelData()) return; // TODO: Add phase for Metadata validation of offsets type row ids etc... }
/// <summary> /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework. /// </summary> /// <param name="nameTable"> /// A collection of IName instances that represent names that are commonly used during compilation. /// This is a provided as a parameter to the host environment in order to allow more than one host /// environment to co-exist while agreeing on how to map strings to IName instances. /// </param> /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers. /// </param> /// <param name="loadPDBs">Whether PDB files should be loaded by the extractors attached to each unit.</param> public CodeContractAwareHostEnvironment(INameTable nameTable, byte pointerSize, bool loadPDBs) : base(nameTable, new InternFactory(), pointerSize, null, false) //^ requires pointerSize == 0 || pointerSize == 4 || pointerSize == 8; { this.peReader = new PeReader(this); this.AllowExtractorsToUsePdbs = loadPDBs; }
//^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null; //^ requires peFileReader.IsAssembly ==> containingAssembly == null; //^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0); /*^ #pragma warning disable 2666, 2669, 2677, 2674 ^*/ internal PEFileToObjectModel( PeReader peReader, PEFileReader peFileReader, ModuleIdentity moduleIdentity, Assembly/*?*/ containingAssembly, byte pointerSize ) { this.pointerSize = pointerSize; this.ModuleReader = peReader; this.PEFileReader = peFileReader; this.NameTable = peReader.metadataReaderHost.NameTable; this.StringIndexToNameTable = new Hashtable<IName>(); this.StringIndexToUnmangledNameTable = new Hashtable<IName>(); this.typeCache = new TypeCache(this); uint moduleNameOffset = peFileReader.ModuleTable.GetName(1); IName moduleName = this.GetNameFromOffset(moduleNameOffset); AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity; if (peFileReader.IsAssembly) { //^ assert assemblyIdentity != null; AssemblyRow assemblyRow = peFileReader.AssemblyTable[1]; IName assemblyName = this.GetNameFromOffset(assemblyRow.Name); byte[] publicKeyArray = TypeCache.EmptyByteArray; if (assemblyRow.PublicKey != 0) { publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey]; } uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity); Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray); this.ContainingAssembly = assem; this.Module = assem; } else { uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity); this.ContainingAssembly = containingAssembly; this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity); } this.LoadAssemblyReferences(); this.LoadModuleReferences(); this.RootModuleNamespace = new RootNamespace(this); this.NamespaceINameHashtable = new Hashtable<Namespace>(); this.LoadNamespaces(); this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>(); this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows); this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows); this.PreLoadTypeDefTableLookup(); this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1]; this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1]; this.ModuleTypeDefLoadState[0] = LoadState.Loaded; this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1]; this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1]; this.ExportedTypeLoadState[0] = LoadState.Loaded; this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1]; if (peFileReader.MethodSpecTable.NumberOfRows > 0) { this.ModuleMethodSpecHashtable = new DoubleHashtable<GenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1); } this.ModuleTypeRefReferenceArray = new TypeRefReference[peFileReader.TypeRefTable.NumberOfRows + 1]; this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1]; this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded; if (peFileReader.TypeSpecTable.NumberOfRows > 0) { this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1); } this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1]; this.ModuleMethodArray = new MethodDefinition[peFileReader.MethodTable.NumberOfRows + 1]; this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1]; this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1]; this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1]; this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1]; this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1]; uint moduleClassTypeDefToken = this.NamespaceTypeTokenTable.Find((uint)this.NameTable.EmptyName.UniqueKey, (uint)peReader._Module_.UniqueKey); _Module_Type/*?*/ _module_ = null; if (moduleClassTypeDefToken != 0 && ((TokenTypeIds.TokenTypeMask & moduleClassTypeDefToken) == TokenTypeIds.TypeDef)) { _module_ = this.Create_Module_Type(moduleClassTypeDefToken & TokenTypeIds.RIDMask); } if (_module_ == null) { // Error throw new MetadataReaderException("<Module> Type not present"); } this._Module_ = _module_; //^ NonNullType.AssertInitialized(this.ModuleGenericParamArray); //^ NonNullType.AssertInitialized(this.ModuleTypeRefReferenceArray); //^ NonNullType.AssertInitialized(this.ModuleFieldArray); //^ NonNullType.AssertInitialized(this.ModuleMethodArray); //^ NonNullType.AssertInitialized(this.ModuleEventArray); //^ NonNullType.AssertInitialized(this.ModulePropertyArray); }
/// <summary> /// Same as LoadUnitFrom(location), but if exactLocation is true, will make sure we didn't unify /// to another assembly. Guarantees that the unit's location loaded is from the exact location given. /// </summary> /// <param name="location">Path to unit to load</param> /// <param name="exactLocation">specifies if we must load from that path</param> /// <returns>The loaded unit or dummy</returns> public virtual IUnit LoadUnitFrom(string location, bool exactLocation) { Contract.Requires(location != null); Contract.Ensures(Contract.Result<IUnit>() != null); Contract.Ensures(!exactLocation || Contract.Result<IUnit>() is Dummy || Contract.Result<IUnit>().Location == location); if (location.StartsWith("file://")) { // then it is a URL try { Uri u = new Uri(location, UriKind.Absolute); // Let the Uri class figure out how to go from URL to local file path location = u.LocalPath; } catch (UriFormatException) { return Dummy.Unit; } } string pathFromTable; var assemblyName = Path.GetFileNameWithoutExtension(location); if (this.assemblyNameToPath.TryGetValue(assemblyName, out pathFromTable)) { location = pathFromTable; } var unloadedOrFirstTime = UnloadPreviouslyLoadedUnitIfLocationIsNewer(location); IUnit result = this.peReader.OpenModule(BinaryDocument.GetBinaryDocumentForFile(Path.GetFullPath(location), this)); if (exactLocation && result.Location != location) { // we got tricked this.peReader = new PeReader(this); this.CleanupStaleUnit(result); // try again result = this.peReader.OpenModule(BinaryDocument.GetBinaryDocumentForFile(Path.GetFullPath(location), this)); unloadedOrFirstTime = true; } this.RegisterAsLatest(result); if (unloadedOrFirstTime) { foreach (var d in result.UnitReferences) { var key = d.UnitIdentity; if (!this.unit2DependentUnits.ContainsKey(key)) { this.unit2DependentUnits[key] = new List<IUnitReference>(); } this.unit2DependentUnits[key].Add(result); } this.unit2ContractExtractor[result.UnitIdentity] = null; // a marker to communicate with GetContractExtractor this.location2Unit[result.Location] = result; } return result; }
public HostEnvironment(INameTable nameTable, IInternFactory internFactory) : base(nameTable, internFactory, 0, null, false) { _reader = new PeReader(this); _unresolvedIdentities = new HashSet <UnresolvedReference <IUnit, AssemblyIdentity> >(); }
/// <summary> /// Allocates an object that can be used as an IMetadataHost which automatically loads reference assemblies and attaches /// a (lazy) contract provider to each unit it loads. /// </summary> /// <param name="searchPaths"> /// Initial value for the set of search paths to use. /// </param> /// <param name="searchInGAC"> /// Whether the GAC (Global Assembly Cache) should be searched when resolving references. /// </param> /// <param name="loadPDBs">Whether PDB files should be loaded by the extractors attached to each unit.</param> public CodeContractAwareHostEnvironment(IEnumerable<string> searchPaths, bool searchInGAC, bool loadPDBs) : base(new NameTable(), new InternFactory(), 0, searchPaths, searchInGAC) { this.peReader = new PeReader(this); this.AllowExtractorsToUsePdbs = loadPDBs; }
internal HostEnvironment() : base(new NameTable(), new InternFactory(), 0, null, true) { this.peReader = new PeReader(this); string/*?*/ loc = typeof(object).Assembly.Location; if (loc == null) { loc = string.Empty; } var mscoreAssembly = this.peReader.OpenAssembly(BinaryDocument.GetBinaryDocumentForFile(loc, this)); this.mscorlibIdentity = mscoreAssembly.AssemblyIdentity; this.RegisterAsLatest(mscoreAssembly); }
internal PEFileReader(PeReader moduleReadWriteFactory, IBinaryDocumentMemoryBlock binaryDocumentMemoryBlock, bool snapshot = false) { this.ErrorContainer = new MetadataErrorContainer(moduleReadWriteFactory, binaryDocumentMemoryBlock.BinaryDocument); this.ReaderState = ReaderState.Initialized; this.BinaryDocumentMemoryBlock = binaryDocumentMemoryBlock; if (!snapshot) { if (!this.ReadPEFileLevelData()) return; if (!this.ReadCORModuleLevelData()) return; } else { this.SectionHeaders = new SectionHeader[0]; if (!this.ReadMetadataRoot()) return; } if (!this.ReadMetadataLevelData()) return; // TODO: Add phase for Metadata validation of offsets type row ids etc... }