/// <summary>
/// Initializes a new instance of the <see cref="ClrMdModule"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrModule">The CLR module.</param>
public ClrMdModule(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrModule clrModule)
{
Provider = provider;
ClrModule = clrModule;
clrPdbReader = SimpleCache.Create(() =>
{
try
{
string pdbPath = ClrModule.Runtime.DataTarget.SymbolLocator.FindPdb(ClrModule.Pdb);
if (!string.IsNullOrEmpty(pdbPath))
{
return(new Microsoft.Diagnostics.Runtime.Utilities.Pdb.PdbReader(pdbPath));
}
}
catch (Exception)
{
}
return(null);
});
module = SimpleCache.Create(() =>
{
return(Provider.GetProcess(ClrModule.Runtime)?.ClrModuleCache[this]);
});
}
/// <summary>
/// Enumerates all objects on the heap.
/// </summary>
/// <returns>An enumeration of all objects on the heap.</returns>
public IEnumerable <Variable> EnumerateObjects()
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
// TODO: Because of ClrMD bug, we must enumerate all modules here...
var modules = Runtime.Modules;
// Enumerate all objects from heap
foreach (ulong address in ClrHeap.EnumerateObjectAddresses())
{
var clrType = ClrHeap.GetObjectType(address);
if (clrType.IsFree)
{
continue;
}
CodeType codeType = Runtime.Process.FromClrType(provider.FromClrType(clrType));
Variable variable;
if (codeType.IsPointer)
{
variable = Variable.CreatePointerNoCast(codeType, address);
}
else
{
// TODO: This address unboxing should be part of ClrMD.
ulong address2 = address + Runtime.Process.GetPointerSize();
variable = Variable.CreateNoCast(codeType, address2);
}
yield return(Variable.UpcastClrVariable(variable));
}
}
/// <summary>
/// Gets the CLR stack frame with the specified instruction offset.
/// </summary>
/// <param name="instructionOffset">The instruction offset.</param>
public IClrStackFrame GetClrStackFrame(ulong instructionOffset)
{
var clrStackFrame = ClrThread.StackTrace?.FirstOrDefault(f => f.InstructionPointer == instructionOffset);
if (clrStackFrame != null && clrStackFrame.Method != null)
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
return(new ClrMdStackFrame(provider, clrStackFrame));
}
return(null);
}
/// <summary>
/// Enumerates the GC references (objects) on the stack.
/// </summary>
public IEnumerable <Variable> EnumerateStackObjects()
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
foreach (Microsoft.Diagnostics.Runtime.ClrRoot root in ClrThread.EnumerateStackObjects())
{
if (root.Type.IsFree || root.Type.Module == null)
{
continue;
}
Variable field = Variable.CreateNoCast(Process.FromClrType(provider.FromClrType(root.Type)), root.Address);
yield return(Variable.UpcastClrVariable(field));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdThread"/> class.
/// </summary>
/// <param name="thread">The thread.</param>
/// <param name="clrThread">The CLR thread.</param>
/// <param name="process">The process.</param>
internal ClrMdThread(Thread thread, Microsoft.Diagnostics.Runtime.ClrThread clrThread, Process process)
{
Thread = thread;
Process = process;
ClrThread = clrThread;
runtime = SimpleCache.Create(() => Process.ClrRuntimes.Single(r => ((ClrMdRuntime)r).ClrRuntime == clrThread.Runtime));
appDomain = SimpleCache.Create(() => Runtime.AppDomains.Single(a => a.Address == clrThread.AppDomain));
clrStackTrace = SimpleCache.Create(() =>
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
StackTrace stackTrace = new StackTrace(Thread);
uint frameNumber = 0;
stackTrace.Frames = ClrThread.StackTrace.Where(f => f.Method != null).Select(f =>
{
return(new StackFrame(stackTrace, new ThreadContext(f.InstructionPointer, f.StackPointer, ulong.MaxValue, null))
{
FrameNumber = frameNumber++,
InstructionOffset = f.InstructionPointer,
StackOffset = f.StackPointer,
FrameOffset = ulong.MaxValue,
ReturnOffset = ulong.MaxValue,
ClrStackFrame = new ClrMdStackFrame(provider, f),
});
}).ToArray();
return(stackTrace);
});
lastThrownException = SimpleCache.Create(() =>
{
if (ClrThread.CurrentException != null)
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
Microsoft.Diagnostics.Runtime.ClrException clrException = ClrThread.CurrentException;
return(Variable.CreatePointer(Process.FromClrType(provider.FromClrType(clrException.Type)), clrException.Address));
}
return(null);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdRuntime" /> class.
/// </summary>
/// <param name="provider">The ClrMD provider.</param>
/// <param name="process">The process.</param>
/// <param name="clrRuntime">The CLR runtime.</param>
internal ClrMdRuntime(CLR.ClrMdProvider provider, Process process, Microsoft.Diagnostics.Runtime.ClrRuntime clrRuntime)
{
Provider = provider;
Process = process;
ClrRuntime = clrRuntime;
appDomains = SimpleCache.Create(() => ClrRuntime.AppDomains.Select(ad => new ClrMdAppDomain(this, ad)).ToArray());
modules = SimpleCache.Create(() => ClrRuntime.Modules.Select(mm => Provider.FromClrModule(mm)).ToArray());
sharedDomain = SimpleCache.Create(() => ClrRuntime.SharedDomain != null ? new ClrMdAppDomain(this, ClrRuntime.SharedDomain) : null);
systemDomain = SimpleCache.Create(() => ClrRuntime.SystemDomain != null ? new ClrMdAppDomain(this, ClrRuntime.SystemDomain) : null);
threads = SimpleCache.Create(() => ClrRuntime.Threads.Select(tt => new ClrMdThread(Process.Threads.Where(t => t.SystemId == tt.OSThreadId).FirstOrDefault(), tt, Process)).ToArray());
gcThreads = SimpleCache.Create(() => ClrRuntime.EnumerateGCThreads().Select(tt => new ClrMdThread(Process.Threads.Where(t => t.SystemId == tt).FirstOrDefault(), ClrRuntime.Threads.First(ct => ct.OSThreadId == tt), Process)).ToArray());
heap = SimpleCache.Create(() => new ClrMdHeap(this, ClrRuntime.GetHeap()));
var version = ClrRuntime.ClrInfo.Version;
Version = new ModuleVersion()
{
Major = version.Major,
Minor = version.Minor,
Patch = version.Patch,
Revision = version.Revision,
};
}
/// <summary>
/// Gets the type of the object at the specified address.
/// </summary>
/// <param name="objectAddress">The object address.</param>
public IClrType GetObjectType(ulong objectAddress)
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
return(provider.FromClrType(ClrHeap.GetObjectType(objectAddress)));
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdType"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrType">The CLR type.</param>
public ClrMdType(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrType clrType)
{
Provider = provider;
ClrType = clrType;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdStackFrame"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrStackFrame">The CLR stack frame.</param>
public ClrMdStackFrame(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrStackFrame clrStackFrame)
{
Provider = provider;
ClrStackFrame = clrStackFrame;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdInstanceField"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrInstanceField">The CLR instance field.</param>
public ClrMdInstanceField(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrInstanceField clrInstanceField)
{
Provider = provider;
ClrInstanceField = clrInstanceField;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdStaticField"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrStaticField">The CLR static field.</param>
public ClrMdStaticField(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrStaticField clrStaticField)
{
Provider = provider;
ClrStaticField = clrStaticField;
}
