diff --git a/src/coreclr/vm/datadescriptor/datadescriptor.inc b/src/coreclr/vm/datadescriptor/datadescriptor.inc index 0effdc9ae95380..0ee65734c32da2 100644 --- a/src/coreclr/vm/datadescriptor/datadescriptor.inc +++ b/src/coreclr/vm/datadescriptor/datadescriptor.inc @@ -393,7 +393,7 @@ CDAC_TYPE_SIZE(sizeof(MethodTable)) CDAC_TYPE_FIELD(MethodTable, T_UINT32, MTFlags, cdac_data::MTFlags) CDAC_TYPE_FIELD(MethodTable, T_UINT32, BaseSize, cdac_data::BaseSize) CDAC_TYPE_FIELD(MethodTable, T_UINT32, MTFlags2, cdac_data::MTFlags2) -CDAC_TYPE_FIELD(MethodTable, T_NUINT, EEClassOrCanonMT, cdac_data::EEClassOrCanonMT) +CDAC_TYPE_FIELD(MethodTable, T_POINTER, EEClassOrCanonMT, cdac_data::EEClassOrCanonMT) CDAC_TYPE_FIELD(MethodTable, T_POINTER, Module, cdac_data::Module) CDAC_TYPE_FIELD(MethodTable, T_POINTER, ParentMethodTable, cdac_data::ParentMethodTable) CDAC_TYPE_FIELD(MethodTable, T_UINT16, NumInterfaces, cdac_data::NumInterfaces) @@ -404,8 +404,8 @@ CDAC_TYPE_END(MethodTable) CDAC_TYPE_BEGIN(DynamicStaticsInfo) CDAC_TYPE_SIZE(sizeof(DynamicStaticsInfo)) -CDAC_TYPE_FIELD(DynamicStaticsInfo, T_UINT32, GCStatics, offsetof(DynamicStaticsInfo, m_pGCStatics)) -CDAC_TYPE_FIELD(DynamicStaticsInfo, T_UINT32, NonGCStatics, offsetof(DynamicStaticsInfo, m_pNonGCStatics)) +CDAC_TYPE_FIELD(DynamicStaticsInfo, T_POINTER, GCStatics, offsetof(DynamicStaticsInfo, m_pGCStatics)) +CDAC_TYPE_FIELD(DynamicStaticsInfo, T_POINTER, NonGCStatics, offsetof(DynamicStaticsInfo, m_pNonGCStatics)) CDAC_TYPE_END(DynamicStaticsInfo) CDAC_TYPE_BEGIN(MethodTableAuxiliaryData) @@ -882,7 +882,7 @@ CDAC_TYPE_BEGIN(NativeCodeVersionNode) CDAC_TYPE_INDETERMINATE(NativeCodeVersionNode) CDAC_TYPE_FIELD(NativeCodeVersionNode, T_POINTER, Next, cdac_data::Next) CDAC_TYPE_FIELD(NativeCodeVersionNode, T_POINTER, MethodDesc, cdac_data::MethodDesc) -CDAC_TYPE_FIELD(NativeCodeVersionNode, T_POINTER, NativeCode, cdac_data::NativeCode) +CDAC_TYPE_FIELD(NativeCodeVersionNode, TYPE(CodePointer), NativeCode, cdac_data::NativeCode) CDAC_TYPE_FIELD(NativeCodeVersionNode, T_UINT32, Flags, cdac_data::Flags) CDAC_TYPE_FIELD(NativeCodeVersionNode, T_NUINT, ILVersionId, cdac_data::ILVersionId) #ifdef HAVE_GCCOVER diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/TargetFieldExtensions.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/TargetFieldExtensions.cs new file mode 100644 index 00000000000000..007af1845cb798 --- /dev/null +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/TargetFieldExtensions.cs @@ -0,0 +1,181 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Numerics; +using Microsoft.Diagnostics.DataContractReader.Data; + +namespace Microsoft.Diagnostics.DataContractReader; + +/// +/// Extension methods for that provide typed field reading with optional +/// type validation. When the data descriptor includes type information (debug/checked builds), +/// these methods assert that the declared field type is compatible with the C# read type. +/// +public static class TargetFieldExtensions +{ + /// + /// Read a primitive integer field from the target with type validation. + /// + public static T ReadField(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + where T : unmanaged, IBinaryInteger, IMinMaxValue + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + AssertPrimitiveType(field, fieldName); + + return target.Read(address + (ulong)field.Offset); + } + + /// + /// Read an optional primitive integer field from the target with type validation. + /// Returns if the field is not present in the descriptor. + /// + public static T ReadFieldOrDefault(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName, T defaultValue = default) + where T : unmanaged, IBinaryInteger, IMinMaxValue + { + if (!typeInfo.Fields.TryGetValue(fieldName, out Target.FieldInfo field)) + return defaultValue; + + AssertPrimitiveType(field, fieldName); + + return target.Read(address + (ulong)field.Offset); + } + + /// + /// Read a pointer field from the target with type validation. + /// + public static TargetPointer ReadPointerField(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + AssertPointerType(field, fieldName); + + return target.ReadPointer(address + (ulong)field.Offset); + } + + /// + /// Read an optional pointer field from the target with type validation. + /// Returns if the field is not present in the descriptor. + /// + public static TargetPointer ReadPointerFieldOrNull(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + { + if (!typeInfo.Fields.TryGetValue(fieldName, out Target.FieldInfo field)) + return TargetPointer.Null; + + AssertPointerType(field, fieldName); + + return target.ReadPointer(address + (ulong)field.Offset); + } + + /// + /// Read a native unsigned integer field from the target with type validation. + /// + public static TargetNUInt ReadNUIntField(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + Debug.Assert( + field.TypeName is null or "" or "nuint", + $"Type mismatch reading field '{fieldName}': declared as '{field.TypeName}', expected nuint"); + + return target.ReadNUInt(address + (ulong)field.Offset); + } + + /// + /// Read a code pointer field from the target with type validation. + /// + public static TargetCodePointer ReadCodePointerField(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + Debug.Assert( + field.TypeName is null or "" or "CodePointer", + $"Type mismatch reading field '{fieldName}': declared as '{field.TypeName}', expected CodePointer"); + + return target.ReadCodePointer(address + (ulong)field.Offset); + } + + /// + /// Read a field that contains an inline Data struct type, with type validation. + /// Returns the data object created by . + /// + public static T ReadDataField(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + where T : IData + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + Debug.Assert( + field.TypeName is null or "" || field.TypeName == typeof(T).Name, + $"Type mismatch reading field '{fieldName}': declared as '{field.TypeName}', reading as {typeof(T).Name}"); + + return target.ProcessedData.GetOrAdd(address + (ulong)field.Offset); + } + + /// + /// Read a field that contains a pointer to a Data struct type, with type validation. + /// Reads the pointer, then creates the data object via . + /// Returns null if the pointer is null. + /// + public static T? ReadDataFieldPointer(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + where T : IData + { + Target.FieldInfo field = typeInfo.Fields[fieldName]; + AssertPointerType(field, fieldName); + + TargetPointer pointer = target.ReadPointer(address + (ulong)field.Offset); + if (pointer == TargetPointer.Null) + return default; + + return target.ProcessedData.GetOrAdd(pointer); + } + + /// + /// Read an optional field that contains a pointer to a Data struct type, with type validation. + /// Returns null if the field is not present in the descriptor or the pointer is null. + /// + public static T? ReadDataFieldPointerOrNull(this Target target, ulong address, Target.TypeInfo typeInfo, string fieldName) + where T : IData + { + if (!typeInfo.Fields.TryGetValue(fieldName, out Target.FieldInfo field)) + return default; + + AssertPointerType(field, fieldName); + + TargetPointer pointer = target.ReadPointer(address + (ulong)field.Offset); + if (pointer == TargetPointer.Null) + return default; + + return target.ProcessedData.GetOrAdd(pointer); + } + + [Conditional("DEBUG")] + private static void AssertPrimitiveType(Target.FieldInfo field, string fieldName) + where T : unmanaged, IBinaryInteger, IMinMaxValue + { + Debug.Assert( + field.TypeName is null or "" || IsCompatiblePrimitiveType(field.TypeName), + $"Type mismatch reading field '{fieldName}': declared as '{field.TypeName}', reading as {typeof(T).Name}"); + } + + [Conditional("DEBUG")] + private static void AssertPointerType(Target.FieldInfo field, string fieldName) + { + Debug.Assert( + field.TypeName is null or "" or "pointer", + $"Type mismatch reading field '{fieldName}': declared as '{field.TypeName}', expected pointer"); + } + + private static bool IsCompatiblePrimitiveType(string typeName) + where T : unmanaged, IBinaryInteger, IMinMaxValue + { + return typeName switch + { + "uint8" => typeof(T) == typeof(byte), + "int8" => typeof(T) == typeof(sbyte), + "uint16" => typeof(T) == typeof(ushort), + "int16" => typeof(T) == typeof(short), + "uint32" => typeof(T) == typeof(uint), + "int32" => typeof(T) == typeof(int), + "uint64" => typeof(T) == typeof(ulong), + "int64" => typeof(T) == typeof(long), + "bool" => typeof(T) == typeof(byte), + _ => false, + }; + } +} diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/BuiltInCOM_1.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/BuiltInCOM_1.cs index a9565fe6abecdf..3de4943a1630cf 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/BuiltInCOM_1.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/BuiltInCOM_1.cs @@ -171,8 +171,8 @@ public SimpleComCallWrapperData GetSimpleComCallWrapperData(TargetPointer ccw) Data.SimpleComCallWrapper data = _target.ProcessedData.GetOrAdd(sccw); return new SimpleComCallWrapperData { - RefCount = data.RefCount & (ulong)ComRefCount.RefCountMask, - IsNeutered = (data.RefCount & (ulong)ComRefCount.CleanupSentinel) != 0, + RefCount = (uint)(data.RefCount & (long)ComRefCount.RefCountMask), + IsNeutered = (data.RefCount & (long)ComRefCount.CleanupSentinel) != 0, IsAggregated = (data.Flags & (uint)SimpleComCallWrapperFlags.IsAggregated) != 0, IsExtendsCOMObject = (data.Flags & (uint)SimpleComCallWrapperFlags.IsExtendsCom) != 0, IsHandleWeak = (data.Flags & (uint)SimpleComCallWrapperFlags.IsHandleWeak) != 0, diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AppDomain.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AppDomain.cs index cd21ff7172abce..e79e879d5f47e2 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AppDomain.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AppDomain.cs @@ -12,9 +12,9 @@ public AppDomain(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.AppDomain); - RootAssembly = target.ReadPointer(address + (ulong)type.Fields[nameof(RootAssembly)].Offset); + RootAssembly = target.ReadPointerField(address, type, nameof(RootAssembly)); DomainAssemblyList = address + (ulong)type.Fields[nameof(DomainAssemblyList)].Offset; - FriendlyName = target.ReadPointer(address + (ulong)type.Fields[nameof(FriendlyName)].Offset); + FriendlyName = target.ReadPointerField(address, type, nameof(FriendlyName)); } public TargetPointer RootAssembly { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Array.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Array.cs index ea4748d6dd4cf2..8ea007c01f75c4 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Array.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Array.cs @@ -12,7 +12,7 @@ public Array(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Array); - NumComponents = target.Read(address + (ulong)type.Fields[Constants.FieldNames.Array.NumComponents].Offset); + NumComponents = target.ReadField(address, type, Constants.FieldNames.Array.NumComponents); DataPointer = address + type.Size!.Value; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ArrayListBase.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ArrayListBase.cs index e9585579371757..d8cc8767697c4b 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ArrayListBase.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ArrayListBase.cs @@ -16,7 +16,7 @@ public ArrayListBase(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ArrayListBase); - Count = target.Read(address + (ulong)type.Fields[nameof(Count)].Offset); + Count = target.ReadField(address, type, nameof(Count)); FirstBlock = address + (ulong)type.Fields[nameof(FirstBlock)].Offset; TargetPointer next = FirstBlock; @@ -56,8 +56,8 @@ public ArrayListBlock(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ArrayListBlock); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); + Size = target.ReadField(address, type, nameof(Size)); ArrayStart = address + (ulong)type.Fields[nameof(ArrayStart)].Offset; for (ulong i = 0; i < Size; i++) diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Assembly.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Assembly.cs index 5c8a3b672e2a34..e84b449383dd01 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Assembly.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Assembly.cs @@ -12,12 +12,12 @@ public Assembly(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Assembly); - Module = target.ReadPointer(address + (ulong)type.Fields[nameof(Module)].Offset); - IsCollectible = target.Read(address + (ulong)type.Fields[nameof(IsCollectible)].Offset); - IsDynamic = target.Read(address + (ulong)type.Fields[nameof(IsDynamic)].Offset) != 0; - Error = target.ReadPointer(address + (ulong)type.Fields[nameof(Error)].Offset); - NotifyFlags = target.Read(address + (ulong)type.Fields[nameof(NotifyFlags)].Offset); - IsLoaded = target.Read(address + (ulong)type.Fields[nameof(IsLoaded)].Offset) != 0; + Module = target.ReadPointerField(address, type, nameof(Module)); + IsCollectible = target.ReadField(address, type, nameof(IsCollectible)); + IsDynamic = target.ReadField(address, type, nameof(IsDynamic)) != 0; + Error = target.ReadPointerField(address, type, nameof(Error)); + NotifyFlags = target.ReadField(address, type, nameof(NotifyFlags)); + IsLoaded = target.ReadField(address, type, nameof(IsLoaded)) != 0; } public TargetPointer Module { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AssemblyBinder.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AssemblyBinder.cs index 2c13c5fe332a95..4ffb63f457472f 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AssemblyBinder.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AssemblyBinder.cs @@ -11,7 +11,7 @@ internal sealed class AssemblyBinder : IData public AssemblyBinder(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.AssemblyBinder); - AssemblyLoadContext = target.ReadPointer(address + (ulong)type.Fields[nameof(AssemblyLoadContext)].Offset); + AssemblyLoadContext = target.ReadPointerField(address, type, nameof(AssemblyLoadContext)); } public TargetPointer AssemblyLoadContext { get; init; } } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AuxiliarySymbolInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AuxiliarySymbolInfo.cs index 77f0fb9054d499..40bc6632aed430 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AuxiliarySymbolInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AuxiliarySymbolInfo.cs @@ -12,8 +12,8 @@ public AuxiliarySymbolInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.AuxiliarySymbolInfo); - Address = target.ReadCodePointer(address + (ulong)type.Fields[nameof(Address)].Offset); - Name = target.ReadPointer(address + (ulong)type.Fields[nameof(Name)].Offset); + Address = target.ReadCodePointerField(address, type, nameof(Address)); + Name = target.ReadPointerField(address, type, nameof(Name)); } public TargetCodePointer Address { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CGrowableSymbolStream.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CGrowableSymbolStream.cs index 78913d53620a8b..e0314173ef1613 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CGrowableSymbolStream.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CGrowableSymbolStream.cs @@ -10,8 +10,8 @@ public CGrowableSymbolStream(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CGrowableSymbolStream); - Buffer = target.ReadPointer(address + (ulong)type.Fields[nameof(Buffer)].Offset); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); + Buffer = target.ReadPointerField(address, type, nameof(Buffer)); + Size = target.ReadField(address, type, nameof(Size)); } public TargetPointer Buffer { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CardTableInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CardTableInfo.cs index 360cd94915c2cb..5a64922dbadb17 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CardTableInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CardTableInfo.cs @@ -11,9 +11,9 @@ static CardTableInfo IData.Create(Target target, TargetPointer ad public CardTableInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CardTableInfo); - Recount = target.Read(address + (ulong)type.Fields[nameof(Recount)].Offset); - Size = target.ReadNUInt(address + (ulong)type.Fields[nameof(Size)].Offset); - NextCardTable = target.ReadPointer(address + (ulong)type.Fields[nameof(NextCardTable)].Offset); + Recount = target.ReadField(address, type, nameof(Recount)); + Size = target.ReadNUIntField(address, type, nameof(Size)); + NextCardTable = target.ReadPointerField(address, type, nameof(NextCardTable)); } public uint Recount { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeap.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeap.cs index d88c9b7a384bf4..e7af1deef527ad 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeap.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeap.cs @@ -11,7 +11,7 @@ static CodeHeap IData.Create(Target target, TargetPointer address) public CodeHeap(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CodeHeap); - HeapType = target.Read(address + (ulong)type.Fields[nameof(HeapType)].Offset); + HeapType = target.ReadField(address, type, nameof(HeapType)); } public byte HeapType { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeapListNode.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeapListNode.cs index edce53f82aa61c..bf1c618f1c2fc2 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeapListNode.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CodeHeapListNode.cs @@ -11,12 +11,12 @@ static CodeHeapListNode IData.Create(Target target, TargetPoin public CodeHeapListNode(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CodeHeapListNode); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - StartAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(StartAddress)].Offset); - EndAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(EndAddress)].Offset); - MapBase = target.ReadPointer(address + (ulong)type.Fields[nameof(MapBase)].Offset); - HeaderMap = target.ReadPointer(address + (ulong)type.Fields[nameof(HeaderMap)].Offset); - Heap = target.ReadPointer(address + (ulong)type.Fields[nameof(Heap)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); + StartAddress = target.ReadPointerField(address, type, nameof(StartAddress)); + EndAddress = target.ReadPointerField(address, type, nameof(EndAddress)); + MapBase = target.ReadPointerField(address, type, nameof(MapBase)); + HeaderMap = target.ReadPointerField(address, type, nameof(HeaderMap)); + Heap = target.ReadPointerField(address, type, nameof(Heap)); } public TargetPointer Next { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComCallWrapper.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComCallWrapper.cs index 549830f54dc778..69bf2e74f038ae 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComCallWrapper.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComCallWrapper.cs @@ -11,9 +11,9 @@ public ComCallWrapper(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ComCallWrapper); - Handle = target.ReadPointer(address + (ulong)type.Fields[nameof(Handle)].Offset); - SimpleWrapper = target.ReadPointer(address + (ulong)type.Fields[nameof(SimpleWrapper)].Offset); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); + Handle = target.ReadPointerField(address, type, nameof(Handle)); + SimpleWrapper = target.ReadPointerField(address, type, nameof(SimpleWrapper)); + Next = target.ReadPointerField(address, type, nameof(Next)); IPtr = address + (ulong)type.Fields[nameof(IPtr)].Offset; int numInterfaces = (int)target.ReadGlobal(Constants.Globals.CCWNumInterfaces); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComMethodTable.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComMethodTable.cs index 81997c5bd0ea4b..a8c336af890150 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComMethodTable.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ComMethodTable.cs @@ -10,8 +10,8 @@ public ComMethodTable(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ComMethodTable); - Flags = target.ReadNUInt(address + (ulong)type.Fields[nameof(Flags)].Offset); - MethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodTable)].Offset); + Flags = target.ReadNUIntField(address, type, nameof(Flags)); + MethodTable = target.ReadPointerField(address, type, nameof(MethodTable)); } public TargetNUInt Flags { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CoreLibBinder.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CoreLibBinder.cs index 49e6155d680cfa..5ce0d444b0d658 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CoreLibBinder.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CoreLibBinder.cs @@ -12,7 +12,7 @@ public CoreLibBinder(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CoreLibBinder); - Classes = target.ReadPointer(address + (ulong)type.Fields[nameof(Classes)].Offset); + Classes = target.ReadPointerField(address, type, nameof(Classes)); } public TargetPointer Classes { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CtxEntry.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CtxEntry.cs index f67fa847424544..7f7b4f0eb862c3 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CtxEntry.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/CtxEntry.cs @@ -10,8 +10,8 @@ public CtxEntry(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.CtxEntry); - STAThread = target.ReadPointer(address + (ulong)type.Fields[nameof(STAThread)].Offset); - CtxCookie = target.ReadPointer(address + (ulong)type.Fields[nameof(CtxCookie)].Offset); + STAThread = target.ReadPointerField(address, type, nameof(STAThread)); + CtxCookie = target.ReadPointerField(address, type, nameof(CtxCookie)); } public TargetPointer STAThread { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DacEnumerableHash.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DacEnumerableHash.cs index 248eb1fcc74ad5..ad4fe352f372aa 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DacEnumerableHash.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DacEnumerableHash.cs @@ -29,8 +29,8 @@ public DacEnumerableHash(Target target, TargetPointer address, Target.TypeInfo t _target = target; _type = type; - Buckets = _target.ReadPointer(address + (ulong)_type.Fields[nameof(Buckets)].Offset); - Count = _target.Read(address + (ulong)_type.Fields[nameof(Count)].Offset); + Buckets = _target.ReadPointerField(address, _type, nameof(Buckets)); + Count = _target.ReadField(address, _type, nameof(Count)); // read items in the hash table uint length = GetLength(); @@ -61,7 +61,7 @@ public VolatileEntry(Target target, TargetPointer address, Target.TypeInfo type) { // offsets are stored on the parent type VolatileEntryValue = address + (ulong)type.Fields[nameof(VolatileEntryValue)].Offset; - VolatileEntryNextEntry = target.ReadPointer(address + (ulong)type.Fields[nameof(VolatileEntryNextEntry)].Offset); + VolatileEntryNextEntry = target.ReadPointerField(address, type, nameof(VolatileEntryNextEntry)); } public TargetPointer VolatileEntryValue { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs index 3165d480333a8e..4955f3682cf5ed 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs @@ -12,9 +12,9 @@ public Debugger(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Debugger); - LeftSideInitialized = target.Read(address + (ulong)type.Fields[nameof(LeftSideInitialized)].Offset); - Defines = target.Read(address + (ulong)type.Fields[nameof(Defines)].Offset); - MDStructuresVersion = target.Read(address + (ulong)type.Fields[nameof(MDStructuresVersion)].Offset); + LeftSideInitialized = target.ReadField(address, type, nameof(LeftSideInitialized)); + Defines = target.ReadField(address, type, nameof(Defines)); + MDStructuresVersion = target.ReadField(address, type, nameof(MDStructuresVersion)); } public int LeftSideInitialized { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicILBlobEntry.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicILBlobEntry.cs index b7f68e9fcee463..cdcd89bd17b440 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicILBlobEntry.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicILBlobEntry.cs @@ -11,8 +11,8 @@ static DynamicILBlobEntry IData.Create(Target target, Target public DynamicILBlobEntry(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.DynamicILBlobTable); - EntryMethodToken = target.Read(address + (ulong)type.Fields[nameof(EntryMethodToken)].Offset); - EntryIL = target.ReadPointer(address + (ulong)type.Fields[nameof(EntryIL)].Offset); + EntryMethodToken = target.ReadField(address, type, nameof(EntryMethodToken)); + EntryIL = target.ReadPointerField(address, type, nameof(EntryIL)); } public DynamicILBlobEntry(uint entryMethodToken, TargetPointer entryIL) diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicMetadata.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicMetadata.cs index 2496c5324e25d4..39181dd5c46284 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicMetadata.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicMetadata.cs @@ -10,7 +10,7 @@ public DynamicMetadata(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.DynamicMetadata); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); + Size = target.ReadField(address, type, nameof(Size)); Data = address + (ulong)type.Fields[nameof(Data)].Offset; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicStaticsInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicStaticsInfo.cs index 649c9ecdd881e3..b308ce5dea088b 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicStaticsInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DynamicStaticsInfo.cs @@ -12,8 +12,8 @@ public DynamicStaticsInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.DynamicStaticsInfo); TargetPointer mask = target.ReadGlobalPointer(Constants.Globals.StaticsPointerMask); - GCStatics = target.ReadPointer(address + (ulong)type.Fields[nameof(GCStatics)].Offset) & mask; - NonGCStatics = target.ReadPointer(address + (ulong)type.Fields[nameof(NonGCStatics)].Offset) & mask; + GCStatics = target.ReadPointerField(address, type, nameof(GCStatics)) & mask; + NonGCStatics = target.ReadPointerField(address, type, nameof(NonGCStatics)) & mask; } public TargetPointer GCStatics { get; init; } public TargetPointer NonGCStatics { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs index bd3efe35aaa593..0d0393f6e4e0df 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs @@ -10,16 +10,16 @@ public EEClass(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.EEClass); - MethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodTable)].Offset); - MethodDescChunk = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDescChunk)].Offset); - NumMethods = target.Read(address + (ulong)type.Fields[nameof(NumMethods)].Offset); - CorTypeAttr = target.Read(address + (ulong)type.Fields[nameof(CorTypeAttr)].Offset); - InternalCorElementType = target.Read(address + (ulong)type.Fields[nameof(InternalCorElementType)].Offset); - NumInstanceFields = target.Read(address + (ulong)type.Fields[nameof(NumInstanceFields)].Offset); - NumStaticFields = target.Read(address + (ulong)type.Fields[nameof(NumStaticFields)].Offset); - NumThreadStaticFields = target.Read(address + (ulong)type.Fields[nameof(NumThreadStaticFields)].Offset); - FieldDescList = target.Read(address + (ulong)type.Fields[nameof(FieldDescList)].Offset); - NumNonVirtualSlots = target.Read(address + (ulong)type.Fields[nameof(NumNonVirtualSlots)].Offset); + MethodTable = target.ReadPointerField(address, type, nameof(MethodTable)); + MethodDescChunk = target.ReadPointerField(address, type, nameof(MethodDescChunk)); + NumMethods = target.ReadField(address, type, nameof(NumMethods)); + CorTypeAttr = target.ReadField(address, type, nameof(CorTypeAttr)); + InternalCorElementType = target.ReadField(address, type, nameof(InternalCorElementType)); + NumInstanceFields = target.ReadField(address, type, nameof(NumInstanceFields)); + NumStaticFields = target.ReadField(address, type, nameof(NumStaticFields)); + NumThreadStaticFields = target.ReadField(address, type, nameof(NumThreadStaticFields)); + FieldDescList = target.ReadPointerField(address, type, nameof(FieldDescList)); + NumNonVirtualSlots = target.ReadField(address, type, nameof(NumNonVirtualSlots)); } public TargetPointer MethodTable { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEJitManager.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEJitManager.cs index 7d2e2d074dd52c..8d52096a6d41fa 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEJitManager.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEJitManager.cs @@ -10,8 +10,8 @@ public EEJitManager(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.EEJitManager); - StoreRichDebugInfo = target.Read(address + (ulong)type.Fields[nameof(StoreRichDebugInfo)].Offset) != 0; - AllCodeHeaps = target.ReadPointer(address + (ulong)type.Fields[nameof(AllCodeHeaps)].Offset); + StoreRichDebugInfo = target.ReadField(address, type, nameof(StoreRichDebugInfo)) != 0; + AllCodeHeaps = target.ReadPointerField(address, type, nameof(AllCodeHeaps)); } public bool StoreRichDebugInfo { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Exception.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Exception.cs index 8f08dc08810e60..d43d56cae17e3f 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Exception.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Exception.cs @@ -12,14 +12,14 @@ public Exception(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Exception); - Message = target.ReadPointer(address + (ulong)type.Fields["_message"].Offset); - InnerException = target.ReadPointer(address + (ulong)type.Fields["_innerException"].Offset); - StackTrace = target.ReadPointer(address + (ulong)type.Fields["_stackTrace"].Offset); - WatsonBuckets = target.ReadPointer(address + (ulong)type.Fields["_watsonBuckets"].Offset); - StackTraceString = target.ReadPointer(address + (ulong)type.Fields["_stackTraceString"].Offset); - RemoteStackTraceString = target.ReadPointer(address + (ulong)type.Fields["_remoteStackTraceString"].Offset); - HResult = target.Read(address + (ulong)type.Fields["_HResult"].Offset); - XCode = target.Read(address + (ulong)type.Fields["_xcode"].Offset); + Message = target.ReadPointerField(address, type, "_message"); + InnerException = target.ReadPointerField(address, type, "_innerException"); + StackTrace = target.ReadPointerField(address, type, "_stackTrace"); + WatsonBuckets = target.ReadPointerField(address, type, "_watsonBuckets"); + StackTraceString = target.ReadPointerField(address, type, "_stackTraceString"); + RemoteStackTraceString = target.ReadPointerField(address, type, "_remoteStackTraceString"); + HResult = target.ReadField(address, type, "_HResult"); + XCode = target.ReadField(address, type, "_xcode"); } public TargetPointer Message { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionClause.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionClause.cs index d8498f67440b59..91b14c79d382f8 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionClause.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionClause.cs @@ -21,13 +21,13 @@ public EEExceptionClause(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.EEExceptionClause); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - TryStartPC = target.Read(address + (ulong)type.Fields[nameof(TryStartPC)].Offset); - TryEndPC = target.Read(address + (ulong)type.Fields[nameof(TryEndPC)].Offset); - HandlerStartPC = target.Read(address + (ulong)type.Fields[nameof(HandlerStartPC)].Offset); - HandlerEndPC = target.Read(address + (ulong)type.Fields[nameof(HandlerEndPC)].Offset); - TypeHandle = target.ReadNUInt(address + (ulong)type.Fields[nameof(TypeHandle)].Offset); - ClassToken = target.Read(address + (ulong)type.Fields[nameof(TypeHandle)].Offset); + Flags = target.ReadField(address, type, nameof(Flags)); + TryStartPC = target.ReadField(address, type, nameof(TryStartPC)); + TryEndPC = target.ReadField(address, type, nameof(TryEndPC)); + HandlerStartPC = target.ReadField(address, type, nameof(HandlerStartPC)); + HandlerEndPC = target.ReadField(address, type, nameof(HandlerEndPC)); + TypeHandle = target.ReadNUIntField(address, type, nameof(TypeHandle)); + ClassToken = (uint)TypeHandle.Value; FilterOffset = ClassToken; } @@ -48,12 +48,12 @@ public R2RExceptionClause(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.R2RExceptionClause); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - TryStartPC = target.Read(address + (ulong)type.Fields[nameof(TryStartPC)].Offset); - TryEndPC = target.Read(address + (ulong)type.Fields[nameof(TryEndPC)].Offset); - HandlerStartPC = target.Read(address + (ulong)type.Fields[nameof(HandlerStartPC)].Offset); - HandlerEndPC = target.Read(address + (ulong)type.Fields[nameof(HandlerEndPC)].Offset); - ClassToken = target.Read(address + (ulong)type.Fields[nameof(ClassToken)].Offset); + Flags = target.ReadField(address, type, nameof(Flags)); + TryStartPC = target.ReadField(address, type, nameof(TryStartPC)); + TryEndPC = target.ReadField(address, type, nameof(TryEndPC)); + HandlerStartPC = target.ReadField(address, type, nameof(HandlerStartPC)); + HandlerEndPC = target.ReadField(address, type, nameof(HandlerEndPC)); + ClassToken = target.ReadField(address, type, nameof(ClassToken)); FilterOffset = ClassToken; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionInfo.cs index 8f2470d6e71996..4e496b82c1b1be 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionInfo.cs @@ -12,17 +12,17 @@ public ExceptionInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ExceptionInfo); - PreviousNestedInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(PreviousNestedInfo)].Offset); - ThrownObjectHandle = target.ReadPointer(address + (ulong)type.Fields[nameof(ThrownObjectHandle)].Offset); - ExceptionFlags = target.Read(address + (ulong)type.Fields[nameof(ExceptionFlags)].Offset); - StackLowBound = target.ReadPointer(address + (ulong)type.Fields[nameof(StackLowBound)].Offset); - StackHighBound = target.ReadPointer(address + (ulong)type.Fields[nameof(StackHighBound)].Offset); + PreviousNestedInfo = target.ReadPointerField(address, type, nameof(PreviousNestedInfo)); + ThrownObjectHandle = target.ReadPointerField(address, type, nameof(ThrownObjectHandle)); if (type.Fields.ContainsKey(nameof(ExceptionWatsonBucketTrackerBuckets))) - ExceptionWatsonBucketTrackerBuckets = target.ReadPointer(address + (ulong)type.Fields[nameof(ExceptionWatsonBucketTrackerBuckets)].Offset); - PassNumber = target.Read(address + (ulong)type.Fields[nameof(PassNumber)].Offset); - CSFEHClause = target.ReadPointer(address + (ulong)type.Fields[nameof(CSFEHClause)].Offset); - CSFEnclosingClause = target.ReadPointer(address + (ulong)type.Fields[nameof(CSFEnclosingClause)].Offset); - CallerOfActualHandlerFrame = target.ReadPointer(address + (ulong)type.Fields[nameof(CallerOfActualHandlerFrame)].Offset); + ExceptionWatsonBucketTrackerBuckets = target.ReadPointerField(address, type, nameof(ExceptionWatsonBucketTrackerBuckets)); + ExceptionFlags = target.ReadField(address, type, nameof(ExceptionFlags)); + StackLowBound = target.ReadPointerField(address, type, nameof(StackLowBound)); + StackHighBound = target.ReadPointerField(address, type, nameof(StackHighBound)); + PassNumber = target.ReadField(address, type, nameof(PassNumber)); + CSFEHClause = target.ReadPointerField(address, type, nameof(CSFEHClause)); + CSFEnclosingClause = target.ReadPointerField(address, type, nameof(CSFEnclosingClause)); + CallerOfActualHandlerFrame = target.ReadPointerField(address, type, nameof(CallerOfActualHandlerFrame)); } public TargetPointer PreviousNestedInfo { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionLookupTableEntry.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionLookupTableEntry.cs index 2b3d9cbe19822f..5914842e854236 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionLookupTableEntry.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ExceptionLookupTableEntry.cs @@ -9,8 +9,8 @@ internal sealed class ExceptionLookupTableEntry : IData(address + (ulong)type.Fields[nameof(MethodStartRVA)].Offset); - ExceptionInfoRVA = target.Read(address + (ulong)type.Fields[nameof(ExceptionInfoRVA)].Offset); + MethodStartRVA = target.ReadField(address, type, nameof(MethodStartRVA)); + ExceptionInfoRVA = target.ReadField(address, type, nameof(ExceptionInfoRVA)); } public uint MethodStartRVA { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FieldDesc.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FieldDesc.cs index 6ce2f4d2227219..4f7cbaf9fad045 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FieldDesc.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FieldDesc.cs @@ -9,9 +9,9 @@ internal sealed class FieldDesc : IData public FieldDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.FieldDesc); - DWord1 = target.Read(address + (ulong)type.Fields[nameof(DWord1)].Offset); - DWord2 = target.Read(address + (ulong)type.Fields[nameof(DWord2)].Offset); - MTOfEnclosingClass = target.ReadPointer(address + (ulong)type.Fields[nameof(MTOfEnclosingClass)].Offset); + DWord1 = target.ReadField(address, type, nameof(DWord1)); + DWord2 = target.ReadField(address, type, nameof(DWord2)); + MTOfEnclosingClass = target.ReadPointerField(address, type, nameof(MTOfEnclosingClass)); } public uint DWord1 { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FixupPrecodeData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FixupPrecodeData.cs index 811508cc4354a1..8a6bb449dc7d93 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FixupPrecodeData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/FixupPrecodeData.cs @@ -11,7 +11,7 @@ static FixupPrecodeData IData.Create(Target target, TargetPoin public FixupPrecodeData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.FixupPrecodeData); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); } public TargetPointer MethodDesc { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/DebuggerEval.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/DebuggerEval.cs index 31352b4cc6880a..e162ce98ae3771 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/DebuggerEval.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/DebuggerEval.cs @@ -12,7 +12,7 @@ public DebuggerEval(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.DebuggerEval); TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset; - EvalDuringException = target.Read(address + (ulong)type.Fields[nameof(EvalDuringException)].Offset) != 0; + EvalDuringException = target.ReadField(address, type, nameof(EvalDuringException)) != 0; Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/Frame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/Frame.cs index cee27f37f723ad..4a3ea03d63edf7 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/Frame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/Frame.cs @@ -12,7 +12,7 @@ public Frame(Target target, TargetPointer address) { Address = address; Target.TypeInfo type = target.GetTypeInfo(DataType.Frame); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); Identifier = target.ReadPointer(address); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FramedMethodFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FramedMethodFrame.cs index 0fcb030bd239eb..ffe01581f9e7f2 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FramedMethodFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FramedMethodFrame.cs @@ -11,8 +11,8 @@ static FramedMethodFrame IData.Create(Target target, TargetPo public FramedMethodFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.FramedMethodFrame); - TransitionBlockPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(TransitionBlockPtr)].Offset); - MethodDescPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDescPtr)].Offset); + TransitionBlockPtr = target.ReadPointerField(address, type, nameof(TransitionBlockPtr)); + MethodDescPtr = target.ReadPointerField(address, type, nameof(MethodDescPtr)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FuncEvalFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FuncEvalFrame.cs index 65379d77d35f49..4dc74145f97458 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FuncEvalFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FuncEvalFrame.cs @@ -14,7 +14,7 @@ static FuncEvalFrame IData.Create(Target target, TargetPointer ad public FuncEvalFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.FuncEvalFrame); - DebuggerEvalPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(DebuggerEvalPtr)].Offset); + DebuggerEvalPtr = target.ReadPointerField(address, type, nameof(DebuggerEvalPtr)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackArgsAMD64.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackArgsAMD64.cs index e6428549a154bd..811b84abc6508a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackArgsAMD64.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackArgsAMD64.cs @@ -16,7 +16,7 @@ public HijackArgsAMD64(Target target, TargetPointer address) // On Windows, Rsp is present if (type.Fields.ContainsKey(nameof(Rsp))) { - Rsp = target.ReadPointer(address + (ulong)type.Fields[nameof(Rsp)].Offset); + Rsp = target.ReadPointerField(address, type, nameof(Rsp)); } } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackFrame.cs index db5061ed271bb0..cd971512063490 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/HijackFrame.cs @@ -11,8 +11,8 @@ static HijackFrame IData.Create(Target target, TargetPointer addres public HijackFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HijackFrame); - ReturnAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(ReturnAddress)].Offset); - HijackArgsPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(HijackArgsPtr)].Offset); + ReturnAddress = target.ReadPointerField(address, type, nameof(ReturnAddress)); + HijackArgsPtr = target.ReadPointerField(address, type, nameof(HijackArgsPtr)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/InlinedCallFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/InlinedCallFrame.cs index b544c9fc6500cc..9ea5f779969770 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/InlinedCallFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/InlinedCallFrame.cs @@ -11,12 +11,12 @@ static InlinedCallFrame IData.Create(Target target, TargetPoin public InlinedCallFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.InlinedCallFrame); - CallSiteSP = target.ReadPointer(address + (ulong)type.Fields[nameof(CallSiteSP)].Offset); - CallerReturnAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(CallerReturnAddress)].Offset); - CalleeSavedFP = target.ReadPointer(address + (ulong)type.Fields[nameof(CalleeSavedFP)].Offset); + CallSiteSP = target.ReadPointerField(address, type, nameof(CallSiteSP)); + CallerReturnAddress = target.ReadPointerField(address, type, nameof(CallerReturnAddress)); + CalleeSavedFP = target.ReadPointerField(address, type, nameof(CalleeSavedFP)); if (type.Fields.ContainsKey(nameof(SPAfterProlog))) - SPAfterProlog = target.ReadPointer(address + (ulong)type.Fields[nameof(SPAfterProlog)].Offset); - Datum = target.ReadPointer(address + (ulong)type.Fields[nameof(Datum)].Offset); + SPAfterProlog = target.ReadPointerField(address, type, nameof(SPAfterProlog)); + Datum = target.ReadPointerField(address, type, nameof(Datum)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/ResumableFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/ResumableFrame.cs index 3faa26701b2102..659710f668eb0c 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/ResumableFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/ResumableFrame.cs @@ -11,7 +11,7 @@ static ResumableFrame IData.Create(Target target, TargetPointer public ResumableFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ResumableFrame); - TargetContextPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(TargetContextPtr)].Offset); + TargetContextPtr = target.ReadPointerField(address, type, nameof(TargetContextPtr)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs index 0cec284982faea..33246adc7ac63e 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs @@ -13,7 +13,7 @@ public SoftwareExceptionFrame(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.SoftwareExceptionFrame); Address = address; TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset; - ReturnAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(ReturnAddress)].Offset); + ReturnAddress = target.ReadPointerField(address, type, nameof(ReturnAddress)); } public TargetPointer Address { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/StubDispatchFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/StubDispatchFrame.cs index f4e677dafddaa9..c49f6919353255 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/StubDispatchFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/StubDispatchFrame.cs @@ -11,9 +11,9 @@ static StubDispatchFrame IData.Create(Target target, TargetPo public StubDispatchFrame(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StubDispatchFrame); - MethodDescPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDescPtr)].Offset); - RepresentativeMTPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(RepresentativeMTPtr)].Offset); - RepresentativeSlot = target.Read(address + (ulong)type.Fields[nameof(RepresentativeSlot)].Offset); + MethodDescPtr = target.ReadPointerField(address, type, nameof(MethodDescPtr)); + RepresentativeMTPtr = target.ReadPointerField(address, type, nameof(RepresentativeMTPtr)); + RepresentativeSlot = target.ReadField(address, type, nameof(RepresentativeSlot)); Address = address; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TailCallFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TailCallFrame.cs index 41381ff5fe88c9..30322766dd84df 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TailCallFrame.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TailCallFrame.cs @@ -13,7 +13,7 @@ public TailCallFrame(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.TailCallFrame); Address = address; CalleeSavedRegisters = address + (ulong)type.Fields[nameof(CalleeSavedRegisters)].Offset; - ReturnAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(ReturnAddress)].Offset); + ReturnAddress = target.ReadPointerField(address, type, nameof(ReturnAddress)); } public TargetPointer Address { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TransitionBlock.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TransitionBlock.cs index 121e7ce2561650..b2c0c71cb47ef9 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TransitionBlock.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/TransitionBlock.cs @@ -11,7 +11,7 @@ static TransitionBlock IData.Create(Target target, TargetPointe public TransitionBlock(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TransitionBlock); - ReturnAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(ReturnAddress)].Offset); + ReturnAddress = target.ReadPointerField(address, type, nameof(ReturnAddress)); CalleeSavedRegisters = address + (ulong)type.Fields[nameof(CalleeSavedRegisters)].Offset; if (type.Fields.ContainsKey(nameof(ArgumentRegisters))) diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/GCHeapSVR.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/GCHeapSVR.cs index b6f4743149844e..7acf5d75459357 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/GCHeapSVR.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/GCHeapSVR.cs @@ -14,27 +14,27 @@ public GCHeapSVR(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.GCHeap); - MarkArray = target.ReadPointer(address + (ulong)type.Fields[nameof(MarkArray)].Offset); - NextSweepObj = target.ReadPointer(address + (ulong)type.Fields[nameof(NextSweepObj)].Offset); - BackgroundMinSavedAddr = target.ReadPointer(address + (ulong)type.Fields[nameof(BackgroundMinSavedAddr)].Offset); - BackgroundMaxSavedAddr = target.ReadPointer(address + (ulong)type.Fields[nameof(BackgroundMaxSavedAddr)].Offset); - AllocAllocated = target.ReadPointer(address + (ulong)type.Fields[nameof(AllocAllocated)].Offset); - EphemeralHeapSegment = target.ReadPointer(address + (ulong)type.Fields[nameof(EphemeralHeapSegment)].Offset); - CardTable = target.ReadPointer(address + (ulong)type.Fields[nameof(CardTable)].Offset); - FinalizeQueue = target.ReadPointer(address + (ulong)type.Fields[nameof(FinalizeQueue)].Offset); + MarkArray = target.ReadPointerField(address, type, nameof(MarkArray)); + NextSweepObj = target.ReadPointerField(address, type, nameof(NextSweepObj)); + BackgroundMinSavedAddr = target.ReadPointerField(address, type, nameof(BackgroundMinSavedAddr)); + BackgroundMaxSavedAddr = target.ReadPointerField(address, type, nameof(BackgroundMaxSavedAddr)); + AllocAllocated = target.ReadPointerField(address, type, nameof(AllocAllocated)); + EphemeralHeapSegment = target.ReadPointerField(address, type, nameof(EphemeralHeapSegment)); + CardTable = target.ReadPointerField(address, type, nameof(CardTable)); + FinalizeQueue = target.ReadPointerField(address, type, nameof(FinalizeQueue)); GenerationTable = address + (ulong)type.Fields[nameof(GenerationTable)].Offset; // Fields only exist segment GC builds if (type.Fields.ContainsKey(nameof(SavedSweepEphemeralSeg))) - SavedSweepEphemeralSeg = target.ReadPointer(address + (ulong)type.Fields[nameof(SavedSweepEphemeralSeg)].Offset); + SavedSweepEphemeralSeg = target.ReadPointerField(address, type, nameof(SavedSweepEphemeralSeg)); if (type.Fields.ContainsKey(nameof(SavedSweepEphemeralStart))) - SavedSweepEphemeralStart = target.ReadPointer(address + (ulong)type.Fields[nameof(SavedSweepEphemeralStart)].Offset); + SavedSweepEphemeralStart = target.ReadPointerField(address, type, nameof(SavedSweepEphemeralStart)); OomData = target.ProcessedData.GetOrAdd(address + (ulong)type.Fields[nameof(OomData)].Offset); - InternalRootArray = target.ReadPointer(address + (ulong)type.Fields[nameof(InternalRootArray)].Offset); - InternalRootArrayIndex = target.ReadNUInt(address + (ulong)type.Fields[nameof(InternalRootArrayIndex)].Offset); - HeapAnalyzeSuccess = target.Read(address + (ulong)type.Fields[nameof(HeapAnalyzeSuccess)].Offset) != 0; + InternalRootArray = target.ReadPointerField(address, type, nameof(InternalRootArray)); + InternalRootArrayIndex = target.ReadNUIntField(address, type, nameof(InternalRootArrayIndex)); + HeapAnalyzeSuccess = target.ReadField(address, type, nameof(HeapAnalyzeSuccess)) != 0; InterestingData = address + (ulong)type.Fields[nameof(InterestingData)].Offset; CompactReasons = address + (ulong)type.Fields[nameof(CompactReasons)].Offset; @@ -42,9 +42,9 @@ public GCHeapSVR(Target target, TargetPointer address) InterestingMechanismBits = address + (ulong)type.Fields[nameof(InterestingMechanismBits)].Offset; if (type.Fields.ContainsKey(nameof(FreeableSohSegment))) - FreeableSohSegment = target.ReadPointer(address + (ulong)type.Fields[nameof(FreeableSohSegment)].Offset); + FreeableSohSegment = target.ReadPointerField(address, type, nameof(FreeableSohSegment)); if (type.Fields.ContainsKey(nameof(FreeableUohSegment))) - FreeableUohSegment = target.ReadPointer(address + (ulong)type.Fields[nameof(FreeableUohSegment)].Offset); + FreeableUohSegment = target.ReadPointerField(address, type, nameof(FreeableUohSegment)); if (type.Fields.ContainsKey(nameof(FreeRegions))) FreeRegions = address + (ulong)type.Fields[nameof(FreeRegions)].Offset; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/Generation.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/Generation.cs index 347442c12cf70e..916dd9aea6e900 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/Generation.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/Generation.cs @@ -11,11 +11,11 @@ public Generation(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.Generation); AllocationContext = target.ProcessedData.GetOrAdd(address + (ulong)type.Fields[nameof(AllocationContext)].Offset); - StartSegment = target.ReadPointer(address + (ulong)type.Fields[nameof(StartSegment)].Offset); + StartSegment = target.ReadPointerField(address, type, nameof(StartSegment)); // Fields only exist segment GC builds if (type.Fields.ContainsKey(nameof(AllocationStart))) - AllocationStart = target.ReadPointer(address + (ulong)type.Fields[nameof(AllocationStart)].Offset); + AllocationStart = target.ReadPointerField(address, type, nameof(AllocationStart)); } public GCAllocContext AllocationContext { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/HeapSegment.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/HeapSegment.cs index 1ae541d30d6df5..60ed0f31a83c63 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/HeapSegment.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/HeapSegment.cs @@ -10,18 +10,18 @@ public HeapSegment(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HeapSegment); - Allocated = target.ReadPointer(address + (ulong)type.Fields[nameof(Allocated)].Offset); - Committed = target.ReadPointer(address + (ulong)type.Fields[nameof(Committed)].Offset); - Reserved = target.ReadPointer(address + (ulong)type.Fields[nameof(Reserved)].Offset); - Used = target.ReadPointer(address + (ulong)type.Fields[nameof(Used)].Offset); - Mem = target.ReadPointer(address + (ulong)type.Fields[nameof(Mem)].Offset); - Flags = target.ReadNUInt(address + (ulong)type.Fields[nameof(Flags)].Offset); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - BackgroundAllocated = target.ReadPointer(address + (ulong)type.Fields[nameof(BackgroundAllocated)].Offset); + Allocated = target.ReadPointerField(address, type, nameof(Allocated)); + Committed = target.ReadPointerField(address, type, nameof(Committed)); + Reserved = target.ReadPointerField(address, type, nameof(Reserved)); + Used = target.ReadPointerField(address, type, nameof(Used)); + Mem = target.ReadPointerField(address, type, nameof(Mem)); + Flags = target.ReadNUIntField(address, type, nameof(Flags)); + Next = target.ReadPointerField(address, type, nameof(Next)); + BackgroundAllocated = target.ReadPointerField(address, type, nameof(BackgroundAllocated)); // Field only exists in MULTIPLE_HEAPS builds if (type.Fields.ContainsKey(nameof(Heap))) - Heap = target.ReadPointer(address + (ulong)type.Fields[nameof(Heap)].Offset); + Heap = target.ReadPointerField(address, type, nameof(Heap)); } public TargetPointer Allocated { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/OOMHistory.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/OOMHistory.cs index 42f21fc5a589c8..5d46ed395611c3 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/OOMHistory.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GC/OOMHistory.cs @@ -10,15 +10,15 @@ public OomHistory(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.OomHistory); - Reason = target.Read(address + (ulong)type.Fields[nameof(Reason)].Offset); - AllocSize = target.ReadNUInt(address + (ulong)type.Fields[nameof(AllocSize)].Offset); - Reserved = target.ReadPointer(address + (ulong)type.Fields[nameof(Reserved)].Offset); - Allocated = target.ReadPointer(address + (ulong)type.Fields[nameof(Allocated)].Offset); - GcIndex = target.ReadNUInt(address + (ulong)type.Fields[nameof(GcIndex)].Offset); - Fgm = target.Read(address + (ulong)type.Fields[nameof(Fgm)].Offset); - Size = target.ReadNUInt(address + (ulong)type.Fields[nameof(Size)].Offset); - AvailablePagefileMb = target.ReadNUInt(address + (ulong)type.Fields[nameof(AvailablePagefileMb)].Offset); - LohP = target.Read(address + (ulong)type.Fields[nameof(LohP)].Offset); + Reason = target.ReadField(address, type, nameof(Reason)); + AllocSize = target.ReadNUIntField(address, type, nameof(AllocSize)); + Reserved = target.ReadPointerField(address, type, nameof(Reserved)); + Allocated = target.ReadPointerField(address, type, nameof(Allocated)); + GcIndex = target.ReadNUIntField(address, type, nameof(GcIndex)); + Fgm = target.ReadField(address, type, nameof(Fgm)); + Size = target.ReadNUIntField(address, type, nameof(Size)); + AvailablePagefileMb = target.ReadNUIntField(address, type, nameof(AvailablePagefileMb)); + LohP = target.ReadField(address, type, nameof(LohP)); } public int Reason { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GCAllocContext.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GCAllocContext.cs index bc6b6e1a98a8a1..2a01f6407bcb75 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GCAllocContext.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GCAllocContext.cs @@ -11,10 +11,10 @@ static GCAllocContext IData.Create(Target target, TargetPointer public GCAllocContext(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.GCAllocContext); - Pointer = target.ReadPointer(address + (ulong)type.Fields[nameof(Pointer)].Offset); - Limit = target.ReadPointer(address + (ulong)type.Fields[nameof(Limit)].Offset); - AllocBytes = target.Read(address + (ulong)type.Fields[nameof(AllocBytes)].Offset); - AllocBytesLoh = target.Read(address + (ulong)type.Fields[nameof(AllocBytesLoh)].Offset); + Pointer = target.ReadPointerField(address, type, nameof(Pointer)); + Limit = target.ReadPointerField(address, type, nameof(Limit)); + AllocBytes = target.ReadField(address, type, nameof(AllocBytes)); + AllocBytesLoh = target.ReadField(address, type, nameof(AllocBytesLoh)); } public TargetPointer Pointer { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GenericsDictInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GenericsDictInfo.cs index 7ece56e8bc139d..bacc4de67d535d 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GenericsDictInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/GenericsDictInfo.cs @@ -10,8 +10,8 @@ public GenericsDictInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.GenericsDictInfo); - NumDicts = target.Read(address + (ulong)type.Fields[nameof(NumDicts)].Offset); - NumTypeArgs = target.Read(address + (ulong)type.Fields[nameof(NumTypeArgs)].Offset); + NumDicts = target.ReadField(address, type, nameof(NumDicts)); + NumTypeArgs = target.ReadField(address, type, nameof(NumTypeArgs)); } public ushort NumDicts { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTable.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTable.cs index 072c9ef00dfe5d..c3442aa6008aee 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTable.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTable.cs @@ -12,7 +12,7 @@ static HandleTable IData.Create(Target target, TargetPointer addres public HandleTable(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HandleTable); - SegmentList = target.ReadPointer(address + (ulong)type.Fields[nameof(SegmentList)].Offset); + SegmentList = target.ReadPointerField(address, type, nameof(SegmentList)); } public TargetPointer SegmentList { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableBucket.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableBucket.cs index 648705c88b31cb..c9aa016c86f0a7 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableBucket.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableBucket.cs @@ -12,7 +12,7 @@ static HandleTableBucket IData.Create(Target target, TargetPo public HandleTableBucket(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HandleTableBucket); - Table = target.ReadPointer(address + (ulong)type.Fields[nameof(Table)].Offset); + Table = target.ReadPointerField(address, type, nameof(Table)); } public TargetPointer Table { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableMap.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableMap.cs index b442c410be0bb0..8e1de496507136 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableMap.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HandleTableMap.cs @@ -14,14 +14,14 @@ static HandleTableMap IData.Create(Target target, TargetPointer public HandleTableMap(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HandleTableMap); - TargetPointer bucketsPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(BucketsPtr)].Offset); + TargetPointer bucketsPtr = target.ReadPointerField(address, type, nameof(BucketsPtr)); uint arrayLength = target.ReadGlobal(Constants.Globals.InitialHandleTableArraySize); for (int i = 0; i < arrayLength; i++) { TargetPointer bucketPtr = target.ReadPointer(bucketsPtr + (ulong)(i * target.PointerSize)); BucketsPtr.Add(bucketPtr); } - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); } public List BucketsPtr { get; init; } = new List(); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HashMap.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HashMap.cs index 3276fdefd569d9..79316a5d600080 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HashMap.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HashMap.cs @@ -12,7 +12,7 @@ public HashMap(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HashMap); - Buckets = target.ReadPointer(address + (ulong)type.Fields[nameof(Buckets)].Offset); + Buckets = target.ReadPointerField(address, type, nameof(Buckets)); } public TargetPointer Buckets { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HostCodeHeap.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HostCodeHeap.cs index e17cf7782cc5d3..1bf9d695c80d29 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HostCodeHeap.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/HostCodeHeap.cs @@ -11,8 +11,8 @@ static HostCodeHeap IData.Create(Target target, TargetPointer addr public HostCodeHeap(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.HostCodeHeap); - BaseAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(BaseAddress)].Offset); - CurrentAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(CurrentAddress)].Offset); + BaseAddress = target.ReadPointerField(address, type, nameof(BaseAddress)); + CurrentAddress = target.ReadPointerField(address, type, nameof(CurrentAddress)); } public TargetPointer BaseAddress { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersionNode.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersionNode.cs index dcfac956bb2760..cf0bb305211a5f 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersionNode.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersionNode.cs @@ -12,10 +12,10 @@ public ILCodeVersionNode(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ILCodeVersionNode); - VersionId = target.ReadNUInt(address + (ulong)type.Fields[nameof(VersionId)].Offset); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - RejitState = target.Read(address + (ulong)type.Fields[nameof(RejitState)].Offset); - ILAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(ILAddress)].Offset); + VersionId = target.ReadNUIntField(address, type, nameof(VersionId)); + Next = target.ReadPointerField(address, type, nameof(Next)); + RejitState = target.ReadField(address, type, nameof(RejitState)); + ILAddress = target.ReadPointerField(address, type, nameof(ILAddress)); } public TargetNUInt VersionId { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersioningState.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersioningState.cs index a37e93ed9637e8..8084de6debe133 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersioningState.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ILCodeVersioningState.cs @@ -12,11 +12,11 @@ public ILCodeVersioningState(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ILCodeVersioningState); - FirstVersionNode = target.ReadPointer(address + (ulong)type.Fields[nameof(FirstVersionNode)].Offset); - ActiveVersionKind = target.Read(address + (ulong)type.Fields[nameof(ActiveVersionKind)].Offset); - ActiveVersionNode = target.ReadPointer(address + (ulong)type.Fields[nameof(ActiveVersionNode)].Offset); - ActiveVersionModule = target.ReadPointer(address + (ulong)type.Fields[nameof(ActiveVersionModule)].Offset); - ActiveVersionMethodDef = target.Read(address + (ulong)type.Fields[nameof(ActiveVersionMethodDef)].Offset); + FirstVersionNode = target.ReadPointerField(address, type, nameof(FirstVersionNode)); + ActiveVersionKind = target.ReadField(address, type, nameof(ActiveVersionKind)); + ActiveVersionNode = target.ReadPointerField(address, type, nameof(ActiveVersionNode)); + ActiveVersionModule = target.ReadPointerField(address, type, nameof(ActiveVersionModule)); + ActiveVersionMethodDef = target.ReadField(address, type, nameof(ActiveVersionMethodDef)); } public TargetPointer FirstVersionNode { get; set; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/IdDispenser.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/IdDispenser.cs index 75806fa57e3748..cfc35cbe853878 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/IdDispenser.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/IdDispenser.cs @@ -11,8 +11,8 @@ internal sealed class IdDispenser : IData public IdDispenser(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.IdDispenser); - IdToThread = target.ReadPointer(address + (ulong)type.Fields[nameof(IdToThread)].Offset); - HighestId = target.Read(address + (ulong)type.Fields[nameof(HighestId)].Offset); + IdToThread = target.ReadPointerField(address, type, nameof(IdToThread)); + HighestId = target.ReadField(address, type, nameof(HighestId)); } public TargetPointer IdToThread { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ImageDataDirectory.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ImageDataDirectory.cs index 241cf6daabd540..a84fcc19abaa77 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ImageDataDirectory.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ImageDataDirectory.cs @@ -12,8 +12,8 @@ public ImageDataDirectory(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ImageDataDirectory); - VirtualAddress = target.Read(address + (ulong)type.Fields[nameof(VirtualAddress)].Offset); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); + VirtualAddress = target.ReadField(address, type, nameof(VirtualAddress)); + Size = target.ReadField(address, type, nameof(Size)); } public uint VirtualAddress { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InflightTLSData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InflightTLSData.cs index 4a1cad9672773d..9ec716b491b15d 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InflightTLSData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InflightTLSData.cs @@ -11,9 +11,9 @@ internal sealed class InflightTLSData : IData public InflightTLSData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.InFlightTLSData); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); TlsIndex = target.ProcessedData.GetOrAdd(address + (ulong)type.Fields[nameof(TlsIndex)].Offset); - TLSData = target.ProcessedData.GetOrAdd(target.ReadPointer(address + (ulong)type.Fields[nameof(TLSData)].Offset)); + TLSData = target.ProcessedData.GetOrAdd(target.ReadPointerField(address, type, nameof(TLSData))); } public TargetPointer Next { get; init; } public TLSIndex TlsIndex { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InterfaceEntry.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InterfaceEntry.cs index 2beb7fdc8d903d..ef0232a4065bee 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InterfaceEntry.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/InterfaceEntry.cs @@ -10,8 +10,8 @@ public InterfaceEntry(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.InterfaceEntry); - MethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodTable)].Offset); - Unknown = target.ReadPointer(address + (ulong)type.Fields[nameof(Unknown)].Offset); + MethodTable = target.ReadPointerField(address, type, nameof(MethodTable)); + Unknown = target.ReadPointerField(address, type, nameof(Unknown)); } public TargetPointer MethodTable { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderAllocator.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderAllocator.cs index 3269079ff305e3..20499fa92da6c0 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderAllocator.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderAllocator.cs @@ -12,24 +12,24 @@ public LoaderAllocator(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.LoaderAllocator); - ReferenceCount = target.Read(address + (ulong)type.Fields[nameof(ReferenceCount)].Offset); - HighFrequencyHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(HighFrequencyHeap)].Offset); - LowFrequencyHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(LowFrequencyHeap)].Offset); - StaticsHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(StaticsHeap)].Offset); - StubHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(StubHeap)].Offset); - ExecutableHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(ExecutableHeap)].Offset); + ReferenceCount = target.ReadField(address, type, nameof(ReferenceCount)); + HighFrequencyHeap = target.ReadPointerField(address, type, nameof(HighFrequencyHeap)); + LowFrequencyHeap = target.ReadPointerField(address, type, nameof(LowFrequencyHeap)); + StaticsHeap = target.ReadPointerField(address, type, nameof(StaticsHeap)); + StubHeap = target.ReadPointerField(address, type, nameof(StubHeap)); + ExecutableHeap = target.ReadPointerField(address, type, nameof(ExecutableHeap)); if (type.Fields.ContainsKey(nameof(FixupPrecodeHeap))) - FixupPrecodeHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(FixupPrecodeHeap)].Offset); + FixupPrecodeHeap = target.ReadPointerField(address, type, nameof(FixupPrecodeHeap)); if (type.Fields.ContainsKey(nameof(NewStubPrecodeHeap))) - NewStubPrecodeHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(NewStubPrecodeHeap)].Offset); + NewStubPrecodeHeap = target.ReadPointerField(address, type, nameof(NewStubPrecodeHeap)); if (type.Fields.ContainsKey(nameof(DynamicHelpersStubHeap))) - DynamicHelpersStubHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(DynamicHelpersStubHeap)].Offset); + DynamicHelpersStubHeap = target.ReadPointerField(address, type, nameof(DynamicHelpersStubHeap)); - VirtualCallStubManager = target.ReadPointer(address + (ulong)type.Fields[nameof(VirtualCallStubManager)].Offset); + VirtualCallStubManager = target.ReadPointerField(address, type, nameof(VirtualCallStubManager)); ObjectHandle = target.ProcessedData.GetOrAdd( - target.ReadPointer(address + (ulong)type.Fields[nameof(ObjectHandle)].Offset)); + target.ReadPointerField(address, type, nameof(ObjectHandle))); } public uint ReferenceCount { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ManagedObjectWrapperHolderObject.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ManagedObjectWrapperHolderObject.cs index 5a2d81429021fe..761feb21dc1bbb 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ManagedObjectWrapperHolderObject.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ManagedObjectWrapperHolderObject.cs @@ -11,8 +11,8 @@ internal sealed class ManagedObjectWrapperHolderObject : IData(address + (ulong)type.Fields[nameof(RefCount)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - UserDefinedCount = target.Read(address + (ulong)type.Fields[nameof(UserDefinedCount)].Offset); - UserDefined = target.ReadPointer(address + (ulong)type.Fields[nameof(UserDefined)].Offset); - Dispatches = target.ReadPointer(address + (ulong)type.Fields[nameof(Dispatches)].Offset); + RefCount = target.ReadField(address, type, nameof(RefCount)); + Flags = target.ReadField(address, type, nameof(Flags)); + UserDefinedCount = target.ReadField(address, type, nameof(UserDefinedCount)); + UserDefined = target.ReadPointerField(address, type, nameof(UserDefined)); + Dispatches = target.ReadPointerField(address, type, nameof(Dispatches)); } public long RefCount { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDesc.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDesc.cs index 0181d329a8413a..5f7e1c5b307d6a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDesc.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDesc.cs @@ -12,15 +12,15 @@ public MethodDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodDesc); - ChunkIndex = target.Read(address + (ulong)type.Fields[nameof(ChunkIndex)].Offset); - Slot = target.Read(address + (ulong)type.Fields[nameof(Slot)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - Flags3AndTokenRemainder = target.Read(address + (ulong)type.Fields[nameof(Flags3AndTokenRemainder)].Offset); - EntryPointFlags = target.Read(address + (ulong)type.Fields[nameof(EntryPointFlags)].Offset); - CodeData = target.ReadPointer(address + (ulong)type.Fields[nameof(CodeData)].Offset); + ChunkIndex = target.ReadField(address, type, nameof(ChunkIndex)); + Slot = target.ReadField(address, type, nameof(Slot)); + Flags = target.ReadField(address, type, nameof(Flags)); + Flags3AndTokenRemainder = target.ReadField(address, type, nameof(Flags3AndTokenRemainder)); + EntryPointFlags = target.ReadField(address, type, nameof(EntryPointFlags)); + CodeData = target.ReadPointerField(address, type, nameof(CodeData)); if (type.Fields.ContainsKey(nameof(GCCoverageInfo))) { - GCCoverageInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(GCCoverageInfo)].Offset); + GCCoverageInfo = target.ReadPointerField(address, type, nameof(GCCoverageInfo)); } } @@ -42,9 +42,9 @@ public InstantiatedMethodDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.InstantiatedMethodDesc); - PerInstInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(PerInstInfo)].Offset); - NumGenericArgs = target.Read(address + (ulong)type.Fields[nameof(NumGenericArgs)].Offset); - Flags2 = target.Read(address + (ulong)type.Fields[nameof(Flags2)].Offset); + PerInstInfo = target.ReadPointerField(address, type, nameof(PerInstInfo)); + NumGenericArgs = target.ReadField(address, type, nameof(NumGenericArgs)); + Flags2 = target.ReadField(address, type, nameof(Flags2)); } public TargetPointer PerInstInfo { get; init; } @@ -59,7 +59,7 @@ public DynamicMethodDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.DynamicMethodDesc); - MethodName = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodName)].Offset); + MethodName = target.ReadPointerField(address, type, nameof(MethodName)); } public TargetPointer MethodName { get; init; } @@ -72,9 +72,9 @@ public StoredSigMethodDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StoredSigMethodDesc); - Sig = target.ReadPointer(address + (ulong)type.Fields[nameof(Sig)].Offset); - cSig = target.Read(address + (ulong)type.Fields[nameof(cSig)].Offset); - ExtendedFlags = target.Read(address + (ulong)type.Fields[nameof(ExtendedFlags)].Offset); + Sig = target.ReadPointerField(address, type, nameof(Sig)); + cSig = target.ReadField(address, type, nameof(cSig)); + ExtendedFlags = target.ReadField(address, type, nameof(ExtendedFlags)); } public TargetPointer Sig { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescChunk.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescChunk.cs index a157f76e2c31fc..6af32d4ccf4380 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescChunk.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescChunk.cs @@ -12,11 +12,11 @@ public MethodDescChunk(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodDescChunk); - MethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodTable)].Offset); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); - Count = target.Read(address + (ulong)type.Fields[nameof(Count)].Offset); - FlagsAndTokenRange = target.Read(address + (ulong)type.Fields[nameof(FlagsAndTokenRange)].Offset); + MethodTable = target.ReadPointerField(address, type, nameof(MethodTable)); + Next = target.ReadPointerField(address, type, nameof(Next)); + Size = target.ReadField(address, type, nameof(Size)); + Count = target.ReadField(address, type, nameof(Count)); + FlagsAndTokenRange = target.ReadField(address, type, nameof(FlagsAndTokenRange)); // The first MethodDesc is at the end of the MethodDescChunk FirstMethodDesc = address + type.Size!.Value; diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescCodeData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescCodeData.cs index 69240ebb7bd86b..3c187bfb649311 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescCodeData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescCodeData.cs @@ -11,9 +11,9 @@ public MethodDescCodeData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodDescCodeData); - TemporaryEntryPoint = target.ReadCodePointer(address + (ulong)type.Fields[nameof(TemporaryEntryPoint)].Offset); - VersioningState = target.ReadPointer(address + (ulong)type.Fields[nameof(VersioningState)].Offset); - OptimizationTier = target.Read(address + (ulong)type.Fields[nameof(OptimizationTier)].Offset); + TemporaryEntryPoint = target.ReadCodePointerField(address, type, nameof(TemporaryEntryPoint)); + VersioningState = target.ReadPointerField(address, type, nameof(VersioningState)); + OptimizationTier = target.ReadField(address, type, nameof(OptimizationTier)); } public TargetCodePointer TemporaryEntryPoint { get; set; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescVersioningState.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescVersioningState.cs index 95b404afa29508..4ed45c17c8590a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescVersioningState.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodDescVersioningState.cs @@ -12,8 +12,8 @@ public MethodDescVersioningState(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodDescVersioningState); - NativeCodeVersionNode = target.ReadPointer(address + (ulong)type.Fields[nameof(NativeCodeVersionNode)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); + NativeCodeVersionNode = target.ReadPointerField(address, type, nameof(NativeCodeVersionNode)); + Flags = target.ReadField(address, type, nameof(Flags)); } public TargetPointer NativeCodeVersionNode { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTable.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTable.cs index 522927b02af44b..b7d994528215a3 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTable.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTable.cs @@ -10,16 +10,16 @@ public MethodTable(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodTable); - MTFlags = target.Read(address + (ulong)type.Fields[nameof(MTFlags)].Offset); - BaseSize = target.Read(address + (ulong)type.Fields[nameof(BaseSize)].Offset); - MTFlags2 = target.Read(address + (ulong)type.Fields[nameof(MTFlags2)].Offset); - EEClassOrCanonMT = target.ReadPointer(address + (ulong)type.Fields[nameof(EEClassOrCanonMT)].Offset); - Module = target.ReadPointer(address + (ulong)type.Fields[nameof(Module)].Offset); - ParentMethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(ParentMethodTable)].Offset); - NumInterfaces = target.Read(address + (ulong)type.Fields[nameof(NumInterfaces)].Offset); - NumVirtuals = target.Read(address + (ulong)type.Fields[nameof(NumVirtuals)].Offset); - PerInstInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(PerInstInfo)].Offset); - AuxiliaryData = target.ReadPointer(address + (ulong)type.Fields[nameof(AuxiliaryData)].Offset); + MTFlags = target.ReadField(address, type, nameof(MTFlags)); + BaseSize = target.ReadField(address, type, nameof(BaseSize)); + MTFlags2 = target.ReadField(address, type, nameof(MTFlags2)); + EEClassOrCanonMT = target.ReadPointerField(address, type, nameof(EEClassOrCanonMT)); + Module = target.ReadPointerField(address, type, nameof(Module)); + ParentMethodTable = target.ReadPointerField(address, type, nameof(ParentMethodTable)); + NumInterfaces = target.ReadField(address, type, nameof(NumInterfaces)); + NumVirtuals = target.ReadField(address, type, nameof(NumVirtuals)); + PerInstInfo = target.ReadPointerField(address, type, nameof(PerInstInfo)); + AuxiliaryData = target.ReadPointerField(address, type, nameof(AuxiliaryData)); } public uint MTFlags { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTableAuxiliaryData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTableAuxiliaryData.cs index 75b3109b4331e1..79a5b650bad3b3 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTableAuxiliaryData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/MethodTableAuxiliaryData.cs @@ -11,9 +11,9 @@ private MethodTableAuxiliaryData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.MethodTableAuxiliaryData); - LoaderModule = target.ReadPointer(address + (ulong)type.Fields[nameof(LoaderModule)].Offset); - OffsetToNonVirtualSlots = target.Read(address + (ulong)type.Fields[nameof(OffsetToNonVirtualSlots)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); + LoaderModule = target.ReadPointerField(address, type, nameof(LoaderModule)); + OffsetToNonVirtualSlots = target.ReadField(address, type, nameof(OffsetToNonVirtualSlots)); + Flags = target.ReadField(address, type, nameof(Flags)); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Module.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Module.cs index 2e7b7b589eb412..3871489d556fab 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Module.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Module.cs @@ -14,19 +14,19 @@ public Module(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Module); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - Assembly = target.ReadPointer(address + (ulong)type.Fields[nameof(Assembly)].Offset); - PEAssembly = target.ReadPointer(address + (ulong)type.Fields[nameof(PEAssembly)].Offset); - Base = target.ReadPointer(address + (ulong)type.Fields[nameof(Base)].Offset); - LoaderAllocator = target.ReadPointer(address + (ulong)type.Fields[nameof(LoaderAllocator)].Offset); - DynamicMetadata = target.ReadPointer(address + (ulong)type.Fields[nameof(DynamicMetadata)].Offset); - SimpleName = target.ReadPointer(address + (ulong)type.Fields[nameof(SimpleName)].Offset); - Path = target.ReadPointer(address + (ulong)type.Fields[nameof(Path)].Offset); - FileName = target.ReadPointer(address + (ulong)type.Fields[nameof(FileName)].Offset); - ReadyToRunInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(ReadyToRunInfo)].Offset); - GrowableSymbolStream = target.ReadPointer(address + (ulong)type.Fields[nameof(GrowableSymbolStream)].Offset); - AvailableTypeParams = target.ReadPointer(address + (ulong)type.Fields[nameof(AvailableTypeParams)].Offset); - InstMethodHashTable = target.ReadPointer(address + (ulong)type.Fields[nameof(InstMethodHashTable)].Offset); + Flags = target.ReadField(address, type, nameof(Flags)); + Assembly = target.ReadPointerField(address, type, nameof(Assembly)); + PEAssembly = target.ReadPointerField(address, type, nameof(PEAssembly)); + Base = target.ReadPointerField(address, type, nameof(Base)); + LoaderAllocator = target.ReadPointerField(address, type, nameof(LoaderAllocator)); + DynamicMetadata = target.ReadPointerField(address, type, nameof(DynamicMetadata)); + SimpleName = target.ReadPointerField(address, type, nameof(SimpleName)); + Path = target.ReadPointerField(address, type, nameof(Path)); + FileName = target.ReadPointerField(address, type, nameof(FileName)); + ReadyToRunInfo = target.ReadPointerField(address, type, nameof(ReadyToRunInfo)); + GrowableSymbolStream = target.ReadPointerField(address, type, nameof(GrowableSymbolStream)); + AvailableTypeParams = target.ReadPointerField(address, type, nameof(AvailableTypeParams)); + InstMethodHashTable = target.ReadPointerField(address, type, nameof(InstMethodHashTable)); FieldDefToDescMap = address + (ulong)type.Fields[nameof(FieldDefToDescMap)].Offset; ManifestModuleReferencesMap = address + (ulong)type.Fields[nameof(ManifestModuleReferencesMap)].Offset; @@ -35,7 +35,7 @@ public Module(Target target, TargetPointer address) TypeDefToMethodTableMap = address + (ulong)type.Fields[nameof(TypeDefToMethodTableMap)].Offset; TypeRefToMethodTableMap = address + (ulong)type.Fields[nameof(TypeRefToMethodTableMap)].Offset; MethodDefToILCodeVersioningStateMap = address + (ulong)type.Fields[nameof(MethodDefToILCodeVersioningStateMap)].Offset; - DynamicILBlobTable = target.ReadPointer(address + (ulong)type.Fields[nameof(DynamicILBlobTable)].Offset); + DynamicILBlobTable = target.ReadPointerField(address, type, nameof(DynamicILBlobTable)); } public TargetPointer Assembly { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ModuleLookupMap.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ModuleLookupMap.cs index 449dfb0cb04523..4c5da498608afc 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ModuleLookupMap.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ModuleLookupMap.cs @@ -11,10 +11,10 @@ private ModuleLookupMap(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ModuleLookupMap); - TableData = target.ReadPointer(address + (ulong)type.Fields[nameof(TableData)].Offset); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - Count = target.Read(address + (ulong)type.Fields[nameof(Count)].Offset); - SupportedFlagsMask = target.ReadNUInt(address + (ulong)type.Fields[nameof(SupportedFlagsMask)].Offset); + TableData = target.ReadPointerField(address, type, nameof(TableData)); + Next = target.ReadPointerField(address, type, nameof(Next)); + Count = target.ReadField(address, type, nameof(Count)); + SupportedFlagsMask = target.ReadNUIntField(address, type, nameof(SupportedFlagsMask)); } public TargetPointer TableData { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeCodeVersionNode.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeCodeVersionNode.cs index 37a9655c15534c..7420b2a46c3f04 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeCodeVersionNode.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeCodeVersionNode.cs @@ -12,16 +12,16 @@ public NativeCodeVersionNode(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.NativeCodeVersionNode); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); - NativeCode = target.ReadCodePointer(address + (ulong)type.Fields[nameof(NativeCode)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - ILVersionId = target.ReadNUInt(address + (ulong)type.Fields[nameof(ILVersionId)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); + NativeCode = target.ReadCodePointerField(address, type, nameof(NativeCode)); + Flags = target.ReadField(address, type, nameof(Flags)); + ILVersionId = target.ReadNUIntField(address, type, nameof(ILVersionId)); if (type.Fields.ContainsKey(nameof(GCCoverageInfo))) { - GCCoverageInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(GCCoverageInfo)].Offset); + GCCoverageInfo = target.ReadPointerField(address, type, nameof(GCCoverageInfo)); } - OptimizationTier = target.Read(address + (ulong)type.Fields[nameof(OptimizationTier)].Offset); + OptimizationTier = target.ReadField(address, type, nameof(OptimizationTier)); } public TargetPointer Next { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeObjectWrapperObject.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeObjectWrapperObject.cs index f1d61ef69559ec..a344ad5ad2c10f 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeObjectWrapperObject.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/NativeObjectWrapperObject.cs @@ -11,7 +11,7 @@ internal sealed class NativeObjectWrapperObject : IData(target.ReadPointer(address + (ulong)type.Fields["m_pMethTab"].Offset)); + MethodTable = target.ProcessedData.GetOrAdd(target.ReadPointerField(address, type, "m_pMethTab")); Data = address + (type.Size ?? throw new InvalidOperationException("Object size must be known")); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ObjectHeader.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ObjectHeader.cs index 96cc3247cf70d2..c32481de18b7ab 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ObjectHeader.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ObjectHeader.cs @@ -11,7 +11,7 @@ static ObjectHeader IData.Create(Target target, TargetPointer addr public ObjectHeader(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ObjectHeader); - SyncBlockValue = target.Read(address + (ulong)type.Fields[nameof(SyncBlockValue)].Offset); + SyncBlockValue = target.ReadField(address, type, nameof(SyncBlockValue)); } public uint SyncBlockValue { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEAssembly.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEAssembly.cs index 09a03cb527217a..6b0ce945896cd9 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEAssembly.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEAssembly.cs @@ -12,8 +12,8 @@ public PEAssembly(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PEAssembly); - PEImage = target.ReadPointer(address + (ulong)type.Fields[nameof(PEImage)].Offset); - AssemblyBinder = target.ReadPointer(address + (ulong)type.Fields[nameof(AssemblyBinder)].Offset); + PEImage = target.ReadPointerField(address, type, nameof(PEImage)); + AssemblyBinder = target.ReadPointerField(address, type, nameof(AssemblyBinder)); } public TargetPointer PEImage { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImage.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImage.cs index 5731b28e2cd4ea..54636b9b559269 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImage.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImage.cs @@ -10,7 +10,7 @@ public PEImage(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PEImage); - LoadedImageLayout = target.ReadPointer(address + (ulong)type.Fields[nameof(LoadedImageLayout)].Offset); + LoadedImageLayout = target.ReadPointerField(address, type, nameof(LoadedImageLayout)); ProbeExtensionResult = target.ProcessedData.GetOrAdd(address + (ulong)type.Fields[nameof(ProbeExtensionResult)].Offset); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImageLayout.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImageLayout.cs index 773bc0f26ce378..fb6876885aff52 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImageLayout.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PEImageLayout.cs @@ -10,10 +10,10 @@ public PEImageLayout(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PEImageLayout); - Base = target.ReadPointer(address + (ulong)type.Fields[nameof(Base)].Offset); - Size = target.Read(address + (ulong)type.Fields[nameof(Size)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - Format = target.Read(address + (ulong)type.Fields[nameof(Format)].Offset); + Base = target.ReadPointerField(address, type, nameof(Base)); + Size = target.ReadField(address, type, nameof(Size)); + Flags = target.ReadField(address, type, nameof(Flags)); + Format = target.ReadField(address, type, nameof(Format)); } public TargetPointer Base { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PatchpointInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PatchpointInfo.cs index 482174b7465406..60a283d7031e83 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PatchpointInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PatchpointInfo.cs @@ -14,7 +14,7 @@ public PatchpointInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PatchpointInfo); - LocalCount = target.Read(address + (ulong)type.Fields[nameof(LocalCount)].Offset); + LocalCount = target.ReadField(address, type, nameof(LocalCount)); } public uint LocalCount { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PlatformMetadata.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PlatformMetadata.cs index b58055f4486e32..96ca1d554ad2c6 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PlatformMetadata.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PlatformMetadata.cs @@ -12,7 +12,7 @@ public PlatformMetadata(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PlatformMetadata); PrecodeMachineDescriptor = address + (ulong)type.Fields[nameof(PrecodeMachineDescriptor)].Offset; - CodePointerFlags = target.Read(address + (ulong)type.Fields[nameof(CodePointerFlags)].Offset); + CodePointerFlags = target.ReadField(address, type, nameof(CodePointerFlags)); } /* Address of */ diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PortableEntryPoint.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PortableEntryPoint.cs index 591d6e83420f28..d5ec1f3461c17a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PortableEntryPoint.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PortableEntryPoint.cs @@ -12,7 +12,7 @@ public PortableEntryPoint(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.PortableEntryPoint); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); } public TargetPointer MethodDesc { get; } } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PrecodeMachineDescriptor.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PrecodeMachineDescriptor.cs index 3e1ec015b41048..840059e1511c95 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PrecodeMachineDescriptor.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/PrecodeMachineDescriptor.cs @@ -13,9 +13,9 @@ public PrecodeMachineDescriptor(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.PrecodeMachineDescriptor); if (type.Fields.ContainsKey(nameof(OffsetOfPrecodeType))) { - OffsetOfPrecodeType = target.Read(address + (ulong)type.Fields[nameof(OffsetOfPrecodeType)].Offset); - ReadWidthOfPrecodeType = target.Read(address + (ulong)type.Fields[nameof(ReadWidthOfPrecodeType)].Offset); - ShiftOfPrecodeType = target.Read(address + (ulong)type.Fields[nameof(ShiftOfPrecodeType)].Offset); + OffsetOfPrecodeType = target.ReadField(address, type, nameof(OffsetOfPrecodeType)); + ReadWidthOfPrecodeType = target.ReadField(address, type, nameof(ReadWidthOfPrecodeType)); + ShiftOfPrecodeType = target.ReadField(address, type, nameof(ShiftOfPrecodeType)); } else { @@ -23,12 +23,12 @@ public PrecodeMachineDescriptor(Target target, TargetPointer address) ReadWidthOfPrecodeType = null; ShiftOfPrecodeType = null; } - InvalidPrecodeType = target.Read(address + (ulong)type.Fields[nameof(InvalidPrecodeType)].Offset); - StubPrecodeType = target.Read(address + (ulong)type.Fields[nameof(StubPrecodeType)].Offset); + InvalidPrecodeType = target.ReadField(address, type, nameof(InvalidPrecodeType)); + StubPrecodeType = target.ReadField(address, type, nameof(StubPrecodeType)); if (type.Fields.ContainsKey(nameof(FixupStubPrecodeSize))) { - FixupStubPrecodeSize = target.Read(address + (ulong)type.Fields[nameof(FixupStubPrecodeSize)].Offset); + FixupStubPrecodeSize = target.ReadField(address, type, nameof(FixupStubPrecodeSize)); FixupBytes = new byte[FixupStubPrecodeSize.Value]; target.ReadBuffer(address + (ulong)type.Fields[nameof(FixupBytes)].Offset, FixupBytes); FixupIgnoredBytes = new byte[FixupStubPrecodeSize.Value]; @@ -43,7 +43,7 @@ public PrecodeMachineDescriptor(Target target, TargetPointer address) if (type.Fields.ContainsKey(nameof(StubPrecodeSize))) { - StubPrecodeSize = target.Read(address + (ulong)type.Fields[nameof(FixupStubPrecodeSize)].Offset); + StubPrecodeSize = target.ReadField(address, type, nameof(FixupStubPrecodeSize)); StubBytes = new byte[StubPrecodeSize.Value]; target.ReadBuffer(address + (ulong)type.Fields[nameof(StubBytes)].Offset, StubBytes); StubIgnoredBytes = new byte[StubPrecodeSize.Value]; @@ -63,7 +63,7 @@ public PrecodeMachineDescriptor(Target target, TargetPointer address) UMEntryPrecodeType = MaybeGetPrecodeType(target, address, nameof(UMEntryPrecodeType)); DynamicHelperPrecodeType = MaybeGetPrecodeType(target, address, nameof(DynamicHelperPrecodeType)); - StubCodePageSize = target.Read(address + (ulong)type.Fields[nameof(StubCodePageSize)].Offset); + StubCodePageSize = target.ReadField(address, type, nameof(StubCodePageSize)); static byte? MaybeGetPrecodeType(Target target, TargetPointer address, string fieldName) { diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProbeExtensionResult.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProbeExtensionResult.cs index d356170b30a81c..49d9a690662657 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProbeExtensionResult.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProbeExtensionResult.cs @@ -12,7 +12,7 @@ public ProbeExtensionResult(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ProbeExtensionResult); - Type = target.Read(address + (ulong)type.Fields[nameof(Type)].Offset); + Type = target.ReadField(address, type, nameof(Type)); } public int Type { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProfControlBlock.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProfControlBlock.cs index 6ff54d01f8bb62..e98a6134e3afe2 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProfControlBlock.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ProfControlBlock.cs @@ -11,8 +11,8 @@ static ProfControlBlock IData.Create(Target target, TargetPoin public ProfControlBlock(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ProfControlBlock); - GlobalEventMask = target.Read(address + (ulong)type.Fields[nameof(GlobalEventMask)].Offset); - RejitOnAttachEnabled = target.Read(address + (ulong)type.Fields[nameof(RejitOnAttachEnabled)].Offset) != 0; + GlobalEventMask = target.ReadField(address, type, nameof(GlobalEventMask)); + RejitOnAttachEnabled = target.ReadField(address, type, nameof(RejitOnAttachEnabled)) != 0; } public ulong GlobalEventMask { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCW.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCW.cs index 2022ef69a101ea..f900d3e82fe18c 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCW.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCW.cs @@ -12,17 +12,17 @@ public RCW(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RCW); - NextCleanupBucket = target.ReadPointer(address + (ulong)type.Fields[nameof(NextCleanupBucket)].Offset); - NextRCW = target.ReadPointer(address + (ulong)type.Fields[nameof(NextRCW)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - CtxCookie = target.ReadPointer(address + (ulong)type.Fields[nameof(CtxCookie)].Offset); - CtxEntry = target.ReadPointer(address + (ulong)type.Fields[nameof(CtxEntry)].Offset); - IdentityPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(IdentityPointer)].Offset); - SyncBlockIndex = target.Read(address + (ulong)type.Fields[nameof(SyncBlockIndex)].Offset); - VTablePtr = target.ReadPointer(address + (ulong)type.Fields[nameof(VTablePtr)].Offset); - CreatorThread = target.ReadPointer(address + (ulong)type.Fields[nameof(CreatorThread)].Offset); - RefCount = target.Read(address + (ulong)type.Fields[nameof(RefCount)].Offset); - UnknownPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(UnknownPointer)].Offset); + NextCleanupBucket = target.ReadPointerField(address, type, nameof(NextCleanupBucket)); + NextRCW = target.ReadPointerField(address, type, nameof(NextRCW)); + Flags = target.ReadField(address, type, nameof(Flags)); + CtxCookie = target.ReadPointerField(address, type, nameof(CtxCookie)); + CtxEntry = target.ReadPointerField(address, type, nameof(CtxEntry)); + IdentityPointer = target.ReadPointerField(address, type, nameof(IdentityPointer)); + SyncBlockIndex = target.ReadField(address, type, nameof(SyncBlockIndex)); + VTablePtr = target.ReadPointerField(address, type, nameof(VTablePtr)); + CreatorThread = target.ReadPointerField(address, type, nameof(CreatorThread)); + RefCount = target.ReadField(address, type, nameof(RefCount)); + UnknownPointer = target.ReadPointerField(address, type, nameof(UnknownPointer)); TargetPointer interfaceEntriesAddr = address + (ulong)type.Fields[nameof(InterfaceEntries)].Offset; uint cacheSize = target.ReadGlobal(Constants.Globals.RCWInterfaceCacheSize); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCWCleanupList.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCWCleanupList.cs index ede3543a0e66bf..a12947b7a9f079 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCWCleanupList.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RCWCleanupList.cs @@ -10,7 +10,7 @@ public RCWCleanupList(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RCWCleanupList); - FirstBucket = target.ReadPointer(address + (ulong)type.Fields[nameof(FirstBucket)].Offset); + FirstBucket = target.ReadPointerField(address, type, nameof(FirstBucket)); } public TargetPointer FirstBucket { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSection.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSection.cs index 2cd68418ce85cd..cf54d9ddcef9d6 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSection.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSection.cs @@ -11,13 +11,13 @@ static RangeSection IData.Create(Target target, TargetPointer addr public RangeSection(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RangeSection); - RangeBegin = target.ReadPointer(address + (ulong)type.Fields[nameof(RangeBegin)].Offset); - RangeEndOpen = target.ReadPointer(address + (ulong)type.Fields[nameof(RangeEndOpen)].Offset); - NextForDelete = target.ReadPointer(address + (ulong)type.Fields[nameof(NextForDelete)].Offset); - JitManager = target.ReadPointer(address + (ulong)type.Fields[nameof(JitManager)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - HeapList = target.ReadPointer(address + (ulong)type.Fields[nameof(HeapList)].Offset); - R2RModule = target.ReadPointer(address + (ulong)type.Fields[nameof(R2RModule)].Offset); + RangeBegin = target.ReadPointerField(address, type, nameof(RangeBegin)); + RangeEndOpen = target.ReadPointerField(address, type, nameof(RangeEndOpen)); + NextForDelete = target.ReadPointerField(address, type, nameof(NextForDelete)); + JitManager = target.ReadPointerField(address, type, nameof(JitManager)); + Flags = target.ReadField(address, type, nameof(Flags)); + HeapList = target.ReadPointerField(address, type, nameof(HeapList)); + R2RModule = target.ReadPointerField(address, type, nameof(R2RModule)); } public TargetPointer RangeBegin { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSectionFragment.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSectionFragment.cs index 8073ad3dfe9094..b0c3d95f28ff17 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSectionFragment.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RangeSectionFragment.cs @@ -11,12 +11,12 @@ static RangeSectionFragment IData.Create(Target target, Ta public RangeSectionFragment(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RangeSectionFragment); - RangeBegin = target.ReadPointer(address + (ulong)type.Fields[nameof(RangeBegin)].Offset); - RangeEndOpen = target.ReadPointer(address + (ulong)type.Fields[nameof(RangeEndOpen)].Offset); - RangeSection = target.ReadPointer(address + (ulong)type.Fields[nameof(RangeSection)].Offset); + RangeBegin = target.ReadPointerField(address, type, nameof(RangeBegin)); + RangeEndOpen = target.ReadPointerField(address, type, nameof(RangeEndOpen)); + RangeSection = target.ReadPointerField(address, type, nameof(RangeSection)); // The Next pointer uses the low bit as a collectible flag (see RangeSectionFragmentPointer in codeman.h). // Strip it to get the actual address. - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset) & ~1ul; + Next = target.ReadPointerField(address, type, nameof(Next)) & ~1ul; } public TargetPointer RangeBegin { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreHeader.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreHeader.cs index 3419ee49abc0d1..75d53d3a5d941a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreHeader.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreHeader.cs @@ -14,7 +14,7 @@ public ReadyToRunCoreHeader(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ReadyToRunCoreHeader); - NumberOfSections = target.Read(address + (ulong)type.Fields[nameof(NumberOfSections)].Offset); + NumberOfSections = target.ReadField(address, type, nameof(NumberOfSections)); Target.TypeInfo sectionType = target.GetTypeInfo(DataType.ReadyToRunSection); for (int i = 0; i < NumberOfSections; i++) { diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreInfo.cs index 48b4b988463e08..bbd0fbb6874a95 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunCoreInfo.cs @@ -11,7 +11,7 @@ static ReadyToRunCoreInfo IData.Create(Target target, Target public ReadyToRunCoreInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ReadyToRunCoreInfo); - TargetPointer headerAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(Header)].Offset); + TargetPointer headerAddress = target.ReadPointerField(address, type, nameof(Header)); Header = target.ProcessedData.GetOrAdd(headerAddress); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunHeader.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunHeader.cs index acc35d21d80859..934ce2b0deea41 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunHeader.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunHeader.cs @@ -12,8 +12,8 @@ public ReadyToRunHeader(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ReadyToRunHeader); - MajorVersion = target.Read(address + (ulong)type.Fields[nameof(MajorVersion)].Offset); - MinorVersion = target.Read(address + (ulong)type.Fields[nameof(MinorVersion)].Offset); + MajorVersion = target.ReadField(address, type, nameof(MajorVersion)); + MinorVersion = target.ReadField(address, type, nameof(MinorVersion)); } public ushort MajorVersion { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunInfo.cs index 843bc82f7f1328..3241fa45b965a0 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunInfo.cs @@ -14,29 +14,29 @@ public ReadyToRunInfo(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ReadyToRunInfo); - CompositeInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(CompositeInfo)].Offset); + CompositeInfo = target.ReadPointerField(address, type, nameof(CompositeInfo)); - ReadyToRunHeader = target.ReadPointer(address + (ulong)type.Fields[nameof(ReadyToRunHeader)].Offset); + ReadyToRunHeader = target.ReadPointerField(address, type, nameof(ReadyToRunHeader)); - NumRuntimeFunctions = target.Read(address + (ulong)type.Fields[nameof(NumRuntimeFunctions)].Offset); + NumRuntimeFunctions = target.ReadField(address, type, nameof(NumRuntimeFunctions)); RuntimeFunctions = NumRuntimeFunctions > 0 - ? target.ReadPointer(address + (ulong)type.Fields[nameof(RuntimeFunctions)].Offset) + ? target.ReadPointerField(address, type, nameof(RuntimeFunctions)) : TargetPointer.Null; - NumHotColdMap = target.Read(address + (ulong)type.Fields[nameof(NumHotColdMap)].Offset); + NumHotColdMap = target.ReadField(address, type, nameof(NumHotColdMap)); Debug.Assert(NumHotColdMap % 2 == 0, "Hot/cold map should have an even number of entries (pairs of hot/cold runtime function indexes)"); HotColdMap = NumHotColdMap > 0 - ? target.ReadPointer(address + (ulong)type.Fields[nameof(HotColdMap)].Offset) + ? target.ReadPointerField(address, type, nameof(HotColdMap)) : TargetPointer.Null; - DelayLoadMethodCallThunks = target.ReadPointer(address + (ulong)type.Fields[nameof(DelayLoadMethodCallThunks)].Offset); - DebugInfoSection = target.ReadPointer(address + (ulong)type.Fields[nameof(DebugInfoSection)].Offset); - ExceptionInfoSection = target.ReadPointer(address + (ulong)type.Fields[nameof(ExceptionInfoSection)].Offset); + DelayLoadMethodCallThunks = target.ReadPointerField(address, type, nameof(DelayLoadMethodCallThunks)); + DebugInfoSection = target.ReadPointerField(address, type, nameof(DebugInfoSection)); + ExceptionInfoSection = target.ReadPointerField(address, type, nameof(ExceptionInfoSection)); // Map is from the composite info pointer (set to itself for non-multi-assembly composite images) EntryPointToMethodDescMap = CompositeInfo + (ulong)type.Fields[nameof(EntryPointToMethodDescMap)].Offset; - LoadedImageBase = target.ReadPointer(address + (ulong)type.Fields[nameof(LoadedImageBase)].Offset); - Composite = target.ReadPointer(address + (ulong)type.Fields[nameof(Composite)].Offset); + LoadedImageBase = target.ReadPointerField(address, type, nameof(LoadedImageBase)); + Composite = target.ReadPointerField(address, type, nameof(Composite)); } internal TargetPointer CompositeInfo { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunSection.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunSection.cs index 8fcc22401f9dca..79b07573fc3c34 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunSection.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ReadyToRunSection.cs @@ -12,7 +12,7 @@ public ReadyToRunSection(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ReadyToRunSection); - Type = target.Read(address + (ulong)type.Fields[nameof(Type)].Offset); + Type = target.ReadField(address, type, nameof(Type)); Section = target.ProcessedData.GetOrAdd(address + (ulong)type.Fields[nameof(Section)].Offset); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs index 9111838126ae78..e141a55174a991 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs @@ -11,12 +11,12 @@ static RealCodeHeader IData.Create(Target target, TargetPointer public RealCodeHeader(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RealCodeHeader); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); - DebugInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(DebugInfo)].Offset); - EHInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(EHInfo)].Offset); - GCInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(GCInfo)].Offset); - NumUnwindInfos = target.Read(address + (ulong)type.Fields[nameof(NumUnwindInfos)].Offset); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); + DebugInfo = target.ReadPointerField(address, type, nameof(DebugInfo)); + GCInfo = target.ReadPointerField(address, type, nameof(GCInfo)); + NumUnwindInfos = target.ReadField(address, type, nameof(NumUnwindInfos)); UnwindInfos = address + (ulong)type.Fields[nameof(UnwindInfos)].Offset; + EHInfo = target.ReadPointerField(address, type, nameof(EHInfo)); } public TargetPointer MethodDesc { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RegionFreeList.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RegionFreeList.cs index d31afbc0bf459d..c617a42ef994e6 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RegionFreeList.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RegionFreeList.cs @@ -11,7 +11,7 @@ static RegionFreeList IData.Create(Target target, TargetPointer public RegionFreeList(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RegionFreeList); - HeadFreeRegion = target.ReadPointer(address + (ulong)type.Fields[nameof(HeadFreeRegion)].Offset); + HeadFreeRegion = target.ReadPointerField(address, type, nameof(HeadFreeRegion)); } public TargetPointer HeadFreeRegion { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RuntimeFunction.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RuntimeFunction.cs index f614803e0efabc..54a7bbe20fd17a 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RuntimeFunction.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RuntimeFunction.cs @@ -12,13 +12,13 @@ public RuntimeFunction(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.RuntimeFunction); - BeginAddress = target.Read(address + (ulong)type.Fields[nameof(BeginAddress)].Offset); + BeginAddress = target.ReadField(address, type, nameof(BeginAddress)); // Not all platforms define EndAddress if (type.Fields.ContainsKey(nameof(EndAddress))) - EndAddress = target.Read(address + (ulong)type.Fields[nameof(EndAddress)].Offset); + EndAddress = target.ReadField(address, type, nameof(EndAddress)); - UnwindData = target.Read(address + (ulong)type.Fields[nameof(UnwindData)].Offset); + UnwindData = target.ReadField(address, type, nameof(UnwindData)); } public uint BeginAddress { get; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SimpleComCallWrapper.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SimpleComCallWrapper.cs index 5739b64522130b..621ffb92081877 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SimpleComCallWrapper.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SimpleComCallWrapper.cs @@ -12,15 +12,15 @@ public SimpleComCallWrapper(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.SimpleComCallWrapper); - OuterIUnknown = target.ReadPointer(address + (ulong)type.Fields[nameof(OuterIUnknown)].Offset); - RefCount = target.Read(address + (ulong)type.Fields[nameof(RefCount)].Offset); - Flags = target.Read(address + (ulong)type.Fields[nameof(Flags)].Offset); - MainWrapper = target.ReadPointer(address + (ulong)type.Fields[nameof(MainWrapper)].Offset); + OuterIUnknown = target.ReadPointerField(address, type, nameof(OuterIUnknown)); + RefCount = target.ReadField(address, type, nameof(RefCount)); + Flags = target.ReadField(address, type, nameof(Flags)); + MainWrapper = target.ReadPointerField(address, type, nameof(MainWrapper)); VTablePtr = address + (ulong)type.Fields[nameof(VTablePtr)].Offset; } public TargetPointer OuterIUnknown { get; init; } - public ulong RefCount { get; init; } + public long RefCount { get; init; } public uint Flags { get; init; } public TargetPointer MainWrapper { get; init; } public TargetPointer VTablePtr { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLog.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLog.cs index b23eff5acda316..8745dcce81c3c8 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLog.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLog.cs @@ -14,19 +14,19 @@ public StressLog(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StressLog); - LoggedFacilities = target.Read(address + (ulong)type.Fields[nameof(LoggedFacilities)].Offset); - Level = target.Read(address + (ulong)type.Fields[nameof(Level)].Offset); - MaxSizePerThread = target.Read(address + (ulong)type.Fields[nameof(MaxSizePerThread)].Offset); - MaxSizeTotal = target.Read(address + (ulong)type.Fields[nameof(MaxSizeTotal)].Offset); - TotalChunks = target.Read(address + (ulong)type.Fields[nameof(TotalChunks)].Offset); - TickFrequency = target.Read(address + (ulong)type.Fields[nameof(TickFrequency)].Offset); - StartTimestamp = target.Read(address + (ulong)type.Fields[nameof(StartTimestamp)].Offset); - ModuleOffset = target.ReadNUInt(address + (ulong)type.Fields[nameof(ModuleOffset)].Offset); + LoggedFacilities = target.ReadField(address, type, nameof(LoggedFacilities)); + Level = target.ReadField(address, type, nameof(Level)); + MaxSizePerThread = target.ReadField(address, type, nameof(MaxSizePerThread)); + MaxSizeTotal = target.ReadField(address, type, nameof(MaxSizeTotal)); + TotalChunks = target.ReadField(address, type, nameof(TotalChunks)); + TickFrequency = target.ReadField(address, type, nameof(TickFrequency)); + StartTimestamp = target.ReadField(address, type, nameof(StartTimestamp)); + ModuleOffset = target.ReadNUIntField(address, type, nameof(ModuleOffset)); if (type.Fields.ContainsKey(nameof(Modules))) - Modules = target.ReadPointer(address + (ulong)type.Fields[nameof(Modules)].Offset); + Modules = target.ReadPointerField(address, type, nameof(Modules)); - Logs = target.ReadPointer(address + (ulong)type.Fields[nameof(Logs)].Offset); + Logs = target.ReadPointerField(address, type, nameof(Logs)); } public uint LoggedFacilities { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogChunk.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogChunk.cs index fed0e5ba3c0c7b..9e4003e3fb4d37 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogChunk.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogChunk.cs @@ -12,12 +12,12 @@ public StressLogChunk(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StressLogChunk); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - Prev = target.ReadPointer(address + (ulong)type.Fields[nameof(Prev)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); + Prev = target.ReadPointerField(address, type, nameof(Prev)); Buf = new TargetPointer(address + (ulong)type.Fields[nameof(Buf)].Offset); BufSize = target.ReadGlobal(Constants.Globals.StressLogChunkSize); - Sig1 = target.Read(address + (ulong)type.Fields[nameof(Sig1)].Offset); - Sig2 = target.Read(address + (ulong)type.Fields[nameof(Sig2)].Offset); + Sig1 = target.ReadField(address, type, nameof(Sig1)); + Sig2 = target.ReadField(address, type, nameof(Sig2)); } public TargetPointer Next { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogModuleDesc.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogModuleDesc.cs index 06a9fdc8be2173..f6303a34b40f4f 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogModuleDesc.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StressLogModuleDesc.cs @@ -12,8 +12,8 @@ public StressLogModuleDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StressLogModuleDesc); - BaseAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(BaseAddress)].Offset); - Size = target.ReadNUInt(address + (ulong)type.Fields[nameof(Size)].Offset); + BaseAddress = target.ReadPointerField(address, type, nameof(BaseAddress)); + Size = target.ReadNUIntField(address, type, nameof(Size)); } public TargetPointer BaseAddress { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/String.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/String.cs index 088d1060a7d960..a8eb77e9adc383 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/String.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/String.cs @@ -13,7 +13,7 @@ public String(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.String); FirstChar = address + (ulong)type.Fields["m_FirstChar"].Offset; - StringLength = target.Read(address + (ulong)type.Fields["m_StringLength"].Offset); + StringLength = target.ReadField(address, type, "m_StringLength"); } public TargetPointer FirstChar { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StubPrecodeData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StubPrecodeData.cs index 442d3067c83f24..4486a8017b14a0 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StubPrecodeData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/StubPrecodeData.cs @@ -11,8 +11,8 @@ static StubPrecodeData_1 IData.Create(Target target, TargetPo public StubPrecodeData_1(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StubPrecodeData); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); - Type = target.Read(address + (ulong)type.Fields[nameof(Type)].Offset); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); + Type = target.ReadField(address, type, nameof(Type)); } public TargetPointer MethodDesc { get; init; } @@ -27,8 +27,8 @@ static StubPrecodeData_2 IData.Create(Target target, TargetPo public StubPrecodeData_2(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.StubPrecodeData); - SecretParam = target.ReadPointer(address + (ulong)type.Fields[nameof(SecretParam)].Offset); - Type = target.Read(address + (ulong)type.Fields[nameof(Type)].Offset); + SecretParam = target.ReadPointerField(address, type, nameof(SecretParam)); + Type = target.ReadField(address, type, nameof(Type)); } public TargetPointer SecretParam { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlock.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlock.cs index 4d04c48e0cbcf6..e9a7cfbbd8bc63 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlock.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlock.cs @@ -13,16 +13,16 @@ public SyncBlock(Target target, TargetPointer address) Target.TypeInfo type = target.GetTypeInfo(DataType.SyncBlock); Address = address; - TargetPointer interopInfoPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(InteropInfo)].Offset); + TargetPointer interopInfoPointer = target.ReadPointerField(address, type, nameof(InteropInfo)); if (interopInfoPointer != TargetPointer.Null) InteropInfo = target.ProcessedData.GetOrAdd(interopInfoPointer); - TargetPointer lockPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(Lock)].Offset); + TargetPointer lockPointer = target.ReadPointerField(address, type, nameof(Lock)); if (lockPointer != TargetPointer.Null) Lock = target.ProcessedData.GetOrAdd(lockPointer); - ThinLock = target.Read(address + (ulong)type.Fields[nameof(ThinLock)].Offset); - LinkNext = target.ReadPointer(address + (ulong)type.Fields[nameof(LinkNext)].Offset); - HashCode = target.Read(address + (ulong)type.Fields[nameof(HashCode)].Offset); + ThinLock = target.ReadField(address, type, nameof(ThinLock)); + LinkNext = target.ReadPointerField(address, type, nameof(LinkNext)); + HashCode = target.ReadField(address, type, nameof(HashCode)); } public TargetPointer Address { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlockCache.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlockCache.cs index 517d2778b3dd0b..1811f6e97a1a43 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlockCache.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncBlockCache.cs @@ -12,8 +12,8 @@ public SyncBlockCache(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.SyncBlockCache); - FreeSyncTableIndex = target.Read(address + (ulong)type.Fields[nameof(FreeSyncTableIndex)].Offset); - CleanupBlockList = target.ReadPointer(address + (ulong)type.Fields[nameof(CleanupBlockList)].Offset); + FreeSyncTableIndex = target.ReadField(address, type, nameof(FreeSyncTableIndex)); + CleanupBlockList = target.ReadPointerField(address, type, nameof(CleanupBlockList)); } public uint FreeSyncTableIndex { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncTableEntry.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncTableEntry.cs index 415d0ae6b4497b..c9fae0ba0d08d1 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncTableEntry.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SyncTableEntry.cs @@ -12,11 +12,11 @@ public SyncTableEntry(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.SyncTableEntry); - TargetPointer syncBlockPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(SyncBlock)].Offset); + TargetPointer syncBlockPointer = target.ReadPointerField(address, type, nameof(SyncBlock)); if (syncBlockPointer != TargetPointer.Null) SyncBlock = target.ProcessedData.GetOrAdd(syncBlockPointer); - TargetPointer objectPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(Object)].Offset); + TargetPointer objectPointer = target.ReadPointerField(address, type, nameof(Object)); if (objectPointer != TargetPointer.Null && (objectPointer & 1) == 0) // Defensive check: if the lowest bit is set, this is a free sync block entry and the pointer is not valid. Object = target.ProcessedData.GetOrAdd(objectPointer); } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemDomain.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemDomain.cs index 526ff3cdda71d0..03ab3e05cd2623 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemDomain.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemDomain.cs @@ -12,7 +12,7 @@ public SystemDomain(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.SystemDomain); GlobalLoaderAllocator = address + (ulong)type.Fields[nameof(GlobalLoaderAllocator)].Offset; - SystemAssembly = target.ReadPointer(address + (ulong)type.Fields[nameof(SystemAssembly)].Offset); + SystemAssembly = target.ReadPointerField(address, type, nameof(SystemAssembly)); } public TargetPointer GlobalLoaderAllocator { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TLSIndex.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TLSIndex.cs index 6f76423fe7e364..20d419fc5db62d 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TLSIndex.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TLSIndex.cs @@ -11,7 +11,7 @@ internal sealed class TLSIndex : IData public TLSIndex(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TLSIndex); - TLSIndexRawIndex = target.Read(address + (ulong)type.Fields[nameof(TLSIndexRawIndex)].Offset); + TLSIndexRawIndex = target.ReadField(address, type, nameof(TLSIndexRawIndex)); IndexOffset = (int)(TLSIndexRawIndex & 0xFFFFFF); IndexType = (int)(TLSIndexRawIndex >> 24); IsAllocated = (TLSIndexRawIndex != 0xFFFFFFFF); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TableSegment.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TableSegment.cs index 6ff3113662bf16..1ab229c38a82c4 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TableSegment.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TableSegment.cs @@ -10,7 +10,7 @@ internal sealed class TableSegment : IData public TableSegment(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TableSegment); - NextSegment = target.ReadPointer(address + (ulong)type.Fields[nameof(NextSegment)].Offset); + NextSegment = target.ReadPointerField(address, type, nameof(NextSegment)); uint handleBlocksPerSegment = target.ReadGlobal(Constants.Globals.HandleBlocksPerSegment); uint handleMaxInternalTypes = target.ReadGlobal(Constants.Globals.HandleMaxInternalTypes); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThisPtrRetBufPrecodeData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThisPtrRetBufPrecodeData.cs index 1468ec622ecf78..b2b6c7dae40d5e 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThisPtrRetBufPrecodeData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThisPtrRetBufPrecodeData.cs @@ -11,7 +11,7 @@ static ThisPtrRetBufPrecodeData IData.Create(Target ta public ThisPtrRetBufPrecodeData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ThisPtrRetBufPrecodeData); - MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset); + MethodDesc = target.ReadPointerField(address, type, nameof(MethodDesc)); } public TargetPointer MethodDesc { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs index 6d0d675b0db0ee..8cb0fe073b957d 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs @@ -12,39 +12,30 @@ public Thread(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.Thread); - Id = target.Read(address + (ulong)type.Fields[nameof(Id)].Offset); - OSId = target.ReadNUInt(address + (ulong)type.Fields[nameof(OSId)].Offset); - State = target.Read(address + (ulong)type.Fields[nameof(State)].Offset); - PreemptiveGCDisabled = target.Read(address + (ulong)type.Fields[nameof(PreemptiveGCDisabled)].Offset); + Id = target.ReadField(address, type, nameof(Id)); + OSId = target.ReadNUIntField(address, type, nameof(OSId)); + State = target.ReadField(address, type, nameof(State)); + PreemptiveGCDisabled = target.ReadField(address, type, nameof(PreemptiveGCDisabled)); - TargetPointer runtimeThreadLocalsPointer = target.ReadPointer(address + (ulong)type.Fields[nameof(RuntimeThreadLocals)].Offset); - if (runtimeThreadLocalsPointer != TargetPointer.Null) - RuntimeThreadLocals = target.ProcessedData.GetOrAdd(runtimeThreadLocalsPointer); + RuntimeThreadLocals = target.ReadDataFieldPointer(address, type, nameof(RuntimeThreadLocals)); - Frame = target.ReadPointer(address + (ulong)type.Fields[nameof(Frame)].Offset); - CachedStackBase = target.ReadPointer(address + (ulong)type.Fields[nameof(CachedStackBase)].Offset); - CachedStackLimit = target.ReadPointer(address + (ulong)type.Fields[nameof(CachedStackLimit)].Offset); + Frame = target.ReadPointerField(address, type, nameof(Frame)); + CachedStackBase = target.ReadPointerField(address, type, nameof(CachedStackBase)); + CachedStackLimit = target.ReadPointerField(address, type, nameof(CachedStackLimit)); // TEB does not exist on certain platforms - TEB = type.Fields.TryGetValue(nameof(TEB), out Target.FieldInfo fieldInfo) - ? target.ReadPointer(address + (ulong)fieldInfo.Offset) - : TargetPointer.Null; + TEB = target.ReadPointerFieldOrNull(address, type, nameof(TEB)); LastThrownObject = target.ProcessedData.GetOrAdd( - target.ReadPointer(address + (ulong)type.Fields[nameof(LastThrownObject)].Offset)); - LinkNext = target.ReadPointer(address + (ulong)type.Fields[nameof(LinkNext)].Offset); + target.ReadPointerField(address, type, nameof(LastThrownObject))); + LinkNext = target.ReadPointerField(address, type, nameof(LinkNext)); // Address of the exception tracker ExceptionTracker = address + (ulong)type.Fields[nameof(ExceptionTracker)].Offset; // UEWatsonBucketTrackerBuckets does not exist on non-Windows platforms - UEWatsonBucketTrackerBuckets = type.Fields.TryGetValue(nameof(UEWatsonBucketTrackerBuckets), out Target.FieldInfo watsonFieldInfo) - ? target.ReadPointer(address + (ulong)watsonFieldInfo.Offset) - : TargetPointer.Null; - ThreadLocalDataPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(ThreadLocalDataPtr)].Offset); - - DebuggerFilterContext = target.ReadPointer(address + (ulong)type.Fields[nameof(DebuggerFilterContext)].Offset); - ProfilerFilterContext = type.Fields.TryGetValue(nameof(ProfilerFilterContext), out Target.FieldInfo profilerFilterContextInfo) - ? target.ReadPointer(address + (ulong)profilerFilterContextInfo.Offset) - : TargetPointer.Null; + UEWatsonBucketTrackerBuckets = target.ReadPointerFieldOrNull(address, type, nameof(UEWatsonBucketTrackerBuckets)); + ThreadLocalDataPtr = target.ReadPointerField(address, type, nameof(ThreadLocalDataPtr)); + DebuggerFilterContext = target.ReadPointerField(address, type, nameof(DebuggerFilterContext)); + ProfilerFilterContext = target.ReadPointerFieldOrNull(address, type, nameof(ProfilerFilterContext)); } public uint Id { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadLocalData.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadLocalData.cs index 6ea3ce3204b68b..3d3fbebdd597dc 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadLocalData.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadLocalData.cs @@ -11,11 +11,11 @@ internal sealed class ThreadLocalData : IData public ThreadLocalData(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ThreadLocalData); - CollectibleTlsArrayData = target.ReadPointer(address + (ulong)type.Fields[nameof(CollectibleTlsArrayData)].Offset); - NonCollectibleTlsArrayData = target.ReadPointer(address + (ulong)type.Fields[nameof(NonCollectibleTlsArrayData)].Offset); - CollectibleTlsDataCount = target.Read(address + (ulong)type.Fields[nameof(CollectibleTlsDataCount)].Offset); - NonCollectibleTlsDataCount = target.Read(address + (ulong)type.Fields[nameof(NonCollectibleTlsDataCount)].Offset); - InFlightData = target.ReadPointer(address + (ulong)type.Fields[nameof(InFlightData)].Offset); + CollectibleTlsArrayData = target.ReadPointerField(address, type, nameof(CollectibleTlsArrayData)); + NonCollectibleTlsArrayData = target.ReadPointerField(address, type, nameof(NonCollectibleTlsArrayData)); + CollectibleTlsDataCount = target.ReadField(address, type, nameof(CollectibleTlsDataCount)); + NonCollectibleTlsDataCount = target.ReadField(address, type, nameof(NonCollectibleTlsDataCount)); + InFlightData = target.ReadPointerField(address, type, nameof(InFlightData)); } public TargetPointer CollectibleTlsArrayData { get; init; } public TargetPointer NonCollectibleTlsArrayData { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStore.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStore.cs index afef1e835be324..19e1a6b821fd05 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStore.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStore.cs @@ -12,12 +12,12 @@ public ThreadStore(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ThreadStore); - ThreadCount = target.Read(address + (ulong)type.Fields[nameof(ThreadCount)].Offset); - FirstThreadLink = target.ReadPointer(address + (ulong)type.Fields[nameof(FirstThreadLink)].Offset); - UnstartedCount = target.Read(address + (ulong)type.Fields[nameof(UnstartedCount)].Offset); - BackgroundCount = target.Read(address + (ulong)type.Fields[nameof(BackgroundCount)].Offset); - PendingCount = target.Read(address + (ulong)type.Fields[nameof(PendingCount)].Offset); - DeadCount = target.Read(address + (ulong)type.Fields[nameof(DeadCount)].Offset); + ThreadCount = target.ReadField(address, type, nameof(ThreadCount)); + FirstThreadLink = target.ReadPointerField(address, type, nameof(FirstThreadLink)); + UnstartedCount = target.ReadField(address, type, nameof(UnstartedCount)); + BackgroundCount = target.ReadField(address, type, nameof(BackgroundCount)); + PendingCount = target.ReadField(address, type, nameof(PendingCount)); + DeadCount = target.ReadField(address, type, nameof(DeadCount)); } public int ThreadCount { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStressLog.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStressLog.cs index 4c01c4d527e345..ee0fc1caf13f43 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStressLog.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ThreadStressLog.cs @@ -12,13 +12,13 @@ public ThreadStressLog(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.ThreadStressLog); - Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset); - ThreadId = target.Read(address + (ulong)type.Fields[nameof(ThreadId)].Offset); - WriteHasWrapped = target.Read(address + (ulong)type.Fields[nameof(WriteHasWrapped)].Offset) != 0; - CurrentPtr = target.ReadPointer(address + (ulong)type.Fields[nameof(CurrentPtr)].Offset); - ChunkListHead = target.ReadPointer(address + (ulong)type.Fields[nameof(ChunkListHead)].Offset); - ChunkListTail = target.ReadPointer(address + (ulong)type.Fields[nameof(ChunkListTail)].Offset); - CurrentWriteChunk = target.ReadPointer(address + (ulong)type.Fields[nameof(CurrentWriteChunk)].Offset); + Next = target.ReadPointerField(address, type, nameof(Next)); + ThreadId = target.ReadField(address, type, nameof(ThreadId)); + WriteHasWrapped = target.ReadField(address, type, nameof(WriteHasWrapped)) != 0; + CurrentPtr = target.ReadPointerField(address, type, nameof(CurrentPtr)); + ChunkListHead = target.ReadPointerField(address, type, nameof(ChunkListHead)); + ChunkListTail = target.ReadPointerField(address, type, nameof(ChunkListTail)); + CurrentWriteChunk = target.ReadPointerField(address, type, nameof(CurrentWriteChunk)); } public TargetPointer Next { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TypeDesc.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TypeDesc.cs index e46782241e6bbf..9f14c6fc49e903 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TypeDesc.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/TypeDesc.cs @@ -9,7 +9,7 @@ internal sealed class TypeDesc : IData public TypeDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TypeDesc); - TypeAndFlags = target.Read(address + (ulong)type.Fields[nameof(TypeAndFlags)].Offset); + TypeAndFlags = target.ReadField(address, type, nameof(TypeAndFlags)); } public uint TypeAndFlags { get; init; } @@ -21,10 +21,10 @@ internal sealed class ParamTypeDesc : IData public ParamTypeDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TypeDesc); - TypeAndFlags = target.Read(address + (ulong)type.Fields[nameof(TypeAndFlags)].Offset); + TypeAndFlags = target.ReadField(address, type, nameof(TypeAndFlags)); type = target.GetTypeInfo(DataType.ParamTypeDesc); - TypeArg = target.ReadPointer(address + (ulong)type.Fields[nameof(TypeArg)].Offset); + TypeArg = target.ReadPointerField(address, type, nameof(TypeArg)); } public uint TypeAndFlags { get; init; } @@ -37,12 +37,12 @@ internal sealed class TypeVarTypeDesc : IData public TypeVarTypeDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TypeDesc); - TypeAndFlags = target.Read(address + (ulong)type.Fields[nameof(TypeAndFlags)].Offset); + TypeAndFlags = target.ReadField(address, type, nameof(TypeAndFlags)); type = target.GetTypeInfo(DataType.TypeVarTypeDesc); - Module = target.ReadPointer(address + (ulong)type.Fields[nameof(Module)].Offset); - Token = target.Read(address + (ulong)type.Fields[nameof(Token)].Offset); + Module = target.ReadPointerField(address, type, nameof(Module)); + Token = target.ReadField(address, type, nameof(Token)); } public uint TypeAndFlags { get; init; } @@ -56,14 +56,14 @@ internal sealed class FnPtrTypeDesc : IData public FnPtrTypeDesc(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.TypeDesc); - TypeAndFlags = target.Read(address + (ulong)type.Fields[nameof(TypeAndFlags)].Offset); + TypeAndFlags = target.ReadField(address, type, nameof(TypeAndFlags)); type = target.GetTypeInfo(DataType.FnPtrTypeDesc); - NumArgs = target.Read(address + (ulong)type.Fields[nameof(NumArgs)].Offset); - CallConv = target.Read(address + (ulong)type.Fields[nameof(CallConv)].Offset); + NumArgs = target.ReadField(address, type, nameof(NumArgs)); + CallConv = target.ReadField(address, type, nameof(CallConv)); RetAndArgTypes = (TargetPointer)(address + (ulong)type.Fields[nameof(RetAndArgTypes)].Offset); - LoaderModule = target.ReadPointer(address + (ulong)type.Fields[nameof(LoaderModule)].Offset); + LoaderModule = target.ReadPointerField(address, type, nameof(LoaderModule)); } public uint TypeAndFlags { get; init; } diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/UnwindInfo.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/UnwindInfo.cs index 6af069e342b7ca..f5b09b0a423a4e 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/UnwindInfo.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/UnwindInfo.cs @@ -17,7 +17,7 @@ public UnwindInfo(Target target, TargetPointer address) if (type.Fields.ContainsKey(nameof(FunctionLength))) { // The unwind info contains the function length on some platforms (x86) - FunctionLength = target.Read(address + (ulong)type.Fields[nameof(FunctionLength)].Offset); + FunctionLength = target.ReadField(address, type, nameof(FunctionLength)); } else { diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/VirtualCallStubManager.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/VirtualCallStubManager.cs index 3db6402ad829fc..1c24e6ba26dd4c 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/VirtualCallStubManager.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/VirtualCallStubManager.cs @@ -12,10 +12,10 @@ public VirtualCallStubManager(Target target, TargetPointer address) { Target.TypeInfo type = target.GetTypeInfo(DataType.VirtualCallStubManager); - IndcellHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(IndcellHeap)].Offset); + IndcellHeap = target.ReadPointerField(address, type, nameof(IndcellHeap)); if (type.Fields.ContainsKey(nameof(CacheEntryHeap))) - CacheEntryHeap = target.ReadPointer(address + (ulong)type.Fields[nameof(CacheEntryHeap)].Offset); + CacheEntryHeap = target.ReadPointerField(address, type, nameof(CacheEntryHeap)); } public TargetPointer IndcellHeap { get; init; }