public SerializedMetadata( MetadataSizes sizes, BlobBuilder stringHeap, ImmutableArray<int> stringMap) { Sizes = sizes; StringHeap = stringHeap; StringMap = stringMap; }
public SerializedMetadata( MetadataSizes sizes, BlobBuilder stringHeap, ImmutableArray <int> stringMap) { Sizes = sizes; StringHeap = stringHeap; StringMap = stringMap; }
/// <summary> /// Serialized #Pdb stream. /// </summary> protected override void SerializeStandalonePdbStream(BlobBuilder builder) { int startPosition = builder.Count; // the id will be filled in later _pdbIdBlob = builder.ReserveBytes(MetadataSizes.PdbIdSize); builder.WriteInt32(_entryPoint.IsNil ? 0 : MetadataTokens.GetToken(_entryPoint)); builder.WriteUInt64(MetadataSizes.ExternalTablesMask); MetadataWriterUtilities.SerializeRowCounts(builder, MetadataSizes.ExternalRowCounts); int endPosition = builder.Count; Debug.Assert(MetadataSizes.CalculateStandalonePdbStreamSize() == endPosition - startPosition); }
internal SerializedMetadata GetSerializedMetadata(ImmutableArray <int> externalRowCounts, int metadataVersionByteCount, bool isStandaloneDebugMetadata) { var stringHeapBuilder = new HeapBlobBuilder(_stringHeapCapacity); var stringMap = SerializeStringHeap(stringHeapBuilder, _strings, _stringHeapStartOffset); Debug.Assert(HeapIndex.UserString == 0); Debug.Assert((int)HeapIndex.String == 1); Debug.Assert((int)HeapIndex.Blob == 2); Debug.Assert((int)HeapIndex.Guid == 3); var heapSizes = ImmutableArray.Create( _userStringBuilder.Count, stringHeapBuilder.Count, _blobHeapSize, _guidBuilder.Count); var sizes = new MetadataSizes(GetRowCounts(), externalRowCounts, heapSizes, metadataVersionByteCount, isStandaloneDebugMetadata); return(new SerializedMetadata(sizes, stringHeapBuilder, stringMap)); }
private static void SerializeStreamHeader(ref int offsetFromStartOfMetadata, int alignedStreamSize, string streamName, BlobBuilder builder) { // 4 for the first uint (offset), 4 for the second uint (padded size), length of stream name + 1 for null terminator (then padded) int sizeOfStreamHeader = MetadataSizes.GetMetadataStreamHeaderSize(streamName); builder.WriteInt32(offsetFromStartOfMetadata); builder.WriteInt32(alignedStreamSize); foreach (char ch in streamName) { builder.WriteByte((byte)ch); } // After offset, size, and stream name, write 0-bytes until we reach our padded size. for (uint i = 8 + (uint)streamName.Length; i < sizeOfStreamHeader; i++) { builder.WriteByte(0); } offsetFromStartOfMetadata += alignedStreamSize; }
internal SerializedMetadata GetSerializedMetadata(ImmutableArray<int> externalRowCounts, int metadataVersionByteCount, bool isStandaloneDebugMetadata) { var stringHeapBuilder = new HeapBlobBuilder(_stringHeapCapacity); var stringMap = SerializeStringHeap(stringHeapBuilder, _strings, _stringHeapStartOffset); Debug.Assert(HeapIndex.UserString == 0); Debug.Assert((int)HeapIndex.String == 1); Debug.Assert((int)HeapIndex.Blob == 2); Debug.Assert((int)HeapIndex.Guid == 3); var heapSizes = ImmutableArray.Create( _userStringBuilder.Count, stringHeapBuilder.Count, _blobHeapSize, _guidBuilder.Count); var sizes = new MetadataSizes(GetRowCounts(), externalRowCounts, heapSizes, metadataVersionByteCount, isStandaloneDebugMetadata); return new SerializedMetadata(sizes, stringHeapBuilder, stringMap); }
private void SerializeCustomDebugInformationTable(BlobBuilder writer, MetadataSizes metadataSizes) { // Note: we can sort the table at this point since no other table can reference its rows via RowId or CodedIndex (which would need updating otherwise). // OrderBy performs a stable sort, so multiple attributes with the same parent and kind will be sorted in the order they were added to the table. foreach (CustomDebugInformationRow row in _customDebugInformationTable.OrderBy((x, y) => { int result = (int)x.Parent - (int)y.Parent; return (result != 0) ? result : MetadataTokens.GetHeapOffset(x.Kind) - MetadataTokens.GetHeapOffset(y.Kind); })) { writer.WriteReference(row.Parent, metadataSizes.HasCustomDebugInformationSize); writer.WriteReference((uint)GetHeapOffset(row.Kind), metadataSizes.GuidIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Value), metadataSizes.BlobIndexSize); } }
private void SerializeStandAloneSigTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (StandaloneSigRow row in _standAloneSigTable) { writer.WriteReference((uint)GetHeapOffset(row.Signature), metadataSizes.BlobIndexSize); } }
private void SerializeLocalVariableTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (var row in _localVariableTable) { writer.WriteUInt16(row.Attributes); writer.WriteUInt16(row.Index); writer.WriteReference((uint)GetHeapOffset(row.Name), metadataSizes.StringIndexSize); } }
private void SerializeImportScopeTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (var row in _importScopeTable) { writer.WriteReference(row.Parent, metadataSizes.ImportScopeIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Imports), metadataSizes.BlobIndexSize); } }
private void SerializeMethodSpecTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (MethodSpecRow methodSpec in _methodSpecTable) { writer.WriteReference(methodSpec.Method, metadataSizes.MethodDefOrRefCodedIndexSize); writer.WriteReference((uint)GetHeapOffset(methodSpec.Instantiation), metadataSizes.BlobIndexSize); } }
private void SerializeMethodDebugInformationTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (var row in _methodDebugInformationTable) { writer.WriteReference(row.Document, metadataSizes.DocumentIndexSize); writer.WriteReference((uint)GetHeapOffset(row.SequencePoints), metadataSizes.BlobIndexSize); } }
private void SerializeManifestResourceTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (ManifestResourceRow manifestResource in _manifestResourceTable) { writer.WriteUInt32(manifestResource.Offset); writer.WriteUInt32(manifestResource.Flags); writer.WriteReference((uint)GetHeapOffset(manifestResource.Name), metadataSizes.StringIndexSize); writer.WriteReference(manifestResource.Implementation, metadataSizes.ImplementationCodedIndexSize); } }
private void SerializeGenericParamTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _genericParamTable.Count; i++) { Debug.Assert( _genericParamTable[i - 1].Owner < _genericParamTable[i].Owner || _genericParamTable[i - 1].Owner == _genericParamTable[i].Owner && _genericParamTable[i - 1].Number < _genericParamTable[i].Number); } #endif foreach (GenericParamRow genericParam in _genericParamTable) { writer.WriteUInt16(genericParam.Number); writer.WriteUInt16(genericParam.Flags); writer.WriteReference(genericParam.Owner, metadataSizes.TypeOrMethodDefCodedIndexSize); writer.WriteReference((uint)GetHeapOffset(genericParam.Name), metadataSizes.StringIndexSize); } }
private void SerializeFileTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (FileTableRow fileReference in _fileTable) { writer.WriteUInt32(fileReference.Flags); writer.WriteReference((uint)GetHeapOffset(fileReference.FileName), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(fileReference.HashValue), metadataSizes.BlobIndexSize); } }
private void SerializeFieldRvaTable(BlobBuilder writer, MetadataSizes metadataSizes, int mappedFieldDataStreamRva) { #if DEBUG for (int i = 1; i < _fieldRvaTable.Count; i++) { Debug.Assert(_fieldRvaTable[i - 1].Field < _fieldRvaTable[i].Field); } #endif foreach (FieldRvaRow fieldRva in _fieldRvaTable) { writer.WriteUInt32((uint)mappedFieldDataStreamRva + fieldRva.Offset); writer.WriteReference(fieldRva.Field, metadataSizes.FieldDefIndexSize); } }
public MetadataSerializer(MetadataBuilder builder, MetadataSizes sizes, string metadataVersion) { _builder = builder; _sizes = sizes; _metadataVersion = metadataVersion; }
public MetadataSerializer(MetadataBuilder tables, MetadataSizes sizes, string metadataVersion) { _tables = tables; _sizes = sizes; _metadataVersion = metadataVersion; }
internal static void SerializeMetadataHeader(BlobBuilder builder, string metadataVersion, MetadataSizes sizes) { int startOffset = builder.Count; // signature builder.WriteUInt32(0x424A5342); // major version builder.WriteUInt16(1); // minor version builder.WriteUInt16(1); // reserved builder.WriteUInt32(0); // Spec (section 24.2.1 Metadata Root): // Length ... Number of bytes allocated to hold version string (including null terminator), call this x. // Call the length of the string (including the terminator) m (we require m <= 255); // the length x is m rounded up to a multiple of four. builder.WriteInt32(sizes.MetadataVersionPaddedLength); int metadataVersionStart = builder.Count; builder.WriteUTF8(metadataVersion); builder.WriteByte(0); int metadataVersionEnd = builder.Count; for (int i = 0; i < sizes.MetadataVersionPaddedLength - (metadataVersionEnd - metadataVersionStart); i++) { builder.WriteByte(0); } // reserved builder.WriteUInt16(0); // number of streams builder.WriteUInt16((ushort)(5 + (sizes.IsEncDelta ? 1 : 0) + (sizes.IsStandaloneDebugMetadata ? 1 : 0))); // stream headers int offsetFromStartOfMetadata = sizes.MetadataHeaderSize; // emit the #Pdb stream first so that only a single page has to be read in order to find out PDB ID if (sizes.IsStandaloneDebugMetadata) { SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.StandalonePdbStreamSize, "#Pdb", builder); } // Spec: Some compilers store metadata in a #- stream, which holds an uncompressed, or non-optimized, representation of metadata tables; // this includes extra metadata -Ptr tables. Such PE files do not form part of ECMA-335 standard. // // Note: EnC delta is stored as uncompressed metadata stream. SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.MetadataTableStreamSize, (sizes.IsCompressed ? "#~" : "#-"), builder); SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.GetAlignedHeapSize(HeapIndex.String), "#Strings", builder); SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.GetAlignedHeapSize(HeapIndex.UserString), "#US", builder); SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.GetAlignedHeapSize(HeapIndex.Guid), "#GUID", builder); SerializeStreamHeader(ref offsetFromStartOfMetadata, sizes.GetAlignedHeapSize(HeapIndex.Blob), "#Blob", builder); if (sizes.IsEncDelta) { SerializeStreamHeader(ref offsetFromStartOfMetadata, 0, "#JTD", builder); } int endOffset = builder.Count; Debug.Assert(endOffset - startOffset == sizes.MetadataHeaderSize); }
private void SerializeAssemblyRefTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (AssemblyRefTableRow row in _assemblyRefTable) { writer.WriteUInt16((ushort)row.Version.Major); writer.WriteUInt16((ushort)row.Version.Minor); writer.WriteUInt16((ushort)row.Version.Build); writer.WriteUInt16((ushort)row.Version.Revision); writer.WriteUInt32(row.Flags); writer.WriteReference((uint)GetHeapOffset(row.PublicKeyToken), metadataSizes.BlobIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Name), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Culture), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(row.HashValue), metadataSizes.BlobIndexSize); } }
private void SerializeEventMapTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (EventMapRow eventMap in _eventMapTable) { writer.WriteReference(eventMap.Parent, metadataSizes.TypeDefIndexSize); writer.WriteReference(eventMap.EventList, metadataSizes.EventDefIndexSize); } }
private void SerializeExportedTypeTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (ExportedTypeRow exportedType in _exportedTypeTable) { writer.WriteUInt32((uint)exportedType.Flags); writer.WriteUInt32(exportedType.TypeDefId); writer.WriteReference((uint)GetHeapOffset(exportedType.TypeName), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(exportedType.TypeNamespace), metadataSizes.StringIndexSize); writer.WriteReference(exportedType.Implementation, metadataSizes.ImplementationCodedIndexSize); } }
private void SerializeEventTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (EventRow eventRow in _eventTable) { writer.WriteUInt16(eventRow.EventFlags); writer.WriteReference((uint)GetHeapOffset(eventRow.Name), metadataSizes.StringIndexSize); writer.WriteReference(eventRow.EventType, metadataSizes.TypeDefOrRefCodedIndexSize); } }
private void SerializeNestedClassTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _nestedClassTable.Count; i++) { Debug.Assert(_nestedClassTable[i - 1].NestedClass <= _nestedClassTable[i].NestedClass); } #endif foreach (NestedClassRow nestedClass in _nestedClassTable) { writer.WriteReference(nestedClass.NestedClass, metadataSizes.TypeDefIndexSize); writer.WriteReference(nestedClass.EnclosingClass, metadataSizes.TypeDefIndexSize); } }
private void SerializePropertyMapTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (PropertyMapRow propertyMap in _propertyMapTable) { writer.WriteReference(propertyMap.Parent, metadataSizes.TypeDefIndexSize); writer.WriteReference(propertyMap.PropertyList, metadataSizes.PropertyDefIndexSize); } }
private void SerializeGenericParamConstraintTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _genericParamConstraintTable.Count; i++) { Debug.Assert(_genericParamConstraintTable[i - 1].Owner <= _genericParamConstraintTable[i].Owner); } #endif foreach (GenericParamConstraintRow genericParamConstraint in _genericParamConstraintTable) { writer.WriteReference(genericParamConstraint.Owner, metadataSizes.GenericParamIndexSize); writer.WriteReference(genericParamConstraint.Constraint, metadataSizes.TypeDefOrRefCodedIndexSize); } }
private void SerializePropertyTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (PropertyRow property in _propertyTable) { writer.WriteUInt16(property.PropFlags); writer.WriteReference((uint)GetHeapOffset(property.Name), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(property.Type), metadataSizes.BlobIndexSize); } }
private void SerializeDocumentTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (var row in _documentTable) { writer.WriteReference((uint)GetHeapOffset(row.Name), metadataSizes.BlobIndexSize); writer.WriteReference((uint)GetHeapOffset(row.HashAlgorithm), metadataSizes.GuidIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Hash), metadataSizes.BlobIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Language), metadataSizes.GuidIndexSize); } }
private void SerializeMethodSemanticsTable(BlobBuilder writer, MetadataSizes metadataSizes) { // Note: we can sort the table at this point since no other table can reference its rows via RowId or CodedIndex (which would need updating otherwise). // OrderBy performs a stable sort, so multiple attributes with the same parent will be sorted in the order they were added to the table. var ordered = _methodSemanticsTableNeedsSorting ? (IEnumerable<MethodSemanticsRow>)_methodSemanticsTable.OrderBy((x, y) => (int)x.Association - (int)y.Association) : _methodSemanticsTable; foreach (MethodSemanticsRow methodSemantic in ordered) { writer.WriteUInt16(methodSemantic.Semantic); writer.WriteReference(methodSemantic.Method, metadataSizes.MethodDefIndexSize); writer.WriteReference(methodSemantic.Association, metadataSizes.HasSemanticsCodedIndexSize); } }
private void SerializeLocalScopeTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG // Spec: The table is required to be sorted first by Method in ascending order, then by StartOffset in ascending order, then by Length in descending order. for (int i = 1; i < _localScopeTable.Count; i++) { Debug.Assert(_localScopeTable[i - 1].Method <= _localScopeTable[i].Method); if (_localScopeTable[i - 1].Method == _localScopeTable[i].Method) { Debug.Assert(_localScopeTable[i - 1].StartOffset <= _localScopeTable[i].StartOffset); if (_localScopeTable[i - 1].StartOffset == _localScopeTable[i].StartOffset) { Debug.Assert(_localScopeTable[i - 1].Length >= _localScopeTable[i].Length); } } } #endif foreach (var row in _localScopeTable) { writer.WriteReference(row.Method, metadataSizes.MethodDefIndexSize); writer.WriteReference(row.ImportScope, metadataSizes.ImportScopeIndexSize); writer.WriteReference(row.VariableList, metadataSizes.LocalVariableIndexSize); writer.WriteReference(row.ConstantList, metadataSizes.LocalConstantIndexSize); writer.WriteUInt32(row.StartOffset); writer.WriteUInt32(row.Length); } }
private void SerializeMethodImplTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _methodImplTable.Count; i++) { Debug.Assert(_methodImplTable[i - 1].Class <= _methodImplTable[i].Class); } #endif foreach (MethodImplRow methodImpl in _methodImplTable) { writer.WriteReference(methodImpl.Class, metadataSizes.TypeDefIndexSize); writer.WriteReference(methodImpl.MethodBody, metadataSizes.MethodDefOrRefCodedIndexSize); writer.WriteReference(methodImpl.MethodDecl, metadataSizes.MethodDefOrRefCodedIndexSize); } }
private void SerializeLocalConstantTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (var row in _localConstantTable) { writer.WriteReference((uint)GetHeapOffset(row.Name), metadataSizes.StringIndexSize); writer.WriteReference((uint)GetHeapOffset(row.Signature), metadataSizes.BlobIndexSize); } }
private void SerializeModuleRefTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (ModuleRefRow moduleRef in _moduleRefTable) { writer.WriteReference((uint)GetHeapOffset(moduleRef.Name), metadataSizes.StringIndexSize); } }
private void SerializeStateMachineMethodTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _stateMachineMethodTable.Count; i++) { Debug.Assert(_stateMachineMethodTable[i - 1].MoveNextMethod < _stateMachineMethodTable[i].MoveNextMethod); } #endif foreach (var row in _stateMachineMethodTable) { writer.WriteReference(row.MoveNextMethod, metadataSizes.MethodDefIndexSize); writer.WriteReference(row.KickoffMethod, metadataSizes.MethodDefIndexSize); } }
private void SerializeTypeSpecTable(BlobBuilder writer, MetadataSizes metadataSizes) { foreach (TypeSpecRow typeSpec in _typeSpecTable) { writer.WriteReference((uint)GetHeapOffset(typeSpec.Signature), metadataSizes.BlobIndexSize); } }
internal void SerializeMetadataTables( BlobBuilder writer, MetadataSizes metadataSizes, int methodBodyStreamRva, int mappedFieldDataStreamRva) { int startPosition = writer.Position; this.SerializeTablesHeader(writer, metadataSizes); if (metadataSizes.IsPresent(TableIndex.Module)) { SerializeModuleTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.TypeRef)) { this.SerializeTypeRefTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.TypeDef)) { this.SerializeTypeDefTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.Field)) { this.SerializeFieldTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MethodDef)) { this.SerializeMethodDefTable(writer, metadataSizes, methodBodyStreamRva); } if (metadataSizes.IsPresent(TableIndex.Param)) { this.SerializeParamTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.InterfaceImpl)) { this.SerializeInterfaceImplTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MemberRef)) { this.SerializeMemberRefTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.Constant)) { this.SerializeConstantTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.CustomAttribute)) { this.SerializeCustomAttributeTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.FieldMarshal)) { this.SerializeFieldMarshalTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.DeclSecurity)) { this.SerializeDeclSecurityTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ClassLayout)) { this.SerializeClassLayoutTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.FieldLayout)) { this.SerializeFieldLayoutTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.StandAloneSig)) { this.SerializeStandAloneSigTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.EventMap)) { this.SerializeEventMapTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.Event)) { this.SerializeEventTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.PropertyMap)) { this.SerializePropertyMapTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.Property)) { this.SerializePropertyTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MethodSemantics)) { this.SerializeMethodSemanticsTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MethodImpl)) { this.SerializeMethodImplTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ModuleRef)) { this.SerializeModuleRefTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.TypeSpec)) { this.SerializeTypeSpecTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ImplMap)) { this.SerializeImplMapTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.FieldRva)) { this.SerializeFieldRvaTable(writer, metadataSizes, mappedFieldDataStreamRva); } if (metadataSizes.IsPresent(TableIndex.EncLog)) { this.SerializeEncLogTable(writer); } if (metadataSizes.IsPresent(TableIndex.EncMap)) { this.SerializeEncMapTable(writer); } if (metadataSizes.IsPresent(TableIndex.Assembly)) { this.SerializeAssemblyTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.AssemblyRef)) { this.SerializeAssemblyRefTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.File)) { this.SerializeFileTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ExportedType)) { this.SerializeExportedTypeTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ManifestResource)) { this.SerializeManifestResourceTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.NestedClass)) { this.SerializeNestedClassTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.GenericParam)) { this.SerializeGenericParamTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MethodSpec)) { this.SerializeMethodSpecTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.GenericParamConstraint)) { this.SerializeGenericParamConstraintTable(writer, metadataSizes); } // debug tables if (metadataSizes.IsPresent(TableIndex.Document)) { this.SerializeDocumentTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.MethodDebugInformation)) { this.SerializeMethodDebugInformationTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.LocalScope)) { this.SerializeLocalScopeTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.LocalVariable)) { this.SerializeLocalVariableTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.LocalConstant)) { this.SerializeLocalConstantTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.ImportScope)) { this.SerializeImportScopeTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.StateMachineMethod)) { this.SerializeStateMachineMethodTable(writer, metadataSizes); } if (metadataSizes.IsPresent(TableIndex.CustomDebugInformation)) { this.SerializeCustomDebugInformationTable(writer, metadataSizes); } writer.WriteByte(0); writer.Align(4); int endPosition = writer.Position; Debug.Assert(metadataSizes.MetadataTableStreamSize == endPosition - startPosition); }
private void SerializeImplMapTable(BlobBuilder writer, MetadataSizes metadataSizes) { #if DEBUG for (int i = 1; i < _implMapTable.Count; i++) { Debug.Assert(_implMapTable[i - 1].MemberForwarded < _implMapTable[i].MemberForwarded); } #endif foreach (ImplMapRow implMap in _implMapTable) { writer.WriteUInt16(implMap.MappingFlags); writer.WriteReference(implMap.MemberForwarded, metadataSizes.MemberForwardedCodedIndexSize); writer.WriteReference((uint)GetHeapOffset(implMap.ImportName), metadataSizes.StringIndexSize); writer.WriteReference(implMap.ImportScope, metadataSizes.ModuleRefIndexSize); } }