public ClrStackInteriorRoot(ClrSegment seg, ulong address, ulong objAddr, ClrStackFrame stackFrame, bool pinned)
{
_segment = seg;
ObjectPointer = objAddr;
Address = address;
StackFrame = stackFrame;
IsPinned = pinned;
}
/// <summary>
/// Converts the specified segment.
/// </summary>
/// <param name="segment">The segment.</param>
/// <returns>IClrSegment.</returns>
public IClrSegment Convert(ClrMd.ClrSegment segment)
{
if (segment == null)
{
return(null);
}
var item = new ClrSegmentAdapter(this, segment);
return(Cache.GetOrAdd <IClrSegment>(segment, () => item, () => item.Setup()));
}
internal static bool IsTooLarge(ulong obj, ClrType type, ClrSegment seg)
{
ulong size = type.GetSize(obj);
if (!seg.IsLarge && size >= 85000)
{
return(true);
}
return(obj + size > seg.End);
}
/// <summary>
/// Returns the object after this one on the segment.
/// </summary>
/// <param name="obj">The object to find the next for.</param>
/// <returns>The next object on the segment, or 0 if the object was the last one on the segment.</returns>
public virtual ulong NextObject(ulong obj)
{
ClrSegment seg = GetSegmentByAddress(obj);
if (seg == null)
{
return(0);
}
return(seg.NextObject(obj));
}
/// <summary>
/// Returns the generation of an object.
/// </summary>
public int GetGeneration(ulong obj)
{
ClrSegment seg = GetSegmentByAddress(obj);
if (seg == null)
{
return(-1);
}
return(seg.GetGeneration(obj));
}
protected internal override IEnumerable <ClrObjectReference> EnumerateObjectReferencesWithFields(ulong obj, ClrType type, bool carefully)
{
if (type == null)
{
type = GetObjectType(obj);
}
else
{
Debug.Assert(type == GetObjectType(obj));
}
if (type == null || (!type.ContainsPointers && !type.IsCollectible))
{
return(s_emptyObjectReferenceSet);
}
List <ClrObjectReference> result = null;
if (type.ContainsPointers)
{
GCDesc gcdesc = type.GCDesc;
if (gcdesc == null)
{
return(s_emptyObjectReferenceSet);
}
ulong size = type.GetSize(obj);
if (carefully)
{
ClrSegment seg = GetSegmentByAddress(obj);
if (seg == null || obj + size > seg.End || (!seg.IsLarge && size > 85000))
{
return(s_emptyObjectReferenceSet);
}
}
result = new List <ClrObjectReference>();
MemoryReader reader = GetMemoryReaderForAddress(obj);
gcdesc.WalkObject(obj, size, ptr => ReadPointer(reader, ptr), (reference, offset) => result.Add(new ClrObjectReference(offset, reference, GetObjectType(reference))));
}
if (type.IsCollectible)
{
result ??= new List <ClrObjectReference>(1);
ulong loaderAllocatorObject = type.LoaderAllocatorObject;
result.Add(new ClrObjectReference(-1, loaderAllocatorObject, GetObjectType(loaderAllocatorObject)));
}
return(result);
}
public override IEnumerable <ulong> EnumerateObjectAddresses()
{
RevisionValidator.Validate(Revision, GetRuntimeRevision());
for (int i = 0; i < _segments.Length; ++i)
{
ClrSegment seg = _segments[i];
for (ulong obj = seg.FirstObject; obj != 0; obj = seg.NextObject(obj))
{
_lastSegmentIdx = i;
yield return(obj);
}
}
}
public override IEnumerable <ClrObject> EnumerateObjects()
{
RevisionValidator.Validate(Revision, GetRuntimeRevision());
for (int i = 0; i < _segments.Length; ++i)
{
ClrSegment seg = _segments[i];
for (ulong obj = seg.GetFirstObject(out ClrType type); obj != 0; obj = seg.NextObject(obj, out type))
{
_lastSegmentIdx = i;
yield return(ClrObject.Create(obj, type));
}
}
}
public override IEnumerable <ulong> EnumerateObjectAddresses()
{
if (Revision != GetRuntimeRevision())
{
ClrDiagnosticsException.ThrowRevisionError(Revision, GetRuntimeRevision());
}
for (int i = 0; i < _segments.Length; ++i)
{
ClrSegment seg = _segments[i];
for (ulong obj = seg.FirstObject; obj != 0; obj = seg.NextObject(obj))
{
_lastSegmentIdx = i;
yield return(obj);
}
}
}
public override IEnumerable <ClrObject> EnumerateObjects()
{
if (Revision != GetRuntimeRevision())
{
ClrDiagnosticsException.ThrowRevisionError(Revision, GetRuntimeRevision());
}
for (int i = 0; i < _segments.Length; ++i)
{
ClrSegment seg = _segments[i];
for (ulong obj = seg.GetFirstObject(out ClrType type); obj != 0; obj = seg.NextObject(obj, out type))
{
_lastSegmentIdx = i;
yield return(ClrObject.Create(obj, type));
}
}
}
protected internal override IEnumerable <ClrObject> EnumerateObjectReferences(ulong obj, ClrType type, bool carefully)
{
if (type == null)
{
type = GetObjectType(obj);
}
else
{
Debug.Assert(type == GetObjectType(obj));
}
if (!type.ContainsPointers)
{
return(s_emptyObjectSet);
}
GCDesc gcdesc = type.GCDesc;
if (gcdesc == null)
{
return(s_emptyObjectSet);
}
ulong size = type.GetSize(obj);
if (carefully)
{
ClrSegment seg = GetSegmentByAddress(obj);
if (seg == null || obj + size > seg.End || !seg.IsLarge && size > 85000)
{
return(s_emptyObjectSet);
}
}
List <ClrObject> result = new List <ClrObject>();
MemoryReader reader = GetMemoryReaderForAddress(obj);
gcdesc.WalkObject(obj, size, ptr => ReadPointer(reader, ptr), (reference, offset) => result.Add(new ClrObject(reference, GetObjectType(reference))));
return(result);
}
public override ClrSegment GetSegmentByAddress(ulong objRef)
{
if (_minAddr <= objRef && objRef < _maxAddr)
{
// Start the segment search where you where last
int curIdx = _lastSegmentIdx;
for (;;)
{
ClrSegment segment = _segments[curIdx];
unchecked
{
long offsetInSegment = (long)(objRef - segment.Start);
if (0 <= offsetInSegment)
{
long intOffsetInSegment = offsetInSegment;
if (intOffsetInSegment < (long)segment.Length)
{
_lastSegmentIdx = curIdx;
return(segment);
}
}
}
// Get the next segment loop until you come back to where you started.
curIdx++;
if (curIdx >= Segments.Count)
{
curIdx = 0;
}
if (curIdx == _lastSegmentIdx)
{
break;
}
}
}
return(null);
}
protected internal override void EnumerateObjectReferences(ulong obj, ClrType type, bool carefully, Action <ulong, int> callback)
{
if (type == null)
{
type = GetObjectType(obj);
}
else
{
Debug.Assert(type == GetObjectType(obj));
}
if (!type.ContainsPointers)
{
return;
}
GCDesc gcdesc = type.GCDesc;
if (gcdesc == null)
{
return;
}
ulong size = type.GetSize(obj);
if (carefully)
{
ClrSegment seg = GetSegmentByAddress(obj);
if (seg == null || obj + size > seg.End || !seg.IsLarge && size > 85000)
{
return;
}
}
MemoryReader reader = GetMemoryReaderForAddress(obj);
gcdesc.WalkObject(obj, size, ptr => ReadPointer(reader, ptr), callback);
}
public MDSegment(ClrSegment seg)
{
m_seg = seg;
}
public SegmentInformation(ClrSegment segment)
{
this.segment = segment;
}
private bool IsInSegment(ClrSegment seg, Address p)
{
return(seg.Start <= p && p <= seg.End);
}
private void UpdateSegments(ClrSegment[] segments)
{
// sort the segments.
Array.Sort(segments, delegate (ClrSegment x, ClrSegment y) { return x.Start.CompareTo(y.Start); });
_segments = segments;
_minAddr = Address.MaxValue;
_maxAddr = Address.MinValue;
_totalHeapSize = 0;
_sizeByGen = new ulong[4];
foreach (var gcSegment in _segments)
{
if (gcSegment.Start < _minAddr)
_minAddr = gcSegment.Start;
if (_maxAddr < gcSegment.End)
_maxAddr = gcSegment.End;
_totalHeapSize += gcSegment.Length;
if (gcSegment.IsLarge)
_sizeByGen[3] += gcSegment.Length;
else
{
_sizeByGen[2] += gcSegment.Gen2Length;
_sizeByGen[1] += gcSegment.Gen1Length;
_sizeByGen[0] += gcSegment.Gen0Length;
}
}
}
public ObjectSegmentEnum(ClrSegment seg)
{
m_seg = seg;
m_obj = seg.FirstObject;
}
