public AppDomainBuilder(SOSDac sos, IAppDomainHelpers helpers)
{
_sos = sos;
Helpers = helpers;
_sos.GetAppDomainStoreData(out _appDomainStore);
}
public HeapBuilder(IHeapHelpers helper, SOSDac sos)
{
HeapHelpers = helper;
if (sos.GetCommonMethodTables(out _mts))
{
CanWalkHeap = ArrayMethodTable != 0 && StringMethodTable != 0 && ExceptionMethodTable != 0 && FreeMethodTable != 0 && ObjectMethodTable != 0;
}
if (sos.GetGcHeapData(out GCInfo gcdata))
{
if (gcdata.MaxGeneration != 2)
{
throw new NotSupportedException($"The GC reported a max generation of {gcdata.MaxGeneration} which this build of ClrMD does not support.");
}
IsServer = gcdata.ServerMode != 0;
LogicalHeapCount = gcdata.HeapCount;
CanWalkHeap &= gcdata.GCStructuresValid != 0;
}
else
{
CanWalkHeap = false;
}
}
public void GetThreadTebTest()
{
using DataTarget dt = TestTargets.AppDomains.LoadFullDumpWithDbgEng();
IThreadReader threadReader = (IThreadReader)dt.DataReader;
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
using SOSDac dac = runtime.DacLibrary.SOSDacInterface;
foreach (ClrThread thread in runtime.Threads)
{
if (!thread.IsAlive)
{
continue;
}
Assert.NotEqual(0u, thread.OSThreadId);
ulong teb = threadReader.GetThreadTeb(thread.OSThreadId);
Assert.NotEqual(0ul, teb);
if (dac.GetThreadData(thread.Address, out ThreadData threadData))
{
Assert.Equal((ulong)threadData.Teb, teb);
}
}
}
protected override void InitApi()
{
if (_sos == null)
{
_sos = DacLibrary.SOSDacInterface;
}
Debug.Assert(_sos != null);
}
internal SOSDac GetSOSInterfaceNoAddRef()
{
if (_sos == null)
{
_sos = InternalDacPrivateInterface.GetSOSDacInterface();
}
return(_sos);
}
protected override void InitApi()
{
if (_sos == null)
{
_sos = DacLibrary.GetSOSInterfaceNoAddRef();
}
Debug.Assert(_sos != null);
}
public bool Init(SOSDac sos, ulong methodTable, ITypeHelpers helpers)
{
if (!sos.GetMethodTableData(methodTable, out _mtData))
{
return(false);
}
MethodTable = methodTable;
_helpers = helpers;
return(true);
}
private ClrMethodData?GetJitCompiledMethodByCodeHeaderIfValid(SOSDac sos, CodeHeaderData codeHeader)
{
if (codeHeader.MethodStart.Value == -1 || codeHeader.HotRegionSize == 0)
{
return(null);
}
return(new(
sos.GetMethodDescName(codeHeader.MethodDesc),
unchecked ((ulong)codeHeader.MethodStart.Value),
codeHeader.HotRegionSize
));
}
public bool Init(SOSDac sos, ulong methodDesc, IMethodHelpers helpers)
{
MethodDesc = methodDesc;
if (!sos.GetMethodDescData(methodDesc, 0, out _mdData))
{
return(false);
}
_helpers = helpers;
ulong slot = sos.GetMethodTableSlot(_mdData.MethodTable, _mdData.SlotNumber);
return(sos.GetCodeHeaderData(slot, out _codeHeaderData));
}
public bool Init(SOSDac sos, ulong mt, uint i, IMethodHelpers helpers)
{
ulong slot = sos.GetMethodTableSlot(mt, i);
if (!sos.GetCodeHeaderData(slot, out _codeHeaderData))
{
return(false);
}
_helpers = helpers;
MethodDesc = _codeHeaderData.MethodDesc;
return(sos.GetMethodDescData(_codeHeaderData.MethodDesc, 0, out _mdData));
}
private ClrMethodData?FindJitCompiledMethodInMethodTable(SOSDac sos, MethodDescData originalMethodDesc)
{
// I can't really explain this, but it seems that some methods
// are present multiple times in the same type -- one compiled
// and one not compiled.
if (!sos.GetMethodTableData(originalMethodDesc.MethodTable, out var methodTable))
{
return(null);
}
ClrMethodData?methodData = null;
for (var i = 0u; i < methodTable.NumMethods; i++)
{
if (i == originalMethodDesc.SlotNumber)
{
continue;
}
var slot = sos.GetMethodTableSlot(originalMethodDesc.MethodTable, i);
if (!sos.GetCodeHeaderData(slot, out var candidateCodeHeader))
{
continue;
}
if (!sos.GetMethodDescData(candidateCodeHeader.MethodDesc, 0, out var candidateMethodDesc))
{
continue;
}
if (candidateMethodDesc.MDToken != originalMethodDesc.MDToken)
{
continue;
}
methodData = GetJitCompiledMethodByCodeHeaderIfValid(sos, candidateCodeHeader);
if (methodData != null)
{
break;
}
}
return(methodData);
}
private ClrMethodData?GetJitCompiledMethodByMethodDescIfValid(SOSDac sos, MethodDescData methodDesc)
{
// https://github.com/microsoft/clrmd/issues/935
var codeHeaderAddress = methodDesc.HasNativeCode != 0
? (ulong)methodDesc.NativeCodeAddr
: sos.GetMethodTableSlot(methodDesc.MethodTable, methodDesc.SlotNumber);
if (codeHeaderAddress == unchecked ((ulong)-1))
{
return(null);
}
if (!sos.GetCodeHeaderData(codeHeaderAddress, out var codeHeader))
{
return(null);
}
return(GetJitCompiledMethodByCodeHeaderIfValid(sos, codeHeader));
}
public bool Init(SOSDac sos, ulong md)
{
if (!sos.GetMethodDescData(md, 0, out MethodDescData data))
{
return(false);
}
_md = data.MethodDesc;
_ip = data.NativeCodeAddr;
_module = data.Module;
_token = data.MDToken;
_mt = data.MethodTable;
if (sos.GetCodeHeaderData(data.NativeCodeAddr, out CodeHeaderData header))
{
if (header.JITType == 1)
{
_jitType = MethodCompilationType.Jit;
}
else if (header.JITType == 2)
{
_jitType = MethodCompilationType.Ngen;
}
else
{
_jitType = MethodCompilationType.None;
}
_gcInfo = header.GCInfo;
_coldStart = header.ColdRegionStart;
_coldSize = header.ColdRegionSize;
_hotSize = header.HotRegionSize;
}
else
{
_jitType = MethodCompilationType.None;
}
return(true);
}
public bool Init(SOSDac sos, ulong md)
{
if (!sos.GetMethodDescData(md, 0, out MethodDescData data))
{
return(false);
}
MethodDesc = data.MethodDesc;
NativeCodeAddr = data.NativeCodeAddr;
Module = data.Module;
MDToken = data.MDToken;
MethodTable = data.MethodTable;
if (sos.GetCodeHeaderData(data.NativeCodeAddr, out CodeHeaderData header))
{
if (header.JITType == 1)
{
JITType = MethodCompilationType.Jit;
}
else if (header.JITType == 2)
{
JITType = MethodCompilationType.Ngen;
}
else
{
JITType = MethodCompilationType.None;
}
GCInfo = header.GCInfo;
ColdStart = header.ColdRegionStart;
ColdSize = header.ColdRegionSize;
HotSize = header.HotRegionSize;
}
else
{
JITType = MethodCompilationType.None;
}
return(true);
}
public SegmentBuilder(SOSDac sos, int pointerSize)
{
_sos = sos;
_sizeofPlugAndGap = (ulong)pointerSize * 4;
}
public SegmentBuilder(SOSDac sos)
{
_sos = sos;
}
public RcwBuilder(SOSDac sos, RuntimeBuilder builder)
{
_sos = sos;
_builder = builder;
}
public ThreadBuilder(SOSDac sos, ulong finalizer, IThreadHelpers helpers)
{
_sos = sos;
_finalizer = finalizer;
Helpers = helpers;
}
public ModuleBuilder(IModuleHelpers helpers, SOSDac sos, Dictionary <ulong, ulong> moduleSizes)
{
_sos = sos;
_moduleSizes = moduleSizes;
Helpers = helpers;
}
public ModuleBuilder(IModuleHelpers helpers, SOSDac sos)
{
_sos = sos;
Helpers = helpers;
}
public ModuleBuilder(SOSDac sos)
{
_sos = sos;
}
internal bool Init(SOSDac sos, ulong fieldDesc, IFieldHelpers helpers)
{
_helpers = helpers;
return(sos.GetFieldData(fieldDesc, out _fieldData));
}
