public SymbolMethod(ISymUnmanagedMethod unmanagedMethod) { if (unmanagedMethod == null) { throw new ArgumentNullException("unmanagedMethod"); } this.unmanagedMethod = unmanagedMethod; }
public SymMethod(ISymUnmanagedMethod unmanagedMethod) { // We should not wrap null instances if (unmanagedMethod == null) throw new ArgumentNullException("unmanagedMethod"); m_unmanagedMethod = unmanagedMethod; }
public int GetMethodByVersionPreRemap( int methodToken, int version, out ISymUnmanagedMethod retVal ) { retVal = null; return(HResult.E_NOTIMPL); }
public static ISymUnmanagedMethod[] GetMethodsFromDocumentPosition(this CorSymReader_SxSClass instance, ISymUnmanagedDocument document, uint line, uint column) { uint count; instance.__GetMethodsFromDocumentPosition(document, line, column, 0, out count, new ISymUnmanagedMethod[0]); var methods = new ISymUnmanagedMethod[count]; instance.__GetMethodsFromDocumentPosition(document, line, column, count, out count, methods); ProcessOutParameter(methods); return methods; }
public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMethod retVal) { // Versions are 1-based. Debug.Assert(version >= 1); var reader = _readerVersions[version - 1]; version = _readerVersions.Length > 1 ? 1 : version; return(reader.GetMethodByVersion(methodToken, version, out retVal)); }
public int GetMethodFromDocumentPosition( ISymUnmanagedDocument document, int line, int column, out ISymUnmanagedMethod method ) { throw new NotImplementedException(); }
public ISymbolMethod GetMethodFromDocumentPosition(ISymbolDocument document, int line, int column) { ISymUnmanagedMethod unmanagedMethod = null; m_reader.GetMethodFromDocumentPosition(((SymbolDocument)document).InternalDocument, line, column, out unmanagedMethod); return(new SymMethod(unmanagedMethod)); }
internal static void GetAllScopes( this ISymUnmanagedMethod method, ArrayBuilder <ISymUnmanagedScope> allScopes, ArrayBuilder <ISymUnmanagedScope> containingScopes, int offset, bool isScopeEndInclusive) { GetAllScopes(method.GetRootScope(), allScopes, containingScopes, offset, isScopeEndInclusive); }
public int GetMethodByVersion(SymbolToken methodToken, int version, out ISymUnmanagedMethod retVal) { var hr = _reader.GetMethodByVersion(methodToken, version, out retVal); if (retVal != null) { retVal = new SymMethod(this, retVal); } return hr; }
public SymbolMethod(ISymUnmanagedMethod unmanaged) { if (unmanaged == null) { throw new ArgumentNullException("unmanaged"); } _unmanaged = unmanaged; }
public SymMethod(ISymUnmanagedMethod unmanagedMethod) { // We should not wrap null instances if (unmanagedMethod == null) { throw new ArgumentNullException("unmanagedMethod"); } m_unmanagedMethod = unmanagedMethod; }
/// <remarks> /// Test helper. /// </remarks> internal static void GetAllScopes( this ISymUnmanagedMethod method, ArrayBuilder <ISymUnmanagedScope> builder ) { var unused = ArrayBuilder <ISymUnmanagedScope> .GetInstance(); GetAllScopes(method, builder, unused, offset: -1, isScopeEndInclusive: false); unused.Free(); }
public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMethod retVal) { var hr = _reader.GetMethodByVersion(methodToken, version, out retVal); if (retVal != null) { retVal = new SymMethod(this, retVal); } return(hr); }
public static int GetToken(this ISymUnmanagedMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } ThrowExceptionForHR(method.GetToken(out int token)); return(token); }
public static ISymUnmanagedScope GetRootScope(this ISymUnmanagedMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } ThrowExceptionForHR(method.GetRootScope(out var scope)); return(scope); }
public int GetMethodFromDocumentPosition( ISymUnmanagedDocument document, int line, int column, out ISymUnmanagedMethod retVal ) { retVal = null; return(HResult.E_NOTIMPL); }
public static ISymUnmanagedDocument[] GetDocumentsForMethod(this ISymUnmanagedMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } return(NullToEmpty(GetItems((ISymEncUnmanagedMethod)method, (ISymEncUnmanagedMethod a, out int b) => a.GetDocumentsForMethodCount(out b), (ISymEncUnmanagedMethod a, int b, out int c, ISymUnmanagedDocument[] d) => a.GetDocumentsForMethod(b, out c, d)))); }
public static ISymUnmanagedMethod[] GetMethodsFromDocumentPosition(this CorSymReader_SxSClass instance, ISymUnmanagedDocument document, uint line, uint column) { uint count; instance.__GetMethodsFromDocumentPosition(document, line, column, 0, out count, new ISymUnmanagedMethod[0]); var methods = new ISymUnmanagedMethod[count]; instance.__GetMethodsFromDocumentPosition(document, line, column, count, out count, methods); ProcessOutParameter(methods); return(methods); }
/// <summary> /// Get a string representing the source location for the given IL offset and method /// </summary> /// <param name="method">The method of interest</param> /// <param name="ilOffset">The offset into the IL</param> /// <returns>A string of the format [filepath]:[line] (eg. "C:\temp\foo.cs:123"), or null /// if a matching PDB couldn't be found</returns> /// <remarks>Thows various COMExceptions (from DIA SDK error values) if a PDB couldn't be opened/read</remarks> public SourceLoc GetSourceLoc(MethodBase method, int ilOffset) { // Get the symbol reader corresponding to the module of the supplied method string modulePath = method.Module.FullyQualifiedName; ISymUnmanagedReader symReader = GetSymbolReaderForFile(modulePath); if (symReader == null) { return(null); // no PDBs } ISymUnmanagedMethod symMethod = symReader.GetMethod(new SymbolToken(method.MetadataToken)); // Get all the sequence points for the method int count = symMethod.GetSequencePointCount(); ISymUnmanagedDocument[] docs = new ISymUnmanagedDocument[count]; int[] startLines = new int[count]; int[] ilOffsets = new int[count]; int[] endLines = new int[count]; int[] startCols = new int[count]; int[] endCols = new int[count]; int outPoints; symMethod.GetSequencePoints(count, out outPoints, ilOffsets, docs, startLines, startCols, endLines, endCols); // Find the closest sequence point to the requested offset // Sequence points are returned sorted by offset so we're looking for the last one with // an offset less than or equal to the requested offset. // Note that this won't necessarily match the real source location exactly if // the code was jit-compiled with optimizations. int i; for (i = 0; i < count; i++) { if (ilOffsets[i] > ilOffset) { break; } } // Found the first mismatch, back up if it wasn't the first if (i > 0) { i--; } // Now return the source file and line number for this sequence point StringBuilder url = new StringBuilder(512); int len; docs[i].GetURL(url.Capacity, out len, url); return(new SourceLoc(url.ToString(), startLines[i], endLines[i], startCols[i], endCols[i])); }
public static int GetMethodVersion(this ISymUnmanagedReader reader, ISymUnmanagedMethod method) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } int version; ThrowExceptionForHR(reader.GetMethodVersion(method, out version)); return(version); }
public int GetMethodVersion(ISymUnmanagedMethod method, out int version) { var symMethod = AsSymMethod(method); if (symMethod == null) { version = 0; return(HResult.E_INVALIDARG); } version = symMethod.PdbReader.Version; return(HResult.S_OK); }
private static bool TryGetDocsAndLines( ISymUnmanagedMethod methodSymbols, CompetitionState competitionState, out ISymUnmanagedDocument[] documents, out int[] startLines) { documents = Array <ISymUnmanagedDocument> .Empty; startLines = Array <int> .Empty; try { int numAvailable; var hr = methodSymbols.GetSequencePointCount(out numAvailable); ThrowExceptionForHR(hr); documents = new ISymUnmanagedDocument[numAvailable]; startLines = new int[numAvailable]; if (numAvailable > 0) { var offsets = new int[numAvailable]; var startColumns = new int[numAvailable]; var endLines = new int[numAvailable]; var endColumns = new int[numAvailable]; int numRead; hr = methodSymbols.GetSequencePoints( numAvailable, out numRead, offsets, documents, startLines, startColumns, endLines, endColumns); ThrowExceptionForHR(hr); if (numRead != numAvailable) { throw new COMException($"Read only {numRead} of {numAvailable} sequence points."); } } } catch (COMException ex) { // ReSharper disable once PossibleNullReferenceException competitionState.WriteExceptionMessage( MessageSource.Analyser, MessageSeverity.ExecutionError, "Could not parse method symbols.", ex); return(false); } return(startLines.Length > 0); }
public int GetMethodFromDocumentPosition( ISymUnmanagedDocument document, int line, int column, [MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedMethod method) { var symDocument = AsSymDocument(document); if (symDocument == null) { method = null; return(HResult.E_INVALIDARG); } var methodExtents = GetMethodExtents(); var methods = methodExtents.GetMethodsContainingLine(symDocument.GetId(), line); if (methods == null) { method = null; return(HResult.E_FAIL); } var candidate = default((MethodId Id, int Version)); foreach (var(methodId, version) in methods) { if (candidate.Id.IsDefault || methodId < candidate.Id) { candidate = (methodId, version); } } if (candidate.Id.IsDefault) { method = null; return(HResult.E_FAIL); } var pdbReader = GetReader(candidate.Version); if (!pdbReader.TryGetMethodHandle(candidate.Id, out var handle)) { method = null; return(HResult.E_FAIL); } method = new SymMethod(pdbReader, handle); return(HResult.S_OK); }
public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMethod retVal) { Assert.Equal(1, version); MethodDebugInfoBytes info; if (!_methodDebugInfoMap.TryGetValue(methodToken, out info)) { retVal = null; return(HResult.E_FAIL); } Assert.NotNull(info); retVal = info.Method; return(HResult.S_OK); }
public Builder(string[][] importStringGroups = null, bool suppressUsingInfo = false, ISymUnmanagedConstant[] constants = null) { _bytesBuilder = ArrayBuilder<byte>.GetInstance(); if (importStringGroups != null && !suppressUsingInfo) { var groupSizes = importStringGroups.Select(g => (short)g.Length).ToArray(); AddUsingInfo(groupSizes); } var namespaces = importStringGroups == null ? default(ImmutableArray<ISymUnmanagedNamespace>) : importStringGroups.SelectMany(names => names.Select(name => (ISymUnmanagedNamespace)new MockSymUnmanagedNamespace(name))).ToImmutableArray(); var childScope = new MockSymUnmanagedScope(default(ImmutableArray<ISymUnmanagedScope>), namespaces, constants); var rootScope = new MockSymUnmanagedScope(ImmutableArray.Create<ISymUnmanagedScope>(childScope), default(ImmutableArray<ISymUnmanagedNamespace>)); _method = new MockSymUnmanagedMethod(rootScope); }
public static ISymUnmanagedMethod GetMethodByVersion(this ISymUnmanagedReader reader, int methodToken, int methodVersion) { ISymUnmanagedMethod method = null; int hr = reader.GetMethodByVersion(new SymbolToken(methodToken), methodVersion, out method); ThrowExceptionForHR(hr); if (hr < 0) { // method has no symbol info return(null); } Debug.Assert(method != null); return(method); }
public static ISymUnmanagedMethod GetMethodByVersion(this ISymUnmanagedReader reader, int methodToken, int methodVersion) { ISymUnmanagedMethod method = null; int hr = reader.GetMethodByVersion(new SymbolToken(methodToken), methodVersion, out method); ThrowExceptionForHR(hr); if (hr < 0) { // method has no symbol info Debug.WriteLine(string.Format("Invalid method token '0x{0:x8}' or version '{1}' (hresult = 0x{2:x8})", methodToken, methodVersion, hr)); return(null); } Debug.Assert(method != null); return(method); }
public ISymbolMethod GetMethod(SymbolToken method, int version) { ISymUnmanagedMethod unmanagedMethod = null; int hr = m_reader.GetMethodByVersion(method, version, out unmanagedMethod); if (hr == (int)HResult.E_FAIL) { // This means that the method has no symbol info because it's probably empty // This can happen for virtual methods with no IL return(null); } else { Marshal.ThrowExceptionForHR(hr); } return(new SymMethod(unmanagedMethod)); }
internal static ISymUnmanagedMethod[] GetMethodsFromDocumentPosition( ISymUnmanagedReader symReader, ISymUnmanagedDocument symDocument, int line, int column) { Assert.True(line >= 1); Assert.True(column >= 0); Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, line, column, 0, out int count, null)); var methods = new ISymUnmanagedMethod[count]; Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, line, column, count, out int count2, methods)); Assert.Equal(count, count2); return(methods); }
// ISymUnmanagedMethod public static SequencePoint[] GetSequencePoints(this ISymUnmanagedMethod symMethod, int codesize) { uint count = symMethod.GetSequencePointCount(); ISymUnmanagedDocument[] documents = new ISymUnmanagedDocument[count]; uint[] offsets = new uint[count]; uint[] lines = new uint[count]; uint[] columns = new uint[count]; uint[] endLines = new uint[count]; uint[] endColumns = new uint[count]; symMethod.GetSequencePoints( count, out count, offsets, documents, lines, columns, endLines, endColumns ); var sequencePoints = new SequencePoint[count]; var urls = documents.Distinct().ToDictionary(d => d, d => d.GetURL()); var sums = documents.Distinct().ToDictionary(d => d, d => d.GetCheckSum()); uint token = symMethod.GetToken(); for (int i = 0; i < count; i++) { sequencePoints[i] = new SequencePoint() { MethodDefToken = token, ILRanges = new [] { new ILRange((int)offsets[i], i + 1 < count ? (int)offsets[i + 1] : codesize) }, Filename = urls[documents[i]], FileCheckSum = sums[documents[i]], StartLine = (int)lines[i], StartColumn = (int)columns[i], EndLine = (int)endLines[i], EndColumn = (int)endColumns[i] }; } return(sequencePoints); }
public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMethod retVal) { // Versions are 1-based. Debug.Assert(version >= 1); var reader = _readerVersions[version - 1]; version = _readerVersions.Length > 1 ? 1 : version; var hr = reader.GetMethodByVersion(methodToken, version, out retVal); if (retVal != null) { var asyncMethod = retVal as ISymUnmanagedAsyncMethod; retVal = asyncMethod == null ? (ISymUnmanagedMethod) new SymMethod(this, retVal) : new SymAsyncMethod(this, asyncMethod); } return(hr); }
public ISymbolMethod[] GetMethodsFromDocumentPosition(ISymbolDocument document, int line, int column) { ISymUnmanagedMethod[] unmanagedMethods; ISymbolMethod[] methods; int count; uint i; unmanagedReader.GetMethodsFromDocumentPosition(((SymbolDocument)document).InternalDocument, line, column, 0, out count, null); unmanagedMethods = new ISymUnmanagedMethod[count]; unmanagedReader.GetMethodsFromDocumentPosition(((SymbolDocument)document).InternalDocument, line, column, count, out count, unmanagedMethods); methods = new ISymbolMethod[count]; for (i = 0; i < count; i++) { methods[i] = new SymbolMethod(unmanagedMethods[i]); } return(methods); }
internal static ISymUnmanagedMethod GetBaselineMethod(this ISymUnmanagedReader reader, int methodToken) { ISymUnmanagedMethod method = null; int hr = reader.GetMethodByVersion(methodToken, 1, out method); if (hr == E_FAIL) { // method has no symbol info return(null); } else if (hr != 0) { throw new ArgumentException(string.Format("Invalid method token '0x{0:x8}' (hresult = 0x{1:x8})", methodToken, hr), "methodToken"); } Debug.Assert(method != null); return(method); }
public Builder(string[][] importStringGroups = null, bool suppressUsingInfo = false, ISymUnmanagedConstant[] constants = null) { _bytesBuilder = ArrayBuilder <byte> .GetInstance(); if (importStringGroups != null && !suppressUsingInfo) { var groupSizes = importStringGroups.Select(g => (short)g.Length).ToArray(); AddUsingInfo(groupSizes); } var namespaces = importStringGroups == null ? default(ImmutableArray <ISymUnmanagedNamespace>) : importStringGroups.SelectMany(names => names.Select(name => (ISymUnmanagedNamespace) new MockSymUnmanagedNamespace(name))).ToImmutableArray(); var childScope = new MockSymUnmanagedScope(default(ImmutableArray <ISymUnmanagedScope>), namespaces, constants); var rootScope = new MockSymUnmanagedScope(ImmutableArray.Create <ISymUnmanagedScope>(childScope), default(ImmutableArray <ISymUnmanagedNamespace>)); _method = new MockSymUnmanagedMethod(rootScope); }
// Write the sequence points for the given method // Sequence points are the map between IL offsets and source lines. // A single method could span multiple files (use C#'s #line directive to see for yourself). private void WriteSequencePoints(ISymUnmanagedMethod method) { writer.WriteStartElement("sequencePoints"); var sequencePoints = method.GetSequencePoints(); // Write out sequence points foreach (var sequencePoint in sequencePoints) { writer.WriteStartElement("entry"); writer.WriteAttributeString("offset", AsILOffset(sequencePoint.Offset)); // If it's a special 0xFeeFee sequence point (eg, "hidden"), // place an attribute on it to make it very easy for tools to recognize. // See http://blogs.msdn.com/jmstall/archive/2005/06/19/FeeFee_SequencePoints.aspx if (sequencePoint.IsHidden) { if (sequencePoint.StartLine != sequencePoint.EndLine || sequencePoint.StartColumn != 0 || sequencePoint.EndColumn != 0) { writer.WriteAttributeString("hidden", "invalid"); } else { writer.WriteAttributeString("hidden", XmlConvert.ToString(true)); } } else { writer.WriteAttributeString("startLine", CultureInvariantToString(sequencePoint.StartLine)); writer.WriteAttributeString("startColumn", CultureInvariantToString(sequencePoint.StartColumn)); writer.WriteAttributeString("endLine", CultureInvariantToString(sequencePoint.EndLine)); writer.WriteAttributeString("endColumn", CultureInvariantToString(sequencePoint.EndColumn)); } //EDMAURER allow there to be PDBs generated for sources that don't have a name (document). int fileRefVal = -1; this.m_fileMapping.TryGetValue(sequencePoint.Document.GetName(), out fileRefVal); writer.WriteAttributeString("document", CultureInvariantToString(fileRefVal)); writer.WriteEndElement(); } writer.WriteEndElement(); // sequencepoints }
private int[] GetMethodTokensFromDocumentPosition( ISymUnmanagedReader symReader, ISymUnmanagedDocument symDocument, int zeroBasedLine, int zeroBasedColumn) { int count; Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, zeroBasedLine, zeroBasedColumn, 0, out count, null)); var methods = new ISymUnmanagedMethod[count]; int count2; Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, zeroBasedLine, zeroBasedColumn, count, out count2, methods)); Assert.Equal(count, count2); return methods.Select(m => { int token; Assert.Equal(HResult.S_OK, m.GetToken(out token)); return token; }).ToArray(); }
public MethodDebugInfoBytes(ImmutableArray<byte> bytes, ISymUnmanagedMethod method) { this.Bytes = bytes; this.Method = method; }
public int GetMethodVersion(ISymUnmanagedMethod pMethod, out int version) { version = 0; return SymUnmanagedReaderExtensions.E_NOTIMPL; }
internal MethodSymbols(RuntimeFunction function, ISymUnmanagedMethod symMethod) { Function = function; SymMethod = symMethod; }
internal void RecordSequencePoints(ISymUnmanagedMethod methodInfo) { if(methodInfo == null || this.contextForOffset != null) return; this.contextForOffset = new TrivialHashtable(); uint count = methodInfo.GetSequencePointCount(); IntPtr[] docPtrs = new IntPtr[count]; uint[] startLines = new uint[count]; uint[] startCols = new uint[count]; uint[] endLines = new uint[count]; uint[] endCols = new uint[count]; uint[] offsets = new uint[count]; uint numPoints; methodInfo.GetSequencePoints(count, out numPoints, offsets, docPtrs, startLines, startCols, endLines, endCols); Debug.Assert(count == numPoints); for(int i = 0; i < count; i++) { //The magic hex constant below works around weird data reported from GetSequencePoints. //The constant comes from ILDASM's source code, which performs essentially the same test. const uint Magic = 0xFEEFEE; if(startLines[i] >= Magic || endLines[i] >= Magic) continue; UnmanagedDocument doc = new UnmanagedDocument(docPtrs[i]); this.contextForOffset[(int)offsets[i] + 1] = new SourceContext(doc, doc.GetOffset(startLines[i], startCols[i]), doc.GetOffset(endLines[i], endCols[i])); } for(int i = 0; i < count; i++) System.Runtime.InteropServices.Marshal.Release(docPtrs[i]); }
internal SymbolMethod(ISymUnmanagedMethod unMeth) { private_method = unMeth; }
public static int GetMethodVersion(this CorSymReader_SxSClass instance, ISymUnmanagedMethod pMethod) { int version; instance.__GetMethodVersion(pMethod, out version); return version; }
private static ISymUnmanagedMethod[] GetMethodsInDocument(ISymUnmanagedReader2 symReader, ISymUnmanagedDocument symDocument) { int count; symReader.GetMethodsInDocument(symDocument, 0, out count, null); var result = new ISymUnmanagedMethod[count]; symReader.GetMethodsInDocument(symDocument, count, out count, result); return result; }
public int GetMethodFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, out ISymUnmanagedMethod retVal) { retVal = null; return SymUnmanagedReaderExtensions.E_NOTIMPL; }
internal static int[] GetMethodTokensFromDocumentPosition( ISymUnmanagedReader symReader, ISymUnmanagedDocument symDocument, int line, int column) { Assert.True(line >= 1); Assert.True(column >= 0); int count; Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, line, column, 0, out count, null)); var methods = new ISymUnmanagedMethod[count]; int count2; Assert.Equal(HResult.S_OK, symReader.GetMethodsFromDocumentPosition(symDocument, line, column, count, out count2, methods)); Assert.Equal(count, count2); return methods.Select(m => { int token; Assert.Equal(HResult.S_OK, m.GetToken(out token)); return token; }).ToArray(); }
public int GetMethod(SymbolToken methodToken, out ISymUnmanagedMethod retVal) { // The EE should never be calling ISymUnmanagedReader.GetMethod. In order to account // for EnC updates, it should always be calling GetMethodByVersion instead. throw ExceptionUtilities.Unreachable; }
public int GetMethodsInDocument(ISymUnmanagedDocument document, int cMethod, out int pcMethod, ISymUnmanagedMethod[] methods) { pcMethod = 0; return SymUnmanagedReaderExtensions.E_NOTIMPL; }
public int GetMethodFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, out ISymUnmanagedMethod retVal) { throw new NotImplementedException(); }
public SymbolMethod(ISymUnmanagedMethod method) { this.method = method; }
public ISymbolMethod[] GetMethodsFromDocumentPosition( ISymbolDocument document, int line, int column) { ISymUnmanagedMethod[] unmanagedMethods; ISymbolMethod[] methods; int count = 0; uint i; m_reader.GetMethodsFromDocumentPosition(((SymbolDocument)document).InternalDocument, line, column, 0, out count, null); unmanagedMethods = new ISymUnmanagedMethod[count]; m_reader.GetMethodsFromDocumentPosition(((SymbolDocument)document).InternalDocument, line, column, count, out count, unmanagedMethods); methods = new ISymbolMethod[count]; for (i = 0; i < count; i++) { methods[i] = new SymMethod(unmanagedMethods[i]); } return methods; }
public int GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, int cMethod, out int pcMethod, ISymUnmanagedMethod[] pRetVal) { throw new NotImplementedException(); }
public int GetMethodVersion(ISymUnmanagedMethod pMethod, out int version) { throw new NotImplementedException(); }
public int GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, int cMethod, out int pcMethod, ISymUnmanagedMethod[] pRetVal) { pcMethod = 0; return SymUnmanagedReaderExtensions.E_NOTIMPL; }
public int GetMethod(out ISymUnmanagedMethod pRetVal) { throw new NotImplementedException(); }
public SymMethod(ISymUnmanagedMethod unmanagedMethod) { m_unmanagedMethod = unmanagedMethod; }
internal SymMethod(SymReader reader, ISymUnmanagedMethod method) { _reader = reader; _method = method; }
// Write all the locals in the given method out to an XML file. // Since the symbol store represents the locals in a recursive scope structure, we need to walk a tree. // Although the locals are technically a hierarchy (based off nested scopes), it's easiest for clients // if we present them as a linear list. We will provide the range for each local's scope so that somebody // could reconstruct an approximation of the scope tree. The reconstruction may not be exact. // (Note this would still break down if you had an empty scope nested in another scope. private void WriteLocals(ISymUnmanagedMethod method, Dictionary<int, ImmutableArray<string>> slotNames) { writer.WriteStartElement("locals"); { // If there are no locals, then this element will just be empty. WriteLocalsHelper(method.GetRootScope(), slotNames, includeChildScopes: true); } writer.WriteEndElement(); }
public int GetMethodVersion(ISymUnmanagedMethod method, out int version) { version = _version; return HResult.S_OK; }
}; // class SequencePointComparer // Constructors. public unsafe SymMethod(ISymUnmanagedMethod *pMethod) { this.pMethod = pMethod; }
public static int GetMethodVersion(this ISymUnmanagedReader instance, ISymUnmanagedMethod pMethod) { int version; instance.__GetMethodVersion(pMethod, out version); return version; }