internal MetadataReader(string path) { MemoryMappedFile memmap = this.memmap = new MemoryMappedFile(path); try { this.cursor = new MemoryCursor(memmap); //^ base(); ReadHeader(); } catch { this.Dispose(); throw; } }
internal MemoryCursor/*!*/ GetNewCursor(int RVA, out PESection targetSection) { MemoryCursor c = new MemoryCursor(this.cursor); c.Position = this.RvaToOffset(RVA, out targetSection); return c; }
internal static NTHeader/*!*/ ReadNTHeader(MemoryCursor/*!*/ c) { NTHeader header = new NTHeader(); header.signature = c.ReadInt32(); header.machine = c.ReadUInt16(); header.numberOfSections = c.ReadUInt16(); header.timeDateStamp = c.ReadInt32(); header.pointerToSymbolTable = c.ReadInt32(); header.numberOfSymbols = c.ReadInt32(); header.sizeOfOptionalHeader = c.ReadUInt16(); header.characteristics = c.ReadUInt16(); header.magic = c.ReadUInt16(); header.majorLinkerVersion = c.ReadByte(); header.minorLinkerVersion = c.ReadByte(); header.sizeOfCode = c.ReadInt32(); header.sizeOfInitializedData = c.ReadInt32(); header.sizeOfUninitializedData = c.ReadInt32(); header.addressOfEntryPoint = c.ReadInt32(); header.baseOfCode = c.ReadInt32(); if (header.magic == 0x10B) { header.baseOfData = c.ReadInt32(); header.imageBase = c.ReadInt32(); } else { header.baseOfData = 0; header.imageBase = c.ReadInt64(); } header.sectionAlignment = c.ReadInt32(); header.fileAlignment = c.ReadInt32(); header.majorOperatingSystemVersion = c.ReadUInt16(); header.minorOperatingSystemVersion = c.ReadUInt16(); header.majorImageVersion = c.ReadUInt16(); header.minorImageVersion = c.ReadUInt16(); header.majorSubsystemVersion = c.ReadUInt16(); header.minorSubsystemVersion = c.ReadUInt16(); header.win32VersionValue = c.ReadInt32(); header.sizeOfImage = c.ReadInt32(); header.sizeOfHeaders = c.ReadInt32(); header.checkSum = c.ReadInt32(); header.subsystem = c.ReadUInt16(); header.dllCharacteristics = c.ReadUInt16(); if (header.magic == 0x10B) { header.sizeOfStackReserve = c.ReadInt32(); header.sizeOfStackCommit = c.ReadInt32(); header.sizeOfHeapReserve = c.ReadInt32(); header.sizeOfHeapCommit = c.ReadInt32(); } else { header.sizeOfStackReserve = c.ReadInt64(); header.sizeOfStackCommit = c.ReadInt64(); header.sizeOfHeapReserve = c.ReadInt64(); header.sizeOfHeapCommit = c.ReadInt64(); } header.loaderFlags = c.ReadInt32(); header.numberOfDataDirectories = c.ReadInt32(); // Verify that the header signature and magic number are valid if (header.signature != 0x00004550 /* "PE\0\0" */) throw new InvalidMetadataException(ExceptionStrings.BadCOFFHeaderSignature); if (header.magic != 0x010B && header.magic != 0x020B) throw new InvalidMetadataException(ExceptionStrings.BadPEHeaderMagicNumber); //Read the data directories header.exportTable = ReadDirectoryEntry(c); header.importTable = ReadDirectoryEntry(c); header.resourceTable = ReadDirectoryEntry(c); header.exceptionTable = ReadDirectoryEntry(c); header.certificateTable = ReadDirectoryEntry(c); header.baseRelocationTable = ReadDirectoryEntry(c); header.debugTable = ReadDirectoryEntry(c); header.copyrightTable = ReadDirectoryEntry(c); header.globalPointerTable = ReadDirectoryEntry(c); header.threadLocalStorageTable = ReadDirectoryEntry(c); header.loadConfigTable = ReadDirectoryEntry(c); header.boundImportTable = ReadDirectoryEntry(c); header.importAddressTable = ReadDirectoryEntry(c); header.delayImportTable = ReadDirectoryEntry(c); header.cliHeaderTable = ReadDirectoryEntry(c); header.reserved = ReadDirectoryEntry(c); return header; }
private static StreamHeader ReadStreamHeader(MemoryCursor/*!*/ c) { StreamHeader header = new StreamHeader(); header.offset = c.ReadInt32(); header.size = c.ReadInt32(); header.name = c.ReadASCII(); int n = header.name.Length + 1; c.Position += (4 - (n % 4)) % 4; return header; }
private static CLIHeader/*!*/ ReadCLIHeader(MemoryCursor/*!*/ c) { CLIHeader header = new CLIHeader(); header.cb = c.Int32(0); c.SkipInt32(1); header.majorRuntimeVersion = c.UInt16(0); header.minorRuntimeVersion = c.UInt16(1); c.SkipUInt16(2); header.metaData = ReadDirectoryEntry(c); header.flags = c.Int32(0); header.entryPointToken = c.Int32(1); c.SkipInt32(2); header.resources = ReadDirectoryEntry(c); header.strongNameSignature = ReadDirectoryEntry(c); header.codeManagerTable = ReadDirectoryEntry(c); header.vtableFixups = ReadDirectoryEntry(c); header.exportAddressTableJumps = ReadDirectoryEntry(c); if (header.majorRuntimeVersion < 2) throw new InvalidMetadataException(ExceptionStrings.BadCLIHeader); return header; }
internal static void ReadDOSHeader(MemoryCursor/*!*/ c) { c.Position = 0; int magicNumber = c.UInt16(0); if (magicNumber != 0x5a4d) throw new InvalidMetadataException(ExceptionStrings.BadMagicNumber); c.Position = 0x3c; int ntHeaderOffset = c.Int32(0); c.Position = ntHeaderOffset; }
private TypeNodeList/*!*/ ParseParameterTypes(out TypeNodeList varArgTypes, MemoryCursor/*!*/ sigReader, int paramCount, ref bool genericParameterEncountered) { varArgTypes = null; TypeNodeList paramTypes = new TypeNodeList(); for(int j = 0; j < paramCount; j++) { TypeNode paramType = this.ParseTypeSignature(sigReader); if(paramType == null) { // Got a sentinel varArgTypes = new TypeNodeList(); j--; continue; } if(varArgTypes != null) { varArgTypes.Add(paramType); continue; } if(paramType.IsGeneric) genericParameterEncountered = true; paramTypes.Add(paramType); } return paramTypes; }
private static int ReadWin32ResourceDirectoryHeader(MemoryCursor/*!*/ c) { c.ReadInt32(); //Characteristics c.ReadInt32(); //TimeDate stamp c.ReadInt32(); //Version int numberOfNamedEntries = c.ReadUInt16(); int numberOfIdEntries = c.ReadUInt16(); return numberOfNamedEntries + numberOfIdEntries; }
private object GetCustomAttributeLiteralValue(MemoryCursor/*!*/ sigReader, ref TypeNode/*!*/ type) { if (type == null) return sigReader.ReadInt32(); switch (type.typeCode) { case ElementType.Boolean: return sigReader.ReadBoolean(); case ElementType.Char: return sigReader.ReadChar(); case ElementType.Double: return sigReader.ReadDouble(); case ElementType.Single: return sigReader.ReadSingle(); case ElementType.Int16: return sigReader.ReadInt16(); case ElementType.Int32: return sigReader.ReadInt32(); case ElementType.Int64: return sigReader.ReadInt64(); case ElementType.Int8: return sigReader.ReadSByte(); case ElementType.UInt16: return sigReader.ReadUInt16(); case ElementType.UInt32: return sigReader.ReadUInt32(); case ElementType.UInt64: return sigReader.ReadUInt64(); case ElementType.UInt8: return sigReader.ReadByte(); case ElementType.String: return ReadSerString(sigReader); case ElementType.ValueType: EnumNode etype = GetCustomAttributeEnumNode(ref type); return this.GetCustomAttributeLiteralValue(sigReader, etype.UnderlyingType); case ElementType.Class: return this.GetTypeFromSerializedName(ReadSerString(sigReader)); case ElementType.SzArray: int numElems = sigReader.ReadInt32(); TypeNode elemType = ((ArrayType)type).ElementType; return this.GetCustomAttributeLiteralArray(sigReader, numElems, elemType); case ElementType.Object: { type = this.ParseTypeSignature(sigReader); return this.GetCustomAttributeLiteralValue(sigReader, ref type); } } throw new InvalidMetadataException(ExceptionStrings.UnexpectedTypeInCustomAttribute); }
private Array GetCustomAttributeLiteralArray(MemoryCursor/*!*/ sigReader, int numElems, TypeNode/*!*/ elemType) { Array array = this.ConstructCustomAttributeLiteralArray(numElems, elemType); for (int i = 0; i < numElems; i++) { object elem = this.GetCustomAttributeLiteralValue(sigReader, elemType); array.SetValue(elem, i); } return array; }
private object GetCustomAttributeLiteralValue(MemoryCursor/*!*/ sigReader, TypeNode/*!*/ type) { TypeNode/*!*/ t = type; object result = this.GetCustomAttributeLiteralValue(sigReader, ref t); EnumNode enumType = t as EnumNode; if (enumType != null && type == CoreSystemTypes.Object) result = new Literal(result, enumType); return result; }
private void GetCustomAttributeNamedArguments(ExpressionList/*!*/ arguments, ushort numNamed, MemoryCursor/*!*/ sigReader) { for (int j = 0; j < numNamed; j++) { int nameTag = sigReader.ReadByte(); bool mustBox = sigReader.Byte(0) == (byte)ElementType.BoxedEnum; TypeNode/*!*/ vType = this.ParseTypeSignature(sigReader); Identifier id = sigReader.ReadIdentifierFromSerString(); object val = this.GetCustomAttributeLiteralValue(sigReader, ref vType); Literal lit = val as Literal; if (lit == null) lit = new Literal(val, vType); NamedArgument narg = new NamedArgument(id, lit); narg.Type = vType; narg.IsCustomAttributeProperty = nameTag == 0x54; narg.ValueIsBoxed = mustBox; arguments.Add(narg); } }
private AttributeNode GetCustomAttribute(Method/*!*/ cons, MemoryCursor/*!*/ sigReader, int blobLength) { AttributeNode attr = new AttributeNode(); attr.Constructor = new MemberBinding(null, cons); int n = cons.Parameters == null ? 0 : cons.Parameters.Count; ExpressionList arguments = attr.Expressions = new ExpressionList(); int posAtBlobStart = sigReader.Position; sigReader.ReadUInt16(); //Prolog for (int j = 0; j < n; j++) { TypeNode t = TypeNode.StripModifiers(cons.Parameters[j].Type); if (t == null) continue; TypeNode/*!*/ pt = t; object val = null; try { val = this.GetCustomAttributeLiteralValue(sigReader, ref pt); } catch (Exception e) { if (this.module.MetadataImportErrors == null) this.module.MetadataImportErrors = new ArrayList(); this.module.MetadataImportErrors.Add(e); } Literal lit = val as Literal; if (lit == null) lit = new Literal(val, pt); arguments.Add(lit); } if (sigReader.Position + 1 < posAtBlobStart + blobLength) { ushort numNamed = sigReader.ReadUInt16(); this.GetCustomAttributeNamedArguments(arguments, numNamed, sigReader); } return attr; }
private AttributeNode GetPermissionAttribute2(MemoryCursor/*!*/ sigReader, System.Security.Permissions.SecurityAction action) { int typeNameLength = sigReader.ReadCompressedInt(); string serializedTypeName = sigReader.ReadUTF8(typeNameLength); TypeNode attrType = null; try { attrType = this.GetTypeFromSerializedName(serializedTypeName); } catch (InvalidMetadataException) { } if (attrType == null) { HandleError(this.module, String.Format(CultureInfo.CurrentCulture, ExceptionStrings.CouldNotResolveType, serializedTypeName)); return null; } InstanceInitializer cons = attrType.GetConstructor(CoreSystemTypes.SecurityAction); if (cons == null) { HandleError(this.module, String.Format(CultureInfo.CurrentCulture, ExceptionStrings.SecurityAttributeTypeDoesNotHaveADefaultConstructor, serializedTypeName)); return null; } sigReader.ReadCompressedInt(); //caBlobLength int numProps = sigReader.ReadCompressedInt(); //Skip over the number of properties in the CA blob ExpressionList arguments = new ExpressionList(); arguments.Add(new Literal(action, CoreSystemTypes.SecurityAction)); this.GetCustomAttributeNamedArguments(arguments, (ushort)numProps, sigReader); return new AttributeNode(new MemberBinding(null, cons), arguments); }
private TypeNodeList/*!*/ ParseTypeList(MemoryCursor/*!*/ sigReader) { int n = sigReader.ReadCompressedInt(); TypeNodeList result = new TypeNodeList(); for(int i = 0; i < n; i++) { TypeNode t = this.ParseTypeSignature(sigReader); if(t == null || t == Struct.Dummy) { // Can happen when dealing with a primitive type that implements an interface that references the primitive type. // For example, System.String implements IComparable<System.String>. if(this.currentType != null && !CoreSystemTypes.Initialized) t = this.currentType; else { Debug.Assert(false); t = new TypeParameter(); t.Name = Identifier.For("Bad type parameter in position " + i); t.DeclaringModule = this.module; } } result.Add(t); } return result; }
internal Win32ResourceList ReadWin32Resources() { Win32ResourceList rs = new Win32ResourceList(); int startPos = this.win32ResourcesOffset; if (startPos < 0) return rs; MemoryCursor c = this.cursor; c.Position = startPos; int sizeOfTypeDirectory = ReadWin32ResourceDirectoryHeader(c); for (int i = 0; i < sizeOfTypeDirectory; i++) { string TypeName = null; int TypeID = c.ReadInt32(); if (TypeID < 0) { MemoryCursor nac = new MemoryCursor(c); nac.Position = startPos + (TypeID & 0x7FFFFFFF); int strLength = nac.ReadUInt16(); TypeName = nac.ReadUTF16(strLength); } int offset = c.ReadInt32(); if (offset >= 0) rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, null, 0, 0)); else { MemoryCursor nc = new MemoryCursor(c); nc.Position = startPos + (offset & 0x7FFFFFFF); int sizeOfNameDirectory = ReadWin32ResourceDirectoryHeader(nc); for (int j = 0; j < sizeOfNameDirectory; j++) { string Name = null; int ID = nc.ReadInt32(); if (ID < 0) { MemoryCursor nac = new MemoryCursor(c); int strLength = nac.ReadUInt16(); Name = nac.ReadUTF16(strLength); } offset = nc.ReadInt32(); if (offset >= 0) rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, Name, ID, 0)); else { MemoryCursor lc = new MemoryCursor(c); lc.Position = startPos + (offset & 0x7FFFFFFF); int sizeOfLanguageDirectory = ReadWin32ResourceDirectoryHeader(lc); for (int k = 0; k < sizeOfLanguageDirectory; k++) { int LanguageID = lc.ReadInt32(); offset = lc.ReadInt32(); rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, Name, ID, LanguageID)); } } } } } return rs; }
private bool TypeSignatureIsClass(MemoryCursor/*!*/ sigReader) { ElementType tok = (ElementType)sigReader.ReadCompressedInt(); switch (tok) { case ElementType.Pinned: case ElementType.Pointer: case ElementType.Reference: return this.TypeSignatureIsClass(sigReader); case ElementType.OptionalModifier: case ElementType.RequiredModifier: sigReader.ReadCompressedInt(); return this.TypeSignatureIsClass(sigReader); case ElementType.Class: return true; case ElementType.GenericTypeInstance: return this.TypeSignatureIsClass(sigReader); case ElementType.TypeParameter: { int pnum = sigReader.ReadCompressedInt(); if (this.currentTypeParameters != null && this.currentTypeParameters.Count > pnum) { TypeNode tPar = this.currentTypeParameters[pnum]; return tPar != null && tPar is Class; } return false; } case ElementType.MethodParameter: { int pnum = sigReader.ReadCompressedInt(); if (this.currentMethodTypeParameters != null && this.currentMethodTypeParameters.Count > pnum) { TypeNode tPar = this.currentMethodTypeParameters[pnum]; return tPar != null && tPar is Class; } return false; } default: return false; } }
private Win32Resource ReadWin32ResourceDataEntry(MemoryCursor/*!*/ c, int position, string TypeName, int TypeID, string Name, int ID, int LanguageID) { Win32Resource rsrc = new Win32Resource(); rsrc.TypeName = TypeName; rsrc.TypeId = TypeID; rsrc.Name = Name; rsrc.Id = ID; rsrc.LanguageId = LanguageID; c = new MemoryCursor(c); c.Position = position; int dataRVA = c.ReadInt32(); int dataSize = c.ReadInt32(); rsrc.CodePage = c.ReadInt32(); c.Position = this.RvaToOffset(dataRVA); rsrc.Data = c.ReadBytes(dataSize); return rsrc; }
private TypeNode ParseTypeSignature(MemoryCursor/*!*/ sigReader, ref bool pinned) { bool junk = false; return this.ParseTypeSignature(sigReader, ref pinned, ref junk); }
private static DirectoryEntry ReadDirectoryEntry(MemoryCursor/*!*/ c) { DirectoryEntry entry = new DirectoryEntry(); entry.virtualAddress = c.Int32(0); entry.size = c.Int32(1); c.SkipInt32(2); return entry; }
private TypeNode ParseTypeSignature(MemoryCursor/*!*/ sigReader, ref bool pinned, ref bool isTypeArgument) { TypeNode elementType; ElementType tok = (ElementType)sigReader.ReadCompressedInt(); if (tok == ElementType.Pinned) { pinned = true; tok = (ElementType)sigReader.ReadCompressedInt(); } switch (tok) { case ElementType.Boolean: return CoreSystemTypes.Boolean; case ElementType.Char: return CoreSystemTypes.Char; case ElementType.Double: return CoreSystemTypes.Double; case ElementType.Int16: return CoreSystemTypes.Int16; case ElementType.Int32: return CoreSystemTypes.Int32; case ElementType.Int64: return CoreSystemTypes.Int64; case ElementType.Int8: return CoreSystemTypes.Int8; case ElementType.IntPtr: return CoreSystemTypes.IntPtr; case ElementType.BoxedEnum: case ElementType.Object: return CoreSystemTypes.Object; case ElementType.Single: return CoreSystemTypes.Single; case ElementType.String: return CoreSystemTypes.String; case ElementType.DynamicallyTypedReference: return CoreSystemTypes.DynamicallyTypedReference; case ElementType.UInt16: return CoreSystemTypes.UInt16; case ElementType.UInt32: return CoreSystemTypes.UInt32; case ElementType.UInt64: return CoreSystemTypes.UInt64; case ElementType.UInt8: return CoreSystemTypes.UInt8; case ElementType.UIntPtr: return CoreSystemTypes.UIntPtr; case ElementType.Void: return CoreSystemTypes.Void; case ElementType.Pointer: elementType = this.ParseTypeSignature(sigReader, ref pinned); if (elementType == null) elementType = CoreSystemTypes.Object; if (elementType == null) return null; return elementType.GetPointerType(); case ElementType.Reference: elementType = this.ParseTypeSignature(sigReader, ref pinned); if (elementType == null) elementType = CoreSystemTypes.Object; return elementType.GetReferenceType(); case ElementType.FunctionPointer: return this.ParseFunctionPointer(sigReader); case ElementType.OptionalModifier: case ElementType.RequiredModifier: TypeNode modifier = this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt()); if (modifier == null) modifier = CoreSystemTypes.Object; TypeNode modified = this.ParseTypeSignature(sigReader, ref pinned); if (modified == null) modified = CoreSystemTypes.Object; if (modified == null || modified == null) return null; if (tok == ElementType.RequiredModifier) return RequiredModifier.For(modifier, modified); else return OptionalModifier.For(modifier, modified); case ElementType.Class: return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt()); case ElementType.ValueType: return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt(), true); case ElementType.TypeParameter: TypeNode tPar = null; int pnum = sigReader.ReadCompressedInt(); if (this.currentTypeParameters != null && this.currentTypeParameters.Count > pnum) tPar = this.currentTypeParameters[pnum]; if (tPar == null) { HandleError(this.module, String.Format(CultureInfo.CurrentCulture, ExceptionStrings.BadTypeParameterInPositionForType, pnum, this.currentType == null ? "" : this.currentType.FullName)); tPar = new TypeParameter(); tPar.Name = Identifier.For("Bad type parameter in position " + pnum); tPar.DeclaringModule = this.module; } isTypeArgument = true; return tPar; case ElementType.MethodParameter: TypeNode mTPar = null; pnum = sigReader.ReadCompressedInt(); if (this.currentMethodTypeParameters != null && this.currentMethodTypeParameters.Count > pnum) mTPar = this.currentMethodTypeParameters[pnum]; if (mTPar == null) { HandleError(this.module, String.Format(CultureInfo.CurrentCulture, ExceptionStrings.BadMethodTypeParameterInPosition, pnum)); mTPar = new MethodTypeParameter(); mTPar.Name = Identifier.For("Bad method type parameter in position " + pnum); } isTypeArgument = true; return mTPar; case ElementType.GenericTypeInstance: TypeNodeList savedCurrentTypeParameters = this.currentTypeParameters; TypeNode template = this.ParseTypeSignature(sigReader, ref pinned); this.currentTypeParameters = savedCurrentTypeParameters; if (template == null || template.ConsolidatedTemplateParameters == null) return template; //Likely a dummy type if (CoreSystemTypes.Initialized) { if (this.currentTypeParameters == null || this.currentTypeParameters.Count == 0) this.currentTypeParameters = template.ConsolidatedTemplateParameters; TypeNodeList genArgs = this.ParseTypeList(sigReader); if (this.module == null) return null; TypeNode genInst = template.GetGenericTemplateInstance(this.module, genArgs); this.currentTypeParameters = savedCurrentTypeParameters; return genInst; } InterfaceExpression ifaceExpr = new InterfaceExpression(null); ifaceExpr.Template = template; ifaceExpr.Namespace = template.Namespace; ifaceExpr.Name = template.Name; ifaceExpr.TemplateArguments = this.ParseTypeList(sigReader); this.currentTypeParameters = savedCurrentTypeParameters; return ifaceExpr; case ElementType.SzArray: elementType = this.ParseTypeSignature(sigReader, ref pinned); if (elementType == null) elementType = CoreSystemTypes.Object; if (elementType == null) return null; return elementType.GetArrayType(1); case ElementType.Array: elementType = this.ParseTypeSignature(sigReader, ref pinned); if (elementType == null) elementType = CoreSystemTypes.Object; if (elementType == null) return null; int rank = sigReader.ReadCompressedInt(); int numSizes = sigReader.ReadCompressedInt(); int[] sizes = new int[numSizes]; for (int i = 0; i < numSizes; i++) sizes[i] = sigReader.ReadCompressedInt(); int numLoBounds = sigReader.ReadCompressedInt(); int[] loBounds = new int[numLoBounds]; for (int i = 0; i < numLoBounds; i++) loBounds[i] = sigReader.ReadCompressedInt(); return elementType.GetArrayType(rank, numSizes, numLoBounds, sizes, loBounds); case ElementType.Sentinel: return null; case ElementType.Type: return CoreSystemTypes.Type; case ElementType.Enum: return this.GetTypeFromSerializedName(ReadSerString(sigReader)); } throw new InvalidMetadataException(ExceptionStrings.MalformedSignature); }
private static MetadataHeader/*!*/ ReadMetadataHeader(MemoryCursor/*!*/ c) { MetadataHeader header = new MetadataHeader(); header.signature = c.ReadInt32(); if (header.signature != 0x424a5342) throw new InvalidMetadataException(ExceptionStrings.BadMetadataHeaderSignature); header.majorVersion = c.ReadUInt16(); header.minorVersion = c.ReadUInt16(); header.reserved = c.ReadInt32(); int len = c.ReadInt32(); header.versionString = c.ReadASCII(len); while (len++ % 4 != 0) c.ReadByte(); header.flags = c.ReadUInt16(); int n = c.ReadUInt16(); StreamHeader[] streamHeaders = header.streamHeaders = new StreamHeader[n]; for (int i = 0; i < n; i++) streamHeaders[i] = ReadStreamHeader(c); return header; }
private FunctionPointer/*!*/ ParseFunctionPointer(MemoryCursor/*!*/ sigReader) { CallingConventionFlags convention = (CallingConventionFlags)sigReader.ReadByte(); int n = sigReader.ReadCompressedInt(); TypeNode returnType = this.ParseTypeSignature(sigReader); if(returnType == null) returnType = CoreSystemTypes.Object; TypeNodeList parameterTypes = new TypeNodeList(); int m = n; for(int i = 0; i < n; i++) { TypeNode t = this.ParseTypeSignature(sigReader); if (t == null) m = i--; else parameterTypes.Add(t); } FunctionPointer fp = FunctionPointer.For(parameterTypes, returnType); fp.CallingConvention = convention; fp.VarArgStart = m; return fp; }
internal static SectionHeader ReadSectionHeader(MemoryCursor/*!*/ c) { SectionHeader header = new SectionHeader(); header.name = c.ReadASCII(8); header.virtualSize = c.Int32(0); header.virtualAddress = c.Int32(1); header.sizeOfRawData = c.Int32(2); header.pointerToRawData = c.Int32(3); header.pointerToRelocations = c.Int32(4); header.pointerToLinenumbers = c.Int32(5); c.SkipInt32(6); header.numberOfRelocations = c.UInt16(0); header.numberOfLinenumbers = c.UInt16(1); c.SkipInt16(2); header.characteristics = c.Int32(0); c.SkipInt32(1); return header; }
internal ILParser(Reader/*!*/ reader, Method/*!*/ method, int methodIndex, int RVA) { this.reader = reader; this.bodyReader = reader.tables.GetNewCursor(); this.method = method; this.method.LocalList = this.locals; this.methodIndex = methodIndex; this.RVA = RVA; //^ base(); }
private static TablesHeader/*!*/ ReadTablesHeader(MemoryCursor/*!*/ c) { TablesHeader header = new TablesHeader(); header.reserved = c.ReadInt32(); // Must be zero header.majorVersion = c.ReadByte(); // Must be one header.minorVersion = c.ReadByte(); // Must be zero header.heapSizes = c.ReadByte(); // Bits for heap sizes header.rowId = c.ReadByte(); // log-base-2 of largest rowId header.maskValid = c.ReadInt64(); // Present table counts header.maskSorted = c.ReadInt64(); // Sorted tables int n = 0; ulong mask = (ulong)header.maskValid; while (mask != 0) { if (mask % 2 == 1) n++; mask /= 2; } int[] countArray = header.countArray = new int[n]; for (int i = 0; i < n; i++) countArray[i] = c.ReadInt32(); return header; }
protected void ParseHeader() { byte header = this.reader.tables.GetMethodBodyHeaderByte(this.RVA); if ((header & 0x3) == 2) { this.size = header >> 2; this.bodyReader = this.reader.tables.GetNewCursor(); this.reader.tables.Skip(size); } else { method.InitLocals = (header & 0x10) != 0; byte header2 = this.reader.tables.GetByte(); int fatHeaderSize = header2 >> 4; if (fatHeaderSize == 2) return; if (fatHeaderSize != 3) throw new InvalidMetadataException(ExceptionStrings.InvalidFatMethodHeader); this.reader.tables.Skip(2); //Skip over maxstack. No need to remember it. this.size = this.reader.tables.GetInt32(); int localIndex = this.reader.tables.GetInt32(); this.bodyReader = this.reader.tables.GetNewCursor(); this.reader.tables.Skip(size); this.reader.tables.AlignTo32BitBoundary(); while ((header & 0x8) != 0) { header = this.reader.tables.GetByte(); if ((header & 3) != 1) throw new InvalidMetadataException(ExceptionStrings.BadMethodHeaderSection); if ((header & 0x80) != 0) throw new InvalidMetadataException(ExceptionStrings.TooManyMethodHeaderSections); this.ParseExceptionHandlerEntry((header & 0x40) == 0); } Hashtable localSourceNames = new Hashtable(); if (this.reader.getDebugSymbols && this.reader.debugReader != null) { ISymUnmanagedMethod methodInfo = null; try { try { this.reader.debugReader.GetMethod(0x6000000 | (uint)methodIndex, ref methodInfo); if (methodInfo != null) { ISymUnmanagedScope rootScope = methodInfo.GetRootScope(); try { this.reader.GetLocalSourceNames(rootScope, localSourceNames); } finally { if (rootScope != null) Marshal.ReleaseComObject(rootScope); } } } catch (COMException) { } catch (InvalidCastException) { } catch (System.Runtime.InteropServices.InvalidComObjectException) { } } finally { if (methodInfo != null) Marshal.ReleaseComObject(methodInfo); } } this.reader.GetLocals(localIndex, this.locals, localSourceNames); } }
internal MetadataReader(byte* buffer, int length) { this.cursor = new MemoryCursor(buffer, length); //^ base(); ReadHeader(); }
private static string ReadSerString(MemoryCursor/*!*/ sigReader) { int n = sigReader.ReadCompressedInt(); if (n < 0) return null; return sigReader.ReadUTF8(n); }
internal MemoryCursor(MemoryCursor/*!*/ c) { this.buffer = c.buffer; this.pb = c.pb; this.Length = c.Length; }
internal MemoryCursor(MemoryCursor /*!*/ c) { this.buffer = c.buffer; this.pb = c.pb; this.Length = c.Length; }