diff --git a/src/coreclr/debug/datadescriptor-shared/README.md b/src/coreclr/debug/datadescriptor-shared/README.md index 07b2748d4d208a..3e2ead0239ff0a 100644 --- a/src/coreclr/debug/datadescriptor-shared/README.md +++ b/src/coreclr/debug/datadescriptor-shared/README.md @@ -31,6 +31,41 @@ The build system uses a two-phase approach: ## Macro Reference +### Field Type Annotation Defines + +Field types in `CDAC_TYPE_FIELD` use preprocessor defines that expand to type name strings in +debug/checked builds and to nothing in release builds. This keeps the release blob compact while +providing type information for diagnostic validation in debug builds. + +These defines are declared in `wrappeddatadescriptor.inc` and are available to all `.inc` files: + +| Define | Debug expansion | Description | +|--------|----------------|-------------| +| `T_UINT8` | `uint8` | 8-bit unsigned integer | +| `T_UINT16` | `uint16` | 16-bit unsigned integer | +| `T_UINT32` | `uint32` | 32-bit unsigned integer | +| `T_UINT64` | `uint64` | 64-bit unsigned integer | +| `T_INT8` | `int8` | 8-bit signed integer | +| `T_INT16` | `int16` | 16-bit signed integer | +| `T_INT32` | `int32` | 32-bit signed integer | +| `T_INT64` | `int64` | 64-bit signed integer | +| `T_NUINT` | `nuint` | Native unsigned integer | +| `T_NINT` | `nint` | Native signed integer | +| `T_POINTER` | `pointer` | Target pointer | +| `T_BOOL` | `bool` | Boolean | +| `TYPE(name)` | `name` | Inline struct type declared with `CDAC_TYPE_BEGIN` in the same descriptor | +| `EXTERN_TYPE(name)` | `name` | Cross-descriptor struct type (not validated locally) | +| `T_ARRAY(type)` | `pointer` | Array of the given element type. Expands to `pointer` in the blob | + +`TYPE(name)` references are validated at compile time in debug builds via +`cdactypevalidation.inc`. If the name does not match any `CDAC_TYPE_BEGIN` in the same +descriptor, a `static_assert` failure is produced. Use `EXTERN_TYPE(name)` for types +declared in a different descriptor (e.g., GC referencing a VM type). + +`T_ARRAY(type)` accepts any type define as its element type (e.g., `T_ARRAY(T_UINT8)`, +`T_ARRAY(TYPE(StressLogModuleDesc))`). The inner type is validated but the array itself +expands to `pointer` in the blob since arrays are accessed via pointers. + ### Structure Definition Macros **`CDAC_BASELINE("identifier")`** @@ -56,7 +91,7 @@ The build system uses a two-phase approach: **`CDAC_TYPE_FIELD(typeName, fieldType, fieldName, offset)`** - Defines a field within the type -- `fieldType`: primitive type or another defined type +- `fieldType`: a type annotation define (see table above) - `fieldName`: diagnostic-friendly name (use managed names for managed types) - `offset`: byte offset, usually `offsetof()` or `cdac_data::FieldName` @@ -72,7 +107,7 @@ The build system uses a two-phase approach: **`CDAC_GLOBAL(globalName, typeName, value)`** - Defines a global literal value - `value` must be a compile-time constant -- `typeName` can be a primitive type or defined type +- `typeName`: a type annotation define (e.g., `T_UINT32`, `T_UINT8`, `T_NUINT`) **`CDAC_GLOBAL_POINTER(globalName, address)`** - Defines a global pointer value @@ -88,6 +123,26 @@ The build system uses a two-phase approach: - Used for multi-contract scenarios where one contract references another - Example: `CDAC_GLOBAL_SUB_DESCRIPTOR(GC, &(g_gc_dac_vars.gc_descriptor))` +## Compile-Time Type Validation + +In debug/checked builds, `cdactypevalidation.inc` validates that every `TYPE(name)` reference +in `CDAC_TYPE_FIELD` corresponds to a type declared with `CDAC_TYPE_BEGIN` in the same +descriptor. It uses two passes: + +1. **Pass 1**: Each `CDAC_TYPE_BEGIN(name)` declares a tag struct `cdac_type_tag_`. +2. **Pass 2**: Each `TYPE(name)` in `CDAC_TYPE_FIELD` expands to `struct cdac_type_tag_`, + and `static_assert(sizeof(...))` fails if the tag struct was not declared. + +Primitive types (`T_UINT32`, etc.) and `EXTERN_TYPE` references expand to `char` during +validation, so they always pass. `T_ARRAY` passes through to its inner type for validation. + +This validation is included from `datadescriptor.cpp` under `#ifdef _DEBUG` and runs before +the blob construction passes. A type mismatch produces a clear compiler error, for example: + +``` +error C2338: static assertion failed: + 'Field Thread.OSId references undeclared cDAC type TYPE(RandomNonExistentType)' +``` ## Current Implementation diff --git a/src/coreclr/debug/datadescriptor-shared/cdactypevalidation.inc b/src/coreclr/debug/datadescriptor-shared/cdactypevalidation.inc new file mode 100644 index 00000000000000..44bb7469ddb7af --- /dev/null +++ b/src/coreclr/debug/datadescriptor-shared/cdactypevalidation.inc @@ -0,0 +1,65 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +// No include guards. This file is included multiple times. +// Validates that every TYPE(name) and T_ARRAY(TYPE(name)) reference in CDAC_TYPE_FIELD +// matches a cDAC type declared with CDAC_TYPE_BEGIN(name) within the same descriptor. +// EXTERN_TYPE references are not validated (cross-descriptor types). +// +// Included from datadescriptor.cpp under #ifdef _DEBUG before the blob construction. +// This file must be included BEFORE any wrappeddatadescriptor.inc inclusion so that +// the type defines (T_*, TYPE, etc.) have not yet been set. After validation, all +// overrides are undef'd so the real defines get established by the first +// wrappeddatadescriptor.inc inclusion via the #ifndef T_UINT8 guard. +// +// Uses two passes over the descriptor: +// Pass 1: CDAC_TYPE_BEGIN(name) declares a tag struct for each cDAC type. +// Pass 2: TYPE(name) and T_ARRAY inner types are validated via static_assert. +// T_* primitives and EXTERN_TYPE expand to char (always valid for sizeof). + +// TYPE(name) expands to a tag struct type -- sizeof() fails if undeclared. +// EXTERN_TYPE and T_* primitives expand to char -- always valid. +// T_ARRAY passes through to its inner type for validation. +#define TYPE(name) struct cdac_type_tag_##name +#define EXTERN_TYPE(name) char +#define T_UINT8 char +#define T_UINT16 char +#define T_UINT32 char +#define T_UINT64 char +#define T_INT8 char +#define T_INT16 char +#define T_INT32 char +#define T_INT64 char +#define T_NUINT char +#define T_NINT char +#define T_POINTER char +#define T_BOOL char +#define T_ARRAY(name) name + +// Pass 1: Declare a tag struct for each CDAC_TYPE_BEGIN in this descriptor. +#define CDAC_TYPE_BEGIN(name) struct cdac_type_tag_##name { char dummy; }; +#include "wrappeddatadescriptor.inc" + +// Pass 2: Validate TYPE() references via static_assert on the tag structs. +#define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) \ + static_assert(sizeof(membertyname) > 0, \ + "Field " #tyname "." #membername " references undeclared cDAC type " #membertyname); +#include "wrappeddatadescriptor.inc" + +// Clean up all validation overrides. The real T_*/TYPE defines will be +// established by the next wrappeddatadescriptor.inc inclusion via #ifndef T_UINT8. +#undef TYPE +#undef EXTERN_TYPE +#undef T_UINT8 +#undef T_UINT16 +#undef T_UINT32 +#undef T_UINT64 +#undef T_INT8 +#undef T_INT16 +#undef T_INT32 +#undef T_INT64 +#undef T_NUINT +#undef T_NINT +#undef T_POINTER +#undef T_BOOL +#undef T_ARRAY diff --git a/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp b/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp index 616a4d96f1d9ff..f9e175c685bf41 100644 --- a/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp +++ b/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp @@ -13,6 +13,11 @@ // begin blob definition +// In debug/checked builds, validate that TYPE() references match declared cDAC types. +#ifdef _DEBUG +#include "cdactypevalidation.inc" +#endif + extern "C" { @@ -70,6 +75,12 @@ struct GlobalContractSpec // __VA_ARGS__ is the argument list comma separated #define STRINGIFY(...) #__VA_ARGS__ +// Double-indirection stringify: expands macros in x before stringifying. +// This is needed because the T_* type annotation defines (T_UINT32, TYPE(GCHandle), etc.) +// must be expanded before stringification. Direct #x does not expand macros. +#define CDAC_STRINGIFY_IMPL(x) #x +#define CDAC_STRINGIFY(x) CDAC_STRINGIFY_IMPL(x) + // define a struct where the size of each field is the length of some string. we will use offsetof to get // the offset of each struct element, which will be equal to the offset of the beginning of that string in the // string pool. @@ -80,14 +91,14 @@ struct CDacStringPoolSizes #define CDAC_BASELINE(name) DECL_LEN(cdac_string_pool_baseline_, (sizeof(name))) #define CDAC_TYPE_BEGIN(name) DECL_LEN(MAKE_TYPELEN_NAME(name), sizeof(#name)) #define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) DECL_LEN(MAKE_FIELDLEN_NAME(tyname,membername), sizeof(#membername)) \ - DECL_LEN(MAKE_FIELDTYPELEN_NAME(tyname,membername), sizeof(#membertyname)) + DECL_LEN(MAKE_FIELDTYPELEN_NAME(tyname,membername), sizeof(CDAC_STRINGIFY(membertyname))) #define CDAC_GLOBAL_STRING(name, stringval) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name)) \ DECL_LEN(MAKE_GLOBALVALUELEN_NAME(name), sizeof(STRINGIFY(stringval))) #define CDAC_GLOBAL_POINTER(name,value) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name)) #define CDAC_GLOBAL_SUB_DESCRIPTOR(name,value) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name)) #define CDAC_GLOBAL_CONTRACT(name,value) DECL_LEN(MAKE_GLOBALCONTRACTLEN_NAME(name), sizeof(#name)) #define CDAC_GLOBAL(name,tyname,value) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name)) \ - DECL_LEN(MAKE_GLOBALTYPELEN_NAME(name), sizeof(#tyname)) + DECL_LEN(MAKE_GLOBALTYPELEN_NAME(name), sizeof(CDAC_STRINGIFY(tyname))) #include "wrappeddatadescriptor.inc" char cdac_string_pool_trailing_nil; #undef DECL_LEN @@ -368,12 +379,12 @@ struct MagicAndBlob BlobDataDescriptor = { /* .NamesPool = */ ("\0" // starts with a nul #define CDAC_BASELINE(name) name "\0" #define CDAC_TYPE_BEGIN(name) #name "\0" -#define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) #membername "\0" #membertyname "\0" +#define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) #membername "\0" CDAC_STRINGIFY(membertyname) "\0" #define CDAC_GLOBAL_STRING(name,value) #name "\0" STRINGIFY(value) "\0" #define CDAC_GLOBAL_POINTER(name,value) #name "\0" #define CDAC_GLOBAL_SUB_DESCRIPTOR(name,value) #name "\0" #define CDAC_GLOBAL_CONTRACT(name,value) #name "\0" -#define CDAC_GLOBAL(name,tyname,value) #name "\0" #tyname "\0" +#define CDAC_GLOBAL(name,tyname,value) #name "\0" CDAC_STRINGIFY(tyname) "\0" #include "wrappeddatadescriptor.inc" ), diff --git a/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc b/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc index 8c668e6869c158..cfa96b67160588 100644 --- a/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc +++ b/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc @@ -4,6 +4,53 @@ // No include guards. This file is included multiple times. // Wraps datadescriptor.inc to define and undefine macros used in the file. +// Field type annotation defines. In debug/checked builds, these expand to type +// names that appear in the data descriptor blob's string pool. In release builds, +// they expand to nothing, keeping the blob compact. +// Primitive types use T_ (e.g., T_UINT32, T_POINTER). +// Inline struct types use TYPE() (e.g., TYPE(GCHandle), TYPE(CodePointer)). +// Cross-descriptor struct types use EXTERN_TYPE() -- same as TYPE() but not +// validated within this descriptor (the type is declared in a different descriptor). +// Array types use T_ARRAY() where is another type define +// (e.g., T_ARRAY(T_UINT8), T_ARRAY(TYPE(StressLogModuleDesc))). +// T_ARRAY always expands to pointer in the blob since arrays are accessed via pointers. +// These are defined once here and persist across multiple inclusions. +#ifndef T_UINT8 +#ifdef _DEBUG +#define T_UINT8 uint8 +#define T_UINT16 uint16 +#define T_UINT32 uint32 +#define T_UINT64 uint64 +#define T_INT8 int8 +#define T_INT16 int16 +#define T_INT32 int32 +#define T_INT64 int64 +#define T_NUINT nuint +#define T_NINT nint +#define T_POINTER pointer +#define T_BOOL bool +#define TYPE(name) name +#define EXTERN_TYPE(name) name +#define T_ARRAY(name) pointer +#else +#define T_UINT8 +#define T_UINT16 +#define T_UINT32 +#define T_UINT64 +#define T_INT8 +#define T_INT16 +#define T_INT32 +#define T_INT64 +#define T_NUINT +#define T_NINT +#define T_POINTER +#define T_BOOL +#define TYPE(name) +#define EXTERN_TYPE(name) +#define T_ARRAY(name) +#endif +#endif + #ifndef CDAC_BASELINE #define CDAC_BASELINE(identifier) #endif diff --git a/src/coreclr/gc/datadescriptor/datadescriptor.inc b/src/coreclr/gc/datadescriptor/datadescriptor.inc index 4a39629193ecf5..1ccbdd94997c6e 100644 --- a/src/coreclr/gc/datadescriptor/datadescriptor.inc +++ b/src/coreclr/gc/datadescriptor/datadescriptor.inc @@ -13,119 +13,119 @@ CDAC_TYPES_BEGIN() #ifdef SERVER_GC CDAC_TYPE_BEGIN(GCHeap) CDAC_TYPE_INDETERMINATE(GCHeap) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, MarkArray, cdac_data::MarkArray) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, NextSweepObj, cdac_data::NextSweepObj) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, BackgroundMinSavedAddr, cdac_data::BackgroundMinSavedAddr) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, BackgroundMaxSavedAddr, cdac_data::BackgroundMaxSavedAddr) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, AllocAllocated, cdac_data::AllocAllocated) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, EphemeralHeapSegment, cdac_data::EphemeralHeapSegment) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, CardTable, cdac_data::CardTable) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, FinalizeQueue, cdac_data::FinalizeQueue) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, GenerationTable, cdac_data::GenerationTable) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, MarkArray, cdac_data::MarkArray) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, NextSweepObj, cdac_data::NextSweepObj) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, BackgroundMinSavedAddr, cdac_data::BackgroundMinSavedAddr) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, BackgroundMaxSavedAddr, cdac_data::BackgroundMaxSavedAddr) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, AllocAllocated, cdac_data::AllocAllocated) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, EphemeralHeapSegment, cdac_data::EphemeralHeapSegment) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, CardTable, cdac_data::CardTable) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, FinalizeQueue, cdac_data::FinalizeQueue) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, GenerationTable, cdac_data::GenerationTable) #ifndef USE_REGIONS -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, SavedSweepEphemeralSeg, cdac_data::SavedSweepEphemeralSeg) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, SavedSweepEphemeralStart, cdac_data::SavedSweepEphemeralStart) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, SavedSweepEphemeralSeg, cdac_data::SavedSweepEphemeralSeg) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, SavedSweepEphemeralStart, cdac_data::SavedSweepEphemeralStart) #endif // !USE_REGIONS -CDAC_TYPE_FIELD(GCHeap, /*oom_history*/, OomData, cdac_data::OomData) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, InternalRootArray, cdac_data::InternalRootArray) -CDAC_TYPE_FIELD(GCHeap, /*nuint*/, InternalRootArrayIndex, cdac_data::InternalRootArrayIndex) -CDAC_TYPE_FIELD(GCHeap, /*int*/, HeapAnalyzeSuccess, cdac_data::HeapAnalyzeSuccess) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, InterestingData, cdac_data::InterestingData) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, CompactReasons, cdac_data::CompactReasons) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, ExpandMechanisms, cdac_data::ExpandMechanisms) -CDAC_TYPE_FIELD(GCHeap, /*pointer*/, InterestingMechanismBits, cdac_data::InterestingMechanismBits) +CDAC_TYPE_FIELD(GCHeap, TYPE(OomHistory), OomData, cdac_data::OomData) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, InternalRootArray, cdac_data::InternalRootArray) +CDAC_TYPE_FIELD(GCHeap, T_NUINT, InternalRootArrayIndex, cdac_data::InternalRootArrayIndex) +CDAC_TYPE_FIELD(GCHeap, T_INT32, HeapAnalyzeSuccess, cdac_data::HeapAnalyzeSuccess) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, InterestingData, cdac_data::InterestingData) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, CompactReasons, cdac_data::CompactReasons) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, ExpandMechanisms, cdac_data::ExpandMechanisms) +CDAC_TYPE_FIELD(GCHeap, T_POINTER, InterestingMechanismBits, cdac_data::InterestingMechanismBits) CDAC_TYPE_END(GCHeap) #endif // SERVER_GC CDAC_TYPE_BEGIN(Generation) CDAC_TYPE_SIZE(sizeof(GC_NAMESPACE::generation)) -CDAC_TYPE_FIELD(Generation, /*AllocContext*/, AllocationContext, offsetof(GC_NAMESPACE::generation, allocation_context)) -CDAC_TYPE_FIELD(Generation, /*pointer*/, StartSegment, offsetof(GC_NAMESPACE::generation, start_segment)) +CDAC_TYPE_FIELD(Generation, EXTERN_TYPE(GCAllocContext), AllocationContext, offsetof(GC_NAMESPACE::generation, allocation_context)) +CDAC_TYPE_FIELD(Generation, T_POINTER, StartSegment, offsetof(GC_NAMESPACE::generation, start_segment)) #ifndef USE_REGIONS -CDAC_TYPE_FIELD(Generation, /*pointer*/, AllocationStart, offsetof(GC_NAMESPACE::generation, allocation_start)) +CDAC_TYPE_FIELD(Generation, T_POINTER, AllocationStart, offsetof(GC_NAMESPACE::generation, allocation_start)) #endif // !USE_REGIONS CDAC_TYPE_END(Generation) CDAC_TYPE_BEGIN(CFinalize) CDAC_TYPE_INDETERMINATE(CFinalize) -CDAC_TYPE_FIELD(CFinalize, /*pointer*/, FillPointers, cdac_data::FillPointers) +CDAC_TYPE_FIELD(CFinalize, T_POINTER, FillPointers, cdac_data::FillPointers) CDAC_TYPE_END(CFinalize) CDAC_TYPE_BEGIN(HeapSegment) CDAC_TYPE_INDETERMINATE(HeapSegment) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Allocated, offsetof(GC_NAMESPACE::heap_segment, allocated)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Committed, offsetof(GC_NAMESPACE::heap_segment, committed)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Reserved, offsetof(GC_NAMESPACE::heap_segment, reserved)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Used, offsetof(GC_NAMESPACE::heap_segment, used)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Mem, offsetof(GC_NAMESPACE::heap_segment, mem)) -CDAC_TYPE_FIELD(HeapSegment, /*nuint*/, Flags, offsetof(GC_NAMESPACE::heap_segment, flags)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Next, offsetof(GC_NAMESPACE::heap_segment, next)) -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, BackgroundAllocated, offsetof(GC_NAMESPACE::heap_segment, background_allocated)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Allocated, offsetof(GC_NAMESPACE::heap_segment, allocated)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Committed, offsetof(GC_NAMESPACE::heap_segment, committed)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Reserved, offsetof(GC_NAMESPACE::heap_segment, reserved)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Used, offsetof(GC_NAMESPACE::heap_segment, used)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Mem, offsetof(GC_NAMESPACE::heap_segment, mem)) +CDAC_TYPE_FIELD(HeapSegment, T_NUINT, Flags, offsetof(GC_NAMESPACE::heap_segment, flags)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Next, offsetof(GC_NAMESPACE::heap_segment, next)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, BackgroundAllocated, offsetof(GC_NAMESPACE::heap_segment, background_allocated)) #ifdef MULTIPLE_HEAPS -CDAC_TYPE_FIELD(HeapSegment, /*pointer*/, Heap, offsetof(GC_NAMESPACE::heap_segment, heap)) +CDAC_TYPE_FIELD(HeapSegment, T_POINTER, Heap, offsetof(GC_NAMESPACE::heap_segment, heap)) #endif // MULTIPLE_HEAPS CDAC_TYPE_END(HeapSegment) CDAC_TYPE_BEGIN(OomHistory) CDAC_TYPE_INDETERMINATE(OomHistory) -CDAC_TYPE_FIELD(OomHistory, /*int32*/, Reason, offsetof(oom_history, reason)) -CDAC_TYPE_FIELD(OomHistory, /*nuint*/, AllocSize, offsetof(oom_history, alloc_size)) -CDAC_TYPE_FIELD(OomHistory, /*pointer*/, Reserved, offsetof(oom_history, reserved)) -CDAC_TYPE_FIELD(OomHistory, /*pointer*/, Allocated, offsetof(oom_history, allocated)) -CDAC_TYPE_FIELD(OomHistory, /*nuint*/, GcIndex, offsetof(oom_history, gc_index)) -CDAC_TYPE_FIELD(OomHistory, /*int32*/, Fgm, offsetof(oom_history, fgm)) -CDAC_TYPE_FIELD(OomHistory, /*nuint*/, Size, offsetof(oom_history, size)) -CDAC_TYPE_FIELD(OomHistory, /*nuint*/, AvailablePagefileMb, offsetof(oom_history, available_pagefile_mb)) -CDAC_TYPE_FIELD(OomHistory, /*uint32*/, LohP, offsetof(oom_history, loh_p)) +CDAC_TYPE_FIELD(OomHistory, T_INT32, Reason, offsetof(oom_history, reason)) +CDAC_TYPE_FIELD(OomHistory, T_NUINT, AllocSize, offsetof(oom_history, alloc_size)) +CDAC_TYPE_FIELD(OomHistory, T_POINTER, Reserved, offsetof(oom_history, reserved)) +CDAC_TYPE_FIELD(OomHistory, T_POINTER, Allocated, offsetof(oom_history, allocated)) +CDAC_TYPE_FIELD(OomHistory, T_NUINT, GcIndex, offsetof(oom_history, gc_index)) +CDAC_TYPE_FIELD(OomHistory, T_INT32, Fgm, offsetof(oom_history, fgm)) +CDAC_TYPE_FIELD(OomHistory, T_NUINT, Size, offsetof(oom_history, size)) +CDAC_TYPE_FIELD(OomHistory, T_NUINT, AvailablePagefileMb, offsetof(oom_history, available_pagefile_mb)) +CDAC_TYPE_FIELD(OomHistory, T_UINT32, LohP, offsetof(oom_history, loh_p)) CDAC_TYPE_END(OomHistory) CDAC_TYPE_BEGIN(HandleTableMap) CDAC_TYPE_INDETERMINATE(HandleTableMap) -CDAC_TYPE_FIELD(HandleTableMap, /*pointer*/, BucketsPtr, offsetof(HandleTableMap, pBuckets)) -CDAC_TYPE_FIELD(HandleTableMap, /*pointer*/, Next, offsetof(HandleTableMap, pNext)) +CDAC_TYPE_FIELD(HandleTableMap, T_POINTER, BucketsPtr, offsetof(HandleTableMap, pBuckets)) +CDAC_TYPE_FIELD(HandleTableMap, T_POINTER, Next, offsetof(HandleTableMap, pNext)) CDAC_TYPE_END(HandleTableMap) CDAC_TYPE_BEGIN(HandleTableBucket) CDAC_TYPE_INDETERMINATE(HandleTableBucket) -CDAC_TYPE_FIELD(HandleTableBucket, /*pointer*/, Table, offsetof(HandleTableBucket, pTable)) +CDAC_TYPE_FIELD(HandleTableBucket, T_POINTER, Table, offsetof(HandleTableBucket, pTable)) CDAC_TYPE_END(HandleTableBucket) CDAC_TYPE_BEGIN(HandleTable) CDAC_TYPE_INDETERMINATE(HandleTable) -CDAC_TYPE_FIELD(HandleTable, /*pointer*/, SegmentList, offsetof(HandleTable, pSegmentList)) +CDAC_TYPE_FIELD(HandleTable, T_POINTER, SegmentList, offsetof(HandleTable, pSegmentList)) CDAC_TYPE_END(HandleTable) CDAC_TYPE_BEGIN(TableSegment) CDAC_TYPE_INDETERMINATE(TableSegment) -CDAC_TYPE_FIELD(TableSegment, /*pointer*/, NextSegment, offsetof(TableSegment, pNextSegment)) -CDAC_TYPE_FIELD(TableSegment, /*uint8_t[]*/, RgAllocation, offsetof(TableSegment, rgAllocation)) -CDAC_TYPE_FIELD(TableSegment, /*uint8_t[]*/, RgTail, offsetof(TableSegment, rgTail)) -CDAC_TYPE_FIELD(TableSegment, /*uint8_t[]*/, RgValue, offsetof(TableSegment, rgValue)) -CDAC_TYPE_FIELD(TableSegment, /*uint8_t[]*/, RgUserData, offsetof(TableSegment, rgUserData)) +CDAC_TYPE_FIELD(TableSegment, T_POINTER, NextSegment, offsetof(TableSegment, pNextSegment)) +CDAC_TYPE_FIELD(TableSegment, T_ARRAY(T_UINT8), RgAllocation, offsetof(TableSegment, rgAllocation)) +CDAC_TYPE_FIELD(TableSegment, T_ARRAY(T_UINT8), RgTail, offsetof(TableSegment, rgTail)) +CDAC_TYPE_FIELD(TableSegment, T_ARRAY(T_UINT8), RgValue, offsetof(TableSegment, rgValue)) +CDAC_TYPE_FIELD(TableSegment, T_ARRAY(T_UINT8), RgUserData, offsetof(TableSegment, rgUserData)) CDAC_TYPE_END(TableSegment) CDAC_TYPES_END() CDAC_GLOBALS_BEGIN() -CDAC_GLOBAL(TotalGenerationCount, /*uint32*/, (uint32_t)total_generation_count) -CDAC_GLOBAL(CFinalizeFillPointersLength, /*uint32*/, (uint32_t)cdac_data::FillPointersLength) -CDAC_GLOBAL(InterestingDataLength, /*uint32*/, NUM_GC_DATA_POINTS) -CDAC_GLOBAL(CompactReasonsLength, /*uint32*/, MAX_COMPACT_REASONS_COUNT) -CDAC_GLOBAL(ExpandMechanismsLength, /*uint32*/, MAX_EXPAND_MECHANISMS_COUNT) -CDAC_GLOBAL(InterestingMechanismBitsLength, /*uint32*/, MAX_GC_MECHANISM_BITS_COUNT) -CDAC_GLOBAL(GlobalMechanismsLength, /*uint32*/, MAX_GLOBAL_GC_MECHANISMS_COUNT) -CDAC_GLOBAL(InitialHandleTableArraySize, /*uint32*/, INITIAL_HANDLE_TABLE_ARRAY_SIZE) +CDAC_GLOBAL(TotalGenerationCount, T_UINT32, (uint32_t)total_generation_count) +CDAC_GLOBAL(CFinalizeFillPointersLength, T_UINT32, (uint32_t)cdac_data::FillPointersLength) +CDAC_GLOBAL(InterestingDataLength, T_UINT32, NUM_GC_DATA_POINTS) +CDAC_GLOBAL(CompactReasonsLength, T_UINT32, MAX_COMPACT_REASONS_COUNT) +CDAC_GLOBAL(ExpandMechanismsLength, T_UINT32, MAX_EXPAND_MECHANISMS_COUNT) +CDAC_GLOBAL(InterestingMechanismBitsLength, T_UINT32, MAX_GC_MECHANISM_BITS_COUNT) +CDAC_GLOBAL(GlobalMechanismsLength, T_UINT32, MAX_GLOBAL_GC_MECHANISMS_COUNT) +CDAC_GLOBAL(InitialHandleTableArraySize, T_UINT32, INITIAL_HANDLE_TABLE_ARRAY_SIZE) #ifdef DEBUG_DestroyedHandleValue -CDAC_GLOBAL(DebugDestroyedHandleValue, /*uintptr_t*/, (uintptr_t)DEBUG_DestroyedHandleValue) +CDAC_GLOBAL(DebugDestroyedHandleValue, T_NUINT, (uintptr_t)DEBUG_DestroyedHandleValue) #else -CDAC_GLOBAL(DebugDestroyedHandleValue, /*uintptr_t*/, (uintptr_t)(0)) +CDAC_GLOBAL(DebugDestroyedHandleValue, T_NUINT, (uintptr_t)(0)) #endif -CDAC_GLOBAL(HandleSegmentSize, /*uint32*/, HANDLE_SEGMENT_SIZE) -CDAC_GLOBAL(HandleBlocksPerSegment, /*uint32*/, HANDLE_BLOCKS_PER_SEGMENT) -CDAC_GLOBAL(HandleMaxInternalTypes, /*uint32*/, HANDLE_MAX_INTERNAL_TYPES) -CDAC_GLOBAL(HandlesPerBlock, /*uint32*/, HANDLE_HANDLES_PER_BLOCK) -CDAC_GLOBAL(BlockInvalid, /*uint8*/, BLOCK_INVALID) +CDAC_GLOBAL(HandleSegmentSize, T_UINT32, HANDLE_SEGMENT_SIZE) +CDAC_GLOBAL(HandleBlocksPerSegment, T_UINT32, HANDLE_BLOCKS_PER_SEGMENT) +CDAC_GLOBAL(HandleMaxInternalTypes, T_UINT32, HANDLE_MAX_INTERNAL_TYPES) +CDAC_GLOBAL(HandlesPerBlock, T_UINT32, HANDLE_HANDLES_PER_BLOCK) +CDAC_GLOBAL(BlockInvalid, T_UINT8, BLOCK_INVALID) #ifndef SERVER_GC diff --git a/src/coreclr/tools/cdac-build-tool/ContractDescriptorSourceFileEmitter.cs b/src/coreclr/tools/cdac-build-tool/ContractDescriptorSourceFileEmitter.cs index 735a8cc7e6b09b..fd2d5692cc5a05 100644 --- a/src/coreclr/tools/cdac-build-tool/ContractDescriptorSourceFileEmitter.cs +++ b/src/coreclr/tools/cdac-build-tool/ContractDescriptorSourceFileEmitter.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Text; using System.Text.RegularExpressions; namespace Microsoft.DotNet.Diagnostics.DataContract.BuildTool; @@ -43,8 +44,32 @@ public void SetPlatformFlags(uint platformFlags) /// The jsonDescriptor should not be C escaped public void SetJsonDescriptor(string jsonDescriptor) { - var count = jsonDescriptor.Length; // return the length before escaping - var escaped = CStringEscape.Replace(jsonDescriptor, "\\$1"); + int count = jsonDescriptor.Length; // return the length before escaping + string escaped = CStringEscape.Replace(jsonDescriptor, "\\$1"); + + // MSVC limits individual string literals to about 2048 bytes (error C2026). + // The C standard only guarantees 4095 characters per literal. To stay portable, + // we split long strings into adjacent literals ("chunk1" "chunk2") which are + // concatenated into a single contiguous string at compile time per the C standard. + const int MaxChunkSize = 2000; + if (escaped.Length > MaxChunkSize) + { + StringBuilder sb = new StringBuilder(escaped.Length + escaped.Length / MaxChunkSize * 4); + int offset = 0; + while (offset < escaped.Length) + { + if (offset > 0) + sb.Append("\" \""); + int chunkEnd = Math.Min(offset + MaxChunkSize, escaped.Length); + // Don't split in the middle of a \" escape sequence + if (chunkEnd < escaped.Length && escaped[chunkEnd - 1] == '\\') + chunkEnd--; + sb.Append(escaped, offset, chunkEnd - offset); + offset = chunkEnd; + } + escaped = sb.ToString(); + } + Elements[JsonDescriptorKey] = escaped; Elements[JsonDescriptorSizeKey] = count.ToString(); } diff --git a/src/coreclr/vm/datadescriptor/datadescriptor.inc b/src/coreclr/vm/datadescriptor/datadescriptor.inc index 3e7993b5dbb078..5baaa0ec7672c9 100644 --- a/src/coreclr/vm/datadescriptor/datadescriptor.inc +++ b/src/coreclr/vm/datadescriptor/datadescriptor.inc @@ -35,84 +35,84 @@ CDAC_TYPES_BEGIN() CDAC_TYPE_BEGIN(Thread) CDAC_TYPE_INDETERMINATE(Thread) -CDAC_TYPE_FIELD(Thread, /*uint32*/, Id, cdac_data::Id) -CDAC_TYPE_FIELD(Thread, /*nuint*/, OSId, cdac_data::OSId) -CDAC_TYPE_FIELD(Thread, /*uint32*/, State, cdac_data::State) -CDAC_TYPE_FIELD(Thread, /*uint32*/, PreemptiveGCDisabled, cdac_data::PreemptiveGCDisabled) -CDAC_TYPE_FIELD(Thread, /*pointer*/, RuntimeThreadLocals, cdac_data::RuntimeThreadLocals) -CDAC_TYPE_FIELD(Thread, /*pointer*/, Frame, cdac_data::Frame) -CDAC_TYPE_FIELD(Thread, /*pointer*/, CachedStackBase, cdac_data::CachedStackBase) -CDAC_TYPE_FIELD(Thread, /*pointer*/, CachedStackLimit, cdac_data::CachedStackLimit) -CDAC_TYPE_FIELD(Thread, /*pointer*/, ExceptionTracker, cdac_data::ExceptionTracker) -CDAC_TYPE_FIELD(Thread, GCHandle, GCHandle, cdac_data::ExposedObject) -CDAC_TYPE_FIELD(Thread, GCHandle, LastThrownObject, cdac_data::LastThrownObject) -CDAC_TYPE_FIELD(Thread, pointer, LinkNext, cdac_data::Link) -CDAC_TYPE_FIELD(Thread, /*pointer*/, ThreadLocalDataPtr, cdac_data::ThreadLocalDataPtr) +CDAC_TYPE_FIELD(Thread, T_UINT32, Id, cdac_data::Id) +CDAC_TYPE_FIELD(Thread, T_NUINT, OSId, cdac_data::OSId) +CDAC_TYPE_FIELD(Thread, T_UINT32, State, cdac_data::State) +CDAC_TYPE_FIELD(Thread, T_UINT32, PreemptiveGCDisabled, cdac_data::PreemptiveGCDisabled) +CDAC_TYPE_FIELD(Thread, T_POINTER, RuntimeThreadLocals, cdac_data::RuntimeThreadLocals) +CDAC_TYPE_FIELD(Thread, T_POINTER, Frame, cdac_data::Frame) +CDAC_TYPE_FIELD(Thread, T_POINTER, CachedStackBase, cdac_data::CachedStackBase) +CDAC_TYPE_FIELD(Thread, T_POINTER, CachedStackLimit, cdac_data::CachedStackLimit) +CDAC_TYPE_FIELD(Thread, T_POINTER, ExceptionTracker, cdac_data::ExceptionTracker) +CDAC_TYPE_FIELD(Thread, TYPE(GCHandle), GCHandle, cdac_data::ExposedObject) +CDAC_TYPE_FIELD(Thread, TYPE(GCHandle), LastThrownObject, cdac_data::LastThrownObject) +CDAC_TYPE_FIELD(Thread, T_POINTER, LinkNext, cdac_data::Link) +CDAC_TYPE_FIELD(Thread, T_POINTER, ThreadLocalDataPtr, cdac_data::ThreadLocalDataPtr) #ifndef TARGET_UNIX -CDAC_TYPE_FIELD(Thread, /*pointer*/, TEB, cdac_data::TEB) -CDAC_TYPE_FIELD(Thread, /*pointer*/, UEWatsonBucketTrackerBuckets, cdac_data::UEWatsonBucketTrackerBuckets) +CDAC_TYPE_FIELD(Thread, T_POINTER, TEB, cdac_data::TEB) +CDAC_TYPE_FIELD(Thread, T_POINTER, UEWatsonBucketTrackerBuckets, cdac_data::UEWatsonBucketTrackerBuckets) #endif CDAC_TYPE_END(Thread) CDAC_TYPE_BEGIN(ThreadStore) CDAC_TYPE_INDETERMINATE(ThreadStore) -CDAC_TYPE_FIELD(ThreadStore, /*SLink*/, FirstThreadLink, cdac_data::FirstThreadLink) -CDAC_TYPE_FIELD(ThreadStore, /*int32*/, ThreadCount, cdac_data::ThreadCount) -CDAC_TYPE_FIELD(ThreadStore, /*int32*/, UnstartedCount, cdac_data::UnstartedCount) -CDAC_TYPE_FIELD(ThreadStore, /*int32*/, BackgroundCount, cdac_data::BackgroundCount) -CDAC_TYPE_FIELD(ThreadStore, /*int32*/, PendingCount, cdac_data::PendingCount) -CDAC_TYPE_FIELD(ThreadStore, /*int32*/, DeadCount, cdac_data::DeadCount) +CDAC_TYPE_FIELD(ThreadStore, TYPE(SLink), FirstThreadLink, cdac_data::FirstThreadLink) +CDAC_TYPE_FIELD(ThreadStore, T_INT32, ThreadCount, cdac_data::ThreadCount) +CDAC_TYPE_FIELD(ThreadStore, T_INT32, UnstartedCount, cdac_data::UnstartedCount) +CDAC_TYPE_FIELD(ThreadStore, T_INT32, BackgroundCount, cdac_data::BackgroundCount) +CDAC_TYPE_FIELD(ThreadStore, T_INT32, PendingCount, cdac_data::PendingCount) +CDAC_TYPE_FIELD(ThreadStore, T_INT32, DeadCount, cdac_data::DeadCount) CDAC_TYPE_END(ThreadStore) CDAC_TYPE_BEGIN(RuntimeThreadLocals) CDAC_TYPE_INDETERMINATE(RuntimeThreadLocals) -CDAC_TYPE_FIELD(RuntimeThreadLocals, /*EEAllocContext*/, AllocContext, offsetof(RuntimeThreadLocals, alloc_context)) +CDAC_TYPE_FIELD(RuntimeThreadLocals, TYPE(EEAllocContext), AllocContext, offsetof(RuntimeThreadLocals, alloc_context)) CDAC_TYPE_END(RuntimeThreadLocals) CDAC_TYPE_BEGIN(IdDispenser) CDAC_TYPE_INDETERMINATE(IdDispenser) -CDAC_TYPE_FIELD(IdDispenser, /*pointer*/, IdToThread, cdac_data::IdToThread) -CDAC_TYPE_FIELD(IdDispenser, /*uint32*/, HighestId, cdac_data::HighestId) +CDAC_TYPE_FIELD(IdDispenser, T_POINTER, IdToThread, cdac_data::IdToThread) +CDAC_TYPE_FIELD(IdDispenser, T_UINT32, HighestId, cdac_data::HighestId) CDAC_TYPE_END(IdDispenser) CDAC_TYPE_BEGIN(ThreadStaticsInfo) CDAC_TYPE_SIZE(sizeof(ThreadStaticsInfo)) -CDAC_TYPE_FIELD(ThreadStaticsInfo, /*TLSIndex*/, GCTlsIndex, offsetof(ThreadStaticsInfo, GCTlsIndex)) -CDAC_TYPE_FIELD(ThreadStaticsInfo, /*TLSIndex*/, NonGCTlsIndex, offsetof(ThreadStaticsInfo, NonGCTlsIndex)) +CDAC_TYPE_FIELD(ThreadStaticsInfo, TYPE(TLSIndex), GCTlsIndex, offsetof(ThreadStaticsInfo, GCTlsIndex)) +CDAC_TYPE_FIELD(ThreadStaticsInfo, TYPE(TLSIndex), NonGCTlsIndex, offsetof(ThreadStaticsInfo, NonGCTlsIndex)) CDAC_TYPE_END(ThreadStaticsInfo) CDAC_TYPE_BEGIN(ThreadLocalData) CDAC_TYPE_INDETERMINATE(ThreadLocalData) -CDAC_TYPE_FIELD(ThreadLocalData, /*pointer*/, CollectibleTlsArrayData, offsetof(ThreadLocalData, pCollectibleTlsArrayData)) -CDAC_TYPE_FIELD(ThreadLocalData, /*pointer*/, NonCollectibleTlsArrayData, offsetof(ThreadLocalData, pNonCollectibleTlsArrayData)) -CDAC_TYPE_FIELD(ThreadLocalData, /*int32*/, CollectibleTlsDataCount, offsetof(ThreadLocalData, cCollectibleTlsData)) -CDAC_TYPE_FIELD(ThreadLocalData, /*int32*/, NonCollectibleTlsDataCount, offsetof(ThreadLocalData, cNonCollectibleTlsData)) -CDAC_TYPE_FIELD(ThreadLocalData, /*pointer*/, InFlightData, offsetof(ThreadLocalData, pInFlightData)) +CDAC_TYPE_FIELD(ThreadLocalData, T_POINTER, CollectibleTlsArrayData, offsetof(ThreadLocalData, pCollectibleTlsArrayData)) +CDAC_TYPE_FIELD(ThreadLocalData, T_POINTER, NonCollectibleTlsArrayData, offsetof(ThreadLocalData, pNonCollectibleTlsArrayData)) +CDAC_TYPE_FIELD(ThreadLocalData, T_INT32, CollectibleTlsDataCount, offsetof(ThreadLocalData, cCollectibleTlsData)) +CDAC_TYPE_FIELD(ThreadLocalData, T_INT32, NonCollectibleTlsDataCount, offsetof(ThreadLocalData, cNonCollectibleTlsData)) +CDAC_TYPE_FIELD(ThreadLocalData, T_POINTER, InFlightData, offsetof(ThreadLocalData, pInFlightData)) CDAC_TYPE_END(ThreadLocalData) CDAC_TYPE_BEGIN(InFlightTLSData) CDAC_TYPE_INDETERMINATE(InFlightTLSData) -CDAC_TYPE_FIELD(InFlightTLSData, /*pointer*/, Next, offsetof(InFlightTLSData, pNext)) -CDAC_TYPE_FIELD(InFlightTLSData, /*TLSIndex*/, TlsIndex, offsetof(InFlightTLSData, tlsIndex)) -CDAC_TYPE_FIELD(InFlightTLSData, /*OBJECTHANDLE*/, TLSData, offsetof(InFlightTLSData, hTLSData)) +CDAC_TYPE_FIELD(InFlightTLSData, T_POINTER, Next, offsetof(InFlightTLSData, pNext)) +CDAC_TYPE_FIELD(InFlightTLSData, TYPE(TLSIndex), TlsIndex, offsetof(InFlightTLSData, tlsIndex)) +CDAC_TYPE_FIELD(InFlightTLSData, T_POINTER, TLSData, offsetof(InFlightTLSData, hTLSData)) CDAC_TYPE_END(InFlightTLSData) CDAC_TYPE_BEGIN(TLSIndex) CDAC_TYPE_INDETERMINATE(TLSIndex) -CDAC_TYPE_FIELD(TLSIndex, /*uint32*/, TLSIndexRawIndex, offsetof(TLSIndex, TLSIndexRawIndex)) +CDAC_TYPE_FIELD(TLSIndex, T_UINT32, TLSIndexRawIndex, offsetof(TLSIndex, TLSIndexRawIndex)) CDAC_TYPE_END(TLSIndex) CDAC_TYPE_BEGIN(EEAllocContext) CDAC_TYPE_INDETERMINATE(EEAllocContext) -CDAC_TYPE_FIELD(EEAllocContext, /*GCAllocContext*/, GCAllocationContext, offsetof(ee_alloc_context, m_GCAllocContext)) +CDAC_TYPE_FIELD(EEAllocContext, TYPE(GCAllocContext), GCAllocationContext, offsetof(ee_alloc_context, m_GCAllocContext)) CDAC_TYPE_END(EEAllocContext) CDAC_TYPE_BEGIN(GCAllocContext) CDAC_TYPE_INDETERMINATE(GCAllocContext) -CDAC_TYPE_FIELD(GCAllocContext, /*pointer*/, Pointer, offsetof(gc_alloc_context, alloc_ptr)) -CDAC_TYPE_FIELD(GCAllocContext, /*pointer*/, Limit, offsetof(gc_alloc_context, alloc_limit)) -CDAC_TYPE_FIELD(GCAllocContext, /*int64*/, AllocBytes, offsetof(gc_alloc_context, alloc_bytes)) -CDAC_TYPE_FIELD(GCAllocContext, /*int64*/, AllocBytesLoh, offsetof(gc_alloc_context, alloc_bytes_uoh)) +CDAC_TYPE_FIELD(GCAllocContext, T_POINTER, Pointer, offsetof(gc_alloc_context, alloc_ptr)) +CDAC_TYPE_FIELD(GCAllocContext, T_POINTER, Limit, offsetof(gc_alloc_context, alloc_limit)) +CDAC_TYPE_FIELD(GCAllocContext, T_INT64, AllocBytes, offsetof(gc_alloc_context, alloc_bytes)) +CDAC_TYPE_FIELD(GCAllocContext, T_INT64, AllocBytesLoh, offsetof(gc_alloc_context, alloc_bytes_uoh)) CDAC_TYPE_END(GCAllocContext) // Exception @@ -120,22 +120,22 @@ CDAC_TYPE_END(GCAllocContext) // Use exact managed type field names for the descriptor as field names often can't change due to binary serialization or implicit diagnostic contracts CDAC_TYPE_BEGIN(Exception) CDAC_TYPE_INDETERMINATE(Exception) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _message, cdac_data::_message) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _innerException, cdac_data::_innerException) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _stackTrace, cdac_data::_stackTrace) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _watsonBuckets, cdac_data::_watsonBuckets) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _stackTraceString, cdac_data::_stackTraceString) -CDAC_TYPE_FIELD(Exception, /*pointer*/, _remoteStackTraceString, cdac_data::_remoteStackTraceString) -CDAC_TYPE_FIELD(Exception, /*int32*/, _HResult, cdac_data::_HResult) -CDAC_TYPE_FIELD(Exception, /*int32*/, _xcode, cdac_data::_xcode) +CDAC_TYPE_FIELD(Exception, T_POINTER, _message, cdac_data::_message) +CDAC_TYPE_FIELD(Exception, T_POINTER, _innerException, cdac_data::_innerException) +CDAC_TYPE_FIELD(Exception, T_POINTER, _stackTrace, cdac_data::_stackTrace) +CDAC_TYPE_FIELD(Exception, T_POINTER, _watsonBuckets, cdac_data::_watsonBuckets) +CDAC_TYPE_FIELD(Exception, T_POINTER, _stackTraceString, cdac_data::_stackTraceString) +CDAC_TYPE_FIELD(Exception, T_POINTER, _remoteStackTraceString, cdac_data::_remoteStackTraceString) +CDAC_TYPE_FIELD(Exception, T_INT32, _HResult, cdac_data::_HResult) +CDAC_TYPE_FIELD(Exception, T_INT32, _xcode, cdac_data::_xcode) CDAC_TYPE_END(Exception) CDAC_TYPE_BEGIN(ExceptionInfo) CDAC_TYPE_INDETERMINATE(ExceptionInfo) -CDAC_TYPE_FIELD(ExceptionInfo, /*pointer*/, ThrownObjectHandle, offsetof(ExInfo, m_hThrowable)) -CDAC_TYPE_FIELD(PreviousNestedInfo, /*pointer*/, PreviousNestedInfo, offsetof(ExInfo, m_pPrevNestedInfo)) +CDAC_TYPE_FIELD(ExceptionInfo, T_POINTER, ThrownObjectHandle, offsetof(ExInfo, m_hThrowable)) +CDAC_TYPE_FIELD(PreviousNestedInfo, T_POINTER, PreviousNestedInfo, offsetof(ExInfo, m_pPrevNestedInfo)) #ifndef TARGET_UNIX -CDAC_TYPE_FIELD(ExceptionWatsonBucketTrackerBuckets, /*pointer*/, ExceptionWatsonBucketTrackerBuckets, cdac_data::ExceptionWatsonBucketTrackerBuckets) +CDAC_TYPE_FIELD(ExceptionWatsonBucketTrackerBuckets, T_POINTER, ExceptionWatsonBucketTrackerBuckets, cdac_data::ExceptionWatsonBucketTrackerBuckets) #endif // TARGET_UNIX CDAC_TYPE_END(ExceptionInfo) @@ -148,349 +148,349 @@ CDAC_TYPE_END(GCHandle) CDAC_TYPE_BEGIN(Object) CDAC_TYPE_SIZE(sizeof(Object)) -CDAC_TYPE_FIELD(Object, /*pointer*/, m_pMethTab, cdac_data::m_pMethTab) +CDAC_TYPE_FIELD(Object, T_POINTER, m_pMethTab, cdac_data::m_pMethTab) CDAC_TYPE_END(Object) CDAC_TYPE_BEGIN(ObjectHeader) CDAC_TYPE_SIZE(OBJHEADER_SIZE) -CDAC_TYPE_FIELD(ObjectHeader, /*uint32*/, SyncBlockValue, cdac_data::SyncBlockValue) +CDAC_TYPE_FIELD(ObjectHeader, T_UINT32, SyncBlockValue, cdac_data::SyncBlockValue) CDAC_TYPE_END(ObjectHeader) CDAC_TYPE_BEGIN(String) CDAC_TYPE_INDETERMINATE(String) -CDAC_TYPE_FIELD(String, /*pointer*/, m_FirstChar, cdac_data::m_FirstChar) -CDAC_TYPE_FIELD(String, /*uint32*/, m_StringLength, cdac_data::m_StringLength) +CDAC_TYPE_FIELD(String, T_POINTER, m_FirstChar, cdac_data::m_FirstChar) +CDAC_TYPE_FIELD(String, T_UINT32, m_StringLength, cdac_data::m_StringLength) CDAC_TYPE_END(String) CDAC_TYPE_BEGIN(Array) CDAC_TYPE_SIZE(sizeof(ArrayBase)) -CDAC_TYPE_FIELD(Array, /*pointer*/, m_NumComponents, cdac_data::m_NumComponents) +CDAC_TYPE_FIELD(Array, T_POINTER, m_NumComponents, cdac_data::m_NumComponents) CDAC_TYPE_END(Array) CDAC_TYPE_BEGIN(InteropSyncBlockInfo) CDAC_TYPE_INDETERMINATE(InteropSyncBlockInfo) #ifdef FEATURE_COMINTEROP -CDAC_TYPE_FIELD(InteropSyncBlockInfo, /*pointer*/, CCW, cdac_data::CCW) -CDAC_TYPE_FIELD(InteropSyncBlockInfo, /*pointer*/, RCW, cdac_data::RCW) -CDAC_TYPE_FIELD(InteropSyncBlockInfo, /*pointer*/, CCF, cdac_data::CCF) +CDAC_TYPE_FIELD(InteropSyncBlockInfo, T_POINTER, CCW, cdac_data::CCW) +CDAC_TYPE_FIELD(InteropSyncBlockInfo, T_POINTER, RCW, cdac_data::RCW) +CDAC_TYPE_FIELD(InteropSyncBlockInfo, T_POINTER, CCF, cdac_data::CCF) #endif // FEATURE_COMINTEROP CDAC_TYPE_END(InteropSyncBlockInfo) CDAC_TYPE_BEGIN(SyncBlock) CDAC_TYPE_INDETERMINATE(SyncBlock) -CDAC_TYPE_FIELD(SyncBlock, /*pointer*/, InteropInfo, cdac_data::InteropInfo) -CDAC_TYPE_FIELD(SyncBlock, /*pointer*/, Lock, cdac_data::Lock) -CDAC_TYPE_FIELD(SyncBlock, /*uint32*/, ThinLock, cdac_data::ThinLock) -CDAC_TYPE_FIELD(SyncBlock, /*pointer*/, LinkNext, cdac_data::LinkNext) -CDAC_TYPE_FIELD(SyncBlock, /*uint32*/, HashCode, cdac_data::HashCode) +CDAC_TYPE_FIELD(SyncBlock, T_POINTER, InteropInfo, cdac_data::InteropInfo) +CDAC_TYPE_FIELD(SyncBlock, T_POINTER, Lock, cdac_data::Lock) +CDAC_TYPE_FIELD(SyncBlock, T_UINT32, ThinLock, cdac_data::ThinLock) +CDAC_TYPE_FIELD(SyncBlock, T_POINTER, LinkNext, cdac_data::LinkNext) +CDAC_TYPE_FIELD(SyncBlock, T_UINT32, HashCode, cdac_data::HashCode) CDAC_TYPE_END(SyncBlock) CDAC_TYPE_BEGIN(SLink) CDAC_TYPE_INDETERMINATE(SLink) -CDAC_TYPE_FIELD(SLink, /*pointer*/, Next, offsetof(SLink, m_pNext)) +CDAC_TYPE_FIELD(SLink, T_POINTER, Next, offsetof(SLink, m_pNext)) CDAC_TYPE_END(SLink) #ifdef FEATURE_COMWRAPPERS CDAC_TYPE_BEGIN(NativeObjectWrapperObject) CDAC_TYPE_INDETERMINATE(NativeObjectWrapperObject) -CDAC_TYPE_FIELD(NativeObjectWrapperObject, /*pointer*/, ExternalComObject, cdac_data::ExternalComObject) +CDAC_TYPE_FIELD(NativeObjectWrapperObject, T_POINTER, ExternalComObject, cdac_data::ExternalComObject) CDAC_TYPE_END(NativeObjectWrapperObject) CDAC_TYPE_BEGIN(ManagedObjectWrapperHolderObject) CDAC_TYPE_INDETERMINATE(ManagedObjectWrapperHolderObject) -CDAC_TYPE_FIELD(ManagedObjectWrapperHolderObject, /*pointer*/, WrappedObject, cdac_data::WrappedObject) -CDAC_TYPE_FIELD(ManagedObjectWrapperHolderObject, /*pointer*/, Wrapper, cdac_data::Wrapper) +CDAC_TYPE_FIELD(ManagedObjectWrapperHolderObject, T_POINTER, WrappedObject, cdac_data::WrappedObject) +CDAC_TYPE_FIELD(ManagedObjectWrapperHolderObject, T_POINTER, Wrapper, cdac_data::Wrapper) CDAC_TYPE_END(ManagedObjectWrapperHolderObject) CDAC_TYPE_BEGIN(ManagedObjectWrapperLayout) CDAC_TYPE_INDETERMINATE(ManagedObjectWrapperLayout) -CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, /*int64*/, RefCount, cdac_data::RefCount) -CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, /*int32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, /*int32*/, UserDefinedCount, cdac_data::UserDefinedCount) -CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, /*pointer*/, UserDefined, cdac_data::UserDefined) -CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, /*pointer*/, Dispatches, cdac_data::Dispatches) +CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, T_INT64, RefCount, cdac_data::RefCount) +CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, T_INT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, T_INT32, UserDefinedCount, cdac_data::UserDefinedCount) +CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, T_POINTER, UserDefined, cdac_data::UserDefined) +CDAC_TYPE_FIELD(ManagedObjectWrapperLayout, T_POINTER, Dispatches, cdac_data::Dispatches) CDAC_TYPE_END(ManagedObjectWrapperLayout) CDAC_TYPE_BEGIN(ComInterfaceEntry) CDAC_TYPE_SIZE(sizeof(InteropLib::ABI::ComInterfaceEntry)) -CDAC_TYPE_FIELD(ComInterfaceEntry, /*nuint*/, IID, cdac_data::IID) +CDAC_TYPE_FIELD(ComInterfaceEntry, T_NUINT, IID, cdac_data::IID) CDAC_TYPE_END(ComInterfaceEntry) CDAC_TYPE_BEGIN(InternalComInterfaceDispatch) CDAC_TYPE_SIZE(sizeof(InteropLib::ABI::InternalComInterfaceDispatch)) -CDAC_TYPE_FIELD(InternalComInterfaceDispatch, /*pointer*/, Entries, cdac_data::Entries) +CDAC_TYPE_FIELD(InternalComInterfaceDispatch, T_POINTER, Entries, cdac_data::Entries) CDAC_TYPE_END(InternalComInterfaceDispatch) #endif // FEATURE_COMWRAPPERS CDAC_TYPE_BEGIN(SyncTableEntry) CDAC_TYPE_SIZE(sizeof(SyncTableEntry)) -CDAC_TYPE_FIELD(SyncTableEntry, /*pointer*/, SyncBlock, offsetof(SyncTableEntry, m_SyncBlock)) -CDAC_TYPE_FIELD(SyncTableEntry, /*pointer*/, Object, offsetof(SyncTableEntry, m_Object)) +CDAC_TYPE_FIELD(SyncTableEntry, T_POINTER, SyncBlock, offsetof(SyncTableEntry, m_SyncBlock)) +CDAC_TYPE_FIELD(SyncTableEntry, T_POINTER, Object, offsetof(SyncTableEntry, m_Object)) CDAC_TYPE_END(SyncTableEntry) // Loader CDAC_TYPE_BEGIN(Module) CDAC_TYPE_INDETERMINATE(Module) -CDAC_TYPE_FIELD(Module, /*pointer*/, Assembly, cdac_data::Assembly) -CDAC_TYPE_FIELD(Module, /*pointer*/, PEAssembly, cdac_data::PEAssembly) -CDAC_TYPE_FIELD(Module, /*pointer*/, Base, cdac_data::Base) -CDAC_TYPE_FIELD(Module, /*uint32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(Module, /*pointer*/, LoaderAllocator, cdac_data::LoaderAllocator) -CDAC_TYPE_FIELD(Module, /*pointer*/, DynamicMetadata, cdac_data::DynamicMetadata) -CDAC_TYPE_FIELD(Module, /*pointer*/, SimpleName, cdac_data::SimpleName) -CDAC_TYPE_FIELD(Module, /*pointer*/, Path, cdac_data::Path) -CDAC_TYPE_FIELD(Module, /*pointer*/, FileName, cdac_data::FileName) -CDAC_TYPE_FIELD(Module, /*pointer*/, ReadyToRunInfo, cdac_data::ReadyToRunInfo) -CDAC_TYPE_FIELD(Module, /*pointer*/, GrowableSymbolStream, cdac_data::GrowableSymbolStream) -CDAC_TYPE_FIELD(Module, /*pointer*/, AvailableTypeParams, offsetof(Module, m_pAvailableParamTypes)) -CDAC_TYPE_FIELD(Module, /*pointer*/, InstMethodHashTable, offsetof(Module, m_pInstMethodHashTable)) - -CDAC_TYPE_FIELD(Module, /*pointer*/, FieldDefToDescMap, cdac_data::FieldDefToDescMap) -CDAC_TYPE_FIELD(Module, /*pointer*/, ManifestModuleReferencesMap, cdac_data::ManifestModuleReferencesMap) -CDAC_TYPE_FIELD(Module, /*pointer*/, MemberRefToDescMap, cdac_data::MemberRefToDescMap) -CDAC_TYPE_FIELD(Module, /*pointer*/, MethodDefToDescMap, cdac_data::MethodDefToDescMap) -CDAC_TYPE_FIELD(Module, /*pointer*/, TypeDefToMethodTableMap, cdac_data::TypeDefToMethodTableMap) -CDAC_TYPE_FIELD(Module, /*pointer*/, TypeRefToMethodTableMap, cdac_data::TypeRefToMethodTableMap) +CDAC_TYPE_FIELD(Module, T_POINTER, Assembly, cdac_data::Assembly) +CDAC_TYPE_FIELD(Module, T_POINTER, PEAssembly, cdac_data::PEAssembly) +CDAC_TYPE_FIELD(Module, T_POINTER, Base, cdac_data::Base) +CDAC_TYPE_FIELD(Module, T_UINT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(Module, T_POINTER, LoaderAllocator, cdac_data::LoaderAllocator) +CDAC_TYPE_FIELD(Module, T_POINTER, DynamicMetadata, cdac_data::DynamicMetadata) +CDAC_TYPE_FIELD(Module, T_POINTER, SimpleName, cdac_data::SimpleName) +CDAC_TYPE_FIELD(Module, T_POINTER, Path, cdac_data::Path) +CDAC_TYPE_FIELD(Module, T_POINTER, FileName, cdac_data::FileName) +CDAC_TYPE_FIELD(Module, T_POINTER, ReadyToRunInfo, cdac_data::ReadyToRunInfo) +CDAC_TYPE_FIELD(Module, T_POINTER, GrowableSymbolStream, cdac_data::GrowableSymbolStream) +CDAC_TYPE_FIELD(Module, T_POINTER, AvailableTypeParams, offsetof(Module, m_pAvailableParamTypes)) +CDAC_TYPE_FIELD(Module, T_POINTER, InstMethodHashTable, offsetof(Module, m_pInstMethodHashTable)) + +CDAC_TYPE_FIELD(Module, T_POINTER, FieldDefToDescMap, cdac_data::FieldDefToDescMap) +CDAC_TYPE_FIELD(Module, T_POINTER, ManifestModuleReferencesMap, cdac_data::ManifestModuleReferencesMap) +CDAC_TYPE_FIELD(Module, T_POINTER, MemberRefToDescMap, cdac_data::MemberRefToDescMap) +CDAC_TYPE_FIELD(Module, T_POINTER, MethodDefToDescMap, cdac_data::MethodDefToDescMap) +CDAC_TYPE_FIELD(Module, T_POINTER, TypeDefToMethodTableMap, cdac_data::TypeDefToMethodTableMap) +CDAC_TYPE_FIELD(Module, T_POINTER, TypeRefToMethodTableMap, cdac_data::TypeRefToMethodTableMap) #ifdef FEATURE_CODE_VERSIONING -CDAC_TYPE_FIELD(Module, /*pointer*/, MethodDefToILCodeVersioningStateMap, cdac_data::MethodDefToILCodeVersioningStateMap) +CDAC_TYPE_FIELD(Module, T_POINTER, MethodDefToILCodeVersioningStateMap, cdac_data::MethodDefToILCodeVersioningStateMap) #endif // FEATURE_CODE_VERSIONING -CDAC_TYPE_FIELD(Module, /*pointer*/, DynamicILBlobTable, cdac_data::DynamicILBlobTable) +CDAC_TYPE_FIELD(Module, T_POINTER, DynamicILBlobTable, cdac_data::DynamicILBlobTable) CDAC_TYPE_END(Module) CDAC_TYPE_BEGIN(ModuleLookupMap) -CDAC_TYPE_FIELD(ModuleLookupMap, /*pointer*/, TableData, offsetof(LookupMapBase, pTable)) -CDAC_TYPE_FIELD(ModuleLookupMap, /*pointer*/, Next, offsetof(LookupMapBase, pNext)) -CDAC_TYPE_FIELD(ModuleLookupMap, /*uint32*/, Count, offsetof(LookupMapBase, dwCount)) -CDAC_TYPE_FIELD(ModuleLookupMap, /*nuint*/, SupportedFlagsMask, offsetof(LookupMapBase, supportedFlags)) +CDAC_TYPE_FIELD(ModuleLookupMap, T_POINTER, TableData, offsetof(LookupMapBase, pTable)) +CDAC_TYPE_FIELD(ModuleLookupMap, T_POINTER, Next, offsetof(LookupMapBase, pNext)) +CDAC_TYPE_FIELD(ModuleLookupMap, T_UINT32, Count, offsetof(LookupMapBase, dwCount)) +CDAC_TYPE_FIELD(ModuleLookupMap, T_NUINT, SupportedFlagsMask, offsetof(LookupMapBase, supportedFlags)) CDAC_TYPE_END(ModuleLookupMap) CDAC_TYPE_BEGIN(Assembly) CDAC_TYPE_INDETERMINATE(Assembly) #ifdef FEATURE_COLLECTIBLE_TYPES -CDAC_TYPE_FIELD(Assembly, /*uint8*/, IsCollectible, cdac_data::IsCollectible) +CDAC_TYPE_FIELD(Assembly, T_UINT8, IsCollectible, cdac_data::IsCollectible) #endif -CDAC_TYPE_FIELD(Assembly, /*bool*/, IsDynamic, cdac_data::IsDynamic) -CDAC_TYPE_FIELD(Assembly, /*pointer*/, Module, cdac_data::Module) -CDAC_TYPE_FIELD(Assembly, /*pointer*/, Error, cdac_data::Error) -CDAC_TYPE_FIELD(Assembly, /*uint32*/, NotifyFlags, cdac_data::NotifyFlags) -CDAC_TYPE_FIELD(Assembly, /*bool*/, IsLoaded, cdac_data::IsLoaded) +CDAC_TYPE_FIELD(Assembly, T_BOOL, IsDynamic, cdac_data::IsDynamic) +CDAC_TYPE_FIELD(Assembly, T_POINTER, Module, cdac_data::Module) +CDAC_TYPE_FIELD(Assembly, T_POINTER, Error, cdac_data::Error) +CDAC_TYPE_FIELD(Assembly, T_UINT32, NotifyFlags, cdac_data::NotifyFlags) +CDAC_TYPE_FIELD(Assembly, T_BOOL, IsLoaded, cdac_data::IsLoaded) CDAC_TYPE_END(Assembly) CDAC_TYPE_BEGIN(LoaderAllocator) CDAC_TYPE_INDETERMINATE(LoaderAllocator) -CDAC_TYPE_FIELD(LoaderAllocator, /*uint32*/, ReferenceCount, cdac_data::ReferenceCount) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, HighFrequencyHeap, cdac_data::HighFrequencyHeap) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, LowFrequencyHeap, cdac_data::LowFrequencyHeap) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, StaticsHeap, cdac_data::StaticsHeap) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, StubHeap, cdac_data::StubHeap) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, ExecutableHeap, cdac_data::ExecutableHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_UINT32, ReferenceCount, cdac_data::ReferenceCount) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, HighFrequencyHeap, cdac_data::HighFrequencyHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, LowFrequencyHeap, cdac_data::LowFrequencyHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, StaticsHeap, cdac_data::StaticsHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, StubHeap, cdac_data::StubHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, ExecutableHeap, cdac_data::ExecutableHeap) #ifdef HAS_FIXUP_PRECODE -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, FixupPrecodeHeap, cdac_data::FixupPrecodeHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, FixupPrecodeHeap, cdac_data::FixupPrecodeHeap) #endif // HAS_FIXUP_PRECODE #ifndef FEATURE_PORTABLE_ENTRYPOINTS -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, NewStubPrecodeHeap, cdac_data::NewStubPrecodeHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, NewStubPrecodeHeap, cdac_data::NewStubPrecodeHeap) #endif // !FEATURE_PORTABLE_ENTRYPOINTS #if defined(FEATURE_READYTORUN) && defined(FEATURE_STUBPRECODE_DYNAMIC_HELPERS) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, DynamicHelpersStubHeap, cdac_data::DynamicHelpersStubHeap) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, DynamicHelpersStubHeap, cdac_data::DynamicHelpersStubHeap) #endif // defined(FEATURE_READYTORUN) && defined(FEATURE_STUBPRECODE_DYNAMIC_HELPERS) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, VirtualCallStubManager, cdac_data::VirtualCallStubManager) -CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, ObjectHandle, cdac_data::ObjectHandle) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, VirtualCallStubManager, cdac_data::VirtualCallStubManager) +CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, ObjectHandle, cdac_data::ObjectHandle) CDAC_TYPE_END(LoaderAllocator) CDAC_TYPE_BEGIN(VirtualCallStubManager) CDAC_TYPE_INDETERMINATE(VirtualCallStubManager) -CDAC_TYPE_FIELD(VirtualCallStubManager, /*pointer*/, IndcellHeap, cdac_data::IndcellHeap) +CDAC_TYPE_FIELD(VirtualCallStubManager, T_POINTER, IndcellHeap, cdac_data::IndcellHeap) #ifdef FEATURE_VIRTUAL_STUB_DISPATCH -CDAC_TYPE_FIELD(VirtualCallStubManager, /*pointer*/, CacheEntryHeap, cdac_data::CacheEntryHeap) +CDAC_TYPE_FIELD(VirtualCallStubManager, T_POINTER, CacheEntryHeap, cdac_data::CacheEntryHeap) #endif // FEATURE_VIRTUAL_STUB_DISPATCH CDAC_TYPE_END(VirtualCallStubManager) CDAC_TYPE_BEGIN(PEAssembly) CDAC_TYPE_INDETERMINATE(PEAssembly) -CDAC_TYPE_FIELD(PEAssembly, /*pointer*/, PEImage, cdac_data::PEImage) -CDAC_TYPE_FIELD(PEAssembly, /*pointer*/, AssemblyBinder, cdac_data::AssemblyBinder) +CDAC_TYPE_FIELD(PEAssembly, T_POINTER, PEImage, cdac_data::PEImage) +CDAC_TYPE_FIELD(PEAssembly, T_POINTER, AssemblyBinder, cdac_data::AssemblyBinder) CDAC_TYPE_END(PEAssembly) CDAC_TYPE_BEGIN(AssemblyBinder) CDAC_TYPE_INDETERMINATE(AssemblyBinder) -CDAC_TYPE_FIELD(AssemblyBinder, /*pointer*/, AssemblyLoadContext, cdac_data::AssemblyLoadContext) +CDAC_TYPE_FIELD(AssemblyBinder, T_POINTER, AssemblyLoadContext, cdac_data::AssemblyLoadContext) CDAC_TYPE_END(AssemblyBinder) CDAC_TYPE_BEGIN(PEImage) CDAC_TYPE_INDETERMINATE(PEImage) -CDAC_TYPE_FIELD(PEImage, /*pointer*/, LoadedImageLayout, cdac_data::LoadedImageLayout) -CDAC_TYPE_FIELD(PEImage, /*ProbeExtensionResult*/, ProbeExtensionResult, cdac_data::ProbeExtensionResult) +CDAC_TYPE_FIELD(PEImage, T_POINTER, LoadedImageLayout, cdac_data::LoadedImageLayout) +CDAC_TYPE_FIELD(PEImage, TYPE(ProbeExtensionResult), ProbeExtensionResult, cdac_data::ProbeExtensionResult) CDAC_TYPE_END(PEImage) CDAC_TYPE_BEGIN(PEImageLayout) -CDAC_TYPE_FIELD(PEImageLayout, /*pointer*/, Base, cdac_data::Base) -CDAC_TYPE_FIELD(PEImageLayout, /*uint32*/, Size, cdac_data::Size) -CDAC_TYPE_FIELD(PEImageLayout, /*uint32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(PEImageLayout, /*uint32*/, Format, cdac_data::Format) +CDAC_TYPE_FIELD(PEImageLayout, T_POINTER, Base, cdac_data::Base) +CDAC_TYPE_FIELD(PEImageLayout, T_UINT32, Size, cdac_data::Size) +CDAC_TYPE_FIELD(PEImageLayout, T_UINT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(PEImageLayout, T_UINT32, Format, cdac_data::Format) CDAC_TYPE_END(PEImageLayout) CDAC_TYPE_BEGIN(CGrowableSymbolStream) CDAC_TYPE_INDETERMINATE(CGrowableSymbolStream) -CDAC_TYPE_FIELD(CGrowableSymbolStream, /*pointer*/, Buffer, cdac_data::Buffer) -CDAC_TYPE_FIELD(CGrowableSymbolStream, /*uint32*/, Size, cdac_data::Size) +CDAC_TYPE_FIELD(CGrowableSymbolStream, T_POINTER, Buffer, cdac_data::Buffer) +CDAC_TYPE_FIELD(CGrowableSymbolStream, T_UINT32, Size, cdac_data::Size) CDAC_TYPE_END(CGrowableSymbolStream) CDAC_TYPE_BEGIN(ProbeExtensionResult) CDAC_TYPE_INDETERMINATE(ProbeExtensionResult) -CDAC_TYPE_FIELD(ProbeExtensionResult, /*int32*/, Type, offsetof(ProbeExtensionResult, Type)) +CDAC_TYPE_FIELD(ProbeExtensionResult, T_INT32, Type, offsetof(ProbeExtensionResult, Type)) CDAC_TYPE_END(ProbeExtensionResult) CDAC_TYPE_BEGIN(AppDomain) CDAC_TYPE_INDETERMINATE(AppDomain) -CDAC_TYPE_FIELD(AppDomain, /*pointer*/, RootAssembly, cdac_data::RootAssembly) -CDAC_TYPE_FIELD(AppDomain, /*DomainAssemblyList*/, DomainAssemblyList, cdac_data::DomainAssemblyList) -CDAC_TYPE_FIELD(AppDomain, /*pointer*/, FriendlyName, cdac_data::FriendlyName) +CDAC_TYPE_FIELD(AppDomain, T_POINTER, RootAssembly, cdac_data::RootAssembly) +CDAC_TYPE_FIELD(AppDomain, TYPE(ArrayListBase), DomainAssemblyList, cdac_data::DomainAssemblyList) +CDAC_TYPE_FIELD(AppDomain, T_POINTER, FriendlyName, cdac_data::FriendlyName) CDAC_TYPE_END(AppDomain) CDAC_TYPE_BEGIN(SystemDomain) CDAC_TYPE_INDETERMINATE(SystemDomain) -CDAC_TYPE_FIELD(SystemDomain, /*GlobalLoaderAllocator*/, GlobalLoaderAllocator, cdac_data::GlobalLoaderAllocator) -CDAC_TYPE_FIELD(SystemDomain, /*pointer*/, SystemAssembly, cdac_data::SystemAssembly) +CDAC_TYPE_FIELD(SystemDomain, TYPE(LoaderAllocator), GlobalLoaderAllocator, cdac_data::GlobalLoaderAllocator) +CDAC_TYPE_FIELD(SystemDomain, T_POINTER, SystemAssembly, cdac_data::SystemAssembly) CDAC_TYPE_END(SystemDomain) CDAC_TYPE_BEGIN(ArrayListBase) CDAC_TYPE_INDETERMINATE(ArrayListBase) -CDAC_TYPE_FIELD(ArrayListBase, /*uint32*/, Count, cdac_data::Count) -CDAC_TYPE_FIELD(ArrayListBase, /*pointer*/, FirstBlock, cdac_data::FirstBlock) +CDAC_TYPE_FIELD(ArrayListBase, T_UINT32, Count, cdac_data::Count) +CDAC_TYPE_FIELD(ArrayListBase, T_POINTER, FirstBlock, cdac_data::FirstBlock) CDAC_TYPE_END(ArrayListBase) CDAC_TYPE_BEGIN(ArrayListBlock) CDAC_TYPE_INDETERMINATE(ArrayListBlock) -CDAC_TYPE_FIELD(ArrayListBlock, /*pointer*/, Next, cdac_data::Next) -CDAC_TYPE_FIELD(ArrayListBlock, /*uint32*/, Size, cdac_data::Size) -CDAC_TYPE_FIELD(ArrayListBlock, /*pointer*/, ArrayStart, cdac_data::ArrayStart) +CDAC_TYPE_FIELD(ArrayListBlock, T_POINTER, Next, cdac_data::Next) +CDAC_TYPE_FIELD(ArrayListBlock, T_UINT32, Size, cdac_data::Size) +CDAC_TYPE_FIELD(ArrayListBlock, T_POINTER, ArrayStart, cdac_data::ArrayStart) CDAC_TYPE_END(ArrayListBlock) // RuntimeTypeSystem CDAC_TYPE_BEGIN(MethodTable) CDAC_TYPE_SIZE(sizeof(MethodTable)) -CDAC_TYPE_FIELD(MethodTable, /*uint32*/, MTFlags, cdac_data::MTFlags) -CDAC_TYPE_FIELD(MethodTable, /*uint32*/, BaseSize, cdac_data::BaseSize) -CDAC_TYPE_FIELD(MethodTable, /*uint32*/, MTFlags2, cdac_data::MTFlags2) -CDAC_TYPE_FIELD(MethodTable, /*nuint*/, EEClassOrCanonMT, cdac_data::EEClassOrCanonMT) -CDAC_TYPE_FIELD(MethodTable, /*pointer*/, Module, cdac_data::Module) -CDAC_TYPE_FIELD(MethodTable, /*pointer*/, ParentMethodTable, cdac_data::ParentMethodTable) -CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumInterfaces, cdac_data::NumInterfaces) -CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumVirtuals, cdac_data::NumVirtuals) -CDAC_TYPE_FIELD(MethodTable, /*pointer*/, PerInstInfo, cdac_data::PerInstInfo) -CDAC_TYPE_FIELD(MethodTable, /*pointer*/, AuxiliaryData, cdac_data::AuxiliaryData) +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, Module, cdac_data::Module) +CDAC_TYPE_FIELD(MethodTable, T_POINTER, ParentMethodTable, cdac_data::ParentMethodTable) +CDAC_TYPE_FIELD(MethodTable, T_UINT16, NumInterfaces, cdac_data::NumInterfaces) +CDAC_TYPE_FIELD(MethodTable, T_UINT16, NumVirtuals, cdac_data::NumVirtuals) +CDAC_TYPE_FIELD(MethodTable, T_POINTER, PerInstInfo, cdac_data::PerInstInfo) +CDAC_TYPE_FIELD(MethodTable, T_POINTER, AuxiliaryData, cdac_data::AuxiliaryData) CDAC_TYPE_END(MethodTable) CDAC_TYPE_BEGIN(DynamicStaticsInfo) CDAC_TYPE_SIZE(sizeof(DynamicStaticsInfo)) -CDAC_TYPE_FIELD(DynamicStaticsInfo, /*uint32*/, GCStatics, offsetof(DynamicStaticsInfo, m_pGCStatics)) -CDAC_TYPE_FIELD(DynamicStaticsInfo, /*uint32*/, NonGCStatics, offsetof(DynamicStaticsInfo, m_pNonGCStatics)) +CDAC_TYPE_FIELD(DynamicStaticsInfo, T_UINT32, GCStatics, offsetof(DynamicStaticsInfo, m_pGCStatics)) +CDAC_TYPE_FIELD(DynamicStaticsInfo, T_UINT32, NonGCStatics, offsetof(DynamicStaticsInfo, m_pNonGCStatics)) CDAC_TYPE_END(DynamicStaticsInfo) CDAC_TYPE_BEGIN(MethodTableAuxiliaryData) CDAC_TYPE_INDETERMINATE(MethodTableAuxiliaryData) -CDAC_TYPE_FIELD(MethodTableAuxiliaryData, /*pointer*/, LoaderModule, offsetof(MethodTableAuxiliaryData, m_pLoaderModule)) -CDAC_TYPE_FIELD(MethodTableAuxiliaryData, /*int16*/, OffsetToNonVirtualSlots, offsetof(MethodTableAuxiliaryData, m_offsetToNonVirtualSlots)) -CDAC_TYPE_FIELD(MethodTableAuxiliaryData, /*uint32*/, Flags, offsetof(MethodTableAuxiliaryData, m_dwFlags)) +CDAC_TYPE_FIELD(MethodTableAuxiliaryData, T_POINTER, LoaderModule, offsetof(MethodTableAuxiliaryData, m_pLoaderModule)) +CDAC_TYPE_FIELD(MethodTableAuxiliaryData, T_INT16, OffsetToNonVirtualSlots, offsetof(MethodTableAuxiliaryData, m_offsetToNonVirtualSlots)) +CDAC_TYPE_FIELD(MethodTableAuxiliaryData, T_UINT32, Flags, offsetof(MethodTableAuxiliaryData, m_dwFlags)) CDAC_TYPE_END(MethodTableAuxiliaryData) CDAC_TYPE_BEGIN(EEClass) CDAC_TYPE_INDETERMINATE(EEClass) -CDAC_TYPE_FIELD(EEClass, /*pointer*/, MethodTable, cdac_data::MethodTable) -CDAC_TYPE_FIELD(EEClass, /*pointer*/, MethodDescChunk, cdac_data::MethodDescChunk) -CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumMethods, cdac_data::NumMethods) -CDAC_TYPE_FIELD(EEClass, /*pointer*/, FieldDescList, cdac_data::FieldDescList) -CDAC_TYPE_FIELD(EEClass, /*uint32*/, CorTypeAttr, cdac_data::CorTypeAttr) -CDAC_TYPE_FIELD(EEClass, /*uint8*/, InternalCorElementType, cdac_data::InternalCorElementType) -CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumInstanceFields, cdac_data::NumInstanceFields) -CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumStaticFields, cdac_data::NumStaticFields) -CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumThreadStaticFields, cdac_data::NumThreadStaticFields) -CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumNonVirtualSlots, cdac_data::NumNonVirtualSlots) +CDAC_TYPE_FIELD(EEClass, T_POINTER, MethodTable, cdac_data::MethodTable) +CDAC_TYPE_FIELD(EEClass, T_POINTER, MethodDescChunk, cdac_data::MethodDescChunk) +CDAC_TYPE_FIELD(EEClass, T_UINT16, NumMethods, cdac_data::NumMethods) +CDAC_TYPE_FIELD(EEClass, T_POINTER, FieldDescList, cdac_data::FieldDescList) +CDAC_TYPE_FIELD(EEClass, T_UINT32, CorTypeAttr, cdac_data::CorTypeAttr) +CDAC_TYPE_FIELD(EEClass, T_UINT8, InternalCorElementType, cdac_data::InternalCorElementType) +CDAC_TYPE_FIELD(EEClass, T_UINT16, NumInstanceFields, cdac_data::NumInstanceFields) +CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data::NumStaticFields) +CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data::NumThreadStaticFields) +CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data::NumNonVirtualSlots) CDAC_TYPE_END(EEClass) CDAC_TYPE_BEGIN(GenericsDictInfo) CDAC_TYPE_INDETERMINATE(GenericsDictInfo) -CDAC_TYPE_FIELD(GenericsDictInfo, /*uint16*/, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts)) -CDAC_TYPE_FIELD(GenericsDictInfo, /*uint16*/, NumTypeArgs, offsetof(GenericsDictInfo, m_wNumTyPars)) +CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts)) +CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumTypeArgs, offsetof(GenericsDictInfo, m_wNumTyPars)) CDAC_TYPE_END(GenericsDictInfo) CDAC_TYPE_BEGIN(TypeDesc) CDAC_TYPE_INDETERMINATE(TypeDesc) -CDAC_TYPE_FIELD(TypeDesc, /*uint32*/, TypeAndFlags, cdac_data::TypeAndFlags) +CDAC_TYPE_FIELD(TypeDesc, T_UINT32, TypeAndFlags, cdac_data::TypeAndFlags) CDAC_TYPE_END(TypeDesc) CDAC_TYPE_BEGIN(FieldDesc) CDAC_TYPE_SIZE(sizeof(FieldDesc)) -CDAC_TYPE_FIELD(FieldDesc, /*uint32*/, DWord1, cdac_data::DWord1) -CDAC_TYPE_FIELD(FieldDesc, /*uint32*/, DWord2, cdac_data::DWord2) -CDAC_TYPE_FIELD(FieldDesc, /*pointer*/, MTOfEnclosingClass, cdac_data::MTOfEnclosingClass) +CDAC_TYPE_FIELD(FieldDesc, T_UINT32, DWord1, cdac_data::DWord1) +CDAC_TYPE_FIELD(FieldDesc, T_UINT32, DWord2, cdac_data::DWord2) +CDAC_TYPE_FIELD(FieldDesc, T_POINTER, MTOfEnclosingClass, cdac_data::MTOfEnclosingClass) CDAC_TYPE_END(FieldDesc) CDAC_TYPE_BEGIN(ParamTypeDesc) CDAC_TYPE_INDETERMINATE(ParamTypeDesc) -CDAC_TYPE_FIELD(ParamTypeDesc, /*pointer*/, TypeArg, cdac_data::TypeArg) +CDAC_TYPE_FIELD(ParamTypeDesc, T_POINTER, TypeArg, cdac_data::TypeArg) CDAC_TYPE_END(ParamTypeDesc) CDAC_TYPE_BEGIN(TypeVarTypeDesc) CDAC_TYPE_INDETERMINATE(TypeVarTypeDesc) -CDAC_TYPE_FIELD(TypeVarTypeDesc, /*pointer*/, Module, cdac_data::Module) -CDAC_TYPE_FIELD(TypeVarTypeDesc, /*uint32*/, Token, cdac_data::Token) +CDAC_TYPE_FIELD(TypeVarTypeDesc, T_POINTER, Module, cdac_data::Module) +CDAC_TYPE_FIELD(TypeVarTypeDesc, T_UINT32, Token, cdac_data::Token) CDAC_TYPE_END(TypeVarTypeDesc) CDAC_TYPE_BEGIN(FnPtrTypeDesc) CDAC_TYPE_INDETERMINATE(FnPtrTypeDesc) -CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, NumArgs, cdac_data::NumArgs) -CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, CallConv, cdac_data::CallConv) -CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, RetAndArgTypes, cdac_data::RetAndArgTypes) -CDAC_TYPE_FIELD(FnPtrTypeDesc, /*pointer*/, LoaderModule, cdac_data::LoaderModule) +CDAC_TYPE_FIELD(FnPtrTypeDesc, T_UINT32, NumArgs, cdac_data::NumArgs) +CDAC_TYPE_FIELD(FnPtrTypeDesc, T_UINT32, CallConv, cdac_data::CallConv) +CDAC_TYPE_FIELD(FnPtrTypeDesc, T_UINT32, RetAndArgTypes, cdac_data::RetAndArgTypes) +CDAC_TYPE_FIELD(FnPtrTypeDesc, T_POINTER, LoaderModule, cdac_data::LoaderModule) CDAC_TYPE_END(FnPtrTypeDesc) CDAC_TYPE_BEGIN(DynamicMetadata) -CDAC_TYPE_FIELD(DynamicMetadata, /*uint32*/, Size, cdac_data::Size) -CDAC_TYPE_FIELD(DynamicMetadata, /*inline byte array*/, Data, cdac_data::Data) +CDAC_TYPE_FIELD(DynamicMetadata, T_UINT32, Size, cdac_data::Size) +CDAC_TYPE_FIELD(DynamicMetadata, T_ARRAY(T_UINT8), Data, cdac_data::Data) CDAC_TYPE_END(DynamicMetadata) #ifdef STRESS_LOG CDAC_TYPE_BEGIN(StressLog) CDAC_TYPE_SIZE(sizeof(StressLog)) -CDAC_TYPE_FIELD(StressLog, /* uint32 */, LoggedFacilities, cdac_offsets::facilitiesToLog) -CDAC_TYPE_FIELD(StressLog, /* uint32 */, Level, cdac_offsets::levelToLog) -CDAC_TYPE_FIELD(StressLog, /* uint32 */, MaxSizePerThread, cdac_offsets::MaxSizePerThread) -CDAC_TYPE_FIELD(StressLog, /* uint32 */, MaxSizeTotal, cdac_offsets::MaxSizeTotal) -CDAC_TYPE_FIELD(StressLog, /* uint32 */, TotalChunks, cdac_offsets::totalChunk) -CDAC_TYPE_FIELD(StressLog, /* pointer */, Logs, cdac_offsets::logs) -CDAC_TYPE_FIELD(StressLog, /* uint64 */, TickFrequency, cdac_offsets::tickFrequency) -CDAC_TYPE_FIELD(StressLog, /* uint64 */, StartTimestamp, cdac_offsets::startTimeStamp) -CDAC_TYPE_FIELD(StressLog, /* nuint */, ModuleOffset, cdac_offsets::moduleOffset) -CDAC_TYPE_FIELD(StressLog, /* StressLogModuleDesc[] */, Modules, cdac_offsets::modules) +CDAC_TYPE_FIELD(StressLog, T_UINT32, LoggedFacilities, cdac_offsets::facilitiesToLog) +CDAC_TYPE_FIELD(StressLog, T_UINT32, Level, cdac_offsets::levelToLog) +CDAC_TYPE_FIELD(StressLog, T_UINT32, MaxSizePerThread, cdac_offsets::MaxSizePerThread) +CDAC_TYPE_FIELD(StressLog, T_UINT32, MaxSizeTotal, cdac_offsets::MaxSizeTotal) +CDAC_TYPE_FIELD(StressLog, T_UINT32, TotalChunks, cdac_offsets::totalChunk) +CDAC_TYPE_FIELD(StressLog, T_POINTER, Logs, cdac_offsets::logs) +CDAC_TYPE_FIELD(StressLog, T_UINT64, TickFrequency, cdac_offsets::tickFrequency) +CDAC_TYPE_FIELD(StressLog, T_UINT64, StartTimestamp, cdac_offsets::startTimeStamp) +CDAC_TYPE_FIELD(StressLog, T_NUINT, ModuleOffset, cdac_offsets::moduleOffset) +CDAC_TYPE_FIELD(StressLog, T_ARRAY(TYPE(StressLogModuleDesc)), Modules, cdac_offsets::modules) CDAC_TYPE_END(StressLog) CDAC_TYPE_BEGIN(StressLogModuleDesc) CDAC_TYPE_SIZE(cdac_offsets::ModuleDesc::type_size) -CDAC_TYPE_FIELD(StressLogModuleDesc, pointer, BaseAddress, cdac_offsets::ModuleDesc::baseAddress) -CDAC_TYPE_FIELD(StressLogModuleDesc, nuint, Size, cdac_offsets::ModuleDesc::size) +CDAC_TYPE_FIELD(StressLogModuleDesc, T_POINTER, BaseAddress, cdac_offsets::ModuleDesc::baseAddress) +CDAC_TYPE_FIELD(StressLogModuleDesc, T_NUINT, Size, cdac_offsets::ModuleDesc::size) CDAC_TYPE_END(StressLogModuleDesc) CDAC_TYPE_BEGIN(ThreadStressLog) CDAC_TYPE_INDETERMINATE(ThreadStressLog) -CDAC_TYPE_FIELD(ThreadStressLog, /* pointer */, Next, cdac_offsets::next) -CDAC_TYPE_FIELD(ThreadStressLog, uint64, ThreadId, cdac_offsets::threadId) -CDAC_TYPE_FIELD(ThreadStressLog, uint8, WriteHasWrapped, cdac_offsets::writeHasWrapped) -CDAC_TYPE_FIELD(ThreadStressLog, pointer, CurrentPtr, cdac_offsets::curPtr) -CDAC_TYPE_FIELD(ThreadStressLog, /* pointer */, ChunkListHead, cdac_offsets::chunkListHead) -CDAC_TYPE_FIELD(ThreadStressLog, /* pointer */, ChunkListTail, cdac_offsets::chunkListTail) -CDAC_TYPE_FIELD(ThreadStressLog, /* pointer */, CurrentWriteChunk, cdac_offsets::curWriteChunk) +CDAC_TYPE_FIELD(ThreadStressLog, T_POINTER, Next, cdac_offsets::next) +CDAC_TYPE_FIELD(ThreadStressLog, T_UINT64, ThreadId, cdac_offsets::threadId) +CDAC_TYPE_FIELD(ThreadStressLog, T_UINT8, WriteHasWrapped, cdac_offsets::writeHasWrapped) +CDAC_TYPE_FIELD(ThreadStressLog, T_POINTER, CurrentPtr, cdac_offsets::curPtr) +CDAC_TYPE_FIELD(ThreadStressLog, T_POINTER, ChunkListHead, cdac_offsets::chunkListHead) +CDAC_TYPE_FIELD(ThreadStressLog, T_POINTER, ChunkListTail, cdac_offsets::chunkListTail) +CDAC_TYPE_FIELD(ThreadStressLog, T_POINTER, CurrentWriteChunk, cdac_offsets::curWriteChunk) CDAC_TYPE_END(ThreadStressLog) CDAC_TYPE_BEGIN(StressLogChunk) CDAC_TYPE_SIZE(sizeof(StressLogChunk)) -CDAC_TYPE_FIELD(StressLogChunk, /* pointer */, Prev, offsetof(StressLogChunk, prev)) -CDAC_TYPE_FIELD(StressLogChunk, /* pointer */, Next, offsetof(StressLogChunk, next)) -CDAC_TYPE_FIELD(StressLogChunk, /* uint8[STRESSLOG_CHUNK_SIZE] */, Buf, offsetof(StressLogChunk, buf)) -CDAC_TYPE_FIELD(StressLogChunk, /* uint32 */, Sig1, offsetof(StressLogChunk, dwSig1)) -CDAC_TYPE_FIELD(StressLogChunk, /* uint32 */, Sig2, offsetof(StressLogChunk, dwSig2)) +CDAC_TYPE_FIELD(StressLogChunk, T_POINTER, Prev, offsetof(StressLogChunk, prev)) +CDAC_TYPE_FIELD(StressLogChunk, T_POINTER, Next, offsetof(StressLogChunk, next)) +CDAC_TYPE_FIELD(StressLogChunk, T_ARRAY(T_UINT8), Buf, offsetof(StressLogChunk, buf)) +CDAC_TYPE_FIELD(StressLogChunk, T_UINT32, Sig1, offsetof(StressLogChunk, dwSig1)) +CDAC_TYPE_FIELD(StressLogChunk, T_UINT32, Sig2, offsetof(StressLogChunk, dwSig2)) CDAC_TYPE_END(StressLogChunk) // The StressMsg Header is the fixed size portion of the StressMsg @@ -500,31 +500,31 @@ CDAC_TYPE_END(StressMsgHeader) CDAC_TYPE_BEGIN(StressMsg) CDAC_TYPE_INDETERMINATE(StressMsg) -CDAC_TYPE_FIELD(StressMsg, StressMsgHeader, Header, 0) -CDAC_TYPE_FIELD(StressMsg, /* pointer */, Args, offsetof(StressMsg, args)) +CDAC_TYPE_FIELD(StressMsg, TYPE(StressMsgHeader), Header, 0) +CDAC_TYPE_FIELD(StressMsg, T_POINTER, Args, offsetof(StressMsg, args)) CDAC_TYPE_END(StressMsg) #endif CDAC_TYPE_BEGIN(MethodDesc) CDAC_TYPE_SIZE(sizeof(MethodDesc)) -CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, ChunkIndex, cdac_data::ChunkIndex) -CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Slot, cdac_data::Slot) -CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags3AndTokenRemainder, cdac_data::Flags3AndTokenRemainder) -CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, EntryPointFlags, cdac_data::EntryPointFlags) -CDAC_TYPE_FIELD(MethodDesc, /*pointer*/, CodeData, cdac_data::CodeData) +CDAC_TYPE_FIELD(MethodDesc, T_UINT8, ChunkIndex, cdac_data::ChunkIndex) +CDAC_TYPE_FIELD(MethodDesc, T_UINT16, Slot, cdac_data::Slot) +CDAC_TYPE_FIELD(MethodDesc, T_UINT16, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(MethodDesc, T_UINT16, Flags3AndTokenRemainder, cdac_data::Flags3AndTokenRemainder) +CDAC_TYPE_FIELD(MethodDesc, T_UINT8, EntryPointFlags, cdac_data::EntryPointFlags) +CDAC_TYPE_FIELD(MethodDesc, T_POINTER, CodeData, cdac_data::CodeData) #ifdef HAVE_GCCOVER -CDAC_TYPE_FIELD(MethodDesc, /*pointer*/, GCCoverageInfo, offsetof(MethodDesc, m_GcCover)) +CDAC_TYPE_FIELD(MethodDesc, T_POINTER, GCCoverageInfo, offsetof(MethodDesc, m_GcCover)) #endif // HAVE_GCCOVER CDAC_TYPE_END(MethodDesc) CDAC_TYPE_BEGIN(MethodDescChunk) CDAC_TYPE_SIZE(sizeof(MethodDescChunk)) -CDAC_TYPE_FIELD(MethodDescChunk, /*pointer*/, MethodTable, cdac_data::MethodTable) -CDAC_TYPE_FIELD(MethodDescChunk, /*pointer*/, Next, cdac_data::Next) -CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Size, cdac_data::Size) -CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Count, cdac_data::Count) -CDAC_TYPE_FIELD(MethodDescChunk, /*uint16*/, FlagsAndTokenRange, cdac_data::FlagsAndTokenRange) +CDAC_TYPE_FIELD(MethodDescChunk, T_POINTER, MethodTable, cdac_data::MethodTable) +CDAC_TYPE_FIELD(MethodDescChunk, T_POINTER, Next, cdac_data::Next) +CDAC_TYPE_FIELD(MethodDescChunk, T_UINT8, Size, cdac_data::Size) +CDAC_TYPE_FIELD(MethodDescChunk, T_UINT8, Count, cdac_data::Count) +CDAC_TYPE_FIELD(MethodDescChunk, T_UINT16, FlagsAndTokenRange, cdac_data::FlagsAndTokenRange) CDAC_TYPE_END(MethodDescChunk) CDAC_TYPE_BEGIN(NonVtableSlot) @@ -545,21 +545,21 @@ CDAC_TYPE_END(AsyncMethodData) CDAC_TYPE_BEGIN(InstantiatedMethodDesc) CDAC_TYPE_SIZE(sizeof(InstantiatedMethodDesc)) -CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*pointer*/, PerInstInfo, cdac_data::PerInstInfo) -CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*uint16*/, Flags2, cdac_data::Flags2) -CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*uint16*/, NumGenericArgs, cdac_data::NumGenericArgs) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, T_POINTER, PerInstInfo, cdac_data::PerInstInfo) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, T_UINT16, Flags2, cdac_data::Flags2) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, T_UINT16, NumGenericArgs, cdac_data::NumGenericArgs) CDAC_TYPE_END(InstantiatedMethodDesc) CDAC_TYPE_BEGIN(StoredSigMethodDesc) CDAC_TYPE_INDETERMINATE(StoredSigMethodDesc) -CDAC_TYPE_FIELD(StoredSigMethodDesc, /*pointer*/, Sig, cdac_data::Sig) -CDAC_TYPE_FIELD(StoredSigMethodDesc, /*uint32*/, cSig, cdac_data::cSig) -CDAC_TYPE_FIELD(StoredSigMethodDesc, /*uint32*/, ExtendedFlags, cdac_data::ExtendedFlags) +CDAC_TYPE_FIELD(StoredSigMethodDesc, T_POINTER, Sig, cdac_data::Sig) +CDAC_TYPE_FIELD(StoredSigMethodDesc, T_UINT32, cSig, cdac_data::cSig) +CDAC_TYPE_FIELD(StoredSigMethodDesc, T_UINT32, ExtendedFlags, cdac_data::ExtendedFlags) CDAC_TYPE_END(StoredSigMethodDesc) CDAC_TYPE_BEGIN(DynamicMethodDesc) CDAC_TYPE_SIZE(sizeof(DynamicMethodDesc)) -CDAC_TYPE_FIELD(DynamicMethodDesc, /*pointer*/, MethodName, cdac_data::MethodName) +CDAC_TYPE_FIELD(DynamicMethodDesc, T_POINTER, MethodName, cdac_data::MethodName) CDAC_TYPE_END(DynamicMethodDesc) CDAC_TYPE_BEGIN(ArrayMethodDesc) @@ -591,350 +591,350 @@ CDAC_TYPE_END(CodePointer) #ifdef FEATURE_PORTABLE_ENTRYPOINTS CDAC_TYPE_BEGIN(PortableEntryPoint) CDAC_TYPE_INDETERMINATE(PortableEntryPoint) -CDAC_TYPE_FIELD(PortableEntryPoint, /*pointer*/, MethodDesc, cdac_data::MethodDesc) +CDAC_TYPE_FIELD(PortableEntryPoint, T_POINTER, MethodDesc, cdac_data::MethodDesc) CDAC_TYPE_END(PortableEntryPoint) #endif CDAC_TYPE_BEGIN(MethodDescCodeData) CDAC_TYPE_INDETERMINATE(MethodDescCodeData) -CDAC_TYPE_FIELD(MethodDescCodeData, /*CodePointer*/, TemporaryEntryPoint, offsetof(MethodDescCodeData,TemporaryEntryPoint)) +CDAC_TYPE_FIELD(MethodDescCodeData, TYPE(CodePointer), TemporaryEntryPoint, offsetof(MethodDescCodeData,TemporaryEntryPoint)) #ifdef FEATURE_CODE_VERSIONING -CDAC_TYPE_FIELD(MethodDescCodeData, /*pointer*/, VersioningState, offsetof(MethodDescCodeData,VersioningState)) +CDAC_TYPE_FIELD(MethodDescCodeData, T_POINTER, VersioningState, offsetof(MethodDescCodeData,VersioningState)) #endif // FEATURE_CODE_VERSIONING CDAC_TYPE_END(MethodDescCodeData) #ifdef FEATURE_CODE_VERSIONING CDAC_TYPE_BEGIN(MethodDescVersioningState) CDAC_TYPE_INDETERMINATE(MethodDescVersioningState) -CDAC_TYPE_FIELD(MethodDescVersioningState, /*pointer*/, NativeCodeVersionNode, cdac_data::NativeCodeVersionNode) -CDAC_TYPE_FIELD(MethodDescVersioningState, /*uint8*/, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(MethodDescVersioningState, T_POINTER, NativeCodeVersionNode, cdac_data::NativeCodeVersionNode) +CDAC_TYPE_FIELD(MethodDescVersioningState, T_UINT8, Flags, cdac_data::Flags) CDAC_TYPE_END(MethodDescVersioningState) #endif // FEATURE_CODE_VERSIONING #ifndef FEATURE_PORTABLE_ENTRYPOINTS CDAC_TYPE_BEGIN(PrecodeMachineDescriptor) CDAC_TYPE_INDETERMINATE(PrecodeMachineDescriptor) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, InvalidPrecodeType, offsetof(PrecodeMachineDescriptor, InvalidPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, InvalidPrecodeType, offsetof(PrecodeMachineDescriptor, InvalidPrecodeType)) #ifdef HAS_PINVOKE_IMPORT_PRECODE -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, PInvokeImportPrecodeType, offsetof(PrecodeMachineDescriptor, PInvokeImportPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, PInvokeImportPrecodeType, offsetof(PrecodeMachineDescriptor, PInvokeImportPrecodeType)) #endif // HAS_PINVOKE_IMPORT_PRECODE #ifdef HAS_FIXUP_PRECODE -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, FixupPrecodeType, offsetof(PrecodeMachineDescriptor, FixupPrecodeType)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, FixupCodeOffset, offsetof(PrecodeMachineDescriptor, FixupCodeOffset)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, FixupStubPrecodeSize, offsetof(PrecodeMachineDescriptor, FixupStubPrecodeSize)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*byte[]*/, FixupBytes, offsetof(PrecodeMachineDescriptor, FixupBytes)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*byte[]*/, FixupIgnoredBytes, offsetof(PrecodeMachineDescriptor, FixupIgnoredBytes)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, FixupPrecodeType, offsetof(PrecodeMachineDescriptor, FixupPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, FixupCodeOffset, offsetof(PrecodeMachineDescriptor, FixupCodeOffset)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, FixupStubPrecodeSize, offsetof(PrecodeMachineDescriptor, FixupStubPrecodeSize)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_ARRAY(T_UINT8), FixupBytes, offsetof(PrecodeMachineDescriptor, FixupBytes)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_ARRAY(T_UINT8), FixupIgnoredBytes, offsetof(PrecodeMachineDescriptor, FixupIgnoredBytes)) #endif // HAS_FIXUP_PRECODE -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, StubPrecodeSize, offsetof(PrecodeMachineDescriptor, StubPrecodeSize)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, StubPrecodeType, offsetof(PrecodeMachineDescriptor, StubPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, StubPrecodeSize, offsetof(PrecodeMachineDescriptor, StubPrecodeSize)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, StubPrecodeType, offsetof(PrecodeMachineDescriptor, StubPrecodeType)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*byte[]*/, StubBytes, offsetof(PrecodeMachineDescriptor, StubBytes)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*byte[]*/, StubIgnoredBytes, offsetof(PrecodeMachineDescriptor, StubIgnoredBytes)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_ARRAY(T_UINT8), StubBytes, offsetof(PrecodeMachineDescriptor, StubBytes)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_ARRAY(T_UINT8), StubIgnoredBytes, offsetof(PrecodeMachineDescriptor, StubIgnoredBytes)) #ifdef HAS_THISPTR_RETBUF_PRECODE -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, ThisPointerRetBufPrecodeType, offsetof(PrecodeMachineDescriptor, ThisPointerRetBufPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, ThisPointerRetBufPrecodeType, offsetof(PrecodeMachineDescriptor, ThisPointerRetBufPrecodeType)) #endif #ifdef FEATURE_INTERPRETER -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, InterpreterPrecodeType, offsetof(PrecodeMachineDescriptor, InterpreterPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, InterpreterPrecodeType, offsetof(PrecodeMachineDescriptor, InterpreterPrecodeType)) #endif #ifdef FEATURE_STUBPRECODE_DYNAMIC_HELPERS -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, DynamicHelperPrecodeType, offsetof(PrecodeMachineDescriptor, DynamicHelperPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, DynamicHelperPrecodeType, offsetof(PrecodeMachineDescriptor, DynamicHelperPrecodeType)) #endif -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint8*/, UMEntryPrecodeType, offsetof(PrecodeMachineDescriptor, UMEntryPrecodeType)) -CDAC_TYPE_FIELD(PrecodeMachineDescriptor, /*uint32*/, StubCodePageSize, offsetof(PrecodeMachineDescriptor, StubCodePageSize)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT8, UMEntryPrecodeType, offsetof(PrecodeMachineDescriptor, UMEntryPrecodeType)) +CDAC_TYPE_FIELD(PrecodeMachineDescriptor, T_UINT32, StubCodePageSize, offsetof(PrecodeMachineDescriptor, StubCodePageSize)) CDAC_TYPE_END(PrecodeMachineDescriptor) #endif // !FEATURE_PORTABLE_ENTRYPOINTS CDAC_TYPE_BEGIN(PlatformMetadata) CDAC_TYPE_INDETERMINATE(PlatformMetadata) #ifndef FEATURE_PORTABLE_ENTRYPOINTS -CDAC_TYPE_FIELD(PlatformMetadata, /*PrecodeMachineDescriptor*/, PrecodeMachineDescriptor, offsetof(CDacPlatformMetadata, precode)) +CDAC_TYPE_FIELD(PlatformMetadata, TYPE(PrecodeMachineDescriptor), PrecodeMachineDescriptor, offsetof(CDacPlatformMetadata, precode)) #endif // !FEATURE_PORTABLE_ENTRYPOINTS -CDAC_TYPE_FIELD(PlatformMetadata, /*uint8*/, CodePointerFlags, offsetof(CDacPlatformMetadata, codePointerFlags)) +CDAC_TYPE_FIELD(PlatformMetadata, T_UINT8, CodePointerFlags, offsetof(CDacPlatformMetadata, codePointerFlags)) CDAC_TYPE_END(PlatformMetadata) #ifndef FEATURE_PORTABLE_ENTRYPOINTS CDAC_TYPE_BEGIN(StubPrecodeData) CDAC_TYPE_INDETERMINATE(StubPrecodeData) -CDAC_TYPE_FIELD(StubPrecodeData, /*pointer*/, SecretParam, offsetof(StubPrecodeData, SecretParam)) -CDAC_TYPE_FIELD(StubPrecodeData, /*uint8*/, Type, offsetof(StubPrecodeData, Type)) +CDAC_TYPE_FIELD(StubPrecodeData, T_POINTER, SecretParam, offsetof(StubPrecodeData, SecretParam)) +CDAC_TYPE_FIELD(StubPrecodeData, T_UINT8, Type, offsetof(StubPrecodeData, Type)) CDAC_TYPE_END(StubPrecodeData) #ifdef HAS_THISPTR_RETBUF_PRECODE CDAC_TYPE_BEGIN(ThisPtrRetBufPrecodeData) CDAC_TYPE_INDETERMINATE(ThisPtrRetBufPrecodeData) -CDAC_TYPE_FIELD(ThisPtrRetBufPrecodeData, /*pointer*/, MethodDesc, offsetof(ThisPtrRetBufPrecodeData, MethodDesc)) +CDAC_TYPE_FIELD(ThisPtrRetBufPrecodeData, T_POINTER, MethodDesc, offsetof(ThisPtrRetBufPrecodeData, MethodDesc)) CDAC_TYPE_END(ThisPtrRetBufPrecodeData) #endif CDAC_TYPE_BEGIN(FixupPrecodeData) CDAC_TYPE_INDETERMINATE(FixupPrecodeData) -CDAC_TYPE_FIELD(FixupPrecodeData, /*pointer*/, MethodDesc, offsetof(FixupPrecodeData, MethodDesc)) +CDAC_TYPE_FIELD(FixupPrecodeData, T_POINTER, MethodDesc, offsetof(FixupPrecodeData, MethodDesc)) CDAC_TYPE_END(FixupPrecodeData) #endif // !FEATURE_PORTABLE_ENTRYPOINTS CDAC_TYPE_BEGIN(ReadyToRunInfo) CDAC_TYPE_INDETERMINATE(ReadyToRunInfo) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, ReadyToRunHeader, cdac_data::ReadyToRunHeader) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, CompositeInfo, cdac_data::CompositeInfo) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*uint32*/, NumRuntimeFunctions, cdac_data::NumRuntimeFunctions) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, RuntimeFunctions, cdac_data::RuntimeFunctions) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*uint32*/, NumHotColdMap, cdac_data::NumHotColdMap) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, HotColdMap, cdac_data::HotColdMap) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, DelayLoadMethodCallThunks, cdac_data::DelayLoadMethodCallThunks) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, DebugInfoSection, cdac_data::DebugInfoSection) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*HashMap*/, EntryPointToMethodDescMap, cdac_data::EntryPointToMethodDescMap) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, LoadedImageBase, cdac_data::LoadedImageBase) -CDAC_TYPE_FIELD(ReadyToRunInfo, /*pointer*/, Composite, cdac_data::Composite) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, ReadyToRunHeader, cdac_data::ReadyToRunHeader) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, CompositeInfo, cdac_data::CompositeInfo) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_UINT32, NumRuntimeFunctions, cdac_data::NumRuntimeFunctions) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, RuntimeFunctions, cdac_data::RuntimeFunctions) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_UINT32, NumHotColdMap, cdac_data::NumHotColdMap) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, HotColdMap, cdac_data::HotColdMap) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, DelayLoadMethodCallThunks, cdac_data::DelayLoadMethodCallThunks) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, DebugInfoSection, cdac_data::DebugInfoSection) +CDAC_TYPE_FIELD(ReadyToRunInfo, TYPE(HashMap), EntryPointToMethodDescMap, cdac_data::EntryPointToMethodDescMap) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, LoadedImageBase, cdac_data::LoadedImageBase) +CDAC_TYPE_FIELD(ReadyToRunInfo, T_POINTER, Composite, cdac_data::Composite) CDAC_TYPE_END(ReadyToRunInfo) CDAC_TYPE_BEGIN(ReadyToRunHeader) CDAC_TYPE_INDETERMINATE(ReadyToRunHeader) -CDAC_TYPE_FIELD(ReadyToRunHeader, /*uint16*/, MajorVersion, offsetof(READYTORUN_HEADER, MajorVersion)) -CDAC_TYPE_FIELD(ReadyToRunHeader, /*uint16*/, MinorVersion, offsetof(READYTORUN_HEADER, MinorVersion)) +CDAC_TYPE_FIELD(ReadyToRunHeader, T_UINT16, MajorVersion, offsetof(READYTORUN_HEADER, MajorVersion)) +CDAC_TYPE_FIELD(ReadyToRunHeader, T_UINT16, MinorVersion, offsetof(READYTORUN_HEADER, MinorVersion)) CDAC_TYPE_END(ReadyToRunHeader) CDAC_TYPE_BEGIN(ReadyToRunCoreHeader) CDAC_TYPE_SIZE(sizeof(READYTORUN_CORE_HEADER)) -CDAC_TYPE_FIELD(ReadyToRunCoreHeader, /*uint32*/, Flags, offsetof(READYTORUN_CORE_HEADER, Flags)) -CDAC_TYPE_FIELD(ReadyToRunCoreHeader, /*uint32*/, NumberOfSections, offsetof(READYTORUN_CORE_HEADER, NumberOfSections)) +CDAC_TYPE_FIELD(ReadyToRunCoreHeader, T_UINT32, Flags, offsetof(READYTORUN_CORE_HEADER, Flags)) +CDAC_TYPE_FIELD(ReadyToRunCoreHeader, T_UINT32, NumberOfSections, offsetof(READYTORUN_CORE_HEADER, NumberOfSections)) CDAC_TYPE_END(ReadyToRunCoreHeader) CDAC_TYPE_BEGIN(ReadyToRunCoreInfo) CDAC_TYPE_INDETERMINATE(ReadyToRunCoreInfo) -CDAC_TYPE_FIELD(ReadyToRunCoreInfo, /*pointer*/, Header, cdac_data::Header) +CDAC_TYPE_FIELD(ReadyToRunCoreInfo, T_POINTER, Header, cdac_data::Header) CDAC_TYPE_END(ReadyToRunCoreInfo) CDAC_TYPE_BEGIN(ReadyToRunSection) CDAC_TYPE_SIZE(sizeof(READYTORUN_SECTION)) -CDAC_TYPE_FIELD(ReadyToRunSection, /*uint32*/, Type, offsetof(READYTORUN_SECTION, Type)) -CDAC_TYPE_FIELD(ReadyToRunSection, /* IMAGE_DATA_DIRECTORY */, Section, offsetof(READYTORUN_SECTION, Section)) +CDAC_TYPE_FIELD(ReadyToRunSection, T_UINT32, Type, offsetof(READYTORUN_SECTION, Type)) +CDAC_TYPE_FIELD(ReadyToRunSection, TYPE(ImageDataDirectory), Section, offsetof(READYTORUN_SECTION, Section)) CDAC_TYPE_END(ReadyToRunSection) CDAC_TYPE_BEGIN(ExceptionLookupTableEntry) CDAC_TYPE_SIZE(sizeof(CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY)) -CDAC_TYPE_FIELD(ExceptionLookupTableEntry, /*uint32*/, MethodStartRVA, offsetof(CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY, MethodStartRVA)) -CDAC_TYPE_FIELD(ExceptionLookupTableEntry, /*uint32*/, ExceptionInfoRVA, offsetof(CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY, ExceptionInfoRVA)) +CDAC_TYPE_FIELD(ExceptionLookupTableEntry, T_UINT32, MethodStartRVA, offsetof(CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY, MethodStartRVA)) +CDAC_TYPE_FIELD(ExceptionLookupTableEntry, T_UINT32, ExceptionInfoRVA, offsetof(CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY, ExceptionInfoRVA)) CDAC_TYPE_END(ExceptionLookupTableEntry) CDAC_TYPE_BEGIN(ImageDataDirectory) CDAC_TYPE_SIZE(sizeof(IMAGE_DATA_DIRECTORY)) -CDAC_TYPE_FIELD(ImageDataDirectory, /*uint32*/, VirtualAddress, offsetof(IMAGE_DATA_DIRECTORY, VirtualAddress)) -CDAC_TYPE_FIELD(ImageDataDirectory, /*uint32*/, Size, offsetof(IMAGE_DATA_DIRECTORY, Size)) +CDAC_TYPE_FIELD(ImageDataDirectory, T_UINT32, VirtualAddress, offsetof(IMAGE_DATA_DIRECTORY, VirtualAddress)) +CDAC_TYPE_FIELD(ImageDataDirectory, T_UINT32, Size, offsetof(IMAGE_DATA_DIRECTORY, Size)) CDAC_TYPE_END(ImageDataDirectory) CDAC_TYPE_BEGIN(RuntimeFunction) CDAC_TYPE_SIZE(sizeof(RUNTIME_FUNCTION)) -CDAC_TYPE_FIELD(RuntimeFunction, /*uint32*/, BeginAddress, offsetof(RUNTIME_FUNCTION, BeginAddress)) +CDAC_TYPE_FIELD(RuntimeFunction, T_UINT32, BeginAddress, offsetof(RUNTIME_FUNCTION, BeginAddress)) #ifdef TARGET_AMD64 -CDAC_TYPE_FIELD(RuntimeFunction, /*uint32*/, EndAddress, offsetof(RUNTIME_FUNCTION, EndAddress)) +CDAC_TYPE_FIELD(RuntimeFunction, T_UINT32, EndAddress, offsetof(RUNTIME_FUNCTION, EndAddress)) #endif -CDAC_TYPE_FIELD(RuntimeFunction, /*uint32*/, UnwindData, offsetof(RUNTIME_FUNCTION, UnwindData)) +CDAC_TYPE_FIELD(RuntimeFunction, T_UINT32, UnwindData, offsetof(RUNTIME_FUNCTION, UnwindData)) CDAC_TYPE_END(RuntimeFunction) CDAC_TYPE_BEGIN(UnwindInfo) CDAC_TYPE_INDETERMINATE(UnwindInfo) #ifdef TARGET_X86 -CDAC_TYPE_FIELD(UnwindInfo, /*uint32*/, FunctionLength, offsetof(UNWIND_INFO, FunctionLength)) +CDAC_TYPE_FIELD(UnwindInfo, T_UINT32, FunctionLength, offsetof(UNWIND_INFO, FunctionLength)) #endif CDAC_TYPE_END(UnwindInfo) CDAC_TYPE_BEGIN(HashMap) CDAC_TYPE_INDETERMINATE(HashMap) -CDAC_TYPE_FIELD(HashMap, /*pointer*/, Buckets, cdac_data::Buckets) +CDAC_TYPE_FIELD(HashMap, T_POINTER, Buckets, cdac_data::Buckets) CDAC_TYPE_END(HashMap) CDAC_TYPE_BEGIN(Bucket) CDAC_TYPE_SIZE(sizeof(Bucket)) -CDAC_TYPE_FIELD(Bucket, /*pointer*/, Keys, offsetof(Bucket, m_rgKeys)) -CDAC_TYPE_FIELD(Bucket, /*pointer*/, Values, offsetof(Bucket, m_rgValues)) +CDAC_TYPE_FIELD(Bucket, T_POINTER, Keys, offsetof(Bucket, m_rgKeys)) +CDAC_TYPE_FIELD(Bucket, T_POINTER, Values, offsetof(Bucket, m_rgValues)) CDAC_TYPE_END(Bucket) CDAC_TYPE_BEGIN(RangeSectionMap) CDAC_TYPE_INDETERMINATE(RangeSectionMap) -CDAC_TYPE_FIELD(RangeSectionMap, /*pointer*/, TopLevelData, cdac_data::TopLevelData) +CDAC_TYPE_FIELD(RangeSectionMap, T_POINTER, TopLevelData, cdac_data::TopLevelData) CDAC_TYPE_END(RangeSectionMap) CDAC_TYPE_BEGIN(RangeSectionFragment) CDAC_TYPE_INDETERMINATE(RangeSectionFragment) -CDAC_TYPE_FIELD(RangeSectionFragment, /*pointer*/, RangeBegin, cdac_data::RangeSectionFragment::RangeBegin) -CDAC_TYPE_FIELD(RangeSectionFragment, /*pointer*/, RangeEndOpen, cdac_data::RangeSectionFragment::RangeEndOpen) -CDAC_TYPE_FIELD(RangeSectionFragment, /*pointer*/, RangeSection, cdac_data::RangeSectionFragment::RangeSection) -CDAC_TYPE_FIELD(RangeSectionFragment, /*pointer*/, Next, cdac_data::RangeSectionFragment::Next) +CDAC_TYPE_FIELD(RangeSectionFragment, T_POINTER, RangeBegin, cdac_data::RangeSectionFragment::RangeBegin) +CDAC_TYPE_FIELD(RangeSectionFragment, T_POINTER, RangeEndOpen, cdac_data::RangeSectionFragment::RangeEndOpen) +CDAC_TYPE_FIELD(RangeSectionFragment, T_POINTER, RangeSection, cdac_data::RangeSectionFragment::RangeSection) +CDAC_TYPE_FIELD(RangeSectionFragment, T_POINTER, Next, cdac_data::RangeSectionFragment::Next) CDAC_TYPE_END(RangeSectionFragment) CDAC_TYPE_BEGIN(RangeSection) CDAC_TYPE_INDETERMINATE(RangeSection) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, RangeBegin, cdac_data::RangeBegin) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, RangeEndOpen, cdac_data::RangeEndOpen) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, NextForDelete, cdac_data::NextForDelete) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, JitManager, cdac_data::JitManager) -CDAC_TYPE_FIELD(RangeSection, /*int32_t*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, HeapList, cdac_data::HeapList) -CDAC_TYPE_FIELD(RangeSection, /*pointer*/, R2RModule, cdac_data::R2RModule) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, RangeBegin, cdac_data::RangeBegin) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, RangeEndOpen, cdac_data::RangeEndOpen) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, NextForDelete, cdac_data::NextForDelete) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, JitManager, cdac_data::JitManager) +CDAC_TYPE_FIELD(RangeSection, T_INT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, HeapList, cdac_data::HeapList) +CDAC_TYPE_FIELD(RangeSection, T_POINTER, R2RModule, cdac_data::R2RModule) CDAC_TYPE_END(RangeSection) CDAC_TYPE_BEGIN(EEJitManager) CDAC_TYPE_INDETERMINATE(EEJitManager) -CDAC_TYPE_FIELD(EEJitManager, /*bool*/, StoreRichDebugInfo, cdac_data::StoreRichDebugInfo) -CDAC_TYPE_FIELD(EEJitManager, /*pointer*/, AllCodeHeaps, cdac_data::AllCodeHeaps) +CDAC_TYPE_FIELD(EEJitManager, T_BOOL, StoreRichDebugInfo, cdac_data::StoreRichDebugInfo) +CDAC_TYPE_FIELD(EEJitManager, T_POINTER, AllCodeHeaps, cdac_data::AllCodeHeaps) CDAC_TYPE_END(EEJitManager) CDAC_TYPE_BEGIN(RealCodeHeader) CDAC_TYPE_INDETERMINATE(RealCodeHeader) -CDAC_TYPE_FIELD(RealCodeHeader, /*pointer*/, MethodDesc, offsetof(RealCodeHeader, phdrMDesc)) -CDAC_TYPE_FIELD(RealCodeHeader, /*pointer*/, DebugInfo, offsetof(RealCodeHeader, phdrDebugInfo)) -CDAC_TYPE_FIELD(RealCodeHeader, /*pointer*/, GCInfo, offsetof(RealCodeHeader, phdrJitGCInfo)) -CDAC_TYPE_FIELD(RealCodeHeader, /*uint32*/, NumUnwindInfos, offsetof(RealCodeHeader, nUnwindInfos)) -CDAC_TYPE_FIELD(RealCodeHeader, /* T_RUNTIME_FUNCTION */, UnwindInfos, offsetof(RealCodeHeader, unwindInfos)) -CDAC_TYPE_FIELD(RealCodeHeader, /*pointer*/, JitEHInfo, offsetof(RealCodeHeader, phdrJitEHInfo)) +CDAC_TYPE_FIELD(RealCodeHeader, T_POINTER, MethodDesc, offsetof(RealCodeHeader, phdrMDesc)) +CDAC_TYPE_FIELD(RealCodeHeader, T_POINTER, DebugInfo, offsetof(RealCodeHeader, phdrDebugInfo)) +CDAC_TYPE_FIELD(RealCodeHeader, T_POINTER, GCInfo, offsetof(RealCodeHeader, phdrJitGCInfo)) +CDAC_TYPE_FIELD(RealCodeHeader, T_UINT32, NumUnwindInfos, offsetof(RealCodeHeader, nUnwindInfos)) +CDAC_TYPE_FIELD(RealCodeHeader, TYPE(RuntimeFunction), UnwindInfos, offsetof(RealCodeHeader, unwindInfos)) +CDAC_TYPE_FIELD(RealCodeHeader, T_POINTER, JitEHInfo, offsetof(RealCodeHeader, phdrJitEHInfo)) CDAC_TYPE_END(RealCodeHeader) CDAC_TYPE_BEGIN(EEExceptionClause) CDAC_TYPE_SIZE(sizeof(EE_ILEXCEPTION_CLAUSE)) -CDAC_TYPE_FIELD(EEExceptionClause, /*uint32*/, Flags, offsetof(EE_ILEXCEPTION_CLAUSE, Flags)) -CDAC_TYPE_FIELD(EEExceptionClause, /*uint32*/, TryStartPC, offsetof(EE_ILEXCEPTION_CLAUSE, TryStartPC)) -CDAC_TYPE_FIELD(EEExceptionClause, /*uint32*/, TryEndPC, offsetof(EE_ILEXCEPTION_CLAUSE, TryEndPC)) -CDAC_TYPE_FIELD(EEExceptionClause, /*uint32*/, HandlerStartPC, offsetof(EE_ILEXCEPTION_CLAUSE, HandlerStartPC)) -CDAC_TYPE_FIELD(EEExceptionClause, /*uint32*/, HandlerEndPC, offsetof(EE_ILEXCEPTION_CLAUSE, HandlerEndPC)) -CDAC_TYPE_FIELD(EEExceptionClause, /*nuint*/, TypeHandle, offsetof(EE_ILEXCEPTION_CLAUSE, TypeHandle)) +CDAC_TYPE_FIELD(EEExceptionClause, T_UINT32, Flags, offsetof(EE_ILEXCEPTION_CLAUSE, Flags)) +CDAC_TYPE_FIELD(EEExceptionClause, T_UINT32, TryStartPC, offsetof(EE_ILEXCEPTION_CLAUSE, TryStartPC)) +CDAC_TYPE_FIELD(EEExceptionClause, T_UINT32, TryEndPC, offsetof(EE_ILEXCEPTION_CLAUSE, TryEndPC)) +CDAC_TYPE_FIELD(EEExceptionClause, T_UINT32, HandlerStartPC, offsetof(EE_ILEXCEPTION_CLAUSE, HandlerStartPC)) +CDAC_TYPE_FIELD(EEExceptionClause, T_UINT32, HandlerEndPC, offsetof(EE_ILEXCEPTION_CLAUSE, HandlerEndPC)) +CDAC_TYPE_FIELD(EEExceptionClause, T_NUINT, TypeHandle, offsetof(EE_ILEXCEPTION_CLAUSE, TypeHandle)) CDAC_TYPE_END(EEExceptionClause) CDAC_TYPE_BEGIN(R2RExceptionClause) CDAC_TYPE_SIZE(sizeof(CORCOMPILE_EXCEPTION_CLAUSE)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, Flags, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, Flags)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, TryStartPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, TryStartPC)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, TryEndPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, TryEndPC)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, HandlerStartPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, HandlerStartPC)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, HandlerEndPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, HandlerEndPC)) -CDAC_TYPE_FIELD(R2RExceptionClause, /*uint32*/, ClassToken, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, ClassToken)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, Flags, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, Flags)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, TryStartPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, TryStartPC)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, TryEndPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, TryEndPC)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, HandlerStartPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, HandlerStartPC)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, HandlerEndPC, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, HandlerEndPC)) +CDAC_TYPE_FIELD(R2RExceptionClause, T_UINT32, ClassToken, offsetof(CORCOMPILE_EXCEPTION_CLAUSE, ClassToken)) CDAC_TYPE_END(R2RExceptionClause) CDAC_TYPE_BEGIN(EEILException) CDAC_TYPE_INDETERMINATE(EEILException) -CDAC_TYPE_FIELD(EEILException, /* EE_ILEXCEPTION_CLAUSE */, Clauses, offsetof(EE_ILEXCEPTION, Clauses)) +CDAC_TYPE_FIELD(EEILException, TYPE(EEExceptionClause), Clauses, offsetof(EE_ILEXCEPTION, Clauses)) CDAC_TYPE_END(EEILException) CDAC_TYPE_BEGIN(CodeHeapListNode) -CDAC_TYPE_FIELD(CodeHeapListNode, /*pointer*/, Next, offsetof(HeapList, hpNext)) -CDAC_TYPE_FIELD(CodeHeapListNode, /*pointer*/, StartAddress, offsetof(HeapList, startAddress)) -CDAC_TYPE_FIELD(CodeHeapListNode, /*pointer*/, EndAddress, offsetof(HeapList, endAddress)) -CDAC_TYPE_FIELD(CodeHeapListNode, /*pointer*/, MapBase, offsetof(HeapList, mapBase)) -CDAC_TYPE_FIELD(CodeHeapListNode, /*pointer*/, HeaderMap, offsetof(HeapList, pHdrMap)) +CDAC_TYPE_FIELD(CodeHeapListNode, T_POINTER, Next, offsetof(HeapList, hpNext)) +CDAC_TYPE_FIELD(CodeHeapListNode, T_POINTER, StartAddress, offsetof(HeapList, startAddress)) +CDAC_TYPE_FIELD(CodeHeapListNode, T_POINTER, EndAddress, offsetof(HeapList, endAddress)) +CDAC_TYPE_FIELD(CodeHeapListNode, T_POINTER, MapBase, offsetof(HeapList, mapBase)) +CDAC_TYPE_FIELD(CodeHeapListNode, T_POINTER, HeaderMap, offsetof(HeapList, pHdrMap)) CDAC_TYPE_END(CodeHeapListNode) #ifdef FEATURE_CODE_VERSIONING CDAC_TYPE_BEGIN(ILCodeVersioningState) CDAC_TYPE_INDETERMINATE(ILCodeVersioningState) -CDAC_TYPE_FIELD(ILCodeVersioningState, /*pointer*/, FirstVersionNode, cdac_data::FirstVersionNode) -CDAC_TYPE_FIELD(ILCodeVersioningState, /*uint32*/, ActiveVersionKind, cdac_data::ActiveVersionKind) -CDAC_TYPE_FIELD(ILCodeVersioningState, /*pointer*/, ActiveVersionNode, cdac_data::ActiveVersionNode) -CDAC_TYPE_FIELD(ILCodeVersioningState, /*pointer*/, ActiveVersionModule, cdac_data::ActiveVersionModule) -CDAC_TYPE_FIELD(ILCodeVersioningState, /*uint32*/, ActiveVersionMethodDef, cdac_data::ActiveVersionMethodDef) +CDAC_TYPE_FIELD(ILCodeVersioningState, T_POINTER, FirstVersionNode, cdac_data::FirstVersionNode) +CDAC_TYPE_FIELD(ILCodeVersioningState, T_UINT32, ActiveVersionKind, cdac_data::ActiveVersionKind) +CDAC_TYPE_FIELD(ILCodeVersioningState, T_POINTER, ActiveVersionNode, cdac_data::ActiveVersionNode) +CDAC_TYPE_FIELD(ILCodeVersioningState, T_POINTER, ActiveVersionModule, cdac_data::ActiveVersionModule) +CDAC_TYPE_FIELD(ILCodeVersioningState, T_UINT32, ActiveVersionMethodDef, cdac_data::ActiveVersionMethodDef) CDAC_TYPE_END(ILCodeVersioningState) CDAC_TYPE_BEGIN(NativeCodeVersionNode) CDAC_TYPE_INDETERMINATE(NativeCodeVersionNode) -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, Next, cdac_data::Next) -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, MethodDesc, cdac_data::MethodDesc) -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, NativeCode, cdac_data::NativeCode) -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*uint32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*nuint*/, ILVersionId, cdac_data::ILVersionId) +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, T_UINT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(NativeCodeVersionNode, T_NUINT, ILVersionId, cdac_data::ILVersionId) #ifdef HAVE_GCCOVER -CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, GCCoverageInfo, cdac_data::GCCoverageInfo) +CDAC_TYPE_FIELD(NativeCodeVersionNode, T_POINTER, GCCoverageInfo, cdac_data::GCCoverageInfo) #endif // HAVE_GCCOVER CDAC_TYPE_END(NativeCodeVersionNode) CDAC_TYPE_BEGIN(ILCodeVersionNode) CDAC_TYPE_INDETERMINATE(ILCodeVersionNode) -CDAC_TYPE_FIELD(ILCodeVersionNode, /*nuint*/, VersionId, cdac_data::VersionId) -CDAC_TYPE_FIELD(ILCodeVersionNode, /*pointer*/, Next, cdac_data::Next) -CDAC_TYPE_FIELD(ILCodeVersionNode, /*uint32*/, RejitState, cdac_data::RejitState) -CDAC_TYPE_FIELD(ILCodeVersionNode, /*pointer*/, ILAddress, cdac_data::ILAddress) +CDAC_TYPE_FIELD(ILCodeVersionNode, T_NUINT, VersionId, cdac_data::VersionId) +CDAC_TYPE_FIELD(ILCodeVersionNode, T_POINTER, Next, cdac_data::Next) +CDAC_TYPE_FIELD(ILCodeVersionNode, T_UINT32, RejitState, cdac_data::RejitState) +CDAC_TYPE_FIELD(ILCodeVersionNode, T_POINTER, ILAddress, cdac_data::ILAddress) CDAC_TYPE_END(ILCodeVersionNode) #endif // FEATURE_CODE_VERSIONING CDAC_TYPE_BEGIN(ProfControlBlock) -CDAC_TYPE_FIELD(ProfControlBlock, /*uint64*/, GlobalEventMask, offsetof(ProfControlBlock, globalEventMask)) -CDAC_TYPE_FIELD(ProfControlBlock, /*bool*/, RejitOnAttachEnabled, offsetof(ProfControlBlock, fRejitOnAttachEnabled)) +CDAC_TYPE_FIELD(ProfControlBlock, T_UINT64, GlobalEventMask, offsetof(ProfControlBlock, globalEventMask)) +CDAC_TYPE_FIELD(ProfControlBlock, T_BOOL, RejitOnAttachEnabled, offsetof(ProfControlBlock, fRejitOnAttachEnabled)) CDAC_TYPE_END(ProfControlBlock) #ifdef HAVE_GCCOVER CDAC_TYPE_BEGIN(GCCoverageInfo) CDAC_TYPE_INDETERMINATE(GCCoverageInfo) -CDAC_TYPE_FIELD(GCCoverageInfo, /*pointer*/, SavedCode, offsetof(GCCoverageInfo, savedCode)) +CDAC_TYPE_FIELD(GCCoverageInfo, T_POINTER, SavedCode, offsetof(GCCoverageInfo, savedCode)) CDAC_TYPE_END(GCCoverageInfo) #endif // HAVE_GCCOVER CDAC_TYPE_BEGIN(Frame) CDAC_TYPE_INDETERMINATE(Frame) -CDAC_TYPE_FIELD(Frame, /*pointer*/, Next, cdac_data::Next) +CDAC_TYPE_FIELD(Frame, T_POINTER, Next, cdac_data::Next) CDAC_TYPE_END(Frame) CDAC_TYPE_BEGIN(InlinedCallFrame) CDAC_TYPE_SIZE(sizeof(InlinedCallFrame)) -CDAC_TYPE_FIELD(InlinedCallFrame, /*pointer*/, CallSiteSP, offsetof(InlinedCallFrame, m_pCallSiteSP)) -CDAC_TYPE_FIELD(InlinedCallFrame, /*pointer*/, CallerReturnAddress, offsetof(InlinedCallFrame, m_pCallerReturnAddress)) -CDAC_TYPE_FIELD(InlinedCallFrame, /*pointer*/, CalleeSavedFP, offsetof(InlinedCallFrame, m_pCalleeSavedFP)) -CDAC_TYPE_FIELD(InlinedCallFrame, /*pointer*/, Datum, offsetof(InlinedCallFrame, m_Datum)) +CDAC_TYPE_FIELD(InlinedCallFrame, T_POINTER, CallSiteSP, offsetof(InlinedCallFrame, m_pCallSiteSP)) +CDAC_TYPE_FIELD(InlinedCallFrame, T_POINTER, CallerReturnAddress, offsetof(InlinedCallFrame, m_pCallerReturnAddress)) +CDAC_TYPE_FIELD(InlinedCallFrame, T_POINTER, CalleeSavedFP, offsetof(InlinedCallFrame, m_pCalleeSavedFP)) +CDAC_TYPE_FIELD(InlinedCallFrame, T_POINTER, Datum, offsetof(InlinedCallFrame, m_Datum)) #ifdef TARGET_ARM -CDAC_TYPE_FIELD(InlinedCallFrame, /*pointer*/, SPAfterProlog, offsetof(InlinedCallFrame, m_pSPAfterProlog)) +CDAC_TYPE_FIELD(InlinedCallFrame, T_POINTER, SPAfterProlog, offsetof(InlinedCallFrame, m_pSPAfterProlog)) #endif // TARGET_ARM CDAC_TYPE_END(InlinedCallFrame) CDAC_TYPE_BEGIN(SoftwareExceptionFrame) CDAC_TYPE_SIZE(sizeof(SoftwareExceptionFrame)) -CDAC_TYPE_FIELD(SoftwareExceptionFrame, /*T_CONTEXT*/, TargetContext, cdac_data::TargetContext) -CDAC_TYPE_FIELD(SoftwareExceptionFrame, /*pointer*/, ReturnAddress, cdac_data::ReturnAddress) +CDAC_TYPE_FIELD(SoftwareExceptionFrame, T_POINTER, TargetContext, cdac_data::TargetContext) +CDAC_TYPE_FIELD(SoftwareExceptionFrame, T_POINTER, ReturnAddress, cdac_data::ReturnAddress) CDAC_TYPE_END(SoftwareExceptionFrame) CDAC_TYPE_BEGIN(FramedMethodFrame) CDAC_TYPE_SIZE(sizeof(FramedMethodFrame)) -CDAC_TYPE_FIELD(FramedMethodFrame, /*pointer*/, TransitionBlockPtr, cdac_data::TransitionBlockPtr) -CDAC_TYPE_FIELD(FramedMethodFrame, /*pointer*/, MethodDescPtr, cdac_data::MethodDescPtr) +CDAC_TYPE_FIELD(FramedMethodFrame, T_POINTER, TransitionBlockPtr, cdac_data::TransitionBlockPtr) +CDAC_TYPE_FIELD(FramedMethodFrame, T_POINTER, MethodDescPtr, cdac_data::MethodDescPtr) CDAC_TYPE_END(FramedMethodFrame) CDAC_TYPE_BEGIN(TransitionBlock) CDAC_TYPE_SIZE(sizeof(TransitionBlock)) -CDAC_TYPE_FIELD(TransitionBlock, /*pointer*/, ReturnAddress, offsetof(TransitionBlock, m_ReturnAddress)) -CDAC_TYPE_FIELD(TransitionBlock, /*CalleeSavedRegisters*/, CalleeSavedRegisters, offsetof(TransitionBlock, m_calleeSavedRegisters)) +CDAC_TYPE_FIELD(TransitionBlock, T_POINTER, ReturnAddress, offsetof(TransitionBlock, m_ReturnAddress)) +CDAC_TYPE_FIELD(TransitionBlock, TYPE(CalleeSavedRegisters), CalleeSavedRegisters, offsetof(TransitionBlock, m_calleeSavedRegisters)) #ifdef TARGET_ARM -CDAC_TYPE_FIELD(TransitionBlock, /*ArgumentRegisters*/, ArgumentRegisters, offsetof(TransitionBlock, m_argumentRegisters)) +CDAC_TYPE_FIELD(TransitionBlock, TYPE(ArgumentRegisters), ArgumentRegisters, offsetof(TransitionBlock, m_argumentRegisters)) #endif // TARGET_ARM CDAC_TYPE_END(TransitionBlock) #ifdef DEBUGGING_SUPPORTED CDAC_TYPE_BEGIN(FuncEvalFrame) CDAC_TYPE_SIZE(sizeof(FuncEvalFrame)) -CDAC_TYPE_FIELD(FuncEvalFrame, /*pointer*/, DebuggerEvalPtr, cdac_data::DebuggerEvalPtr) +CDAC_TYPE_FIELD(FuncEvalFrame, T_POINTER, DebuggerEvalPtr, cdac_data::DebuggerEvalPtr) CDAC_TYPE_END(FuncEvalFrame) CDAC_TYPE_BEGIN(DebuggerEval) CDAC_TYPE_SIZE(sizeof(DebuggerEval)) -CDAC_TYPE_FIELD(DebuggerEval, /*T_CONTEXT*/, TargetContext, offsetof(DebuggerEval, m_context)) -CDAC_TYPE_FIELD(DebuggerEval, /*bool*/, EvalDuringException, offsetof(DebuggerEval, m_evalDuringException)) +CDAC_TYPE_FIELD(DebuggerEval, T_POINTER, TargetContext, offsetof(DebuggerEval, m_context)) +CDAC_TYPE_FIELD(DebuggerEval, T_BOOL, EvalDuringException, offsetof(DebuggerEval, m_evalDuringException)) CDAC_TYPE_END(DebuggerEval) #endif // DEBUGGING_SUPPORTED CDAC_TYPE_BEGIN(StubDispatchFrame) CDAC_TYPE_SIZE(sizeof(StubDispatchFrame)) -CDAC_TYPE_FIELD(StubDispatchFrame, /*pointer*/, RepresentativeMTPtr, cdac_data::RepresentativeMTPtr) -CDAC_TYPE_FIELD(StubDispatchFrame, /*pointer*/, MethodDescPtr, cdac_data::MethodDescPtr) -CDAC_TYPE_FIELD(StubDispatchFrame, /*uint32*/, RepresentativeSlot, cdac_data::RepresentativeSlot) +CDAC_TYPE_FIELD(StubDispatchFrame, T_POINTER, RepresentativeMTPtr, cdac_data::RepresentativeMTPtr) +CDAC_TYPE_FIELD(StubDispatchFrame, T_POINTER, MethodDescPtr, cdac_data::MethodDescPtr) +CDAC_TYPE_FIELD(StubDispatchFrame, T_UINT32, RepresentativeSlot, cdac_data::RepresentativeSlot) CDAC_TYPE_END(StubDispatchFrame) #ifdef FEATURE_HIJACK CDAC_TYPE_BEGIN(ResumableFrame) CDAC_TYPE_SIZE(sizeof(ResumableFrame)) -CDAC_TYPE_FIELD(ResumableFrame, /*pointer*/, TargetContextPtr, cdac_data::TargetContextPtr) +CDAC_TYPE_FIELD(ResumableFrame, T_POINTER, TargetContextPtr, cdac_data::TargetContextPtr) CDAC_TYPE_END(ResumableFrame) CDAC_TYPE_BEGIN(HijackFrame) CDAC_TYPE_SIZE(sizeof(HijackFrame)) -CDAC_TYPE_FIELD(HijackFrame, /*pointer*/, ReturnAddress, cdac_data::ReturnAddress) -CDAC_TYPE_FIELD(HijackFrame, /*pointer*/, HijackArgsPtr, cdac_data::HijackArgsPtr) +CDAC_TYPE_FIELD(HijackFrame, T_POINTER, ReturnAddress, cdac_data::ReturnAddress) +CDAC_TYPE_FIELD(HijackFrame, T_POINTER, HijackArgsPtr, cdac_data::HijackArgsPtr) CDAC_TYPE_END(HijackFrame) // HijackArgs struct is different on each platform @@ -942,87 +942,87 @@ CDAC_TYPE_BEGIN(HijackArgs) CDAC_TYPE_SIZE(sizeof(HijackArgs)) #if defined(TARGET_AMD64) -CDAC_TYPE_FIELD(HijackArgs, /*CalleeSavedRegisters*/, CalleeSavedRegisters, offsetof(HijackArgs, Regs)) +CDAC_TYPE_FIELD(HijackArgs, TYPE(CalleeSavedRegisters), CalleeSavedRegisters, offsetof(HijackArgs, Regs)) #ifdef TARGET_WINDOWS -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Rsp, offsetof(HijackArgs, Rsp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Rsp, offsetof(HijackArgs, Rsp)) #endif // TARGET_WINDOWS #elif defined(TARGET_ARM64) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X0, offsetof(HijackArgs, X0)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X1, offsetof(HijackArgs, X1)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X19, offsetof(HijackArgs, X19)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X20, offsetof(HijackArgs, X20)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X21, offsetof(HijackArgs, X21)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X22, offsetof(HijackArgs, X22)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X23, offsetof(HijackArgs, X23)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X24, offsetof(HijackArgs, X24)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X25, offsetof(HijackArgs, X25)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X26, offsetof(HijackArgs, X26)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X27, offsetof(HijackArgs, X27)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X28, offsetof(HijackArgs, X28)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Fp, offsetof(HijackArgs, X29)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Lr, offsetof(HijackArgs, Lr)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X0, offsetof(HijackArgs, X0)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X1, offsetof(HijackArgs, X1)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X19, offsetof(HijackArgs, X19)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X20, offsetof(HijackArgs, X20)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X21, offsetof(HijackArgs, X21)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X22, offsetof(HijackArgs, X22)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X23, offsetof(HijackArgs, X23)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X24, offsetof(HijackArgs, X24)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X25, offsetof(HijackArgs, X25)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X26, offsetof(HijackArgs, X26)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X27, offsetof(HijackArgs, X27)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, X28, offsetof(HijackArgs, X28)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Fp, offsetof(HijackArgs, X29)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Lr, offsetof(HijackArgs, Lr)) #elif defined(TARGET_X86) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Edi, offsetof(HijackArgs, Edi)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Esi, offsetof(HijackArgs, Esi)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Ebx, offsetof(HijackArgs, Ebx)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Edx, offsetof(HijackArgs, Edx)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Ecx, offsetof(HijackArgs, Ecx)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Eax, offsetof(HijackArgs, Eax)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Ebp, offsetof(HijackArgs, Ebp)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Eip, offsetof(HijackArgs, Eip)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Edi, offsetof(HijackArgs, Edi)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Esi, offsetof(HijackArgs, Esi)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Ebx, offsetof(HijackArgs, Ebx)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Edx, offsetof(HijackArgs, Edx)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Ecx, offsetof(HijackArgs, Ecx)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Eax, offsetof(HijackArgs, Eax)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Ebp, offsetof(HijackArgs, Ebp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Eip, offsetof(HijackArgs, Eip)) #elif defined(TARGET_ARM) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R0, offsetof(HijackArgs, R0)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R2, offsetof(HijackArgs, R2)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R4, offsetof(HijackArgs, R4)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R5, offsetof(HijackArgs, R5)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R6, offsetof(HijackArgs, R6)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R7, offsetof(HijackArgs, R7)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R8, offsetof(HijackArgs, R8)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R9, offsetof(HijackArgs, R9)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R10, offsetof(HijackArgs, R10)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, R11, offsetof(HijackArgs, R11)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R0, offsetof(HijackArgs, R0)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R2, offsetof(HijackArgs, R2)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R4, offsetof(HijackArgs, R4)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R5, offsetof(HijackArgs, R5)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R6, offsetof(HijackArgs, R6)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R7, offsetof(HijackArgs, R7)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R8, offsetof(HijackArgs, R8)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R9, offsetof(HijackArgs, R9)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R10, offsetof(HijackArgs, R10)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, R11, offsetof(HijackArgs, R11)) #elif defined(TARGET_RISCV64) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Fp, offsetof(HijackArgs, Fp)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Ra, offsetof(HijackArgs, Ra)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S1, offsetof(HijackArgs, S1)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S2, offsetof(HijackArgs, S2)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S3, offsetof(HijackArgs, S3)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S4, offsetof(HijackArgs, S4)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S5, offsetof(HijackArgs, S5)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S6, offsetof(HijackArgs, S6)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S7, offsetof(HijackArgs, S7)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S8, offsetof(HijackArgs, S8)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S9, offsetof(HijackArgs, S9)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S10, offsetof(HijackArgs, S10)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S11, offsetof(HijackArgs, S11)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Gp, offsetof(HijackArgs, Gp)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Tp, offsetof(HijackArgs, Tp)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, A0, offsetof(HijackArgs, A0)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, A1, offsetof(HijackArgs, A1)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Fp, offsetof(HijackArgs, Fp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Ra, offsetof(HijackArgs, Ra)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S1, offsetof(HijackArgs, S1)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S2, offsetof(HijackArgs, S2)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S3, offsetof(HijackArgs, S3)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S4, offsetof(HijackArgs, S4)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S5, offsetof(HijackArgs, S5)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S6, offsetof(HijackArgs, S6)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S7, offsetof(HijackArgs, S7)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S8, offsetof(HijackArgs, S8)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S9, offsetof(HijackArgs, S9)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S10, offsetof(HijackArgs, S10)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S11, offsetof(HijackArgs, S11)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Gp, offsetof(HijackArgs, Gp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Tp, offsetof(HijackArgs, Tp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, A0, offsetof(HijackArgs, A0)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, A1, offsetof(HijackArgs, A1)) #elif defined(TARGET_LOONGARCH64) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Fp, offsetof(HijackArgs, Fp)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Ra, offsetof(HijackArgs, Ra)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S0, offsetof(HijackArgs, S0)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S1, offsetof(HijackArgs, S1)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S2, offsetof(HijackArgs, S2)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S3, offsetof(HijackArgs, S3)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S4, offsetof(HijackArgs, S4)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S5, offsetof(HijackArgs, S5)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S6, offsetof(HijackArgs, S6)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S7, offsetof(HijackArgs, S7)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, S8, offsetof(HijackArgs, S8)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, A0, offsetof(HijackArgs, A0)) -CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, A1, offsetof(HijackArgs, A1)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Fp, offsetof(HijackArgs, Fp)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, Ra, offsetof(HijackArgs, Ra)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S0, offsetof(HijackArgs, S0)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S1, offsetof(HijackArgs, S1)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S2, offsetof(HijackArgs, S2)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S3, offsetof(HijackArgs, S3)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S4, offsetof(HijackArgs, S4)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S5, offsetof(HijackArgs, S5)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S6, offsetof(HijackArgs, S6)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S7, offsetof(HijackArgs, S7)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, S8, offsetof(HijackArgs, S8)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, A0, offsetof(HijackArgs, A0)) +CDAC_TYPE_FIELD(HijackArgs, T_POINTER, A1, offsetof(HijackArgs, A1)) #endif // Platform switch CDAC_TYPE_END(HijackArgs) @@ -1030,14 +1030,14 @@ CDAC_TYPE_END(HijackArgs) CDAC_TYPE_BEGIN(FaultingExceptionFrame) CDAC_TYPE_SIZE(sizeof(FaultingExceptionFrame)) -CDAC_TYPE_FIELD(FaultingExceptionFrame, /*T_CONTEXT*/, TargetContext, cdac_data::TargetContext) +CDAC_TYPE_FIELD(FaultingExceptionFrame, T_POINTER, TargetContext, cdac_data::TargetContext) CDAC_TYPE_END(FaultingExceptionFrame) #if defined(TARGET_X86) && !defined(UNIX_X86_ABI) CDAC_TYPE_BEGIN(TailCallFrame) CDAC_TYPE_SIZE(sizeof(TailCallFrame)) -CDAC_TYPE_FIELD(TailCallFrame, /*CalleeSavedRegisters*/, CalleeSavedRegisters, cdac_data::CalleeSavedRegisters) -CDAC_TYPE_FIELD(TailCallFrame, /*pointer*/, ReturnAddress, cdac_data::ReturnAddress) +CDAC_TYPE_FIELD(TailCallFrame, TYPE(CalleeSavedRegisters), CalleeSavedRegisters, cdac_data::CalleeSavedRegisters) +CDAC_TYPE_FIELD(TailCallFrame, T_POINTER, ReturnAddress, cdac_data::ReturnAddress) CDAC_TYPE_END(TailCallFrame) #endif // TARGET_X86 && !UNIX_X86_ABI @@ -1046,10 +1046,10 @@ CDAC_TYPE_BEGIN(ArgumentRegisters) CDAC_TYPE_SIZE(sizeof(ArgumentRegisters)) #if defined(TARGET_ARM) -CDAC_TYPE_FIELD(ArgumentRegisters, /*nuint*/, R0, offsetof(ArgumentRegisters, r[0])) -CDAC_TYPE_FIELD(ArgumentRegisters, /*nuint*/, R1, offsetof(ArgumentRegisters, r[1])) -CDAC_TYPE_FIELD(ArgumentRegisters, /*nuint*/, R2, offsetof(ArgumentRegisters, r[2])) -CDAC_TYPE_FIELD(ArgumentRegisters, /*nuint*/, R3, offsetof(ArgumentRegisters, r[3])) +CDAC_TYPE_FIELD(ArgumentRegisters, T_NUINT, R0, offsetof(ArgumentRegisters, r[0])) +CDAC_TYPE_FIELD(ArgumentRegisters, T_NUINT, R1, offsetof(ArgumentRegisters, r[1])) +CDAC_TYPE_FIELD(ArgumentRegisters, T_NUINT, R2, offsetof(ArgumentRegisters, r[2])) +CDAC_TYPE_FIELD(ArgumentRegisters, T_NUINT, R3, offsetof(ArgumentRegisters, r[3])) #endif // TARGET_ARM CDAC_TYPE_END(ArgumentRegisters) @@ -1060,156 +1060,156 @@ CDAC_TYPE_SIZE(sizeof(CalleeSavedRegisters)) #if defined(TARGET_AMD64) || defined(TARGET_X86) #define CALLEE_SAVED_REGISTER(regname) \ - CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, regname, offsetof(CalleeSavedRegisters, regname)) + CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, regname, offsetof(CalleeSavedRegisters, regname)) ENUM_CALLEE_SAVED_REGISTERS() #undef CALLEE_SAVED_REGISTER #elif defined(TARGET_ARM) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R4, offsetof(CalleeSavedRegisters, r4)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R5, offsetof(CalleeSavedRegisters, r5)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R6, offsetof(CalleeSavedRegisters, r6)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R7, offsetof(CalleeSavedRegisters, r7)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R8, offsetof(CalleeSavedRegisters, r8)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R9, offsetof(CalleeSavedRegisters, r9)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R10, offsetof(CalleeSavedRegisters, r10)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, R11, offsetof(CalleeSavedRegisters, r11)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Lr, offsetof(CalleeSavedRegisters, r14)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R4, offsetof(CalleeSavedRegisters, r4)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R5, offsetof(CalleeSavedRegisters, r5)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R6, offsetof(CalleeSavedRegisters, r6)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R7, offsetof(CalleeSavedRegisters, r7)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R8, offsetof(CalleeSavedRegisters, r8)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R9, offsetof(CalleeSavedRegisters, r9)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R10, offsetof(CalleeSavedRegisters, r10)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, R11, offsetof(CalleeSavedRegisters, r11)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Lr, offsetof(CalleeSavedRegisters, r14)) #elif defined(TARGET_ARM64) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X19, offsetof(CalleeSavedRegisters, x19)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X20, offsetof(CalleeSavedRegisters, x20)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X21, offsetof(CalleeSavedRegisters, x21)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X22, offsetof(CalleeSavedRegisters, x22)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X23, offsetof(CalleeSavedRegisters, x23)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X24, offsetof(CalleeSavedRegisters, x24)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X25, offsetof(CalleeSavedRegisters, x25)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X26, offsetof(CalleeSavedRegisters, x26)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X27, offsetof(CalleeSavedRegisters, x27)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X28, offsetof(CalleeSavedRegisters, x28)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Fp, offsetof(CalleeSavedRegisters, x29)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Lr, offsetof(CalleeSavedRegisters, x30)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X19, offsetof(CalleeSavedRegisters, x19)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X20, offsetof(CalleeSavedRegisters, x20)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X21, offsetof(CalleeSavedRegisters, x21)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X22, offsetof(CalleeSavedRegisters, x22)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X23, offsetof(CalleeSavedRegisters, x23)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X24, offsetof(CalleeSavedRegisters, x24)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X25, offsetof(CalleeSavedRegisters, x25)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X26, offsetof(CalleeSavedRegisters, x26)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X27, offsetof(CalleeSavedRegisters, x27)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, X28, offsetof(CalleeSavedRegisters, x28)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Fp, offsetof(CalleeSavedRegisters, x29)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Lr, offsetof(CalleeSavedRegisters, x30)) #elif defined(TARGET_RISCV64) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Fp, offsetof(CalleeSavedRegisters, fp)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Ra, offsetof(CalleeSavedRegisters, ra)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S1, offsetof(CalleeSavedRegisters, s1)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S2, offsetof(CalleeSavedRegisters, s2)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S3, offsetof(CalleeSavedRegisters, s3)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S4, offsetof(CalleeSavedRegisters, s4)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S5, offsetof(CalleeSavedRegisters, s5)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S6, offsetof(CalleeSavedRegisters, s6)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S7, offsetof(CalleeSavedRegisters, s7)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S8, offsetof(CalleeSavedRegisters, s8)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S9, offsetof(CalleeSavedRegisters, s9)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S10, offsetof(CalleeSavedRegisters, s10)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S11, offsetof(CalleeSavedRegisters, s11)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Tp, offsetof(CalleeSavedRegisters, tp)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Gp, offsetof(CalleeSavedRegisters, gp)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Fp, offsetof(CalleeSavedRegisters, fp)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Ra, offsetof(CalleeSavedRegisters, ra)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S1, offsetof(CalleeSavedRegisters, s1)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S2, offsetof(CalleeSavedRegisters, s2)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S3, offsetof(CalleeSavedRegisters, s3)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S4, offsetof(CalleeSavedRegisters, s4)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S5, offsetof(CalleeSavedRegisters, s5)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S6, offsetof(CalleeSavedRegisters, s6)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S7, offsetof(CalleeSavedRegisters, s7)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S8, offsetof(CalleeSavedRegisters, s8)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S9, offsetof(CalleeSavedRegisters, s9)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S10, offsetof(CalleeSavedRegisters, s10)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S11, offsetof(CalleeSavedRegisters, s11)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Tp, offsetof(CalleeSavedRegisters, tp)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Gp, offsetof(CalleeSavedRegisters, gp)) #elif defined(TARGET_LOONGARCH64) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Fp, offsetof(CalleeSavedRegisters, fp)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Ra, offsetof(CalleeSavedRegisters, ra)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S0, offsetof(CalleeSavedRegisters, s0)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S1, offsetof(CalleeSavedRegisters, s1)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S2, offsetof(CalleeSavedRegisters, s2)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S3, offsetof(CalleeSavedRegisters, s3)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S4, offsetof(CalleeSavedRegisters, s4)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S5, offsetof(CalleeSavedRegisters, s5)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S6, offsetof(CalleeSavedRegisters, s6)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S7, offsetof(CalleeSavedRegisters, s7)) -CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, S8, offsetof(CalleeSavedRegisters, s8)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Fp, offsetof(CalleeSavedRegisters, fp)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, Ra, offsetof(CalleeSavedRegisters, ra)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S0, offsetof(CalleeSavedRegisters, s0)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S1, offsetof(CalleeSavedRegisters, s1)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S2, offsetof(CalleeSavedRegisters, s2)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S3, offsetof(CalleeSavedRegisters, s3)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S4, offsetof(CalleeSavedRegisters, s4)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S5, offsetof(CalleeSavedRegisters, s5)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S6, offsetof(CalleeSavedRegisters, s6)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S7, offsetof(CalleeSavedRegisters, s7)) +CDAC_TYPE_FIELD(CalleeSavedRegisters, T_NUINT, S8, offsetof(CalleeSavedRegisters, s8)) #endif // Platform switch CDAC_TYPE_END(CalleeSavedRegisters) CDAC_TYPE_BEGIN(EETypeHashTable) CDAC_TYPE_INDETERMINATE(EETypeHashTable) -CDAC_TYPE_FIELD(EETypeHashTable, /*pointer*/, Buckets, cdac_data::Buckets) -CDAC_TYPE_FIELD(EETypeHashTable, /*uint32*/, Count, cdac_data::Count) -CDAC_TYPE_FIELD(EETypeHashTable, /*pointer*/, VolatileEntryValue, cdac_data::VolatileEntryValue) -CDAC_TYPE_FIELD(EETypeHashTable, /*pointer*/, VolatileEntryNextEntry, cdac_data::VolatileEntryNextEntry) +CDAC_TYPE_FIELD(EETypeHashTable, T_POINTER, Buckets, cdac_data::Buckets) +CDAC_TYPE_FIELD(EETypeHashTable, T_UINT32, Count, cdac_data::Count) +CDAC_TYPE_FIELD(EETypeHashTable, T_POINTER, VolatileEntryValue, cdac_data::VolatileEntryValue) +CDAC_TYPE_FIELD(EETypeHashTable, T_POINTER, VolatileEntryNextEntry, cdac_data::VolatileEntryNextEntry) CDAC_TYPE_END(EETypeHashTable) CDAC_TYPE_BEGIN(InstMethodHashTable) CDAC_TYPE_INDETERMINATE(InstMethodHashTable) -CDAC_TYPE_FIELD(InstMethodHashTable, /*pointer*/, Buckets, cdac_data::Buckets) -CDAC_TYPE_FIELD(InstMethodHashTable, /*uint32*/, Count, cdac_data::Count) -CDAC_TYPE_FIELD(InstMethodHashTable, /*pointer*/, VolatileEntryValue, cdac_data::VolatileEntryValue) -CDAC_TYPE_FIELD(InstMethodHashTable, /*pointer*/, VolatileEntryNextEntry, cdac_data::VolatileEntryNextEntry) +CDAC_TYPE_FIELD(InstMethodHashTable, T_POINTER, Buckets, cdac_data::Buckets) +CDAC_TYPE_FIELD(InstMethodHashTable, T_UINT32, Count, cdac_data::Count) +CDAC_TYPE_FIELD(InstMethodHashTable, T_POINTER, VolatileEntryValue, cdac_data::VolatileEntryValue) +CDAC_TYPE_FIELD(InstMethodHashTable, T_POINTER, VolatileEntryNextEntry, cdac_data::VolatileEntryNextEntry) CDAC_TYPE_END(InstMethodHashTable) CDAC_TYPE_BEGIN(CoreLibBinder) CDAC_TYPE_INDETERMINATE(CoreLibBinder) -CDAC_TYPE_FIELD(CoreLibBinder, /*pointer*/, Classes, cdac_data::Classes) +CDAC_TYPE_FIELD(CoreLibBinder, T_POINTER, Classes, cdac_data::Classes) CDAC_TYPE_END(CoreLibBinder) // this is an SHash type CDAC_TYPE_BEGIN(DynamicILBlobTable) CDAC_TYPE_SIZE(cdac_data::EntrySize) -CDAC_TYPE_FIELD(DynamicILBlobTable, /*pointer*/, Table, cdac_data::Table) -CDAC_TYPE_FIELD(DynamicILBlobTable, /*uint32*/, TableSize, cdac_data::TableSize) -CDAC_TYPE_FIELD(DynamicILBlobTable, /*uint32*/, EntryMethodToken, cdac_data::EntryMethodToken) -CDAC_TYPE_FIELD(DynamicILBlobTable, /*pointer*/, EntryIL, cdac_data::EntryIL) +CDAC_TYPE_FIELD(DynamicILBlobTable, T_POINTER, Table, cdac_data::Table) +CDAC_TYPE_FIELD(DynamicILBlobTable, T_UINT32, TableSize, cdac_data::TableSize) +CDAC_TYPE_FIELD(DynamicILBlobTable, T_UINT32, EntryMethodToken, cdac_data::EntryMethodToken) +CDAC_TYPE_FIELD(DynamicILBlobTable, T_POINTER, EntryIL, cdac_data::EntryIL) CDAC_TYPE_END(DynamicILBlobTable) #ifdef FEATURE_COMINTEROP CDAC_TYPE_BEGIN(ComCallWrapper) CDAC_TYPE_INDETERMINATE(ComCallWrapper) -CDAC_TYPE_FIELD(ComCallWrapper, /*pointer*/, Handle, cdac_data::Handle) -CDAC_TYPE_FIELD(ComCallWrapper, /*pointer*/, SimpleWrapper, cdac_data::SimpleWrapper) -CDAC_TYPE_FIELD(ComCallWrapper, /*pointer*/, IPtr, cdac_data::IPtr) -CDAC_TYPE_FIELD(ComCallWrapper, /*pointer*/, Next, cdac_data::Next) +CDAC_TYPE_FIELD(ComCallWrapper, T_POINTER, Handle, cdac_data::Handle) +CDAC_TYPE_FIELD(ComCallWrapper, T_POINTER, SimpleWrapper, cdac_data::SimpleWrapper) +CDAC_TYPE_FIELD(ComCallWrapper, T_POINTER, IPtr, cdac_data::IPtr) +CDAC_TYPE_FIELD(ComCallWrapper, T_POINTER, Next, cdac_data::Next) CDAC_TYPE_END(ComCallWrapper) CDAC_TYPE_BEGIN(SimpleComCallWrapper) CDAC_TYPE_INDETERMINATE(SimpleComCallWrapper) -CDAC_TYPE_FIELD(SimpleComCallWrapper, /*pointer*/, OuterIUnknown, cdac_data::OuterIUnknown) -CDAC_TYPE_FIELD(SimpleComCallWrapper, /*int64*/, RefCount, cdac_data::RefCount) -CDAC_TYPE_FIELD(SimpleComCallWrapper, /*uint32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(SimpleComCallWrapper, /*pointer*/, MainWrapper, cdac_data::MainWrapper) -CDAC_TYPE_FIELD(SimpleComCallWrapper, /*pointer*/, VTablePtr, cdac_data::VTablePtr) +CDAC_TYPE_FIELD(SimpleComCallWrapper, T_POINTER, OuterIUnknown, cdac_data::OuterIUnknown) +CDAC_TYPE_FIELD(SimpleComCallWrapper, T_INT64, RefCount, cdac_data::RefCount) +CDAC_TYPE_FIELD(SimpleComCallWrapper, T_UINT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(SimpleComCallWrapper, T_POINTER, MainWrapper, cdac_data::MainWrapper) +CDAC_TYPE_FIELD(SimpleComCallWrapper, T_POINTER, VTablePtr, cdac_data::VTablePtr) CDAC_TYPE_END(SimpleComCallWrapper) CDAC_TYPE_BEGIN(ComMethodTable) CDAC_TYPE_SIZE(sizeof(ComMethodTable)) -CDAC_TYPE_FIELD(ComMethodTable, /*nuint*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(ComMethodTable, /*pointer*/, MethodTable, cdac_data::MethodTable) +CDAC_TYPE_FIELD(ComMethodTable, T_NUINT, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(ComMethodTable, T_POINTER, MethodTable, cdac_data::MethodTable) CDAC_TYPE_END(ComMethodTable) CDAC_TYPE_BEGIN(RCWCleanupList) CDAC_TYPE_INDETERMINATE(RCWCleanupList) -CDAC_TYPE_FIELD(RCWCleanupList, /*pointer*/, FirstBucket, cdac_data::FirstBucket) +CDAC_TYPE_FIELD(RCWCleanupList, T_POINTER, FirstBucket, cdac_data::FirstBucket) CDAC_TYPE_END(RCWCleanupList) CDAC_TYPE_BEGIN(RCW) CDAC_TYPE_INDETERMINATE(RCW) -CDAC_TYPE_FIELD(RCW, /*pointer*/, NextCleanupBucket, cdac_data::NextCleanupBucket) -CDAC_TYPE_FIELD(RCW, /*pointer*/, NextRCW, cdac_data::NextRCW) -CDAC_TYPE_FIELD(RCW, /*uint32*/, Flags, cdac_data::Flags) -CDAC_TYPE_FIELD(RCW, /*pointer*/, CtxCookie, cdac_data::CtxCookie) -CDAC_TYPE_FIELD(RCW, /*pointer*/, CtxEntry, cdac_data::CtxEntry) -CDAC_TYPE_FIELD(RCW, /*inline array*/, InterfaceEntries, cdac_data::InterfaceEntries) -CDAC_TYPE_FIELD(RCW, /*pointer*/, IdentityPointer, cdac_data::IdentityPointer) -CDAC_TYPE_FIELD(RCW, /*uint32*/, SyncBlockIndex, cdac_data::SyncBlockIndex) -CDAC_TYPE_FIELD(RCW, /*pointer*/, VTablePtr, cdac_data::VTablePtr) -CDAC_TYPE_FIELD(RCW, /*pointer*/, CreatorThread, cdac_data::CreatorThread) -CDAC_TYPE_FIELD(RCW, /*uint32*/, RefCount, cdac_data::RefCount) -CDAC_TYPE_FIELD(RCW, /*pointer*/, UnknownPointer, cdac_data::UnknownPointer) +CDAC_TYPE_FIELD(RCW, T_POINTER, NextCleanupBucket, cdac_data::NextCleanupBucket) +CDAC_TYPE_FIELD(RCW, T_POINTER, NextRCW, cdac_data::NextRCW) +CDAC_TYPE_FIELD(RCW, T_UINT32, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(RCW, T_POINTER, CtxCookie, cdac_data::CtxCookie) +CDAC_TYPE_FIELD(RCW, T_POINTER, CtxEntry, cdac_data::CtxEntry) +CDAC_TYPE_FIELD(RCW, T_ARRAY(TYPE(InterfaceEntry)), InterfaceEntries, cdac_data::InterfaceEntries) +CDAC_TYPE_FIELD(RCW, T_POINTER, IdentityPointer, cdac_data::IdentityPointer) +CDAC_TYPE_FIELD(RCW, T_UINT32, SyncBlockIndex, cdac_data::SyncBlockIndex) +CDAC_TYPE_FIELD(RCW, T_POINTER, VTablePtr, cdac_data::VTablePtr) +CDAC_TYPE_FIELD(RCW, T_POINTER, CreatorThread, cdac_data::CreatorThread) +CDAC_TYPE_FIELD(RCW, T_UINT32, RefCount, cdac_data::RefCount) +CDAC_TYPE_FIELD(RCW, T_POINTER, UnknownPointer, cdac_data::UnknownPointer) CDAC_TYPE_END(RCW) CDAC_TYPE_BEGIN(CtxEntry) CDAC_TYPE_INDETERMINATE(CtxEntry) -CDAC_TYPE_FIELD(CtxEntry, /*pointer*/, STAThread, cdac_data::STAThread) -CDAC_TYPE_FIELD(CtxEntry, /*pointer*/, CtxCookie, cdac_data::CtxCookie) +CDAC_TYPE_FIELD(CtxEntry, T_POINTER, STAThread, cdac_data::STAThread) +CDAC_TYPE_FIELD(CtxEntry, T_POINTER, CtxCookie, cdac_data::CtxCookie) CDAC_TYPE_END(CtxEntry) CDAC_TYPE_BEGIN(InterfaceEntry) CDAC_TYPE_SIZE(sizeof(InterfaceEntry)) -CDAC_TYPE_FIELD(InterfaceEntry, /*pointer*/, MethodTable, cdac_data::MethodTable) -CDAC_TYPE_FIELD(InterfaceEntry, /*pointer*/, Unknown, cdac_data::Unknown) +CDAC_TYPE_FIELD(InterfaceEntry, T_POINTER, MethodTable, cdac_data::MethodTable) +CDAC_TYPE_FIELD(InterfaceEntry, T_POINTER, Unknown, cdac_data::Unknown) CDAC_TYPE_END(InterfaceEntry) #endif // FEATURE_COMINTEROP @@ -1221,22 +1221,22 @@ CDAC_TYPE_END(ComWrappersVtablePtrs) CDAC_TYPE_BEGIN(SyncBlockCache) CDAC_TYPE_INDETERMINATE(SyncBlockCache) -CDAC_TYPE_FIELD(SyncBlockCache, /*uint32*/, FreeSyncTableIndex, cdac_data::FreeSyncTableIndex) -CDAC_TYPE_FIELD(SyncBlockCache, /*pointer*/, CleanupBlockList, cdac_data::CleanupBlockList) +CDAC_TYPE_FIELD(SyncBlockCache, T_UINT32, FreeSyncTableIndex, cdac_data::FreeSyncTableIndex) +CDAC_TYPE_FIELD(SyncBlockCache, T_POINTER, CleanupBlockList, cdac_data::CleanupBlockList) CDAC_TYPE_END(SyncBlockCache) #ifdef FEATURE_WEBCIL CDAC_TYPE_BEGIN(WebcilHeader) CDAC_TYPE_SIZE(sizeof(WebcilHeader)) -CDAC_TYPE_FIELD(WebcilHeader, /*uint16*/, CoffSections, offsetof(WebcilHeader, CoffSections)) +CDAC_TYPE_FIELD(WebcilHeader, T_UINT16, CoffSections, offsetof(WebcilHeader, CoffSections)) CDAC_TYPE_END(WebcilHeader) CDAC_TYPE_BEGIN(WebcilSectionHeader) CDAC_TYPE_SIZE(sizeof(WebcilSectionHeader)) -CDAC_TYPE_FIELD(WebcilSectionHeader, /*uint32*/, VirtualSize, offsetof(WebcilSectionHeader, VirtualSize)) -CDAC_TYPE_FIELD(WebcilSectionHeader, /*uint32*/, VirtualAddress, offsetof(WebcilSectionHeader, VirtualAddress)) -CDAC_TYPE_FIELD(WebcilSectionHeader, /*uint32*/, SizeOfRawData, offsetof(WebcilSectionHeader, SizeOfRawData)) -CDAC_TYPE_FIELD(WebcilSectionHeader, /*uint32*/, PointerToRawData, offsetof(WebcilSectionHeader, PointerToRawData)) +CDAC_TYPE_FIELD(WebcilSectionHeader, T_UINT32, VirtualSize, offsetof(WebcilSectionHeader, VirtualSize)) +CDAC_TYPE_FIELD(WebcilSectionHeader, T_UINT32, VirtualAddress, offsetof(WebcilSectionHeader, VirtualAddress)) +CDAC_TYPE_FIELD(WebcilSectionHeader, T_UINT32, SizeOfRawData, offsetof(WebcilSectionHeader, SizeOfRawData)) +CDAC_TYPE_FIELD(WebcilSectionHeader, T_UINT32, PointerToRawData, offsetof(WebcilSectionHeader, PointerToRawData)) CDAC_TYPE_END(WebcilSectionHeader) #endif @@ -1283,7 +1283,7 @@ CDAC_GLOBAL_STRING(Architecture, wasm) CDAC_GLOBAL_STRING(RID, RID_STRING) -CDAC_GLOBAL(GCInfoVersion, uint32, GCINFO_VERSION) +CDAC_GLOBAL(GCInfoVersion, T_UINT32, GCINFO_VERSION) CDAC_GLOBAL_POINTER(AppDomain, &AppDomain::m_pTheAppDomain) CDAC_GLOBAL_POINTER(SystemDomain, cdac_data::SystemDomainPtr) @@ -1293,72 +1293,72 @@ CDAC_GLOBAL_POINTER(GCThread, &::g_pSuspensionThread) // Add FrameIdentifier for all defined Frame types. Used to differentiate Frame objects. #define FRAME_TYPE_NAME(frameType) \ - CDAC_GLOBAL(frameType##Identifier, nuint, (uint64_t)FrameIdentifier::frameType) + CDAC_GLOBAL(frameType##Identifier, T_NUINT, (uint64_t)FrameIdentifier::frameType) #include "frames.h" #undef FRAME_TYPE_NAME -CDAC_GLOBAL(MethodDescTokenRemainderBitCount, uint8, METHOD_TOKEN_REMAINDER_BIT_COUNT) +CDAC_GLOBAL(MethodDescTokenRemainderBitCount, T_UINT8, METHOD_TOKEN_REMAINDER_BIT_COUNT) #if FEATURE_COMINTEROP -CDAC_GLOBAL(FeatureCOMInterop, uint8, 1) +CDAC_GLOBAL(FeatureCOMInterop, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureCOMInterop, uint8, 0) +CDAC_GLOBAL(FeatureCOMInterop, T_UINT8, 0) #endif #if FEATURE_COMWRAPPERS -CDAC_GLOBAL(FeatureComWrappers, uint8, 1) +CDAC_GLOBAL(FeatureComWrappers, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureComWrappers, uint8, 0) +CDAC_GLOBAL(FeatureComWrappers, T_UINT8, 0) #endif #if FEATURE_OBJCMARSHAL -CDAC_GLOBAL(FeatureObjCMarshal, uint8, 1) +CDAC_GLOBAL(FeatureObjCMarshal, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureObjCMarshal, uint8, 0) +CDAC_GLOBAL(FeatureObjCMarshal, T_UINT8, 0) #endif #if FEATURE_JAVAMARSHAL -CDAC_GLOBAL(FeatureJavaMarshal, uint8, 1) +CDAC_GLOBAL(FeatureJavaMarshal, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureJavaMarshal, uint8, 0) +CDAC_GLOBAL(FeatureJavaMarshal, T_UINT8, 0) #endif #ifdef FEATURE_ON_STACK_REPLACEMENT -CDAC_GLOBAL(FeatureOnStackReplacement, uint8, 1) +CDAC_GLOBAL(FeatureOnStackReplacement, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureOnStackReplacement, uint8, 0) +CDAC_GLOBAL(FeatureOnStackReplacement, T_UINT8, 0) #endif // FEATURE_ON_STACK_REPLACEMENT #ifdef FEATURE_WEBCIL -CDAC_GLOBAL(FeatureWebcil, uint8, 1) +CDAC_GLOBAL(FeatureWebcil, T_UINT8, 1) #else -CDAC_GLOBAL(FeatureWebcil, uint8, 0) +CDAC_GLOBAL(FeatureWebcil, T_UINT8, 0) #endif // See Object::GetGCSafeMethodTable #ifdef TARGET_64BIT -CDAC_GLOBAL(ObjectToMethodTableUnmask, uint8, 1 | 1 << 1 | 1 << 2) +CDAC_GLOBAL(ObjectToMethodTableUnmask, T_UINT8, 1 | 1 << 1 | 1 << 2) #else -CDAC_GLOBAL(ObjectToMethodTableUnmask, uint8, 1 | 1 << 1) +CDAC_GLOBAL(ObjectToMethodTableUnmask, T_UINT8, 1 | 1 << 1) #endif //TARGET_64BIT #ifdef FEATURE_PORTABLE_ENTRYPOINTS -CDAC_GLOBAL(FeaturePortableEntrypoints, uint8, 1) +CDAC_GLOBAL(FeaturePortableEntrypoints, T_UINT8, 1) #else -CDAC_GLOBAL(FeaturePortableEntrypoints, uint8, 0) +CDAC_GLOBAL(FeaturePortableEntrypoints, T_UINT8, 0) #endif // FEATURE_PORTABLE_ENTRYPOINTS -CDAC_GLOBAL(SOSBreakingChangeVersion, uint8, SOS_BREAKING_CHANGE_VERSION) -CDAC_GLOBAL(RecommendedReaderVersion, uint32, CDAC_RECOMMENDED_READER_VERSION) -CDAC_GLOBAL(DirectorySeparator, uint8, (uint8_t)DIRECTORY_SEPARATOR_CHAR_A) -CDAC_GLOBAL(HashMapSlotsPerBucket, uint32, SLOTS_PER_BUCKET) -CDAC_GLOBAL(HashMapValueMask, uint64, VALUE_MASK) -CDAC_GLOBAL(MethodDescAlignment, uint64, MethodDesc::ALIGNMENT) -CDAC_GLOBAL(ArrayBaseSize, uint32, ARRAYBASE_BASESIZE) -CDAC_GLOBAL(SyncBlockValueToObjectOffset, uint16, OBJHEADER_SIZE - cdac_data::SyncBlockValue) -CDAC_GLOBAL(StubCodeBlockLast, uint8, STUB_CODE_BLOCK_LAST) -CDAC_GLOBAL(DefaultADID, uint32, DefaultADID) +CDAC_GLOBAL(SOSBreakingChangeVersion, T_UINT8, SOS_BREAKING_CHANGE_VERSION) +CDAC_GLOBAL(RecommendedReaderVersion, T_UINT32, CDAC_RECOMMENDED_READER_VERSION) +CDAC_GLOBAL(DirectorySeparator, T_UINT8, (uint8_t)DIRECTORY_SEPARATOR_CHAR_A) +CDAC_GLOBAL(HashMapSlotsPerBucket, T_UINT32, SLOTS_PER_BUCKET) +CDAC_GLOBAL(HashMapValueMask, T_UINT64, VALUE_MASK) +CDAC_GLOBAL(MethodDescAlignment, T_UINT64, MethodDesc::ALIGNMENT) +CDAC_GLOBAL(ArrayBaseSize, T_UINT32, ARRAYBASE_BASESIZE) +CDAC_GLOBAL(SyncBlockValueToObjectOffset, T_UINT16, OBJHEADER_SIZE - cdac_data::SyncBlockValue) +CDAC_GLOBAL(StubCodeBlockLast, T_UINT8, STUB_CODE_BLOCK_LAST) +CDAC_GLOBAL(DefaultADID, T_UINT32, DefaultADID) #ifndef TARGET_UNIX -CDAC_GLOBAL(SizeOfGenericModeBlock, uint32, sizeof(GenericModeBlock)) +CDAC_GLOBAL(SizeOfGenericModeBlock, T_UINT32, sizeof(GenericModeBlock)) #endif -CDAC_GLOBAL(StaticsPointerMask, uintptr_t, DynamicStaticsInfo::STATICSPOINTERMASK) -CDAC_GLOBAL(PtrArrayOffsetToDataArray, uintptr_t, offsetof(PtrArray, m_Array)) -CDAC_GLOBAL(NumberOfTlsOffsetsNotUsedInNoncollectibleArray, uint8, NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY) -CDAC_GLOBAL(MaxClrNotificationArgs, uint32, MAX_CLR_NOTIFICATION_ARGS) -CDAC_GLOBAL(FieldOffsetBigRVA, uint32, FIELD_OFFSET_BIG_RVA) -CDAC_GLOBAL(FieldOffsetDynamicRVA, uint32, FIELD_OFFSET_DYNAMIC_RVA) +CDAC_GLOBAL(StaticsPointerMask, T_NUINT, DynamicStaticsInfo::STATICSPOINTERMASK) +CDAC_GLOBAL(PtrArrayOffsetToDataArray, T_NUINT, offsetof(PtrArray, m_Array)) +CDAC_GLOBAL(NumberOfTlsOffsetsNotUsedInNoncollectibleArray, T_UINT8, NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY) +CDAC_GLOBAL(MaxClrNotificationArgs, T_UINT32, MAX_CLR_NOTIFICATION_ARGS) +CDAC_GLOBAL(FieldOffsetBigRVA, T_UINT32, FIELD_OFFSET_BIG_RVA) +CDAC_GLOBAL(FieldOffsetDynamicRVA, T_UINT32, FIELD_OFFSET_DYNAMIC_RVA) CDAC_GLOBAL_POINTER(ClrNotificationArguments, &::g_clrNotificationArguments) CDAC_GLOBAL_POINTER(ArrayBoundsZero, cdac_data::ArrayBoundsZero) CDAC_GLOBAL_POINTER(ContinuationMethodTable, &::g_pContinuationClassIfSubTypeCreated) @@ -1374,7 +1374,7 @@ CDAC_GLOBAL_POINTER(DacNotificationFlags, &::g_dacNotificationFlags) CDAC_GLOBAL_POINTER(OffsetOfCurrentThreadInfo, &::g_offsetOfCurrentThreadInfo) CDAC_GLOBAL_POINTER(ThinlockThreadIdDispenser, &::g_pThinLockThreadIdDispenser) #ifdef FEATURE_COMWRAPPERS -CDAC_GLOBAL(DispatchThisPtrMask, uintptr_t, InteropLib::ABI::DispatchThisPtrMask) +CDAC_GLOBAL(DispatchThisPtrMask, T_NUINT, InteropLib::ABI::DispatchThisPtrMask) CDAC_GLOBAL_POINTER(ComWrappersVtablePtrs, InteropLib::ABI::g_knownQueryInterfaceImplementations) #endif // FEATURE_COMWRAPPERS CDAC_GLOBAL_POINTER(GcNotificationFlags, &::g_gcNotificationFlags) @@ -1384,39 +1384,39 @@ CDAC_GLOBAL_POINTER(CoreLib, &::g_CoreLib) CDAC_GLOBAL_POINTER(TlsIndexBase, &::_tls_index) #endif // TARGET_WINDOWS #ifdef STRESS_LOG -CDAC_GLOBAL(StressLogEnabled, uint8, 1) +CDAC_GLOBAL(StressLogEnabled, T_UINT8, 1) CDAC_GLOBAL_POINTER(StressLog, &g_pStressLog) -CDAC_GLOBAL(StressLogHasModuleTable, uint8, 1) -CDAC_GLOBAL(StressLogMaxModules, uint64, cdac_offsets::MAX_MODULES) -CDAC_GLOBAL(StressLogChunkSize, uint32, STRESSLOG_CHUNK_SIZE) -CDAC_GLOBAL(StressLogValidChunkSig, uint32, StressLogChunk::ValidChunkSig) -CDAC_GLOBAL(StressLogMaxMessageSize, uint64, (uint64_t)StressMsg::maxMsgSize) +CDAC_GLOBAL(StressLogHasModuleTable, T_UINT8, 1) +CDAC_GLOBAL(StressLogMaxModules, T_UINT64, cdac_offsets::MAX_MODULES) +CDAC_GLOBAL(StressLogChunkSize, T_UINT32, STRESSLOG_CHUNK_SIZE) +CDAC_GLOBAL(StressLogValidChunkSig, T_UINT32, StressLogChunk::ValidChunkSig) +CDAC_GLOBAL(StressLogMaxMessageSize, T_UINT64, (uint64_t)StressMsg::maxMsgSize) #else -CDAC_GLOBAL(StressLogEnabled, uint8, 0) +CDAC_GLOBAL(StressLogEnabled, T_UINT8, 0) #endif CDAC_GLOBAL_POINTER(ExecutionManagerCodeRangeMapAddress, cdac_data::CodeRangeMapAddress) CDAC_GLOBAL_POINTER(EEJitManagerAddress, cdac_data::EEJitManagerAddress) CDAC_GLOBAL_POINTER(PlatformMetadata, &::g_cdacPlatformMetadata) CDAC_GLOBAL_POINTER(ProfilerControlBlock, &::g_profControlBlock) CDAC_GLOBAL_POINTER(SyncBlockCache, &SyncBlockCache::s_pSyncBlockCache) -CDAC_GLOBAL(SyncBlockMaskLockThreadId, uint32, SBLK_MASK_LOCK_THREADID) -CDAC_GLOBAL(SyncBlockMaskLockRecursionLevel, uint32, SBLK_MASK_LOCK_RECLEVEL) -CDAC_GLOBAL(SyncBlockRecursionLevelShift, uint32, SBLK_RECLEVEL_SHIFT) -CDAC_GLOBAL(SyncBlockIsHashOrSyncBlockIndex, uint32, BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) -CDAC_GLOBAL(SyncBlockIsHashCode, uint32, BIT_SBLK_IS_HASHCODE) -CDAC_GLOBAL(SyncBlockIndexMask, uint32, MASK_SYNCBLOCKINDEX) -CDAC_GLOBAL(SyncBlockHashCodeMask, uint32, MASK_HASHCODE) +CDAC_GLOBAL(SyncBlockMaskLockThreadId, T_UINT32, SBLK_MASK_LOCK_THREADID) +CDAC_GLOBAL(SyncBlockMaskLockRecursionLevel, T_UINT32, SBLK_MASK_LOCK_RECLEVEL) +CDAC_GLOBAL(SyncBlockRecursionLevelShift, T_UINT32, SBLK_RECLEVEL_SHIFT) +CDAC_GLOBAL(SyncBlockIsHashOrSyncBlockIndex, T_UINT32, BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) +CDAC_GLOBAL(SyncBlockIsHashCode, T_UINT32, BIT_SBLK_IS_HASHCODE) +CDAC_GLOBAL(SyncBlockIndexMask, T_UINT32, MASK_SYNCBLOCKINDEX) +CDAC_GLOBAL(SyncBlockHashCodeMask, T_UINT32, MASK_HASHCODE) CDAC_GLOBAL_POINTER(GCLowestAddress, &g_lowest_address) CDAC_GLOBAL_POINTER(GCHighestAddress, &g_highest_address) #if FEATURE_COMINTEROP -CDAC_GLOBAL(CCWNumInterfaces, uint32, cdac_data::NumInterfaces) -CDAC_GLOBAL(CCWThisMask, nuint, cdac_data::ThisMask) +CDAC_GLOBAL(CCWNumInterfaces, T_UINT32, cdac_data::NumInterfaces) +CDAC_GLOBAL(CCWThisMask, T_NUINT, cdac_data::ThisMask) CDAC_GLOBAL_POINTER(TearOffAddRef, &g_cdacTearOffAddRef) CDAC_GLOBAL_POINTER(TearOffAddRefSimple, &g_cdacTearOffAddRefSimple) CDAC_GLOBAL_POINTER(TearOffAddRefSimpleInner, &g_cdacTearOffAddRefSimpleInner) CDAC_GLOBAL_POINTER(RCWCleanupList, &g_pRCWCleanupList) -CDAC_GLOBAL(RCWInterfaceCacheSize, uint32, INTERFACE_ENTRY_CACHE_SIZE) +CDAC_GLOBAL(RCWInterfaceCacheSize, T_UINT32, INTERFACE_ENTRY_CACHE_SIZE) #endif // FEATURE_COMINTEROP // It is important for the subdescriptor pointers to be the last pointers in the global structure.