internal DesktopRCWData(DesktopGCHeap heap, ulong rcw, IRCWData data)
{
_addr = rcw;
_rcw = data;
_heap = heap;
_osThreadID = uint.MaxValue;
}
internal DesktopRCWData(DesktopGCHeap heap, Address rcw, IRCWData data)
{
m_addr = rcw;
m_rcw = data;
m_heap = heap;
m_osThreadID = uint.MaxValue;
}
internal ulong GetMTForDomain(ClrAppDomain domain, DesktopHeapType type)
{
DesktopGCHeap heap = null;
IList <MethodTableTokenPair> 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.Heap;
}
if (heap.GetTypeByMethodTable(pair.MethodTable, 0) == type)
{
return(pair.MethodTable);
}
}
}
return(0);
}
public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
{
_field = field;
_name = name;
_token = field.FieldToken;
_type = (BaseDesktopHeapType)heap.GetTypeByMethodTable(field.TypeMethodTable, 0);
}
public BaseDesktopHeapType(ulong mt, DesktopGCHeap heap, DesktopBaseModule module, uint token)
{
_constructedMT = mt;
DesktopHeap = heap;
DesktopModule = module;
_token = token;
_gcDesc = new Lazy <GCDesc>(FillGCDesc);
}
public DesktopPointerType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, uint token, string nameHint)
: base(0, heap, module, token)
{
ElementType = ClrElementType.Pointer;
_pointerElement = eltype;
if (nameHint != null)
{
BuildName(nameHint);
}
}
public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
{
_name = name;
_field = data;
_attributes = attributes;
_token = data.FieldToken;
_heap = heap;
_type = new Lazy <BaseDesktopHeapType>(() => GetType(_heap, data, sig, sigLen, (ClrElementType)_field.CorElementType));
}
public DesktopArrayType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, int ranks, uint token, string nameHint)
: base(0, heap, module, token)
{
ElementType = ClrElementType.Array;
_arrayElement = eltype;
_ranks = ranks;
if (nameHint != null)
{
BuildName(nameHint);
}
}
public override ClrHeap GetHeap()
{
if (_heap == null)
{
if (HasArrayComponentMethodTables)
{
_heap = new LegacyGCHeap(this);
}
else
{
_heap = new V46GCHeap(this);
}
}
return(_heap);
}
/// <summary>
/// Flushes the dac cache. This function MUST be called any time you expect to call the same function
/// but expect different results. For example, after walking the heap, you need to call Flush before
/// attempting to walk the heap again.
/// </summary>
public override void Flush()
{
OnRuntimeFlushed();
Revision++;
_dacInterface.Flush();
_modules.Clear();
_moduleFiles = null;
_moduleSizes = null;
_domains = null;
_system = null;
_shared = null;
_threads = null;
MemoryReader = null;
_heap = null;
_threadpool = null;
}
public override IEnumerable <ClrType> EnumerateTypes()
{
DesktopGCHeap heap = (DesktopGCHeap)_runtime.Heap;
IList <MethodTableTokenPair> mtList = _runtime.GetMethodTableList(_address);
if (_typesLoaded)
{
foreach (ClrType type in heap.EnumerateTypes())
{
if (type.Module == this)
{
yield return(type);
}
}
}
else
{
if (mtList != null)
{
foreach (MethodTableTokenPair pair in mtList)
{
ulong mt = pair.MethodTable;
if (mt != _runtime.ArrayMethodTable)
{
// prefetch element type, as this also can load types
ClrType type = heap.GetTypeByMethodTable(mt, 0, 0);
if (type != null)
{
yield return(type);
}
}
}
}
_typesLoaded = true;
}
}
internal DesktopCCWData(DesktopGCHeap heap, Address ccw, ICCWData data)
{
m_addr = ccw;
m_ccw = data;
m_heap = heap;
}
/// <summary>
/// Gets the GC heap of the process.
/// </summary>
public override ClrHeap GetHeap(TextWriter diagnosticLog)
{
if (_heap == null)
_heap = new DesktopGCHeap(this, diagnosticLog);
return _heap;
}
public override ClrHeap GetHeap()
{
if (_heap == null)
_heap = new DesktopGCHeap(this, null);
return _heap;
}
public SpecialType(DesktopGCHeap heap, string name)
: base(heap, heap.DesktopRuntime.ErrorModule, 0)
{
_name = name;
}
internal DesktopCCWData(DesktopGCHeap heap, ulong ccw, ICCWData data)
{
_addr = ccw;
_ccw = data;
_heap = heap;
}
public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
{
m_name = name;
m_field = data;
m_attributes = attributes;
ulong mt = data.TypeMethodTable;
if (mt != 0)
{
m_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
}
if (m_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
{
m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
{
m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
}
else
{
m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
}
}
if (m_type == null)
{
m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
}
else if (ElementType != ClrElementType.Class)
{
m_type.SetElementType(ElementType);
}
}
internal DesktopHeapType(Func <string> typeNameFactory, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap)
: base(mt, heap, module, token)
{
_name = new Lazy <string>(typeNameFactory);
Shared = mtData.Shared;
_parent = mtData.Parent;
_baseSize = mtData.BaseSize;
_componentSize = mtData.ComponentSize;
_containsPointers = mtData.ContainsPointers;
_hasMethods = mtData.NumMethods > 0;
}
public override ClrHeap GetHeap()
{
if (_heap == null)
{
if (HasArrayComponentMethodTables)
_heap = new LegacyGCHeap(this);
else
_heap = new V46GCHeap(this);
}
return _heap;
}
public DesktopHeapType(ulong mt, DesktopGCHeap heap, DesktopBaseModule module, uint token) : base(mt, heap, module, token)
{
}
internal LockInspection(DesktopGCHeap heap, DesktopRuntimeBase runtime)
{
_heap = heap;
_runtime = runtime;
}
private static BaseDesktopHeapType GetType(DesktopGCHeap heap, IFieldData data, IntPtr sig, int sigLen, ClrElementType elementType)
{
BaseDesktopHeapType result = null;
ulong mt = data.TypeMethodTable;
if (mt != 0)
{
result = (BaseDesktopHeapType)heap.GetTypeByMethodTable(mt, 0);
}
if (result == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int etype = 0;
if (res = sigParser.GetCallingConvInfo(out int sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
// Generic instantiation
if (etype == 0x15)
{
res = res && sigParser.GetElemType(out etype);
}
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
{
result = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
{
result = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
}
else
{
result = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
else if (type == ClrElementType.Pointer)
{
// Only deal with single pointers for now and types that have already been constructed
res = sigParser.GetElemType(out etype);
type = (ClrElementType)etype;
sigParser.GetToken(out int token);
BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));
if (innerType == null)
{
innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
}
result = heap.CreatePointerType(innerType, type, null);
}
else if (type == ClrElementType.Object || type == ClrElementType.Class)
{
result = (BaseDesktopHeapType)heap.ObjectType;
}
else
{
// struct, then try to get the token
int token = 0;
if (etype == 0x11 || etype == 0x12)
{
res = res && sigParser.GetToken(out token);
}
if (token != 0)
{
result = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, (uint)token);
}
if (result == null)
{
if ((result = (BaseDesktopHeapType)heap.GetBasicType((ClrElementType)etype)) == null)
{
result = heap.ErrorType;
}
}
}
}
}
if (result == null)
{
result = (BaseDesktopHeapType)heap.GetBasicType(elementType);
}
}
else if (elementType != ClrElementType.Class)
{
result.ElementType = elementType;
}
if (result.IsArray && result.ComponentType == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int etype = 0;
if (res = sigParser.GetCallingConvInfo(out int sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
res = res && sigParser.GetElemType(out etype);
// Generic instantiation
if (etype == 0x15)
{
res = res && sigParser.GetElemType(out etype);
}
// If it's a class or struct, then try to get the token
int token = 0;
if (etype == 0x11 || etype == 0x12)
{
res = res && sigParser.GetToken(out token);
}
if (token != 0)
{
result.ComponentType = heap.GetGCHeapTypeFromModuleAndToken(data.Module, (uint)token);
}
else if (result.ComponentType == null)
{
if ((result.ComponentType = heap.GetBasicType((ClrElementType)etype)) == null)
{
result.ComponentType = heap.ErrorType;
}
}
}
}
return(result);
}
internal LockInspection(DesktopGCHeap heap, DesktopRuntimeBase runtime)
{
_heap = heap;
_runtime = runtime;
}
public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
{
m_name = name;
m_field = data;
m_attributes = attributes;
ulong mt = data.TypeMethodTable;
if (mt != 0)
m_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
if (m_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
else
m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
}
if (m_type == null)
m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
else if (ElementType != ClrElementType.Class)
{
m_type.SetElementType(ElementType);
}
}
public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
{
m_field = field;
m_name = name;
m_attributes = attributes;
m_type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
m_defaultValue = defaultValue;
m_heap = heap;
if (m_type != null && ElementType != ClrElementType.Class)
{
m_type.SetElementType(ElementType);
}
m_containingType = containingType;
if (m_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
{
m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
{
m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
}
else
{
m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
}
}
if (m_type == null)
{
m_type = (BaseDesktopHeapType)TryBuildType(m_heap);
}
if (m_type == null)
{
m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
}
}
public PrimitiveType(DesktopGCHeap heap, ClrElementType type)
: base(0, heap, heap.DesktopRuntime.ErrorModule, 0)
{
ElementType = type;
}
internal DesktopCCWData(DesktopGCHeap heap, Address ccw, ICCWData data)
{
_addr = ccw;
_ccw = data;
_heap = heap;
}
internal DesktopHeapType(string typeName, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap)
: base(heap, module, token)
{
_name = typeName;
_constructedMT = mt;
Shared = mtData.Shared;
_parent = mtData.Parent;
_baseSize = mtData.BaseSize;
_componentSize = mtData.ComponentSize;
_containsPointers = mtData.ContainsPointers;
_hasMethods = mtData.NumMethods > 0;
}
public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
{
m_field = field;
m_name = name;
m_type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
}
internal DesktopRCWData(DesktopGCHeap heap, Address rcw, IRCWData data)
{
_addr = rcw;
_rcw = data;
_heap = heap;
_osThreadID = uint.MaxValue;
}
public BaseDesktopHeapType(DesktopGCHeap heap, DesktopBaseModule module, uint token)
{
DesktopHeap = heap;
DesktopModule = module;
_token = token;
}
public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
{
_field = field;
_name = name;
_attributes = attributes;
_type = (BaseDesktopHeapType)heap.GetTypeByMethodTable(field.TypeMethodTable, 0);
_defaultValue = defaultValue;
_heap = heap;
_token = field.FieldToken;
if (_type != null && ElementType != ClrElementType.Class)
{
_type.ElementType = ElementType;
}
_containingType = containingType;
if (_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int etype = 0;
if (res = sigParser.GetCallingConvInfo(out int sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
{
_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
{
_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
}
else
{
_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
else if (type == ClrElementType.Pointer)
{
// Only deal with single pointers for now and types that have already been constructed
res = sigParser.GetElemType(out etype);
type = (ClrElementType)etype;
sigParser.GetToken(out int token);
BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(field.Module, Convert.ToUInt32(token));
if (innerType == null)
{
innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
}
_type = heap.CreatePointerType(innerType, type, null);
}
}
}
}
if (_type == null)
{
_typeResolver = new Lazy <ClrType>(() =>
{
ClrType type = (BaseDesktopHeapType)TryBuildType(_heap);
if (type == null)
{
type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
return(type);
});
}
}
internal DesktopHeapType(string typeName, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap, int index)
: base(heap, module, token)
{
m_name = typeName;
m_index = index;
m_handle = mt;
Shared = mtData.Shared;
m_parent = mtData.Parent;
m_baseSize = mtData.BaseSize;
m_componentSize = mtData.ComponentSize;
m_containsPointers = mtData.ContainsPointers;
m_hasMethods = mtData.NumMethods > 0;
}
public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
{
_name = name;
_field = data;
_attributes = attributes;
ulong mt = data.TypeMethodTable;
if (mt != 0)
{
_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
}
if (_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
{
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
{
_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
{
_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
}
else
{
_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
else if (type == ClrElementType.Pointer)
{
// Only deal with single pointers for now and types that have already been constructed
res = sigParser.GetElemType(out etype);
type = (ClrElementType)etype;
int token;
sigParser.GetToken(out token);
BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));
if (innerType == null)
{
innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
}
_type = heap.CreatePointerType(innerType, type, null);
}
}
}
if (_type == null)
{
_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
}
else if (ElementType != ClrElementType.Class)
{
_type.ElementType = ElementType;
}
}
public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
{
m_field = field;
m_name = name;
m_attributes = attributes;
m_type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
m_defaultValue = defaultValue;
m_heap = heap;
if (m_type != null && ElementType != ClrElementType.Class)
m_type.SetElementType(ElementType);
m_containingType = containingType;
if (m_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
else
m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
}
}
if (m_type == null)
m_type = (BaseDesktopHeapType)TryBuildType(m_heap);
if (m_type == null)
m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
}
public ErrorType(DesktopGCHeap heap)
: base(0, heap, heap.DesktopRuntime.ErrorModule, 0)
{
}
public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
{
_field = field;
_name = name;
_type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
}
/// <summary>
/// Flushes the dac cache. This function MUST be called any time you expect to call the same function
/// but expect different results. For example, after walking the heap, you need to call Flush before
/// attempting to walk the heap again.
/// </summary>
public override void Flush()
{
OnRuntimeFlushed();
Revision++;
_dacInterface.Flush();
_modules.Clear();
_moduleFiles = null;
_moduleSizes = null;
_domains = null;
_system = null;
_shared = null;
_threads = null;
MemoryReader = null;
_heap = null;
_threadpool = null;
}
public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
{
_name = name;
_field = data;
_attributes = attributes;
ulong mt = data.TypeMethodTable;
if (mt != 0)
_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
if (_type == null)
{
if (sig != IntPtr.Zero && sigLen > 0)
{
SigParser sigParser = new SigParser(sig, sigLen);
bool res;
int sigType, etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
if (res)
{
ClrElementType type = (ClrElementType)etype;
if (type == ClrElementType.Array)
{
res = sigParser.PeekElemType(out etype);
res = res && sigParser.SkipExactlyOne();
int ranks = 0;
res = res && sigParser.GetData(out ranks);
if (res)
_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
}
else if (type == ClrElementType.SZArray)
{
res = sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (DesktopRuntimeBase.IsObjectReference(type))
_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
else
_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
}
else if (type == ClrElementType.Pointer)
{
// Only deal with single pointers for now and types that have already been constructed
res = sigParser.GetElemType(out etype);
type = (ClrElementType)etype;
int token;
sigParser.GetToken(out token);
BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));
if (innerType == null)
{
innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
}
_type = heap.CreatePointerType(innerType, type, null);
}
}
}
if (_type == null)
_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
}
else if (ElementType != ClrElementType.Class)
{
_type.ElementType = ElementType;
}
}
public DesktopPointerType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, uint token, string nameHint)
: base(heap, module, token)
{
ElementType = ClrElementType.Pointer;
_pointerElement = eltype;
if (nameHint != null)
BuildName(nameHint);
}
internal override IList <ClrStackFrame> GetExceptionStackTrace(ulong obj, ClrType type)
{
List <ClrStackFrame> result = new List <ClrStackFrame>();
if (!GetStackTraceFromField(type, obj, out ulong _stackTrace))
{
if (!ReadPointer(obj + GetStackTraceOffset(), out _stackTrace))
{
return(result);
}
}
if (_stackTrace == 0)
{
return(result);
}
DesktopGCHeap heap = (DesktopGCHeap)Heap;
ClrType stackTraceType = heap.GetObjectType(_stackTrace);
if (stackTraceType == null)
{
stackTraceType = heap.ArrayType;
}
if (!stackTraceType.IsArray)
{
return(result);
}
int len = stackTraceType.GetArrayLength(_stackTrace);
if (len == 0)
{
return(result);
}
int elementSize = CLRVersion == DesktopVersion.v2 ? IntPtr.Size * 4 : IntPtr.Size * 3;
ulong dataPtr = _stackTrace + (ulong)(IntPtr.Size * 2);
if (!ReadPointer(dataPtr, out ulong count))
{
return(result);
}
// Skip size and header
dataPtr += (ulong)(IntPtr.Size * 2);
DesktopThread thread = null;
for (int i = 0; i < (int)count; ++i)
{
if (!ReadPointer(dataPtr, out ulong ip))
{
break;
}
if (!ReadPointer(dataPtr + (ulong)IntPtr.Size, out ulong sp))
{
break;
}
if (!ReadPointer(dataPtr + (ulong)(2 * IntPtr.Size), out ulong md))
{
break;
}
if (i == 0)
{
thread = (DesktopThread)GetThreadByStackAddress(sp);
}
result.Add(new DesktopStackFrame(this, thread, null, ip, sp, md));
dataPtr += (ulong)elementSize;
}
return(result);
}
public DesktopArrayType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, int ranks, uint token, string nameHint)
: base(heap, module, token)
{
ElementType = ClrElementType.Array;
_arrayElement = eltype;
_ranks = ranks;
if (nameHint != null)
BuildName(nameHint);
}
public ErrorType(DesktopGCHeap heap)
: base(heap, heap.DesktopRuntime.ErrorModule, 0)
{
}