public static ISymbolReader CreateReader(string filename)
{
SymBinder binder = new SymBinder();
object objDispenser, objImporter;
CoCreateInstance(ref s_dispenserClassID, null, 1, ref s_dispenserIID, out objDispenser);
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(filename, 0, ref s_importerIID, out objImporter);
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try {
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, filename, null);
} finally {
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
public static ISymbolReader CreateReader(string filename, byte[] binaryFile)
{
SymBinder binder = new SymBinder();
object objDispenser, objImporter;
CoCreateInstance(ref s_dispenserClassID, null, 1, ref s_dispenserIID, out objDispenser);
IntPtr filePtr = Marshal.AllocHGlobal(binaryFile.Length);
Marshal.Copy(binaryFile, 0, filePtr, binaryFile.Length);
IMetaDataDispenserEx dispenser = (IMetaDataDispenserEx)objDispenser;
dispenser.OpenScopeOnMemory(filePtr, (uint)binaryFile.Length, 0, ref s_importerIID, out objImporter);
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, filename, null);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
private string GetLocalVariableName(ulong instructionPointer, uint localIndex)
{
ClrMethod method = _context.Runtime.GetMethodByAddress(instructionPointer);
ClrModule module = method.Type.Module;
string pdbLocation = module.TryDownloadPdb(null);
IntPtr iunkMetadataImport = Marshal.GetIUnknownForObject(module.MetadataImport);
ISymbolReader reader = null;
ISymbolMethod symMethod = null;
try
{
using (var binder = new SymBinder())
{
reader = binder.GetReader(
iunkMetadataImport, module.FileName, Path.GetDirectoryName(pdbLocation));
symMethod = reader.GetMethod(new SymbolToken((int)method.MetadataToken));
return(GetLocalVariableName(symMethod.RootScope, localIndex));
}
}
catch (COMException comEx)
{
// E_FAIL occasionally occurs in ISymbolReader.GetMethod. Nothing we can do about it.
if ((uint)comEx.HResult == 0x80004005)
{
return("");
}
// 0x806D0005 occurs when the PDB cannot be found or doesn't contain the necessary
// information to create a symbol reader. It's OK to ignore.
if ((uint)comEx.HResult == 0x806D0005)
{
return("");
}
throw;
}
finally
{
// These interfaces aren't IDisposable, but the underlying objects are. And it is
// important to dispose of them properly, because if their finalizer runs on exit,
// it crashes with an access violation.
if (reader != null)
{
((IDisposable)reader).Dispose();
}
if (symMethod != null)
{
((IDisposable)symMethod).Dispose();
}
Marshal.Release(iunkMetadataImport);
}
}
private static ISymbolReader TryGetSymbolReaderForFile(
SymBinder binder, string pathModule, string searchPath)
{
ISymbolReader reader;
IMetaDataDispenser dispenser = null;
IMetaDataImportStub importer = null;
var importerPtr = IntPtr.Zero;
try
{
// ReSharper disable once SuspiciousTypeConversion.Global
dispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
var importerGuid = new Guid(InterfaceMetaDataImportGuid);
importer = (IMetaDataImportStub)dispenser.OpenScope(pathModule, 0, ref importerGuid);
// This will manually AddRef the underlying object, so we need to
// be very careful to Release it.
importerPtr = Marshal.GetComInterfaceForObject(importer, typeof(IMetaDataImportStub));
try
{
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
catch (COMException)
{
reader = null;
}
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
if (importer != null)
{
Marshal.ReleaseComObject(importer);
}
if (dispenser != null)
{
Marshal.ReleaseComObject(dispenser);
}
}
return(reader);
}
static ISymbolReader InstantiateReader(SymBinder binder, string filename, object objImporter)
{
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try {
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, filename, null);
} finally {
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
public static ISymbolReader GetSymbolReader(SymBinder binder, string pathModule)
{
try
{
object objDispenser;
CoCreateInstance(ref CLSID_CorMetaDataDispenser,
null,
1,
ref IID_IMetaDataDispenser,
out objDispenser);
object objImporter;
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(pathModule, 0, ref IID_IMetaDataImport, out objImporter);
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, pathModule, null);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
catch (Exception)
{
return(null);
}
}
internal static GotoInfo[] LookupLocationsFromPdb(GotoInfo info, IVsSmartOpenScope vsSmartOpenScope)
{
Debug.Assert(info != null && info.MemberInfo != null, "LookupLocationsFromPdb lacks required parameter");
var sources = new Dictionary <string, Location>();
if (string.IsNullOrEmpty(info.FilePath) || !File.Exists(info.FilePath))
{
return(new GotoInfo[0]);
}
object unkMetaDataImport;
IntPtr ptrMetaDataImport = IntPtr.Zero;
ISymbolBinder1 binder;
ISymbolReader reader;
ISymbolDocument[] documents;
int[] lines;
int[] columns;
int[] endLines;
int[] endColumns;
int[] offsets;
var methods = new List <MethodBase>();
Type ty = null;
try
{
int hr = vsSmartOpenScope.OpenScope(info.FilePath, 0, ref IID_MetaDataImport, out unkMetaDataImport);
if (hr == VSConstants.S_OK)
{
ptrMetaDataImport = Marshal.GetIUnknownForObject(unkMetaDataImport);
binder = new SymBinder();
reader = binder.GetReader(ptrMetaDataImport, info.FilePath, null);
documents = new ISymbolDocument[1];
lines = new int[1];
columns = new int[1];
endLines = new int[1];
endColumns = new int[1];
offsets = new int[1];
}
else
{
Debug.WriteLineIf(TS.TraceWarning,
string.Format("Failed to obtain MetaDataImport from VS, hr 0x{0:X8}", hr), TS.DisplayName);
return(new GotoInfo[0]);
}
switch (info.MemberInfo.MemberType)
{
case MemberTypes.Constructor:
case MemberTypes.Method:
MethodBase mb = (MethodBase)info.MemberInfo;
// Abstract methods does not contain any code.
//
if (mb.IsAbstract)
{
methods.AddRange(mb.DeclaringType.GetMethods(DeclaredMembers));
}
else
{
methods.Add(mb);
}
break;
case MemberTypes.Property:
PropertyInfo pi = (PropertyInfo)info.MemberInfo;
methods.AddRange(pi.GetAccessors(true));
break;
case MemberTypes.Field:
methods.AddRange(info.MemberInfo.DeclaringType.GetMethods(DeclaredMembers));
break;
case MemberTypes.Event:
EventInfo ei = (EventInfo)info.MemberInfo;
methods.Add(ei.GetAddMethod(true));
methods.Add(ei.GetRemoveMethod(true));
methods.Add(ei.GetRaiseMethod(true));
methods.AddRange(ei.GetOtherMethods(true));
break;
case MemberTypes.TypeInfo:
case MemberTypes.NestedType:
ty = (Type)info.MemberInfo;
methods.AddRange(ty.GetMethods(DeclaredMembers));
methods.AddRange(ty.GetConstructors(DeclaredMembers));
break;
default:
Trace.Fail("Unexpected MemberType " + info.MemberInfo.MemberType);
break;
}
foreach (MethodBase mb in methods)
{
if (mb == null || Attribute.GetCustomAttribute(mb, typeof(CompilerGeneratedAttribute)) != null)
{
continue;
}
try
{
SymbolToken token = new SymbolToken(mb.MetadataToken);
ISymbolMethod method = reader.GetMethod(token);
if (method.SequencePointCount > 0)
{
method.GetSequencePoints(offsets, documents, lines, columns, endLines, endColumns);
var path = documents[0].URL;
// We are interested in unique files only.
if (File.Exists(path) && (ty == null || mb.DeclaringType.Equals(ty)))
{
Location value;
if (sources.TryGetValue(path, out value))
{
if ((value.Column == 0 || value.Line == 0) && lines[0] != 0 && columns[0] != 0)
{
sources[path] = new Location(path, lines[0], columns[0], endLines[0], endColumns[0]);
}
}
else
{
sources.Add(path, new Location(path, lines[0], columns[0], endLines[0], endColumns[0]));
}
}
}
}
catch (COMException ex)
{
// Abstract method or not a method at all.
// Sequence points are available only for methods.
//
Trace.WriteLineIf(TS.TraceError,
string.Format("({0}) {1}, code 0x{2:X8}", mb.Name, ex.Message, ex.ErrorCode), TS.DisplayName);
}
}
}
catch (COMException ex)
{
// The file was not found or source locations were stripped from the pdb.
//
Trace.WriteLineIf(TS.TraceError,
string.Format("{0}, code 0x{1:8X}", ex.Message, ex.ErrorCode), TS.DisplayName);
}
finally
{
if (ptrMetaDataImport != IntPtr.Zero)
{
Marshal.Release(ptrMetaDataImport);
}
}
return(sources.Select(x => new GotoInfo(x.Key, x.Value)).ToArray());
}