public RhStackRootWalker(ClrHeap heap, ClrAppDomain domain, ClrThread thread)
{
m_heap = heap;
m_domain = domain;
m_thread = thread;
Roots = new List<ClrRoot>();
}
public NativeStackRootWalker(ClrHeap heap, ClrAppDomain domain, ClrThread thread)
{
_heap = heap;
_domain = domain;
_thread = thread;
Roots = new List<ClrRoot>();
}
public RhHandleRoot(Address addr, Address obj, Address dependentTarget, ClrType type, int hndType, ClrAppDomain domain, string name)
{
Init(addr, obj, dependentTarget, type, hndType, domain, name);
}
internal abstract ulong GetModuleAddress(ClrAppDomain domain);
internal MemoryRegion(DesktopRuntimeBase clr, ulong addr, ulong size, ClrMemoryRegionType type, ClrAppDomain domain)
{
Address = addr;
Size = size;
_runtime = clr;
Type = type;
_domainModuleHeap = domain.Address;
}
public NativeStaticVar(NativeRuntime runtime, Address addr, Address obj, ClrType type, string name, bool pinned, bool interior)
{
Address = addr;
Object = obj;
_type = type;
_name = name;
_pinned = pinned;
_interior = interior;
_type = runtime.GetHeap().GetObjectType(obj);
_appDomain = runtime.GetRhAppDomain();
}
public NativeHandleRoot(Address addr, Address obj, ClrType type, int hndType, ClrAppDomain domain, string name)
{
Init(addr, obj, 0, type, hndType, domain, name);
}
internal override ulong GetDomainModule(ClrAppDomain domain)
{
m_runtime.InitDomains();
if (domain == null)
{
foreach (ulong addr in m_mapping.Values)
return addr;
return 0;
}
ulong value;
if (m_mapping.TryGetValue(domain, out value))
return value;
return 0;
}
public override object GetValue(ClrAppDomain appDomain, ClrThread thread)
{
if (!HasSimpleValue)
return null;
Address addr = GetAddress(appDomain, thread);
if (addr == 0)
return null;
if (ElementType == ClrElementType.String)
{
object val = m_type.m_heap.GetValueAtAddress(ClrElementType.Object, addr);
Debug.Assert(val == null || val is ulong);
if (val == null || !(val is ulong))
return null;
addr = (ulong)val;
}
return m_type.m_heap.GetValueAtAddress(ElementType, addr);
}
public override bool IsInitialized(ClrAppDomain appDomain)
{
if (m_containingType == null)
return false;
if (!m_containingType.Shared)
return true;
Address id = m_containingType.m_module.ModuleId;
IDomainLocalModuleData data = m_containingType.m_heap.m_runtime.GetDomainLocalModule(appDomain.Address, id);
if (data == null)
return false;
return IsInitialized(data);
}
public override object GetValue(ClrAppDomain appDomain)
{
if (!HasSimpleValue)
return null;
Address addr = GetAddress(appDomain);
if (ElementType == ClrElementType.String)
{
object val = m_containingType.m_heap.GetValueAtAddress(ClrElementType.Object, addr);
Debug.Assert(val == null || val is ulong);
if (val == null || !(val is ulong))
return null;
addr = (ulong)val;
}
// Structs are stored as objects.
var elementType = ElementType;
if (elementType == ClrElementType.Struct)
elementType = ClrElementType.Object;
if (elementType == ClrElementType.Object && addr == 0)
return (ulong)0;
return m_containingType.m_heap.GetValueAtAddress(elementType, addr);
}
public RhFinalizerRoot(Address obj, ClrType type, ClrAppDomain domain, string name)
{
Object = obj;
m_name = name;
m_type = type;
m_appDomain = domain;
}
public NativeFinalizerRoot(Address obj, ClrType type, ClrAppDomain domain, string name)
{
Object = obj;
_name = name;
_type = type;
_appDomain = domain;
}
public RhHandleRootWalker(RhRuntime runtime, bool dependentHandleSupport)
{
m_heap = runtime.GetHeap();
m_domain = runtime.GetRhAppDomain();
m_dependentSupport = dependentHandleSupport;
}
public RhStaticVar(RhRuntime runtime, Address addr, Address obj, ClrType type, string name, bool pinned, bool interior)
{
Address = addr;
Object = obj;
m_type = type;
m_name = name;
m_pinned = pinned;
m_interior = interior;
m_type = runtime.GetHeap().GetObjectType(obj);
m_appDomain = runtime.GetRhAppDomain();
}
internal abstract Address GetDomainModule(ClrAppDomain appDomain);
internal void AddMapping(ClrAppDomain domain, ulong domainModule)
{
DesktopAppDomain appDomain = (DesktopAppDomain)domain;
m_mapping[domain] = domainModule;
}
public LocalVarRoot(ulong addr, ulong obj, ClrType type, ClrAppDomain domain, ClrThread thread, bool pinned, bool falsePos, bool interior)
{
Address = addr;
Object = obj;
_pinned = pinned;
_falsePos = falsePos;
_interior = interior;
_domain = domain;
_thread = thread;
_type = type;
}
internal override Address GetDomainModule(ClrAppDomain appDomain)
{
return 0;
}
public override object GetValue(ClrAppDomain appDomain, bool convertStrings = true)
{
if (!HasSimpleValue)
return null;
Address addr = GetAddress(appDomain);
if (ElementType == ClrElementType.String)
{
object val = _containingType.DesktopHeap.GetValueAtAddress(ClrElementType.Object, addr);
Debug.Assert(val == null || val is ulong);
if (val == null || !(val is ulong))
return convertStrings ? null : (object)(ulong)0;
addr = (ulong)val;
if (!convertStrings)
return addr;
}
// Structs are stored as objects.
var elementType = ElementType;
if (elementType == ClrElementType.Struct)
elementType = ClrElementType.Object;
if (elementType == ClrElementType.Object && addr == 0)
return (ulong)0;
return _containingType.DesktopHeap.GetValueAtAddress(elementType, addr);
}
public NativeStackRoot(ClrThread thread, ulong addr, ulong obj, string name, ClrType type, ClrAppDomain domain, bool pinned, bool interior)
{
Address = addr;
Object = obj;
_name = name;
_type = type;
_appDomain = domain;
_pinned = pinned;
_interior = interior;
_thread = thread;
}
public override Address GetAddress(ClrAppDomain appDomain)
{
if (_containingType == null)
return 0;
bool shared = _containingType.Shared;
IDomainLocalModuleData data = null;
if (shared)
{
Address id = _containingType.DesktopModule.ModuleId;
data = _containingType.DesktopHeap.DesktopRuntime.GetDomainLocalModule(appDomain.Address, id);
if (!IsInitialized(data))
return 0;
}
else
{
Address modAddr = _containingType.GetModuleAddress(appDomain);
if (modAddr != 0)
data = _containingType.DesktopHeap.DesktopRuntime.GetDomainLocalModule(modAddr);
}
if (data == null)
return 0;
Address addr;
if (DesktopRuntimeBase.IsPrimitive(ElementType))
addr = data.NonGCStaticDataStart + _field.Offset;
else
addr = data.GCStaticDataStart + _field.Offset;
return addr;
}
private void Init(Address addr, Address obj, Address dependentTarget, ClrType type, int hndType, ClrAppDomain domain, string name)
{
HandleType htype = (HandleType)hndType;
switch (htype)
{
case HandleType.AsyncPinned:
_kind = GCRootKind.AsyncPinning;
break;
case HandleType.Pinned:
_kind = GCRootKind.Pinning;
break;
case HandleType.WeakShort:
case HandleType.WeakLong:
_kind = GCRootKind.Weak;
break;
default:
_kind = GCRootKind.Strong;
break;
}
Address = addr;
_name = name;
_type = type;
_appDomain = domain;
if (htype == HandleType.Dependent && dependentTarget != 0)
Object = dependentTarget;
else
Object = obj;
}
public override bool IsInitialized(ClrAppDomain appDomain)
{
if (_containingType == null)
return false;
if (!_containingType.Shared)
return true;
Address id = _containingType.DesktopModule.ModuleId;
IDomainLocalModuleData data = _containingType.DesktopHeap.DesktopRuntime.GetDomainLocalModule(appDomain.Address, id);
if (data == null)
return false;
return IsInitialized(data);
}
public NativeHandleRootWalker(NativeRuntime runtime, bool dependentHandleSupport)
{
_heap = runtime.GetHeap();
_domain = runtime.GetRhAppDomain();
_dependentSupport = dependentHandleSupport;
}
public override object GetValue(ClrAppDomain appDomain, ClrThread thread, bool convertStrings = true)
{
if (!HasSimpleValue)
return null;
Address addr = GetAddress(appDomain, thread);
if (addr == 0)
return null;
if (ElementType == ClrElementType.String)
{
object val = _type.DesktopHeap.GetValueAtAddress(ClrElementType.Object, addr);
Debug.Assert(val == null || val is ulong);
if (val == null || !(val is ulong))
return convertStrings ? null : (object)(ulong)0;
addr = (ulong)val;
if (!convertStrings)
return addr;
}
return _type.DesktopHeap.GetValueAtAddress(ElementType, addr);
}
internal override Address GetModuleAddress(ClrAppDomain appDomain)
{
if (DesktopModule == null)
return 0;
return DesktopModule.GetDomainModule(appDomain);
}
public override Address GetAddress(ClrAppDomain appDomain, ClrThread thread)
{
if (_type == null)
return 0;
DesktopRuntimeBase runtime = _type.DesktopHeap.DesktopRuntime;
IModuleData moduleData = runtime.GetModuleData(_field.Module);
return runtime.GetThreadStaticPointer(thread.Address, (ClrElementType)_field.CorElementType, (uint)Offset, (uint)moduleData.ModuleId, _type.Shared);
}
internal override Address GetModuleAddress(ClrAppDomain domain)
{
return 0;
}
internal ulong GetMTForDomain(ClrAppDomain domain, DesktopHeapType type)
{
DesktopGCHeap heap = null;
var mtList = _runtime.GetMethodTableList(_mapping[domain]);
bool hasToken = type.MetadataToken != 0 && type.MetadataToken != uint.MaxValue;
uint token = ~0xff000000 & type.MetadataToken;
foreach (MethodTableTokenPair pair in mtList)
{
if (hasToken)
{
if (pair.Token == token)
return pair.MethodTable;
}
else
{
if (heap == null)
heap = (DesktopGCHeap)_runtime.GetHeap();
if (heap.GetTypeByMethodTable(pair.MethodTable, 0) == type)
return pair.MethodTable;
}
}
return 0;
}
