static IMetaDataDispenser InstantiateDispenser (out SymBinder binder)
{
binder = new SymBinder ();
object dispenser;
CoCreateInstance (ref s_dispenserClassID, null, 1, ref s_dispenserIID, out dispenser);
return (IMetaDataDispenser) dispenser;
}
public void GetSymbolReader_ReturnsNotNull_WhenFileFound()
{
var location = Path.Combine(Environment.CurrentDirectory, "PartCover.StressTest.exe");
var binder = new SymBinder();
var x = SymbolReaderWapper.GetSymbolReader(binder, location);
Assert.IsNotNull(x);
}
public static ISymbolReader GetSymbolReaderForFile(
System.Diagnostics.SymbolStore.SymBinder binder, string pathModule, string searchPath)
{
// Guids for imported metadata interfaces.
Guid dispenserClassID = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89,
0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
Guid dispenserIID = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71,
0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67,
0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport
// First create the Metadata dispenser.
object objDispenser;
NativeMethods.CoCreateInstance(ref dispenserClassID, null, 1,
ref dispenserIID, out objDispenser);
// Now open an Importer on the given filename. We'll end up passing this importer
// straight through to the Binder.
object objImporter = null;
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
try
{
dispenser.OpenScope(pathModule, 0, ref importerIID, out objImporter);
}
catch
{
Console.WriteLine(" ERROR: Failed dispenser.OpenScope() - perhaps this app needs to be compiled in x86?");
return(null);
}
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
// This will manually AddRef the underlying object, so we need to
// be very careful to Release it.
importerPtr = Marshal.GetComInterfaceForObject(objImporter,
typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
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;
}
}
public static ISymbolReader GetSymReader(this Module module)
{
object objDispenser;
var dispenserClsid = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89, 0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
var dispenserIid = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71, 0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
NativeMethods.CoCreateInstance(ref dispenserClsid, null, 1, ref dispenserIid, out objDispenser);
var dispenser = (IMetaDataDispenserPrivate)objDispenser;
try
{
object objImporter;
var importerIid = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport
dispenser.OpenScope(module.Name, 0, ref importerIid, out objImporter);
var importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImportPrivateComVisible));
reader = new SymBinder().GetReader(importerPtr, module.Name, null);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return reader;
}
catch (FileNotFoundException)
{
return null;
}
}
private string GetLocalVariableName(ulong instructionPointer, uint localIndex)
{
ClrMethod method = _context.Runtime.GetMethodByAddress(instructionPointer);
ClrModule module = method.Type.Module;
string pdbLocation = _context.SymbolLocator.FindPdb(module.Pdb);
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);
}
}
public void GetSymbolReader_ReturnsNull_WhenFileNotFound()
{
var binder = new SymBinder();
var x = SymbolReaderWapper.GetSymbolReader(binder, "");
Assert.IsNull(x);
}
static ISymbolReader GetReaderFor(string path)
{
CorMetaDataDispenser dispenser = null;
object objImporter = null;
IntPtr pImporter = IntPtr.Zero;
Guid iidImporter = typeof(IMetadataImport).GUID;
try {
dispenser = new CorMetaDataDispenser();
dispenser.OpenScope(path, 0, ref iidImporter, out objImporter);
pImporter = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
var binder = new SymBinder();
return binder.GetReader(pImporter, path, null);
}
finally {
if (pImporter != IntPtr.Zero)
Marshal.Release(pImporter);
if (objImporter != null)
Marshal.ReleaseComObject(objImporter);
if (dispenser != null)
Marshal.ReleaseComObject(dispenser);
}
}
public SymbolReaderFactory()
{
_symBinder = new SymBinder();
}
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();
}
public ISymbolReader GetSymReader()
{
IntPtr uImporter = Marshal.GetIUnknownForObject(GetImporter());
SymBinder binder = new SymBinder();
ISymbolReader reader = binder.GetReader(uImporter,
fullName,
Environment.GetEnvironmentVariable("_NT_SYMBOL_PATH"));
return reader;
}