public static ISymbolReader GetSymbolReaderForFile(SymbolBinder 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;
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(pathModule, 0, ref importerIID, out objImporter);
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;
}
/*
* This private function provides implementation for the two public versions.
* searchPath is a simicolon-delimited list of paths on which to search for pathModule.
* If searchPath is null, pathModule must be a full path to the assembly.
*/
private static ISymbolReader GetReaderForFile(SymbolBinder binder, string pathModule, string searchPath)
{
// 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;
IMetaDataDispenserPrivate dispenser = (IMetaDataDispenserPrivate)objDispenser;
dispenser.OpenScope(pathModule, OPEN_READ, ref importerIID, out objImporter);
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(IMetadataImportPrivateComVisible));
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
public ISymbolReader GetReaderFromStream(IStream stream)
{
var metadata_import = this.GetMetaDataInterface <IMetadataImport>();
var binder = new Microsoft.Samples.Debugging.CorSymbolStore.SymbolBinder();
return(binder.GetReaderFromStream(metadata_import, stream));
}
private ISymbolReader getSymbolReader(CorModule module)
{
ISymbolReader reader = null;
string sympath = Path.GetDirectoryName(module.Name);
string moduleName = module.Name;
try
{
SymbolBinder binder = new SymbolBinder();
var importer = new CorMetadataImport(module);
reader = binder.GetReaderForFile(importer.RawCOMObject, moduleName, sympath);
}
catch (COMException ex)
{
if (ex.ErrorCode == unchecked((int)0x806D0014)) // E_PDB_CORRUPT
{
// Ignore it.
// This may happen for mismatched pdbs
}
else
throw;
}
return reader;
}
void OnUpdateModuleSymbols (object sender, CorUpdateModuleSymbolsEventArgs e)
{
SymbolBinder binder = new SymbolBinder ();
CorMetadataImport mi = new CorMetadataImport (e.Module);
ISymbolReader reader = binder.GetReaderFromStream (mi.RawCOMObject, e.Stream);
foreach (ISymbolDocument doc in reader.GetDocuments ()) {
Console.WriteLine (doc.URL);
}
e.Continue = true;
}
/*
* Implementation which allows customization of the SymbolBinder to use.
* searchPath is a simicolon-delimited list of paths on which to search for pathModule.
* If searchPath is null, pathModule must be a full path to the assembly.
*/
public static ISymbolReader GetReaderForFile(SymbolFormat symFormat, string pathModule, string searchPath)
{
// First create the Metadata dispenser.
// Create the appropriate symbol binder
SymbolBinder binder;
if (symFormat == SymbolFormat.PDB)
binder = new SymbolBinder();
else if (symFormat == SymbolFormat.ILDB)
binder = new IldbSymbolBinder();
else
throw new ArgumentException("Invalid format", "symFormat");
// 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;
IMetaDataDispenserPrivate dispenser = (IMetaDataDispenserPrivate)objDispenser;
dispenser.OpenScope(pathModule, OPEN_READ, ref importerIID, out objImporter);
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(IMetadataImportPrivateComVisible));
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return reader;
}
/// <summary>
/// Read the pdb file for this module and frame
/// Retrieve infomation about the function
/// </summary>
/// <remarks>
/// When an unmanaged app like reflector loads CLR, "Function.Module.Name"
/// doesn't return a valid value and so this function returns null.
/// </remarks>
/// <returns>SourcePosition of the function</returns>
private SourcePosition GetMetaDataInfo(CorMetadataImport importer)
{
SourcePosition functionPos = null; //position in this function where we are
try
{
moduleFullName = thisFrame.Function.Module.Name;
moduleShortName = System.IO.Path.GetFileName(moduleFullName);
}
catch (ArgumentException)
{
moduleFullName = "";
moduleShortName = "";
return null;
}
//TODO: Implement a better method to determine the symbol path than just assuming it's in the same
// directory
string sympath = ".";
//dealing with readinf the source in the module
ISymbolReader metaReader = null;
ISymbolBinder1 symbolBinder = new SymbolBinder();
try
{
if (moduleFullName.Length > 0)
{
metaReader = (symbolBinder as ISymbolBinder2).
GetReaderForFile(importer.RawCOMObject, moduleFullName, sympath);
}
}
catch (COMException)
{
//Debug.WriteLine(ed.ToString(CultureInfo.CurrentCulture.NumberFormat));
//will get here for any function which we cant read the .pdb file for
//its not a big deal we just wont have source and line info
}
if (metaReader != null)
{
ISymbolMethod symMethod = null;
try
{
symMethod = metaReader.GetMethod(new SymbolToken((int)thisFrame.Function.Token), thisFrame.Function.Version);
int sequenceCount = symMethod.SequencePointCount;
symDocs = new ISymbolDocument[sequenceCount];
offsets = new int[sequenceCount];
startLines = new int[sequenceCount];
startColumns = new int[sequenceCount];
endLines = new int[sequenceCount];
endColumns = new int[sequenceCount];
//Get the sequence points and store them in the apporpriate arrays. Seqeunce points
//represent the different points in the files which correlate to il instruction and lines
symMethod.GetSequencePoints(offsets, symDocs, startLines, startColumns, endLines, endColumns);
functionPos = GetSourcePositionFromFrame();
}
catch (COMException)
{
functionPos = null;
}
finally
{
symDocs = null;
symMethod = null;
}
}
CorType ctype = GetClassType();
if (ctype != null)
{
StringBuilder sb = new StringBuilder();
GetFunctionClassPath(sb, ctype);
functionFullName = sb.ToString();
}
else
{
functionFullName = "";
}
MethodInfo methIn = importer.GetMethodInfo(thisFrame.Function.Token);
functionFullName += "." + methIn.Name;
functionShortName = methIn.Name;
return functionPos;
}
public void SetBreakPoint(int lineNumber, string moduleNameHint, string fileNameHint)
{
if (state == ProcessState.Terminated) throw new InvalidProcessException();
List<CorModule> matchingModules =
modules.Where(module => module.Name.Contains(moduleNameHint)).ToList();
if (matchingModules.Count > 1) throw new MultipleMatchException();
if (matchingModules.Count == 0) throw new NoMatchException();
CorModule corModule = matchingModules.First();
var pdbFile = new FileInfo(corModule.Name);
var binder = new SymbolBinder();
var metadataImport = corModule.GetMetaDataInterface<IMetadataImport>();
ISymbolReader reader = binder.GetReaderForFile(metadataImport, pdbFile.FullName, null,
SymSearchPolicies.AllowOriginalPathAccess |
SymSearchPolicies.AllowReferencePathAccess);
Index(reader, corModule);
ISymbolDocument[] documents = reader.GetDocuments();
List<ISymbolDocument> matchingDocuments =
documents.Where(document => Regex.Match(document.URL, fileNameHint).Success).ToList();
if (matchingDocuments.Count > 1) throw new MultipleMatchException();
if (matchingDocuments.Count == 0) throw new NoMatchException();
ISymbolDocument source = matchingDocuments.First();
int line = source.FindClosestLine(lineNumber);
ISymbolMethod method = reader.GetMethodFromDocumentPosition(source, line, 1);
CorFunction function = corModule.GetFunctionFromToken(method.Token.GetToken());
SequencePoints points = SequencePoints.From(method);
SequencePoint pointToBreak =
points.Where(point => lineNumber >= point.StartLine && line <= point.EndLine).First();
CorFunctionBreakpoint breakpoint = function.ILCode.CreateBreakpoint(pointToBreak.Offset);
breakpoints.Add(breakpoint);
breakpoint.Activate(true);
subscriber.Published(string.Format("Successfully set breakpoint on line {0} in file {1} in module {2}",
lineNumber, source.URL, corModule.Name));
}
public SymbolService()
{
this.binder = new SymbolBinder();
}
