[cDAC] Add data descriptor field type annotations

src/coreclr/debug/datadescriptor-shared/README.md

@@ -31,6 +31,47 @@ 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 | 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` | Type not validated locally (cross-descriptor or well-known) |
+| `T_ARRAY(type)` | `pointer` | Array of the given element type. Expands to `pointer` in the blob |
+
+These defines always expand to the type name in all build configurations. Whether the
+type name string is included in the binary blob is controlled by `CDAC_STRINGIFY_TYPE`
+in `datadescriptor.cpp` (currently debug/checked builds only; release builds emit `""`
+to keep the blob compact).
+
+`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 or for well-known types that don't have a
+`CDAC_TYPE_BEGIN` in the current descriptor.
+
+`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 +97,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<T>::FieldName`
 
@@ -72,7 +113,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 +129,27 @@ 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_<name>`.
+2. **Pass 2**: Each `TYPE(name)` in `CDAC_TYPE_FIELD` expands to `struct cdac_type_tag_<name>`,
+   and `static_assert(sizeof(...))` fails if the tag struct was not declared.
+
+Primitive types (`T_UINT32`, etc.) and `EXTERN_TYPE` references (cross-descriptor or
+well-known types) 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
 

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 or well-known 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

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,24 @@ 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)
+
+// CDAC_STRINGIFY_TYPE stringifies a type annotation parameter.
+// Type defines always expand to real type names (e.g., T_UINT32 -> uint32).
+// In debug/checked builds, the type name is included in the blob string pool.
+// In release builds, "" is emitted instead to keep the blob compact.
+// To include type info in release builds, change this to use CDAC_STRINGIFY
+// unconditionally.
+#ifdef _DEBUG
+#define CDAC_STRINGIFY_TYPE(membertyname) CDAC_STRINGIFY(membertyname)
+#else
+#define CDAC_STRINGIFY_TYPE(membertyname) ""
+#endif
+
 // 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 +103,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_TYPE(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_TYPE(tyname)))
 #include "wrappeddatadescriptor.inc"
     char cdac_string_pool_trailing_nil;
 #undef DECL_LEN
@@ -368,12 +391,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_TYPE(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_TYPE(tyname) "\0"
 #include "wrappeddatadescriptor.inc"
                   ),
 

src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc

@@ -4,6 +4,65 @@
 // 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. These always expand to the type name
+// (e.g., T_UINT32 -> uint32, TYPE(GCHandle) -> GCHandle). Whether the type name
+// is included in the data descriptor blob's string pool is controlled by
+// CDAC_STRINGIFY_TYPE in datadescriptor.cpp (currently debug/checked builds only).
+// Primitive types use T_<TYPE> (e.g., T_UINT32, T_POINTER).
+// Inline struct types use TYPE(<name>) (e.g., TYPE(GCHandle), TYPE(CodePointer)).
+// EXTERN_TYPE(<name>) is the same as TYPE() but is not validated within this
+// descriptor. Use it for types declared in a different descriptor or for
+// well-known types that don't have a CDAC_TYPE_BEGIN in the current descriptor.
+// Array types use T_ARRAY(<type>) where <type> 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
+#define T_UINT8    uint8
+#endif
+#ifndef T_UINT16
+#define T_UINT16   uint16
+#endif
+#ifndef T_UINT32
+#define T_UINT32   uint32
+#endif
+#ifndef T_UINT64
+#define T_UINT64   uint64
+#endif
+#ifndef T_INT8
+#define T_INT8     int8
+#endif
+#ifndef T_INT16
+#define T_INT16    int16
+#endif
+#ifndef T_INT32
+#define T_INT32    int32
+#endif
+#ifndef T_INT64
+#define T_INT64    int64
+#endif
+#ifndef T_NUINT
+#define T_NUINT    nuint
+#endif
+#ifndef T_NINT
+#define T_NINT     nint
+#endif
+#ifndef T_POINTER
+#define T_POINTER  pointer
+#endif
+#ifndef T_BOOL
+#define T_BOOL     bool
+#endif
+#ifndef TYPE
+#define TYPE(name)          name
+#endif
+#ifndef EXTERN_TYPE
+#define EXTERN_TYPE(name)   name
+#endif
+#ifndef T_ARRAY
+#define T_ARRAY(name)       pointer
+#endif
+
 #ifndef CDAC_BASELINE
 #define CDAC_BASELINE(identifier)
 #endif