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...
}
