private int GetMethodsCount(uint typeRid, TypeDefRow typeRow) { var types = _reader.TypeDefTable; var methods = _reader.MethodTable; return((typeRid == types.Length) ? methods.Length - typeRow.MethodList : types[typeRid + 1].MethodList - typeRow.MethodList); }
private int GetFieldsCount(uint typeRid, TypeDefRow typeRow) { var types = _reader.TypeDefTable; var fields = _reader.FieldTable; return((typeRid == types.Length) ? fields.Length - typeRow.FieldList : types[typeRid + 1].FieldList - typeRow.FieldList); }
public override void FromRawData(byte [] buff, int offs, int numRows) { for (int i = numRows; --i >= 0;) { Row row = new TypeDefRow(this); row.FromRawData(buff, offs); Add(row); offs += TypeDefRow.LogicalSize; } }
void DumpTypeDef(TypeDefRow row, int index) { Console.WriteLine("TypeDefRow#{0} {1} {2} {3} {4} {5} {6}", index, (uint)row.Flags, row.Name, row.Namespace, row.Extends.ToUInt(), row.FieldList, row.MethodList); }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <param name="result">The result.</param> public void Read(TokenTypes token, out TypeDefRow result) { if ((token & TokenTypes.TableMask) != TokenTypes.TypeDef) { throw new ArgumentException("Invalid token type for TypeDefRow.", "token"); } using (BinaryReader reader = CreateReaderForToken(token)) { result = new TypeDefRow((TypeAttributes)reader.ReadUInt32(), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.TypeDefOrRef), ReadIndexValue(reader, TokenTypes.Field), ReadIndexValue(reader, TokenTypes.MethodDef)); } }
public Collection <FieldDefinition> GetFields(uint typeRid, TypeDefRow typeRow, TypeDefinition typeDef) { var start = typeRow.FieldList; var count = GetFieldsCount(typeRid, typeRow); var fields = new FieldDefinition[count]; for (uint offset = 0; offset < count; offset++) { var fieldRid = start + offset; var fieldRow = _reader.FieldTable[fieldRid]; fields[offset] = FieldDefinitionResolver.Resolve(fieldRid, fieldRow, this, typeDef); } return(new Collection <FieldDefinition>(fields)); }
public Collection <MethodDefinition> GetMethods(uint typeRid, TypeDefRow typeRow, TypeDefinition typeDef) { var start = typeRow.MethodList; var count = GetMethodsCount(typeRid, typeRow); var methods = new MethodDefinition[count]; for (uint offset = 0; offset < count; offset++) { var methodRid = start + offset; var methodRow = _reader.MethodTable[methodRid]; methods[offset] = MethodDefinitionResolver.Resolve(methodRid, methodRow, this, typeDef); } return(new Collection <MethodDefinition>(methods)); }
private TypeDefRow CreateTypeDefRow(TypeDefinition entity, MetadataBuilder metadata) { var row = new TypeDefRow( entity.Attributes, metadata.WriteString(entity.Name), metadata.WriteString(entity.Namespace), metadata.ResolveToken(entity.BaseType), (ushort)(metadata.FieldTable.Length + 1), (ushort)(metadata.MethodTable.Length + 1) ); foreach (var field in entity.Fields) { metadata.ResolveToken(field); } foreach (var method in entity.Methods) { metadata.ResolveToken(method); } return(row); }
/// <summary> /// Initializes a new instance of the <see cref="CilRuntimeType"/> class. /// </summary> /// <param name="token">The token.</param> /// <param name="module">The module.</param> /// <param name="typeDefRow">The type def row.</param> /// <param name="maxField">The max field.</param> /// <param name="maxMethod">The max method.</param> /// <param name="packing">The packing.</param> /// <param name="size">The size.</param> public CilRuntimeType(TokenTypes token, IMetadataModule module, ref TypeDefRow typeDefRow, TokenTypes maxField, TokenTypes maxMethod, int packing, int size) : base((int)token, module) { this.baseTypeToken = typeDefRow.Extends; this.module = module; this.nameIdx = typeDefRow.TypeNameIdx; this.namespaceIdx = typeDefRow.TypeNamespaceIdx; base.Attributes = typeDefRow.Flags; base.Pack = packing; base.Size = size; // Load all fields of the type int members = maxField - typeDefRow.FieldList; if (0 < members) { int i = (int)(typeDefRow.FieldList & TokenTypes.RowIndexMask) - 1 + RuntimeBase.Instance.TypeLoader.GetModuleOffset(module).FieldOffset; base.Fields = new ReadOnlyRuntimeFieldListView(i, members); } else { base.Fields = ReadOnlyRuntimeFieldListView.Empty; } // Load all methods of the type members = maxMethod - typeDefRow.MethodList; if (0 < members) { int i = (int)(typeDefRow.MethodList & TokenTypes.RowIndexMask) - 1 + RuntimeBase.Instance.TypeLoader.GetModuleOffset(module).MethodOffset; base.Methods = new ReadOnlyRuntimeMethodListView(i, members); } else { base.Methods = ReadOnlyRuntimeMethodListView.Empty; } }
public virtual void VisitTypeDefRow(TypeDefRow row) { }
// 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); } } }
// 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; //This does more than just initialize the five types exposed above, since it is also //necessary to initialize any typedefs and typerefs to types with short forms //in such a way that they have the correct type codes. 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) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Void); } else if (typeDefName == booleanName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean); } else if (typeDefName == charName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Char); } else if (typeDefName == byteName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte); } else if (typeDefName == sByteName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte); } else if (typeDefName == int16Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16); } else if (typeDefName == uint16Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16); } else if (typeDefName == int32Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32); } else if (typeDefName == uint32Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32); } else if (typeDefName == int64Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64); } else if (typeDefName == uint64Name) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64); } else if (typeDefName == stringName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.String); } else if (typeDefName == intPtrName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr); } else if (typeDefName == uintPtrName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr); } else if (typeDefName == objectName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Object); } else if (typeDefName == singleName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Single); } else if (typeDefName == doubleName) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Double); } else if (typeDefName == typedReference) { peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference); } else if (typeDefName == enumName) { this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == valueTypeName) { this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == multicastDelegateName) { this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typeName) { this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == paramArrayAttributeName) { this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } } } } } else { uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows; AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peFileToObjectModel.CoreAssemblySymbolicIdentity); if (coreAssemblyRef == null) { // Error... coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 1, peFileToObjectModel.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) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Void); } else if (typeDefName == booleanName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean); } else if (typeDefName == charName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Char); } else if (typeDefName == byteName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte); } else if (typeDefName == sByteName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte); } else if (typeDefName == int16Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16); } else if (typeDefName == uint16Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16); } else if (typeDefName == int32Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32); } else if (typeDefName == uint32Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32); } else if (typeDefName == int64Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64); } else if (typeDefName == uint64Name) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64); } else if (typeDefName == stringName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.String); } else if (typeDefName == intPtrName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr); } else if (typeDefName == uintPtrName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr); } else if (typeDefName == objectName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Object); } else if (typeDefName == singleName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Single); } else if (typeDefName == doubleName) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Double); } else if (typeDefName == typedReference) { peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference); } else if (typeDefName == enumName) { this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == valueTypeName) { this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == multicastDelegateName) { this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == typeName) { this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } else if (typeDefName == paramArrayAttributeName) { this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive); } } } NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System); if (this.SystemEnum == null || (peFileToObjectModel.SystemEnumAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemEnumAssembly)) { this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemEnumAssembly ?? coreAssemblyRef, systemNSR, nameTable.Enum, MetadataReaderSignatureTypeCode.NotModulePrimitive); } if (this.SystemValueType == null || (peFileToObjectModel.SystemValueTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemValueTypeAssembly)) { this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemValueTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.ValueType, MetadataReaderSignatureTypeCode.NotModulePrimitive); } if (this.SystemMulticastDelegate == null || (peFileToObjectModel.SystemMulticastDelegateAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemMulticastDelegateAssembly)) { this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemMulticastDelegateAssembly ?? coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, MetadataReaderSignatureTypeCode.NotModulePrimitive); } if (this.SystemType == null || (peFileToObjectModel.SystemTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemTypeAssembly)) { this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.Type, MetadataReaderSignatureTypeCode.NotModulePrimitive); } if (this.SystemParamArrayAttribute == null || (peFileToObjectModel.SystemParamArrayAttributeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemParamArrayAttributeAssembly)) { this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemParamArrayAttributeAssembly ?? coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, MetadataReaderSignatureTypeCode.NotModulePrimitive); } } }
public override void VisitTypeDefinitionCollection(TypeDefinitionCollection types) { // type def reading TypeDefTable typesTable = m_tableReader.GetTypeDefTable(); m_typeDefs = new TypeDefinition [typesTable.Rows.Count]; for (int i = 0; i < typesTable.Rows.Count; i++) { TypeDefRow type = typesTable [i]; TypeDefinition t = new TypeDefinition( m_root.Streams.StringsHeap [type.Name], m_root.Streams.StringsHeap [type.Namespace], type.Flags); t.MetadataToken = MetadataToken.FromMetadataRow(TokenType.TypeDef, i); m_typeDefs [i] = t; } // nested types if (m_tHeap.HasTable(NestedClassTable.RId)) { NestedClassTable nested = m_tableReader.GetNestedClassTable(); for (int i = 0; i < nested.Rows.Count; i++) { NestedClassRow row = nested [i]; TypeDefinition parent = GetTypeDefAt(row.EnclosingClass); TypeDefinition child = GetTypeDefAt(row.NestedClass); parent.NestedTypes.Add(child); } } foreach (TypeDefinition type in m_typeDefs) { types.Add(type); } // type ref reading if (m_tHeap.HasTable(TypeRefTable.RId)) { TypeRefTable typesRef = m_tableReader.GetTypeRefTable(); m_typeRefs = new TypeReference [typesRef.Rows.Count]; for (int i = 0; i < typesRef.Rows.Count; i++) { AddTypeRef(typesRef, i); } } else { m_typeRefs = new TypeReference [0]; } ReadTypeSpecs(); ReadMethodSpecs(); ReadMethods(); ReadGenericParameters(); // set base types for (int i = 0; i < typesTable.Rows.Count; i++) { TypeDefRow type = typesTable [i]; TypeDefinition child = m_typeDefs [i]; child.BaseType = GetTypeDefOrRef(type.Extends, new GenericContext(child)); } CompleteMethods(); ReadAllFields(); ReadMemberReferences(); }
void IMetadataProvider.Read(TokenTypes token, out TypeDefRow result) { TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables]; theap.Read(token, out result); }
/// <summary> /// Loads all types from the given metadata module. /// </summary> private void LoadTypes() { List <TypeInfo> typeInfos = new List <TypeInfo>(GetTableRows(TableType.TypeDef)); Token maxTypeDef = GetMaxTokenValue(TableType.TypeDef); Token maxMethod = GetMaxTokenValue(TableType.MethodDef); Token maxField = GetMaxTokenValue(TableType.Field); Token maxLayout = GetMaxTokenValue(TableType.ClassLayout); Token maxNestedClass = GetMaxTokenValue(TableType.NestedClass); Token tokenLayout = new Token(TableType.ClassLayout, 1); ClassLayoutRow layoutRow = (maxLayout.RID != 0) ? metadataProvider.ReadClassLayoutRow(tokenLayout) : new ClassLayoutRow(); Token tokenNested = new Token(TableType.NestedClass, 1); NestedClassRow nestedRow = (maxNestedClass.RID != 0) ? metadataProvider.ReadNestedClassRow(tokenNested) : new NestedClassRow(); TypeDefRow nextTypeDefRow = new TypeDefRow(); TypeDefRow typeDefRow = metadataProvider.ReadTypeDefRow(new Token(TableType.TypeDef, 1)); foreach (Token token in new Token(TableType.TypeDef, 1).Upto(maxTypeDef)) { TypeInfo info = new TypeInfo(); info.TypeDefRow = typeDefRow; info.NestedClass = (nestedRow.NestedClass == token) ? nestedRow.NestedClass : Token.Zero; info.EnclosingClass = (nestedRow.NestedClass == token) ? nestedRow.EnclosingClass : Token.Zero; info.Size = (layoutRow.Parent == token) ? layoutRow.ClassSize : 0; info.PackingSize = (layoutRow.Parent == token) ? layoutRow.PackingSize : (short)0; if (token.RID < maxTypeDef.RID) { nextTypeDefRow = metadataProvider.ReadTypeDefRow(token.NextRow); info.MaxField = nextTypeDefRow.FieldList; info.MaxMethod = nextTypeDefRow.MethodList; if (info.MaxMethod.RID > maxMethod.RID) { info.MaxMethod = maxMethod.NextRow; } if (info.MaxField.RID > maxField.RID) { info.MaxField = maxField.NextRow; } } else { info.MaxMethod = maxMethod.NextRow; info.MaxField = maxField.NextRow; } typeInfos.Add(info); if (layoutRow.Parent == token) { tokenLayout = tokenLayout.NextRow; if (tokenLayout.RID <= maxLayout.RID) { layoutRow = metadataProvider.ReadClassLayoutRow(tokenLayout); } } if (nestedRow.NestedClass == token) { tokenNested = tokenNested.NextRow; if (tokenNested.RID <= maxNestedClass.RID) { nestedRow = metadataProvider.ReadNestedClassRow(tokenNested); } } typeDefRow = nextTypeDefRow; } foreach (Token token in new Token(TableType.TypeDef, 1).Upto(maxTypeDef)) { LoadType(token, typeInfos); } }
static void ReadPeInfo2(String dll, Boolean showDllName, Boolean pauseOnDir) { if (showDllName) { Console.WriteLine("Reading file: {0}", dll); } using (PEFile info = new PEFile(StreamLoader.FromFile(dll))) { if (info.Header.IsValid) //Проверка на валидность загруженного файла { foreach (var section in info.Sections) { Utils.ConsoleWriteMembers(section); } if (info.Header.SymbolTable != null) { Utils.ConsoleWriteMembers(info.Header.SymbolTable.Value); } if (!info.Resource.IsEmpty) { Console.WriteLine("===Resources==="); Int32 directoriesCount = 0; foreach (var dir in info.Resource) { directoriesCount++; //Console.WriteLine("dir: {0}", dir.NameAddress); Console.WriteLine("Resource dir: {0}", dir.Name); foreach (var dir1 in dir) { Console.WriteLine("----- {0}", dir1.Name); foreach (var dir2 in dir1) { Console.WriteLine("-------- {0}", dir2.Name); if (dir2.DirectoryEntry.IsDataEntry) { switch (dir.DirectoryEntry.NameType) { case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_VERSION: var version1 = new AlphaOmega.Debug.NTDirectory.Resources.ResourceVersion(dir2); var strFileInfo = version1.GetFileInfo(); Utils.ConsoleWriteMembers(version1.FileInfo.Value); //WinNT.StringFileInfo fInfo = NativeMethods.BytesToStructure<WinNT.StringFileInfo>(bytesV, ptr); break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_STRING: var strings = new AlphaOmega.Debug.NTDirectory.Resources.ResourceString(dir2); foreach (var entry in strings) { Utils.ConsoleWriteMembers(entry); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_ACCELERATOR: var acc = new AlphaOmega.Debug.NTDirectory.Resources.ResourceAccelerator(dir2).ToArray(); String testAcc = String.Empty; foreach (var a in acc) { Utils.ConsoleWriteMembers(a); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MANIFEST: Byte[] bytesM = dir2.GetData(); //http://msdn.microsoft.com/ru-ru/library/eew13bza.aspx String xml = System.Text.Encoding.GetEncoding((Int32)dir2.DataEntry.Value.CodePage).GetString(bytesM); break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MESSAGETABLE: var messageTable = new AlphaOmega.Debug.NTDirectory.Resources.ResourceMessageTable(dir2); foreach (var entry in messageTable) { Utils.ConsoleWriteMembers(entry); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MENU: var resMenu = new AlphaOmega.Debug.NTDirectory.Resources.ResourceMenu(dir2); foreach (var entry in resMenu.GetMenuTemplate()) { Utils.ConsoleWriteMembers(entry); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_TOOLBAR: var resToolbar = new AlphaOmega.Debug.NTDirectory.Resources.ResourceToolBar(dir2); Utils.ConsoleWriteMembers(resToolbar.Header); foreach (var entry in resToolbar.GetToolBarTemplate()) { Utils.ConsoleWriteMembers(entry); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_FONTDIR: var resFontDir = new AlphaOmega.Debug.NTDirectory.Resources.ResourceFontDir(dir2); foreach (var fontItem in resFontDir) { Utils.ConsoleWriteMembers(fontItem); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_FONT: var resFont = new AlphaOmega.Debug.NTDirectory.Resources.ResourceFont(dir2); Utils.ConsoleWriteMembers(resFont.Font); break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_BITMAP: //TODO: // http://www.vbdotnetforums.com/graphics-gdi/49563-i-need-help-converting-bitmap-dib-intptr.html // http://snipplr.com/view/36593/ // http://www.codeproject.com/Articles/16268/DIB-to-System-Bitmap // http://ebersys.blogspot.com/2009/06/how-to-convert-dib-to-bitmap.html // http://hecgeek.blogspot.com/2007/04/converting-from-dib-to.html // http://objectmix.com/dotnet/101391-dib-bitmap-system-drawing-bitmap.html var resBitmap = new AlphaOmega.Debug.NTDirectory.Resources.ResourceBitmap(dir2); try { Utils.ConsoleWriteMembers(resBitmap.Header); } catch (ArgumentOutOfRangeException exc) { Console.WriteLine("!!!ArgumentOutOfRangeException (Corrupt bitmap): {0}", exc.Message); Console.ReadKey(); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_ICON: var resIcon = new AlphaOmega.Debug.NTDirectory.Resources.ResourceIcon(dir2); /*WinGdi.ICONDIR icoHeader = new WinGdi.ICONDIR() { idReserved = 0, idType = 1, idCount = 1 }; * List<Byte> bytes = new List<Byte>(); * bytes.AddRange(PinnedBufferReader.StructureToArray<WinGdi.ICONDIR>(icoHeader)); * * var resHeader=resIcon.Header; * Byte[] payload = resIcon.Directory.GetData().Skip(Marshal.SizeOf(typeof(WinGdi.GRPICONDIRENTRY))).ToArray(); * WinGdi.ICONDIRENTRY icoEntry = new WinGdi.ICONDIRENTRY() * { * bWidth = resHeader.bWidth, * bHeight = resHeader.bHeight, * bColorCount = resHeader.bColorCount, * bReserved = resHeader.bReserved, * wPlanes = resHeader.wPlanes, * wBitCount = resHeader.wBitCount, * dwBytesInRes = (UInt32)payload.Length, * dwImageOffset = (UInt32)(Marshal.SizeOf(typeof(WinGdi.ICONDIR)) + Marshal.SizeOf(typeof(WinGdi.ICONDIRENTRY))), * }; * bytes.AddRange(PinnedBufferReader.StructureToArray<WinGdi.ICONDIRENTRY>(icoEntry)); * bytes.AddRange(payload); * File.WriteAllBytes(@"C:\Visual Studio Projects\C++\DBaseTool\DBaseTool_src\res\RT_ICON.ico", bytes.ToArray());*/ Utils.ConsoleWriteMembers(resIcon.Header); break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_DLGINIT: var dlgInit = new AlphaOmega.Debug.NTDirectory.Resources.ResourceDialogInit(dir2); foreach (var initData in dlgInit) { Utils.ConsoleWriteMembers(initData); } break; case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_DIALOG: var dialog = new AlphaOmega.Debug.NTDirectory.Resources.ResourceDialog(dir2); try { var template = dialog.GetDialogTemplate(); foreach (var ctrl in template.Controls) { if (ctrl.CX < 0 || ctrl.CY < 0 || ctrl.X < 0 || ctrl.Y < 0) { Console.WriteLine("???Invalid position? ({0}) CX: {1} CY: {2} X: {3} Y: {4}", template.Title, ctrl.CX, ctrl.CY, ctrl.X, ctrl.Y); Console.ReadKey(); } else { Utils.ConsoleWriteMembers(ctrl); } } } catch (IndexOutOfRangeException exc) { Console.WriteLine("!!!IndexOutOfRangeException (Corrupt dialog): {0}", exc.Message); Console.ReadKey(); } catch (ArgumentException exc) { Console.WriteLine("!!!ArgumentException (Corrupt dialog): {0}", exc.Message); Console.ReadKey(); } break; } } } } } Console.WriteLine("Total dirs: {0}", directoriesCount); if (pauseOnDir) { Console.ReadKey(); } } if (info.ComDescriptor != null) { //.NET Framework if (info.ComDescriptor.Resources != null) { if (info.ComDescriptor.Resources.Header.IsValid) { foreach (var item in info.ComDescriptor.Resources) { Console.WriteLine("Resource Item: {0}", item.Name); if (item.CanRead) { foreach (var row in item) { Console.WriteLine("\tResource row: {0} {1}", row.Name, row.Type); } } else { Console.WriteLine("\t---Some object---"); } } } else { Console.WriteLine("INVALID. MetaData Address: {0} Resources Address: {1}", info.ComDescriptor.MetaData.Directory.VirtualAddress, info.ComDescriptor.Resources.Directory.VirtualAddress); Console.ReadKey(); } } var meta = info.ComDescriptor.MetaData; Utils.ConsoleWriteMembers("MetaData", meta.Header.Value); foreach (var header in meta) { Console.WriteLine(Utils.GetReflectedMembers(header.Header)); switch (header.Header.Type) { case Cor.StreamHeaderType.StreamTable: var table = (StreamTables)header; Console.WriteLine(Utils.GetReflectedMembers(table.StreamTableHeader)); Array enums = Enum.GetValues(typeof(Cor.MetaTableType)); foreach (Cor.MetaTableType type in enums) { //Пробежка по всем именованным таблицам PropertyInfo property = table.GetType().GetProperty(type.ToString(), BindingFlags.Instance | BindingFlags.Public); foreach (var row in ((IEnumerable)property.GetValue(table, null))) { switch (type) { case Cor.MetaTableType.NestedClass: { NestedClassRow nestedClassRow = (NestedClassRow)row; TypeDefRow parentTypeRow = nestedClassRow.EnclosingClass; TypeDefRow childTypeRow = nestedClassRow.NestedClass; String typeName = parentTypeRow.TypeNamespace + "." + parentTypeRow.TypeName + " {\r\n"; typeName += "\tclass " + childTypeRow.TypeName + " {...}\r\n"; typeName += "}"; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.FieldRVA: { FieldRVARow fieldRVARow = (FieldRVARow)row; FieldRow fieldRow = fieldRVARow.Field; String fieldName = fieldRow.Name + " -> 0x" + fieldRVARow.RVA.ToString("X8"); Console.WriteLine("{0}: {1}", type, fieldName); } break; case Cor.MetaTableType.ImplMap: { ImplMapRow implMapRow = (ImplMapRow)row; ModuleRefRow moduleRow = implMapRow.ImportScope; String moduleName = moduleRow.Name + "-> " + implMapRow.ImportName; Console.WriteLine("{0}: {1}", type, moduleName); } break; case Cor.MetaTableType.MethodImpl: { MethodImplRow methodImplRow = (MethodImplRow)row; TypeDefRow typeRow = methodImplRow.Class; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.PropertyMap: { PropertyMapRow propertyMapRow = (PropertyMapRow)row; TypeDefRow typeRow = propertyMapRow.Parent; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n"; foreach (PropertyRow propertyRow in propertyMapRow.Properties) { typeName += "\t" + propertyRow.Name + ";\r\n"; } typeName += "}"; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.EventMap: { //TODO: Не тестировано EventMapRow eventMapRow = (EventMapRow)row; TypeDefRow typeRow = eventMapRow.Parent; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n"; foreach (EventRow eventRow in eventMapRow.EventList) { typeName += "\tevent " + eventRow.Name + ";\r\n"; } typeName += "}"; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.FieldLayout: { FieldLayoutRow fieldLayoutRow = (FieldLayoutRow)row; FieldRow fieldRow = fieldLayoutRow.Field; String fieldName = fieldRow.Name; Console.WriteLine("{0}: {1}", type, fieldName); } break; case Cor.MetaTableType.ClassLayout: { ClassLayoutRow classLayoutRow = (ClassLayoutRow)row; TypeDefRow typeRow = classLayoutRow.Parent; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.InterfaceImpl: { InterfaceImplRow interfaceRow = (InterfaceImplRow)row; TypeDefRow typeRow = interfaceRow.Class; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.TypeDef: { TypeDefRow typeRow = (TypeDefRow)row; String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n"; foreach (var fieldRow in typeRow.FieldList) { typeName += "\t" + fieldRow.Name + ";\r\n"; } foreach (var methodRow in typeRow.MethodList) { typeName += "\t" + methodRow.Name + "("; foreach (var paramRow in methodRow.ParamList) { typeName += paramRow.Name + ", "; } typeName = typeName.TrimEnd(',', '"', ' ') + ");\r\n"; } typeName += "}"; Console.WriteLine("{0}: {1}", type, typeName); } break; case Cor.MetaTableType.MethodDef: { MethodDefRow methodRow = (MethodDefRow)row; String methodName = methodRow.Name + "("; foreach (var paramRow in methodRow.ParamList) { methodName += paramRow.Name + ", "; } methodName = methodName.TrimEnd(',', '"', ' ') + ")"; Console.WriteLine("{0}: {1}", type, methodName); //TODO: Быстрый набросок чтения тела метода UInt32 methodLength = 0; UInt32 rva = methodRow.RVA; Byte flags = info.Header.PtrToStructure <Byte>(rva); rva += sizeof(Byte); Boolean CorILMethod_FatFormat = (UInt16)(flags & 0x3) == 0x3; Boolean CorILMethod_TinyFormat = (UInt16)(flags & 0x2) == 0x2; Boolean CorILMethod_MoreSects = (UInt16)(flags & 0x8) == 0x8; Boolean CorILMethod_InitLocals = (UInt16)(flags & 0x10) == 0x10; if (CorILMethod_FatFormat) { Byte flags2 = info.Header.PtrToStructure <Byte>(rva); rva += sizeof(Byte); Byte headerSize = Convert.ToByte((flags2 >> 4) * 4); UInt16 maxStack = info.Header.PtrToStructure <UInt16>(rva); rva += sizeof(UInt16); methodLength = info.Header.PtrToStructure <UInt32>(rva); rva += sizeof(UInt32); UInt32 localVarSigTok = info.Header.PtrToStructure <UInt32>(rva); rva += sizeof(UInt32); } else { methodLength = ((UInt32)flags >> 2); } try { Byte[] methodBody = info.Header.ReadBytes(rva, methodLength); Byte[] methodBody2 = methodRow.Body.GetMethodBody(); for (Int32 loop = 0; loop < methodLength; loop++) { if (methodBody[loop] != methodBody2[loop]) { throw new ArgumentException("Method not equals"); } } } catch (Exception exc) { Console.WriteLine("!!!Error while reading method body!!!"); Console.WriteLine(exc.Message); Console.ReadLine(); } } break; default: Utils.ConsoleWriteMembers(row); break; } } //Пробежка по всем таблицам MetaTable moduleTable = table[type]; Console.WriteLine(String.Format("==MetaTableType.{0} Contents:", type)); foreach (MetaRow row in moduleTable.Rows) { StringBuilder result = new StringBuilder(); foreach (MetaCell cell in row) { result.AppendFormat("{0}:\t{1}", cell.Column.Name, cell.Value); } result.AppendLine(); Console.WriteLine(result.ToString()); } Console.WriteLine(String.Format("==MetaTableType.{0} End", type)); } break; case Cor.StreamHeaderType.Guid: var gHeap = (GuidHeap)header; Guid[] guids = gHeap.Data.ToArray(); break; case Cor.StreamHeaderType.Blob: var bHeap = (BlobHeap)header; Byte[][] bytes = bHeap.Data.ToArray(); break; case Cor.StreamHeaderType.String: var sHeap = (StringHeap)header; String[] strings = sHeap.Data.ToArray(); break; case Cor.StreamHeaderType.UnicodeSting: var usHeap = (USHeap)header; String[] usStrings = usHeap.DataString; break; } } if (pauseOnDir) { Console.ReadKey(); } } if (!info.ExceptionTable.IsEmpty) { //TODO: Ошибка при чтении Console.WriteLine("===Exception Table==="); try { foreach (var entry in info.ExceptionTable) { Utils.ConsoleWriteMembers(entry); } } catch (ArgumentOutOfRangeException exc) { Console.WriteLine("Exception: " + exc.Message); Console.WriteLine("========================"); Console.WriteLine(exc.StackTrace); Console.ReadKey(); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Iat.IsEmpty) { Console.WriteLine("===Import Address Table==="); foreach (UInt32 addr in info.Iat) { Console.WriteLine("Addr: {0:X8}", addr); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Tls.IsEmpty) { Console.WriteLine("===Thread Local Storage==="); if (pauseOnDir) { Console.ReadKey(); } } if (!info.Certificate.IsEmpty) { try { var cert = info.Certificate.Certificate.Value; var x509 = info.Certificate.X509; Console.WriteLine("===Security==="); Utils.ConsoleWriteMembers(cert); Console.WriteLine("Certificate: {0}", x509 == null ? "NULL" : x509.ToString()); } catch (ArgumentOutOfRangeException exc) { Console.WriteLine("!!!OverflowException (Corrupted section): {0}", exc.Message); Console.ReadKey(); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.DelayImport.IsEmpty) { Console.WriteLine("===Delay Import==="); foreach (var module in info.DelayImport) { Console.WriteLine(String.Format("Module Name: {0}\tCount: {1}", module.ModuleName, module.Count())); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Relocations.IsEmpty) { //File contains relocation table Console.WriteLine("===Relocations==="); foreach (var block in info.Relocations) { Utils.ConsoleWriteMembers(block.Block); foreach (var section in block) { Utils.ConsoleWriteMembers(section); /*if(!Enum.IsDefined(typeof(WinNT.IMAGE_REL_BASED), section.Type)) * { * Console.WriteLine(String.Format("Enum {0} not defined", section.Type)); * Console.ReadKey(); * }*/ } } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Debug.IsEmpty) { //В файле есть инормация для дебага Console.WriteLine("===Debug info==="); foreach (var debug in info.Debug) { Utils.ConsoleWriteMembers(debug); } var pdb7 = info.Debug.Pdb7CodeView; if (pdb7.HasValue) { Utils.ConsoleWriteMembers(pdb7.Value); } var pdb2 = info.Debug.Pdb2CodeView; if (pdb2.HasValue) { Utils.ConsoleWriteMembers(pdb2.Value); } var misc = info.Debug.Misc; if (misc.HasValue) { Utils.ConsoleWriteMembers(misc.Value); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.LoadConfig.IsEmpty) { Console.WriteLine("===Load Config==="); if (info.LoadConfig.Directory32.HasValue) { var directory = info.LoadConfig.Directory32.Value; Utils.ConsoleWriteMembers(directory); } else if (info.LoadConfig.Directory64.HasValue) { var directory = info.LoadConfig.Directory64.Value; Utils.ConsoleWriteMembers(directory); } else { throw new NotImplementedException(); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.BoundImport.IsEmpty) { Console.WriteLine("===Bound Import==="); Console.WriteLine("ModuleName: {0}", info.BoundImport.ModuleName); foreach (var ffRef in info.BoundImport) { Utils.ConsoleWriteMembers(ffRef); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Export.IsEmpty) { //В файле есть информация о экспортируемых функциях Console.WriteLine("===Export Functions==="); Console.WriteLine("Module name: {0}", info.Export.DllName); foreach (var func in info.Export.GetExportFunctions()) { Utils.ConsoleWriteMembers(func); } if (pauseOnDir) { Console.ReadKey(); } } if (!info.Import.IsEmpty) { //В файле есть информация о импортиуемых модулях Console.WriteLine("===Import Modules==="); foreach (var module in info.Import) { Console.WriteLine("Module name: {0}", module.ModuleName); foreach (var func in module) { Utils.ConsoleWriteMembers(func); } } if (pauseOnDir) { Console.ReadKey(); } } } } }
public static TypeDefinition Resolve(uint rid, TypeDefRow row, MetadataSystem metadata) { var resolver = new TypeDefinitionResolver(rid, row, metadata); return(new TypeDefinition(resolver)); }
private TypeDefinitionResolver(uint rid, TypeDefRow row, MetadataSystem metadata) { _token = new MetadataToken(MetadataTokenType.TypeDef, rid); _row = row; _metadata = metadata; }
public TypeDefRowExt(IMetadataProvider metadata, TypeDefRow row) : base(metadata) { this.row = row; }
/// <summary> /// Loads all types From the given metadata module. /// </summary> /// <param name="module">The metadata module to load the types From.</param> /// <param name="moduleOffsets">The offsets into the metadata arrays, of the current module.</param> private void LoadTypes(IMetadataModule module, ModuleOffsets moduleOffsets) { TokenTypes maxTypeDef, maxField, maxMethod, maxLayout, tokenLayout = TokenTypes.ClassLayout + 1; TypeDefRow typeDefRow, nextTypeDefRow = new TypeDefRow(); ClassLayoutRow layoutRow = new ClassLayoutRow(); IMetadataProvider md = module.Metadata; int size = 0x0, packing = 0; int typeOffset = moduleOffsets.TypeOffset; int methodOffset = moduleOffsets.MethodOffset; int fieldOffset = moduleOffsets.FieldOffset; RuntimeType rt; maxTypeDef = md.GetMaxTokenValue(TokenTypes.TypeDef); maxLayout = md.GetMaxTokenValue(TokenTypes.ClassLayout); if (TokenTypes.ClassLayout < maxLayout) { md.Read(tokenLayout, out layoutRow); } TokenTypes token = TokenTypes.TypeDef + 2; md.Read(token, out typeDefRow); do { /* * string name; * md.Read(typeDefRow.TypeNameIdx, out name); * Debug.WriteLine(name); */ if (token < maxTypeDef) { md.Read(token + 1, out nextTypeDefRow); maxField = nextTypeDefRow.FieldList; maxMethod = nextTypeDefRow.MethodList; } else { maxMethod = md.GetMaxTokenValue(TokenTypes.MethodDef) + 1; maxField = md.GetMaxTokenValue(TokenTypes.Field) + 1; } // Is this our layout info? if ((layoutRow.ParentTypeDefIdx + 1) == token) { size = layoutRow.ClassSize; packing = layoutRow.PackingSize; tokenLayout++; if (tokenLayout <= maxLayout) { md.Read(tokenLayout, out layoutRow); } } // Create and populate the runtime type rt = new CilRuntimeType(token, module, ref typeDefRow, maxField, maxMethod, packing, size); LoadMethods(module, rt, typeDefRow.MethodList, maxMethod, ref methodOffset); LoadFields(module, rt, typeDefRow.FieldList, maxField, ref fieldOffset); _types[typeOffset++] = rt; if (rtCallTypeAttribute == null) { if (rt.Name == "InternalCallTypeAttribute" && rt.Namespace == "Mosa.Runtime.Vm") { rtCallTypeAttribute = rt; } } packing = size = 0; typeDefRow = nextTypeDefRow; }while (token++ < maxTypeDef); }