// <auto-generated/>
#nullable enable
using Microsoft.Diagnostics.DataContractReader;
using Microsoft.Diagnostics.DataContractReader.Contracts;
using Microsoft.Diagnostics.DataContractReader.Generated;
namespace Microsoft.Diagnostics.DataContractReader.Data;
/// <summary>Wraps the <c>GCHeap</c> type.</summary>
partial class GCHeapSVR : global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData
{
private static readonly string[] _typeNames = new[] { "GCHeap" };
[UsesDataDescriptorTypeSize]
public static uint GetSize(Target target)
=> checked((uint)LayoutSet.Resolve(target, _typeNames).InstanceSize);
[DataDescriptorDependency("MarkArray", "pointer")]
public static int GetMarkArrayOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "MarkArray");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("NextSweepObj", "pointer")]
public static int GetNextSweepObjOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "NextSweepObj");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("BackgroundMinSavedAddr", "pointer")]
public static int GetBackgroundMinSavedAddrOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "BackgroundMinSavedAddr");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("BackgroundMaxSavedAddr", "pointer")]
public static int GetBackgroundMaxSavedAddrOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "BackgroundMaxSavedAddr");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("AllocAllocated", "pointer")]
public static int GetAllocAllocatedOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "AllocAllocated");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("EphemeralHeapSegment", "pointer")]
public static int GetEphemeralHeapSegmentOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "EphemeralHeapSegment");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("CardTable", "pointer")]
public static int GetCardTableOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "CardTable");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("FinalizeQueue", "pointer")]
public static int GetFinalizeQueueOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "FinalizeQueue");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("GenerationTable", "pointer")]
public static int GetGenerationTableOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "GenerationTable");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("SavedSweepEphemeralSeg", "pointer")]
public static int GetSavedSweepEphemeralSegOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "SavedSweepEphemeralSeg");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("SavedSweepEphemeralStart", "pointer")]
public static int GetSavedSweepEphemeralStartOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "SavedSweepEphemeralStart");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("OomData", "OomHistory")]
public static int GetOomDataOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "OomData");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("InternalRootArray", "pointer")]
public static int GetInternalRootArrayOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "InternalRootArray");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("InternalRootArrayIndex", "nuint")]
public static int GetInternalRootArrayIndexOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "InternalRootArrayIndex");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("HeapAnalyzeSuccess", "int32")]
public static int GetHeapAnalyzeSuccessOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "HeapAnalyzeSuccess");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("InterestingData", "pointer")]
public static int GetInterestingDataOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "InterestingData");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("CompactReasons", "pointer")]
public static int GetCompactReasonsOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "CompactReasons");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("ExpandMechanisms", "pointer")]
public static int GetExpandMechanismsOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "ExpandMechanisms");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("InterestingMechanismBits", "pointer")]
public static int GetInterestingMechanismBitsOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "InterestingMechanismBits");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("FreeableSohSegment", "pointer")]
public static int GetFreeableSohSegmentOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "FreeableSohSegment");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("FreeableUohSegment", "pointer")]
public static int GetFreeableUohSegmentOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "FreeableUohSegment");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("FreeRegions", "pointer")]
public static int GetFreeRegionsOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "FreeRegions");
return type.Fields[name].Offset;
}
public TargetPointer Address { get; }
private readonly Target _target;
private readonly LayoutSet _layouts;
partial void OnInit(Target target, TargetPointer address);
public GCHeapSVR(Target target, TargetPointer address)
{
Address = address;
_target = target;
_layouts = LayoutSet.Resolve(target, _typeNames);
OnInit(target, address);
}
static GCHeapSVR IData<GCHeapSVR>.Create(Target target, TargetPointer address)
=> new GCHeapSVR(target, address);
private TargetPointer? _MarkArray__value = default!;
private bool _MarkArray__read;
[DataDescriptorDependency("MarkArray", "pointer")]
public partial TargetPointer? MarkArray
{
get
{
if (!_MarkArray__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "MarkArray"))
_MarkArray__value = _target.ReadPointerField(b, t, n);
else
_MarkArray__value = default(TargetPointer?);
_MarkArray__read = true;
}
return _MarkArray__value;
}
}
private TargetPointer? _NextSweepObj__value = default!;
private bool _NextSweepObj__read;
[DataDescriptorDependency("NextSweepObj", "pointer")]
public partial TargetPointer? NextSweepObj
{
get
{
if (!_NextSweepObj__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "NextSweepObj"))
_NextSweepObj__value = _target.ReadPointerField(b, t, n);
else
_NextSweepObj__value = default(TargetPointer?);
_NextSweepObj__read = true;
}
return _NextSweepObj__value;
}
}
private TargetPointer? _BackgroundMinSavedAddr__value = default!;
private bool _BackgroundMinSavedAddr__read;
[DataDescriptorDependency("BackgroundMinSavedAddr", "pointer")]
public partial TargetPointer? BackgroundMinSavedAddr
{
get
{
if (!_BackgroundMinSavedAddr__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "BackgroundMinSavedAddr"))
_BackgroundMinSavedAddr__value = _target.ReadPointerField(b, t, n);
else
_BackgroundMinSavedAddr__value = default(TargetPointer?);
_BackgroundMinSavedAddr__read = true;
}
return _BackgroundMinSavedAddr__value;
}
}
private TargetPointer? _BackgroundMaxSavedAddr__value = default!;
private bool _BackgroundMaxSavedAddr__read;
[DataDescriptorDependency("BackgroundMaxSavedAddr", "pointer")]
public partial TargetPointer? BackgroundMaxSavedAddr
{
get
{
if (!_BackgroundMaxSavedAddr__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "BackgroundMaxSavedAddr"))
_BackgroundMaxSavedAddr__value = _target.ReadPointerField(b, t, n);
else
_BackgroundMaxSavedAddr__value = default(TargetPointer?);
_BackgroundMaxSavedAddr__read = true;
}
return _BackgroundMaxSavedAddr__value;
}
}
private TargetPointer _AllocAllocated__value = default!;
private bool _AllocAllocated__read;
[DataDescriptorDependency("AllocAllocated", "pointer")]
public partial TargetPointer AllocAllocated
{
get
{
if (!_AllocAllocated__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "AllocAllocated");
_AllocAllocated__value = _target.ReadPointerField(b, t, n);
_AllocAllocated__read = true;
}
return _AllocAllocated__value;
}
}
private TargetPointer _EphemeralHeapSegment__value = default!;
private bool _EphemeralHeapSegment__read;
[DataDescriptorDependency("EphemeralHeapSegment", "pointer")]
public partial TargetPointer EphemeralHeapSegment
{
get
{
if (!_EphemeralHeapSegment__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "EphemeralHeapSegment");
_EphemeralHeapSegment__value = _target.ReadPointerField(b, t, n);
_EphemeralHeapSegment__read = true;
}
return _EphemeralHeapSegment__value;
}
}
private TargetPointer _CardTable__value = default!;
private bool _CardTable__read;
[DataDescriptorDependency("CardTable", "pointer")]
public partial TargetPointer CardTable
{
get
{
if (!_CardTable__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "CardTable");
_CardTable__value = _target.ReadPointerField(b, t, n);
_CardTable__read = true;
}
return _CardTable__value;
}
}
private TargetPointer _FinalizeQueue__value = default!;
private bool _FinalizeQueue__read;
[DataDescriptorDependency("FinalizeQueue", "pointer")]
public partial TargetPointer FinalizeQueue
{
get
{
if (!_FinalizeQueue__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "FinalizeQueue");
_FinalizeQueue__value = _target.ReadPointerField(b, t, n);
_FinalizeQueue__read = true;
}
return _FinalizeQueue__value;
}
}
private TargetPointer _GenerationTable__value = default!;
private bool _GenerationTable__read;
[DataDescriptorDependency("GenerationTable", "pointer")]
public partial TargetPointer GenerationTable
{
get
{
if (!_GenerationTable__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "GenerationTable");
_GenerationTable__value = b + (ulong)t.Fields[n].Offset;
_GenerationTable__read = true;
}
return _GenerationTable__value;
}
}
private TargetPointer? _SavedSweepEphemeralSeg__value = default!;
private bool _SavedSweepEphemeralSeg__read;
[DataDescriptorDependency("SavedSweepEphemeralSeg", "pointer")]
public partial TargetPointer? SavedSweepEphemeralSeg
{
get
{
if (!_SavedSweepEphemeralSeg__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "SavedSweepEphemeralSeg"))
_SavedSweepEphemeralSeg__value = _target.ReadPointerField(b, t, n);
else
_SavedSweepEphemeralSeg__value = default(TargetPointer?);
_SavedSweepEphemeralSeg__read = true;
}
return _SavedSweepEphemeralSeg__value;
}
}
private TargetPointer? _SavedSweepEphemeralStart__value = default!;
private bool _SavedSweepEphemeralStart__read;
[DataDescriptorDependency("SavedSweepEphemeralStart", "pointer")]
public partial TargetPointer? SavedSweepEphemeralStart
{
get
{
if (!_SavedSweepEphemeralStart__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "SavedSweepEphemeralStart"))
_SavedSweepEphemeralStart__value = _target.ReadPointerField(b, t, n);
else
_SavedSweepEphemeralStart__value = default(TargetPointer?);
_SavedSweepEphemeralStart__read = true;
}
return _SavedSweepEphemeralStart__value;
}
}
private Data.OomHistory _OomData__value = default!;
private bool _OomData__read;
[DataDescriptorDependency("OomData", "OomHistory")]
public partial Data.OomHistory OomData
{
get
{
if (!_OomData__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "OomData");
_OomData__value = _target.ReadDataField<Data.OomHistory>(b, t, n);
_OomData__read = true;
}
return _OomData__value;
}
}
private TargetPointer? _InternalRootArray__value = default!;
private bool _InternalRootArray__read;
[DataDescriptorDependency("InternalRootArray", "pointer")]
public partial TargetPointer? InternalRootArray
{
get
{
if (!_InternalRootArray__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "InternalRootArray"))
_InternalRootArray__value = _target.ReadPointerField(b, t, n);
else
_InternalRootArray__value = default(TargetPointer?);
_InternalRootArray__read = true;
}
return _InternalRootArray__value;
}
}
private TargetNUInt? _InternalRootArrayIndex__value = default!;
private bool _InternalRootArrayIndex__read;
[DataDescriptorDependency("InternalRootArrayIndex", "nuint")]
public partial TargetNUInt? InternalRootArrayIndex
{
get
{
if (!_InternalRootArrayIndex__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "InternalRootArrayIndex"))
_InternalRootArrayIndex__value = _target.ReadNUIntField(b, t, n);
else
_InternalRootArrayIndex__value = default(TargetNUInt?);
_InternalRootArrayIndex__read = true;
}
return _InternalRootArrayIndex__value;
}
}
private bool? _HeapAnalyzeSuccess__value = default!;
private bool _HeapAnalyzeSuccess__read;
[DataDescriptorDependency("HeapAnalyzeSuccess", "int32")]
public partial bool? HeapAnalyzeSuccess
{
get
{
if (!_HeapAnalyzeSuccess__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "HeapAnalyzeSuccess"))
_HeapAnalyzeSuccess__value = _target.ReadField<int>(b, t, n) != 0;
else
_HeapAnalyzeSuccess__value = default(bool?);
_HeapAnalyzeSuccess__read = true;
}
return _HeapAnalyzeSuccess__value;
}
}
private TargetPointer _InterestingData__value = default!;
private bool _InterestingData__read;
[DataDescriptorDependency("InterestingData", "pointer")]
public partial TargetPointer InterestingData
{
get
{
if (!_InterestingData__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "InterestingData");
_InterestingData__value = b + (ulong)t.Fields[n].Offset;
_InterestingData__read = true;
}
return _InterestingData__value;
}
}
private TargetPointer _CompactReasons__value = default!;
private bool _CompactReasons__read;
[DataDescriptorDependency("CompactReasons", "pointer")]
public partial TargetPointer CompactReasons
{
get
{
if (!_CompactReasons__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "CompactReasons");
_CompactReasons__value = b + (ulong)t.Fields[n].Offset;
_CompactReasons__read = true;
}
return _CompactReasons__value;
}
}
private TargetPointer _ExpandMechanisms__value = default!;
private bool _ExpandMechanisms__read;
[DataDescriptorDependency("ExpandMechanisms", "pointer")]
public partial TargetPointer ExpandMechanisms
{
get
{
if (!_ExpandMechanisms__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "ExpandMechanisms");
_ExpandMechanisms__value = b + (ulong)t.Fields[n].Offset;
_ExpandMechanisms__read = true;
}
return _ExpandMechanisms__value;
}
}
private TargetPointer _InterestingMechanismBits__value = default!;
private bool _InterestingMechanismBits__read;
[DataDescriptorDependency("InterestingMechanismBits", "pointer")]
public partial TargetPointer InterestingMechanismBits
{
get
{
if (!_InterestingMechanismBits__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "InterestingMechanismBits");
_InterestingMechanismBits__value = b + (ulong)t.Fields[n].Offset;
_InterestingMechanismBits__read = true;
}
return _InterestingMechanismBits__value;
}
}
private TargetPointer? _FreeableSohSegment__value = default!;
private bool _FreeableSohSegment__read;
[DataDescriptorDependency("FreeableSohSegment", "pointer")]
public partial TargetPointer? FreeableSohSegment
{
get
{
if (!_FreeableSohSegment__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "FreeableSohSegment"))
_FreeableSohSegment__value = _target.ReadPointerField(b, t, n);
else
_FreeableSohSegment__value = default(TargetPointer?);
_FreeableSohSegment__read = true;
}
return _FreeableSohSegment__value;
}
}
private TargetPointer? _FreeableUohSegment__value = default!;
private bool _FreeableUohSegment__read;
[DataDescriptorDependency("FreeableUohSegment", "pointer")]
public partial TargetPointer? FreeableUohSegment
{
get
{
if (!_FreeableUohSegment__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "FreeableUohSegment"))
_FreeableUohSegment__value = _target.ReadPointerField(b, t, n);
else
_FreeableUohSegment__value = default(TargetPointer?);
_FreeableUohSegment__read = true;
}
return _FreeableUohSegment__value;
}
}
private TargetPointer? _FreeRegions__value = default!;
private bool _FreeRegions__read;
[DataDescriptorDependency("FreeRegions", "pointer")]
public partial TargetPointer? FreeRegions
{
get
{
if (!_FreeRegions__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "FreeRegions"))
_FreeRegions__value = _target.ReadPointerField(b, t, n);
else
_FreeRegions__value = default(TargetPointer?);
_FreeRegions__read = true;
}
return _FreeRegions__value;
}
}
[DataDescriptorDependency("MarkArray", "pointer")]
[DataDescriptorDependency("NextSweepObj", "pointer")]
[DataDescriptorDependency("BackgroundMinSavedAddr", "pointer")]
[DataDescriptorDependency("BackgroundMaxSavedAddr", "pointer")]
[DataDescriptorDependency("AllocAllocated", "pointer")]
[DataDescriptorDependency("EphemeralHeapSegment", "pointer")]
[DataDescriptorDependency("CardTable", "pointer")]
[DataDescriptorDependency("FinalizeQueue", "pointer")]
[DataDescriptorDependency("GenerationTable", "pointer")]
[DataDescriptorDependency("SavedSweepEphemeralSeg", "pointer")]
[DataDescriptorDependency("SavedSweepEphemeralStart", "pointer")]
[DataDescriptorDependency("OomData", "OomHistory")]
[DataDescriptorDependency("InternalRootArray", "pointer")]
[DataDescriptorDependency("InternalRootArrayIndex", "nuint")]
[DataDescriptorDependency("HeapAnalyzeSuccess", "int32")]
[DataDescriptorDependency("InterestingData", "pointer")]
[DataDescriptorDependency("CompactReasons", "pointer")]
[DataDescriptorDependency("ExpandMechanisms", "pointer")]
[DataDescriptorDependency("InterestingMechanismBits", "pointer")]
[DataDescriptorDependency("FreeableSohSegment", "pointer")]
[DataDescriptorDependency("FreeableUohSegment", "pointer")]
[DataDescriptorDependency("FreeRegions", "pointer")]
void global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData.EnsureAllFieldsRead()
{
_ = MarkArray;
_ = NextSweepObj;
_ = BackgroundMinSavedAddr;
_ = BackgroundMaxSavedAddr;
_ = AllocAllocated;
_ = EphemeralHeapSegment;
_ = CardTable;
_ = FinalizeQueue;
_ = GenerationTable;
_ = SavedSweepEphemeralSeg;
_ = SavedSweepEphemeralStart;
_ = OomData;
_ = InternalRootArray;
_ = InternalRootArrayIndex;
_ = HeapAnalyzeSuccess;
_ = InterestingData;
_ = CompactReasons;
_ = ExpandMechanisms;
_ = InterestingMechanismBits;
_ = FreeableSohSegment;
_ = FreeableUohSegment;
_ = FreeRegions;
}
}