PortablePdbSymbolWriter.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Linq;
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
 
using IKVM.Reflection.Emit;
 
namespace IKVM.Reflection.Diagnostics
{
 
    internal class PortablePdbSymbolWriter : IMetadataSymbolWriter
    {
 
        protected sealed class Document : ISymbolDocumentWriter
        {
 
            readonly string url;
            readonly Guid language;
            readonly Guid languageVendor;
            readonly Guid documentType;
 
            Guid algorithmId;
            byte[] checksum;
            byte[] source;
 
            internal Document(string url, Guid language, Guid languageVendor, Guid documentType)
            {
                this.url = url;
                this.language = language;
                this.languageVendor = languageVendor;
                this.documentType = documentType;
            }
 
            public void SetCheckSum(Guid algorithmId, byte[] checksum)
            {
                this.algorithmId = algorithmId;
                this.checksum = checksum;
            }
 
            public void SetSource(byte[] source)
            {
                this.source = source;
            }
 
 
            public string Url => url;
 
            public Guid Language => language;
 
            public Guid LanguageVendor => languageVendor;
 
            public Guid DocumentType => documentType;
 
            public Guid AlgorithmId => algorithmId;
 
            public byte[] Checksum => checksum;
 
            public byte[] Source => source;
 
        }
 
        protected readonly struct LocalVar
        {
 
            readonly System.Reflection.FieldAttributes attributes;
            readonly byte[] signature;
            readonly SymAddressKind addrKind;
            readonly int addr1;
            readonly int addr2;
            readonly int addr3;
            readonly int startOffset;
            readonly int endOffset;
 
            internal LocalVar(System.Reflection.FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3, int startOffset, int endOffset)
            {
                this.attributes = attributes;
                this.signature = signature;
                this.addrKind = addrKind;
                this.addr1 = addr1;
                this.addr2 = addr2;
                this.addr3 = addr3;
                this.startOffset = startOffset;
                this.endOffset = endOffset;
            }
 
            public System.Reflection.FieldAttributes Attributes => attributes;
 
            public byte[] Signature => signature;
 
            public SymAddressKind AddressKind => addrKind;
 
            public int Address1 => addr1;
 
            public int Address2 => addr2;
 
            public int Address3 => addr3;
 
            public int StartOffset => startOffset;
 
            public int EndOffset => endOffset;
 
        }
 
        protected sealed class Scope
        {
 
            internal int startOffset;
            internal int endOffset;
            internal List<Scope> scopes;
            internal Dictionary<string, LocalVar> locals;
            internal List<string> namespaces;
 
            internal Scope(int startOffset)
            {
                this.startOffset = startOffset;
            }
 
            public int StartOffset => startOffset;
 
            public int EndOffset => endOffset;
 
            public IReadOnlyList<Scope> Scopes => (IReadOnlyList<Scope>)scopes ?? Array.Empty<Scope>();
 
            public IReadOnlyDictionary<string, LocalVar> Locals => (IReadOnlyDictionary<string, LocalVar>)locals ?? ImmutableDictionary<string, LocalVar>.Empty;
 
            public IReadOnlyList<string> Namespaces => (IReadOnlyList<string>)namespaces ?? Array.Empty<string>();
 
        }
 
        protected sealed class Method
        {
 
            readonly int token;
            readonly StandaloneSignatureHandle localSignatureHandle;
            internal List<SequencePoint> sequencePoints;
            internal List<Scope> scopes;
            internal Stack<Scope> scopeStack;
 
            internal Method(int token, StandaloneSignatureHandle localSignatureHandle)
            {
                this.token = token;
                this.localSignatureHandle = localSignatureHandle;
            }
 
            public int Token => token;
 
            public StandaloneSignatureHandle LocalSignatureHandle => localSignatureHandle;
 
            public IReadOnlyList<SequencePoint> SequencePoints => (IReadOnlyList<SequencePoint>)sequencePoints ?? Array.Empty<SequencePoint>();
 
            public IReadOnlyList<Scope> Scopes => (IReadOnlyList<Scope>)scopes ?? Array.Empty<Scope>();
 
        }
 
        protected readonly struct SequencePoint
        {
 
            readonly Document document;
            readonly int[] offsets;
            readonly int[] lines;
            readonly int[] columns;
            readonly int[] endLines;
            readonly int[] endColumns;
 
            internal SequencePoint(Document document, int[] offsets, int[] lines, int[] columns, int[] endLines, int[] endColumns)
            {
                this.document = document;
                this.offsets = offsets;
                this.lines = lines;
                this.columns = columns;
                this.endLines = endLines;
                this.endColumns = endColumns;
            }
 
            public Document Document => document;
 
            public int[] Offsets => offsets;
 
            public int[] Lines => lines;
 
            public int[] Columns => columns;
 
            public int[] EndLines => endLines;
 
            public int[] EndColumns => endColumns;
 
        }
 
        readonly ModuleBuilder module;
        Dictionary<string, Document> documents;
        List<Method> methods;
        Method currentMethod;
        int userEntryPoint;
 
        public PortablePdbSymbolWriter(ModuleBuilder module)
        {
            this.module = module ?? throw new ArgumentNullException(nameof(module));
        }
 
        public virtual void Initialize(IntPtr emitter, string filename, bool fFullBuild)
        {
            throw new NotImplementedException();
        }
 
        public virtual ISymbolDocumentWriter DefineDocument(string url, Guid language, Guid languageVendor, Guid documentType)
        {
            documents ??= new();
            if (documents.TryGetValue(url, out var doc) == false)
                documents.Add(url, doc = new Document(url, language, languageVendor, documentType));
 
            return doc;
        }
 
        public virtual void OpenNamespace(string name)
        {
            throw new NotImplementedException();
        }
 
        public virtual void OpenMethod(SymbolToken method)
        {
            Debug.Assert(ModuleBuilder.IsPseudoToken(method.GetToken()) == false);
            currentMethod = new Method(method.GetToken(), default);
        }
 
        public virtual void OpenMethod(SymbolToken method, StandaloneSignatureHandle localSignatureHandle)
        {
            Debug.Assert(ModuleBuilder.IsPseudoToken(method.GetToken()) == false);
            currentMethod = new Method(method.GetToken(), localSignatureHandle);
        }
 
        public virtual void DefineSequencePoints(ISymbolDocumentWriter document, int[] offsets, int[] lines, int[] columns, int[] endLines, int[] endColumns)
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            if (document is not Document doc)
                throw new InvalidOperationException("Document not obtained from symbol writer.");
 
            var sequencePoint = new SequencePoint(doc, offsets, lines, columns, endLines, endColumns);
            currentMethod.sequencePoints ??= new();
            currentMethod.sequencePoints.Add(sequencePoint);
        }
 
        public virtual int OpenScope(int startOffset)
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            var scope = new Scope(startOffset);
 
            if (currentMethod.scopeStack == null || currentMethod.scopeStack.Count == 0)
            {
                currentMethod.scopes ??= new();
                currentMethod.scopes.Add(scope);
            }
            else
            {
                var thisScope = currentMethod.scopeStack != null ? currentMethod.scopeStack.Peek() : null;
                thisScope.scopes ??= new();
                thisScope.scopes.Add(scope);
            }
 
            currentMethod.scopeStack ??= new();
            currentMethod.scopeStack.Push(scope);
 
            return 0;
        }
 
        public virtual void UsingNamespace(string fullName)
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            var scope = currentMethod.scopeStack != null ? currentMethod.scopeStack.Peek() : null;
            if (scope == null)
                throw new InvalidOperationException("No open scope.");
 
            scope.namespaces ??= new();
            scope.namespaces.Add(fullName);
        }
 
        public virtual void DefineLocalVariable(string name, System.Reflection.FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3, int startOffset, int endOffset)
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            var scope = currentMethod.scopeStack != null ? currentMethod.scopeStack.Peek() : null;
            if (scope == null)
                throw new InvalidOperationException("No open scope.");
 
            scope.locals ??= new();
            scope.locals[name] = new LocalVar(attributes, signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
        }
 
        public virtual void CloseScope(int endOffset)
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            var scope = currentMethod.scopeStack != null ? currentMethod.scopeStack.Pop() : null;
            if (scope == null)
                throw new InvalidOperationException("No open scope.");
 
            scope.endOffset = endOffset;
        }
 
        public virtual void CloseMethod()
        {
            if (currentMethod == null)
                throw new InvalidOperationException("No open method.");
 
            methods ??= new();
            methods.Add(currentMethod);
            currentMethod = null;
        }
 
        public virtual void CloseNamespace()
        {
            throw new NotImplementedException();
        }
 
        public virtual void Close()
        {
 
        }
 
        public virtual void WriteTo(MetadataBuilder metadata, out int userEntryPoint)
        {
            metadata.GetOrAddString("");
            metadata.GetOrAddUserString("");
 
            if (methods != null)
            {
                var documentCache = new Dictionary<Document, DocumentHandle>();
                foreach (var method in methods)
                    WriteMethod(metadata, method, documentCache);
            }
 
            userEntryPoint = this.userEntryPoint;
        }
 
        void WriteMethod(MetadataBuilder metadata, Method method, Dictionary<Document, DocumentHandle> documentCache)
        {
            // find first document and set as initial, as it will be directly on method debug information
            var initialDocument = GetSingleDocument(method.SequencePoints);
            var initialDocumentHandle = initialDocument != null ? GetOrWriteDocument(metadata, initialDocument, documentCache) : default;
            var currentDocumentHandle = initialDocumentHandle;
 
            // write sequence points and scopes
            WriteSequencePoints(metadata, method, documentCache, out var sequencePointsHandle, ref currentDocumentHandle);
            WriteScopes(metadata, method);
 
            // final debug information, containing initial document
            var methodDebugHandle = metadata.AddMethodDebugInformation(initialDocumentHandle, sequencePointsHandle);
            Debug.Assert(MetadataTokens.GetRowNumber(methodDebugHandle) == MetadataTokens.GetRowNumber(MetadataTokens.EntityHandle(method.Token)));
        }
 
        Document GetSingleDocument(IEnumerable<SequencePoint> sequencePoints)
        {
            var s = sequencePoints.Select(i => i.Document).Distinct().Take(2).ToList();
            return s.Count == 1 ? s[0] : null;
        }
 
        void WriteSequencePoints(MetadataBuilder metadata, Method method, Dictionary<Document, DocumentHandle> documentCache, out BlobHandle sequencePointHandle, ref DocumentHandle previousDocument)
        {
            // no sequence points?
            sequencePointHandle = default;
            if (method.SequencePoints.Count == 0)
                return;
 
            var buf = new BlobBuilder();
            var enc = new SequencePointEncoder(buf);
 
            // obtain local signature from method builder directly
            if (method.LocalSignatureHandle.IsNil)
                throw new InvalidOperationException("MethodBuilder missing local signature.");
 
            // define the local signature, default seems to work fine
            enc.LocalSignature(default);
 
            // add the sequence points recorded on the method
            foreach (var (document, offset, startLine, endLine, startColumn, endColumn) in ExpandSequencePoints(method.SequencePoints).OrderBy(i => i.Offset))
            {
                var doc = GetOrWriteDocument(metadata, document, documentCache);
                enc.SequencePoint(doc, offset, startLine, startColumn, endLine, endColumn, ref previousDocument);
            }
 
            // add sequence points blob
            sequencePointHandle = metadata.GetOrAddBlob(buf);
        }
 
        IEnumerable<(Document Document, int Offset, int StartLine, int EndLine, int StartColumn, int EndColumn)> ExpandSequencePoints(IReadOnlyList<SequencePoint> sequencePoints)
        {
            for (int i = 0; i < sequencePoints.Count; i++)
                for (int j = 0; j < sequencePoints[i].Offsets.Length; j++)
                    yield return (sequencePoints[i].Document, sequencePoints[i].Offsets[j], sequencePoints[i].Lines[j], sequencePoints[i].EndLines[j], sequencePoints[i].Columns[j], sequencePoints[i].EndColumns[j]);
        }
 
        DocumentHandle GetOrWriteDocument(MetadataBuilder metadata, Document document, Dictionary<Document, DocumentHandle> documentCache)
        {
            if (document == null)
                return default;
 
            if (documentCache.TryGetValue(document, out var handle) == false)
                documentCache.Add(document, handle = WriteDocument(metadata, document));
 
            return handle;
        }
 
        DocumentHandle WriteDocument(MetadataBuilder metadata, Document document)
        {
            return metadata.AddDocument(
                metadata.GetOrAddDocumentName(document.Url ?? ""),
                document.AlgorithmId != Guid.Empty ? metadata.GetOrAddGuid(document.AlgorithmId) : default,
                document.Checksum != null ? metadata.GetOrAddBlob(document.Checksum) : default,
                document.Language != Guid.Empty ? metadata.GetOrAddGuid(document.Language) : default);
        }
 
        void WriteScopes(MetadataBuilder metadata, Method method)
        {
            foreach (var scope in method.Scopes.OrderBy(i => i.StartOffset).ThenByDescending(i => i.EndOffset - i.StartOffset))
                WriteScope(metadata, method, scope);
        }
 
        void WriteScope(MetadataBuilder metadata, Method method, Scope scope)
        {
            WriteScope(metadata, method, scope, default);
        }
 
        void WriteScope(MetadataBuilder metadata, Method method, Scope scope, ImportScopeHandle parentImportScope)
        {
            // insert import scope for this scope
            var importScope = default(ImportScopeHandle);
            if (scope.Namespaces.Count > 0)
            {
                var buf = new BlobBuilder();
                var enc = new ImportsEncoder(buf);
 
                // add namespace imports
                foreach (var ns in scope.Namespaces)
                    enc.ImportNamespace(metadata.GetOrAddBlobUTF8(ns));
 
                // write nested scope imports
                importScope = metadata.AddImportScope(parentImportScope, metadata.GetOrAddBlob(buf));
            }
 
            // insert variables for this scope, keeping first entry
            var variableList = default(LocalVariableHandle);
            foreach (var kvp in scope.Locals.OrderBy(i => i.Value.Address1))
            {
                var h = metadata.AddLocalVariable(LocalVariableAttributes.None, kvp.Value.Address1, metadata.GetOrAddString(kvp.Key));
                if (variableList.IsNil)
                    variableList = h;
            }
 
            // add scope
            metadata.AddLocalScope(
                (MethodDefinitionHandle)MetadataTokens.EntityHandle(method.Token),
                importScope,
                variableList,
                default,
                scope.StartOffset,
                scope.EndOffset - scope.StartOffset);
 
            // repeat for children scopes
            foreach (var nestedScope in scope.Scopes.OrderBy(i => i.StartOffset).ThenByDescending(i => i.EndOffset - i.StartOffset))
                WriteScope(metadata, method, nestedScope, importScope);
        }
 
        #region Not Implemented
 
        public void DefineField(SymbolToken parent, string name, System.Reflection.FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3)
        {
            throw new NotImplementedException();
        }
 
        public void DefineGlobalVariable(string name, System.Reflection.FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3)
        {
            throw new NotImplementedException();
        }
 
        public void DefineParameter(string name, System.Reflection.ParameterAttributes attributes, int sequence, SymAddressKind addrKind, int addr1, int addr2, int addr3)
        {
            throw new NotImplementedException();
        }
 
        public void SetMethodSourceRange(ISymbolDocumentWriter startDoc, int startLine, int startColumn, ISymbolDocumentWriter endDoc, int endLine, int endColumn)
        {
            throw new NotImplementedException();
        }
 
        public void SetScopeRange(int scopeID, int startOffset, int endOffset)
        {
            throw new NotImplementedException();
        }
 
        public void SetSymAttribute(SymbolToken parent, string name, byte[] data)
        {
            throw new NotImplementedException();
        }
 
        public void SetUnderlyingWriter(IntPtr underlyingWriter)
        {
            throw new NotImplementedException();
        }
 
        public void SetUserEntryPoint(SymbolToken entryMethod)
        {
            this.userEntryPoint = entryMethod.GetToken();
        }
 
        #endregion
 
    }
 
}