예제 #1
0
        public CustomMetadataWriter(SymWriter sym_writer)
        {
            this.sym_writer = sym_writer;
            this.stream     = new MemoryStream();
            this.writer     = new BinaryStreamWriter(stream);

            writer.WriteByte(version);
            writer.WriteByte(0);              // count
            writer.Align(4);
        }
예제 #2
0
        void Write(CustomMetadataType type, Action write)
        {
            count++;
            writer.WriteByte(version);
            writer.WriteByte((byte)type);
            writer.Align(4);

            var length_position = writer.Position;

            writer.WriteUInt32(0);

            write();
            writer.Align(4);

            var end    = writer.Position;
            var length = end - length_position + 4;             // header is 4 bytes long

            writer.Position = length_position;
            writer.WriteInt32(length);

            writer.Position = end;
        }
예제 #3
0
        private void DefineCustomMetadata(PdbMethodSymbols pdbSymbols)
        {
            // Custom PDB metadata
            if (pdbSymbols != null)
            {
                using (var memoryStream = new MemoryStream()) {
                    var metadata = new BinaryStreamWriter(memoryStream);
                    metadata.WriteByte(4);                      // version
                    metadata.WriteByte((byte)1);                // count
                    metadata.WriteInt16(0);                     // padding

                    var metadataStartPosition = metadata.BaseStream.Position;
                    var customMetadataCount   = 0;

                    if (pdbSymbols.IteratorClass != null)
                    {
                        customMetadataCount++;
                        metadata.WriteByte(4);                          // version
                        metadata.WriteByte(4);                          // forward iterator
                        metadata.Align(4);
                        using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
                            metadata.WriteString(pdbSymbols.IteratorClass);
                            metadata.WriteInt16(0);
                            metadata.Align(4);
                        }
                    }

                    if (pdbSymbols.UsingCounts != null)
                    {
                        customMetadataCount++;
                        metadata.WriteByte(4);                          // version
                        metadata.WriteByte(0);                          // using info
                        metadata.Align(4);
                        using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
                            metadata.WriteUInt16((ushort)pdbSymbols.UsingCounts.Count);
                            foreach (var uc in pdbSymbols.UsingCounts)
                            {
                                metadata.WriteUInt16(uc);
                            }
                            metadata.Align(4);
                        }
                    }

                    if (pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod != null)
                    {
                        customMetadataCount++;
                        metadata.WriteByte(4);                          // version
                        metadata.WriteByte(1);                          // forward info
                        metadata.Align(4);
                        using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
                            metadata.WriteUInt32(pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod.MetadataToken.ToUInt32());
                        }
                    }

                    if (pdbSymbols.IteratorScopes != null)
                    {
                        customMetadataCount++;
                        metadata.WriteByte(4);                          // version
                        metadata.WriteByte(3);                          // iterator scopes
                        metadata.Align(4);
                        using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
                            metadata.WriteInt32(pdbSymbols.IteratorScopes.Count);
                            foreach (var scope in pdbSymbols.IteratorScopes)
                            {
                                metadata.WriteInt32(scope.Start.Offset);
                                metadata.WriteInt32(scope.End.Offset);
                            }
                        }
                    }

                    if (metadata.BaseStream.Position != metadataStartPosition)
                    {
                        // Update number of entries
                        metadata.Flush();
                        metadata.BaseStream.Position = 1;
                        metadata.WriteByte((byte)customMetadataCount);
                        metadata.Flush();

                        writer.DefineCustomMetadata("MD2", memoryStream.ToArray());
                    }
                }

                // Save back asyncMethodInfo
                if (pdbSymbols.SynchronizationInformation != null)
                {
                    using (var memoryStream = new MemoryStream()) {
                        var metadata = new BinaryStreamWriter(memoryStream);
                        metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.KickoffMethod != null ? pdbSymbols.SynchronizationInformation.KickoffMethod.MetadataToken.ToUInt32() : 0);
                        metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.GeneratedCatchHandlerIlOffset);
                        metadata.WriteUInt32((uint)pdbSymbols.SynchronizationInformation.SynchronizationPoints.Count);
                        foreach (var syncPoint in pdbSymbols.SynchronizationInformation.SynchronizationPoints)
                        {
                            metadata.WriteUInt32(syncPoint.SynchronizeOffset);
                            metadata.WriteUInt32(syncPoint.ContinuationMethod != null ? syncPoint.ContinuationMethod.MetadataToken.ToUInt32() : 0);
                            metadata.WriteUInt32(syncPoint.ContinuationOffset);
                        }

                        writer.DefineCustomMetadata("asyncMethodInfo", memoryStream.ToArray());
                    }
                }
            }
        }
 /// <summary>
 /// Serialises the blob stream buffer to a metadata stream.
 /// </summary>
 /// <returns>The metadata stream.</returns>
 public BlobStream CreateStream()
 {
     _writer.Align(4);
     return(new SerializedBlobStream(Name, _rawStream.ToArray()));
 }
 /// <summary>
 /// Serializes
 /// </summary>
 /// <returns></returns>
 public UserStringsStream CreateStream()
 {
     _writer.Align(4);
     return(new SerializedUserStringsStream(Name, _rawStream.ToArray()));
 }