private bool TryGetDebuggableMethod(int methodToken, out PortablePdbReader pdbReader, out MethodDebugInformationHandle handle) { if (!MetadataUtilities.IsMethodToken(methodToken)) { pdbReader = null; handle = default(MethodDebugInformationHandle); return(false); } var methodId = MethodId.FromToken(methodToken); if (Version == 1) { pdbReader = GetReader(version: 1); if (pdbReader.TryGetMethodHandle(methodId, out handle)) { return(pdbReader.HasDebugInfo(handle)); } } else { var methodMap = GetMethodMap(); if (methodMap.IsValidMethodRowId(methodId.Value)) { var info = methodMap.GetInfo(methodId); pdbReader = GetReader(info.Version); handle = info.Handle; return(pdbReader.HasDebugInfo(handle)); } } pdbReader = null; handle = default(MethodDebugInformationHandle); return(false); }
/// <summary> /// Get a list of all documents, including those added via EnC. /// </summary> public int GetDocuments( int bufferLength, out int count, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0), Out] ISymUnmanagedDocument[] documents) { DocumentMap documentMapOpt = null; PortablePdbReader pdbReaderOpt = null; if (Version > 1) { documentMapOpt = GetDocumentMap(); count = documentMapOpt.DocumentCount; } else { pdbReaderOpt = GetReader(version: 1); count = pdbReaderOpt.MetadataReader.Documents.Count; } if (bufferLength == 0) { return(HResult.S_OK); } if (documents == null) { count = 0; return(HResult.E_INVALIDARG); } int i = 0; if (documentMapOpt != null) { foreach (var info in documentMapOpt.Infos) { if (i >= bufferLength) { break; } documents[i++] = new SymDocument(GetReader(info.Version), info.Handle); } } else { foreach (var documentHandle in pdbReaderOpt.MetadataReader.Documents) { if (i >= bufferLength) { break; } documents[i++] = new SymDocument(pdbReaderOpt, documentHandle); } } return(HResult.S_OK); }
internal void Update(PortablePdbReader pdbReader, MethodDebugInformationHandle methodHandle, ImmutableArray <int> deltas, int expectedSequencePointCount) { var newExtentsByDocument = GroupExtentsByDocument(GetMethodExtents(pdbReader, methodHandle, deltas, expectedSequencePointCount)); foreach (var(documentId, newExtents) in newExtentsByDocument) { // we only created extents for a single methods and all extents of a single method within document were merged into one: _extentsByDocument[documentId] = UpdateExtent(_extentsByDocument[documentId], newExtents.Single()); } }
// Takes ownership of <paramref name="pdbReader"/>. internal SymReader(PortablePdbReader pdbReader) { Debug.Assert(pdbReader != null); _pdbReader = pdbReader; _version = 1; _lazyDocumentMap = new Lazy <DocumentMap>(() => new DocumentMap(MetadataReader)); _lazyVbSemantics = new Lazy <bool>(() => IsVisualBasicAssembly()); }
/// <summary> /// Creates <see cref="SymReader"/>. /// </summary> /// <param name="pdbReader"></param> /// <remarks> /// Takes ownership of <paramref name="pdbReader"/>. /// </remarks> public SymReader(PortablePdbReader pdbReader) { Debug.Assert(pdbReader != null); _pdbReader = pdbReader; _version = 1; _lazyDocumentMap = new Lazy<DocumentMap>(() => new DocumentMap(MetadataReader)); _lazyVbSemantics = new Lazy<bool>(() => IsVisualBasicAssembly()); }
public int GetReaderForFile( [MarshalAs(UnmanagedType.Interface)] object importer, [MarshalAs(UnmanagedType.LPWStr)] string fileName, [MarshalAs(UnmanagedType.LPWStr)] string searchPath, [MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedReader reader) { var pdbReader = new PortablePdbReader(File.OpenRead(fileName), importer); reader = new SymReader(pdbReader); return(HResult.S_OK); }
/// Takes ownership of <paramref name="pdbReader"/> and <paramref name="metadataImport"/>. internal SymReader(PortablePdbReader pdbReader, LazyMetadataImport metadataImport) { Debug.Assert(pdbReader != null); Debug.Assert(metadataImport != null); pdbReader.SymReader = this; _pdbReaders = new List <PortablePdbReader>() { pdbReader }; _metadataImport = metadataImport; _lazyDocumentMap = new Lazy <DocumentMap>(() => new DocumentMap(_pdbReaders[0].MetadataReader)); _methodMap = new Lazy <MethodMap>(() => new MethodMap(_pdbReaders[0])); _lazyMethodExtents = new Lazy <MethodExtents>(() => new MethodExtents(_pdbReaders[0])); _lazyVbSemantics = new Lazy <bool>(() => IsVisualBasicAssembly()); }
private int UpdateSymbolStoreImpl( IStream stream, string fileName, SymUnmanagedLineDelta[] lineDeltas, int lineDeltaCount) { Debug.Assert(stream != null ^ fileName != null); Debug.Assert(lineDeltas != null); Debug.Assert(lineDeltaCount >= 0); lineDeltaCount = Math.Min(lineDeltas.Length, lineDeltaCount); var methodMap = GetMethodMap(); var documentMap = GetDocumentMap(); var methodExtents = GetMethodExtents(); var lineDeltasByDocument = GroupLineDeltasByDocument(lineDeltas, lineDeltaCount); int newVersion = Version + 1; var provider = (stream != null) ? CreateProviderFromStream(stream) : CreateProviderFromFile(fileName); var pdbReader = new PortablePdbReader(provider, newVersion, documentMap.DocumentCount); documentMap.Update(this, pdbReader.MetadataReader, newVersion, out var documentHandleToIdMap); methodMap.Update(this, pdbReader.MetadataReader, newVersion, out var methodHandleToIdMap); pdbReader.InitializeHandleToIdMaps(documentHandleToIdMap, methodHandleToIdMap); methodExtents.Update(pdbReader, lineDeltasByDocument); // remove line deltas of methods updated in this generation: for (int i = 0; i < methodHandleToIdMap.Length; i++) { RemoveLineDeltas(methodHandleToIdMap[i]); } // apply line deltas of methods moved around in this generation: for (int i = 0; i < lineDeltaCount; i++) { UpdateLineDeltas(MethodId.FromToken(lineDeltas[i].MethodToken), new MethodLineDeltas(lineDeltas[i].Delta, ImmutableArray <int> .Empty)); } _pdbReaders.Add(pdbReader); pdbReader.SymReader = this; return(HResult.S_OK); }
private bool TryCreateReaderForMatchingPdb( string pdbFilePath, Guid guid, uint stamp, int age, LazyMetadataImport metadataImport, out ISymUnmanagedReader reader) { if (PortableShim.File.Exists(pdbFilePath)) { PortablePdbReader pdbReader; try { pdbReader = new PortablePdbReader(SymReader.CreateProviderFromFile(pdbFilePath), version: 1, previousDocumentCount: 0); } catch { reader = null; return(false); } try { if (pdbReader.MatchesModule(guid, stamp, age)) { reader = new SymReader(pdbReader, metadataImport); pdbReader = null; return(true); } } finally { pdbReader?.Dispose(); } } reader = null; return(false); }
internal void Update(PortablePdbReader pdbReader, Dictionary <DocumentId, List <(MethodId, int)> > lineDeltasByDocument)
public MethodExtents(PortablePdbReader pdbReader) { _extentsByDocument = GroupExtentsByDocument(GetMethodExtents(pdbReader)); }
internal SymMethod(PortablePdbReader pdbReader, MethodDebugInformationHandle handle) { Debug.Assert(pdbReader != null); PdbReader = pdbReader; DebugHandle = handle; }
internal SymConstant(PortablePdbReader pdbReader, LocalConstantHandle handle) { Debug.Assert(pdbReader != null); _pdbReader = pdbReader; _handle = handle; }
internal SymDocument(PortablePdbReader pdbReader, DocumentHandle documentHandle) { Debug.Assert(pdbReader != null); PdbReader = pdbReader; Handle = documentHandle; }
public MethodMap(PortablePdbReader pdbReader) { _baselineMethodCount = pdbReader.MetadataReader.MethodDebugInformation.Count; }