[cDAC] ArgIterator stress validation: enable byte-identical GCRefMap blobs across x64/x86 and wire ARGITER sub-check into Helix

docs/design/datacontracts/CallingConvention.md

@@ -0,0 +1,41 @@
+# Contract CallingConvention
+
+This contract walks a method's argument signature using the runtime's
+calling-convention rules so consumers can locate each argument on the
+caller's transition frame and reason about which slots hold GC references.
+
+The actual ABI (which registers hold which arguments, what alignment and
+padding rules apply, how structs are promoted to registers vs spilled, how
+varargs are passed, etc.) is documented in the CLR ABI specs and is not
+re-described here:
+
+- [Common CLR ABI conventions](../coreclr/botr/clr-abi.md)
+
+This contract's responsibility is to surface the *result* of that walk in
+a form the cDAC can use, byte-for-byte compatible with what the runtime
+itself produces.
+
+## APIs of contract
+
+``` csharp
+// Encode the argument GCRefMap blob for `methodDesc` byte-for-byte
+// compatible with the runtime's ComputeCallRefMap (frames.cpp).
+// Returns false when this contract declines to encode the method
+// (e.g. an unported ABI path); callers should map false to E_NOTIMPL.
+// When false, the value of `blob` is unspecified.
+bool TryComputeArgGCRefMapBlob(MethodDescHandle methodDesc, out byte[] blob);
+```
+
+## Version 1
+
+The single API is implemented by walking the shared `ArgIterator`
+(`src/coreclr/tools/Common/CallingConvention/ArgIterator.cs`) and feeding
+the per-argument result into a GCRefMap encoder that mirrors
+`GCRefMapBuilder` (`src/coreclr/inc/gcrefmap.h`).
+
+`TryComputeArgGCRefMapBlob` returns `false` for any method whose
+signature, ABI path, or generic context the encoder hasn't been taught
+yet. The cdacstress harness (`src/coreclr/vm/cdacstress.cpp`,
+`ARGITER` sub-check) uses byte-for-byte comparison of the returned blob
+against the runtime's `ComputeCallRefMap` output as its correctness
+oracle.

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -73,6 +73,8 @@ partial interface IRuntimeTypeSystem : IContract
     public virtual bool IsObjRef(TypeHandle typeHandle);
     // True if the MethodTable represents a type that contains managed references
     public virtual bool ContainsGCPointers(TypeHandle typeHandle);
+    // True if the MethodTable represents a byref-like value type (Span<T>, ReadOnlySpan<T>, any ref struct).
+    public virtual bool IsByRefLike(TypeHandle typeHandle);
     // True if the type requires 8-byte alignment on platforms that don't 8-byte align by default (FEATURE_64BIT_ALIGNMENT)
     public virtual bool RequiresAlign8(TypeHandle typeHandle);
     // True if the MethodTable represents a continuation type used by the async continuation feature
@@ -290,6 +292,10 @@ partial interface IRuntimeTypeSystem : IContract
     // Return true if the method is a wrapper stub (unboxing or instantiating).
     public virtual bool IsWrapperStub(MethodDescHandle methodDesc);
 
+    // Return true if the method is an unboxing stub (a wrapper around a
+    // value-type instance method that unboxes `this` before forwarding).
+    public virtual bool IsUnboxingStub(MethodDescHandle methodDesc);
+
 }
 ```
 
@@ -302,6 +308,7 @@ bool IsFieldDescStatic(TargetPointer fieldDescPointer);
 bool IsFieldDescRVA(TargetPointer fieldDescPointer);
 uint GetFieldDescType(TargetPointer fieldDescPointer);
 uint GetFieldDescOffset(TargetPointer fieldDescPointer, FieldDefinition? fieldDef);
+TypeHandle GetFieldDescApproxTypeHandle(TargetPointer fieldDescPointer);
 TargetPointer GetFieldDescStaticAddress(TargetPointer fieldDescPointer, bool unboxValueTypes = true);
 TargetPointer GetFieldDescThreadStaticAddress(TargetPointer fieldDescPointer, TargetPointer thread, bool unboxValueTypes = true);
 ```
@@ -330,6 +337,8 @@ internal partial struct RuntimeTypeSystem_1
         GenericsMask_SharedInst = 0x00000020,            // shared instantiation, e.g. List<__Canon> or List<MyValueType<__Canon>>
         GenericsMask_TypicalInstantiation = 0x00000030,  // the type instantiated at its formal parameters, e.g. List<T>
 
+        IsByRefLike = 0x00001000,                        // value type that may contain managed pointers (e.g. Span<T>, ReadOnlySpan<T>)
+
         StringArrayValues = GenericsMask_NonGeneric,
     }
 
@@ -404,6 +413,7 @@ internal partial struct RuntimeTypeSystem_1
         public bool IsTrackedReferenceWithFinalizer => GetFlag(WFLAGS_HIGH.IsTrackedReferenceWithFinalizer) != 0;
         public bool IsGenericTypeDefinition => TestFlagWithMask(WFLAGS_LOW.GenericsMask, WFLAGS_LOW.GenericsMask_TypicalInstantiation);
         public bool IsSharedByGenericInstantiations => TestFlagWithMask(WFLAGS_LOW.GenericsMask, WFLAGS_LOW.GenericsMask_SharedInst);
+        public bool IsByRefLike => TestFlagWithMask(WFLAGS_LOW.IsByRefLike, WFLAGS_LOW.IsByRefLike);
     }
 
     [Flags]
@@ -663,6 +673,8 @@ Contracts used:
 
     public bool ContainsGCPointers(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.ContainsGCPointers;
 
+    public bool IsByRefLike(TypeHandle typeHandle) => typeHandle.IsMethodTable() && _methodTables[typeHandle.Address].Flags.IsByRefLike;
+
     public bool RequiresAlign8(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[typeHandle.Address].Flags.RequiresAlign8;
 
     public bool IsCanonicalMethodTable(TypeHandle typeHandle)
@@ -1867,6 +1879,17 @@ Determining if a method is a wrapper stub (unboxing or instantiating):
     }
 ```
 
+Determining if a method is an unboxing stub. An unboxing stub is a wrapper
+around a value-type instance method whose `this` is a boxed object: the
+stub unboxes `this` and forwards to the real instance method. The bit is
+stored in `MethodDescFlags3` and surfaces as the `IsUnboxingStub` flag on
+`MethodDesc`:
+
+```csharp
+    public bool IsUnboxingStub(MethodDescHandle methodDescHandle)
+        => _methodDescs[methodDescHandle.Address].IsUnboxingStub;
+```
+
 Extracting a pointer to the `MethodDescVersioningState` data for a given method
 
 ```csharp
@@ -2227,6 +2250,15 @@ TargetPointer GetFieldDescThreadStaticAddress(TargetPointer fieldDescPointer, Ta
     // Uses GetGCThreadStaticsBasePointer / GetNonGCThreadStaticsBasePointer.
     // The unboxValueTypes parameter behaves the same as in GetFieldDescStaticAddress.
 }
+
+TypeHandle GetFieldDescApproxTypeHandle(TargetPointer fieldDescPointer)
+{
+    // Resolve enclosing MT -> Module -> MetadataReader, decode the field's
+    // signature using the SignatureDecoder contract with a SignatureTypeProvider
+    // bound to the enclosing class as generic context, and return the resulting
+    // TypeHandle. Returns TypeHandle.Null if any link in the chain is unavailable
+    // (e.g. uncached constructed instantiation).
+}
 ```
 
 ### Other APIs

eng/pipelines/runtime-diagnostics.yml

@@ -70,6 +70,7 @@ parameters:
   type: object
   default:
     - windows_x64
+    - windows_x86
     - linux_x64
     - windows_arm64
     - linux_arm64

src/coreclr/inc/clrconfigvalues.h

@@ -749,7 +749,7 @@ CONFIG_STRING_INFO(INTERNAL_PrestubHalt, W("PrestubHalt"), "")
 RETAIL_CONFIG_STRING_INFO(EXTERNAL_RestrictedGCStressExe, W("RestrictedGCStressExe"), "")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_CdacStressFailFast, W("CdacStressFailFast"), 0, "If nonzero, assert on cDAC/runtime GC ref mismatch during cDAC stress verification.")
 RETAIL_CONFIG_STRING_INFO(INTERNAL_CdacStressLogFile, W("CdacStressLogFile"), "Log file path for cDAC stress verification results.")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_CdacStress, W("CdacStress"), 0, "Enable cDAC stress verification. Bit flags: 0x1=alloc points, 0x200=verbose per-ref diagnostics.")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_CdacStress, W("CdacStress"), 0, "Enable cDAC stress verification.")
 CONFIG_DWORD_INFO(INTERNAL_ReturnSourceTypeForTesting, W("ReturnSourceTypeForTesting"), 0, "Allows returning the (internal only) source type of an IL to Native mapping for debugging purposes")
 RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_RSStressLog, W("RSStressLog"), 0, "Allows turning on logging for RS startup")
 CONFIG_DWORD_INFO(INTERNAL_SBDumpOnNewIndex, W("SBDumpOnNewIndex"), 0, "Used for Syncblock debugging. It's been a while since any of those have been used.")

src/coreclr/inc/dacprivate.h

@@ -65,12 +65,33 @@ enum
     DACSTACKPRIV_REQUEST_FRAME_DATA = 0xf0000000
 };
 
+#ifdef CDAC_STRESS
 // Private requests for the cDAC stress harness.
 enum
 {
-    DACSTRESSPRIV_REQUEST_FLUSH_TARGET_STATE = 0xf2000000
+    DACSTRESSPRIV_REQUEST_FLUSH_TARGET_STATE   = 0xf2000000,
+    DACSTRESSPRIV_REQUEST_COMPUTE_ARG_GCREFMAP = 0xf2000001
 };
 
+// In/out request descriptor for DACSTRESSPRIV_REQUEST_COMPUTE_ARG_GCREFMAP.
+// outBuffer is unused; the caller-allocated blob destination + size are
+// carried by this struct, and the handler writes cbFilled and cbNeeded in
+// place.
+//   S_OK                                              blob fit; cbFilled bytes written to *BlobBuffer; cbNeeded == cbFilled.
+//   HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)    cbFilled = 0, cbNeeded = required size; *BlobBuffer untouched.
+//   E_NOTIMPL                                         encoder declined this MD (bucketed as ARG_SKIP).
+//   E_FAIL                                            encoder threw (bucketed as ARG_ERROR).
+//   E_INVALIDARG                                      bad inBuffer.
+struct DacStressArgGCRefMapRequest
+{
+    CLRDATA_ADDRESS MethodDesc;     // [in]
+    CLRDATA_ADDRESS BlobBuffer;     // [in]  caller-allocated destination (in-proc pointer)
+    ULONG32         BlobBufferLen;  // [in]  capacity at BlobBuffer
+    ULONG32         cbFilled;       // [out] bytes actually written to *BlobBuffer
+    ULONG32         cbNeeded;       // [out] total bytes the blob requires
+};
+#endif // CDAC_STRESS
+
 enum DacpObjectType { OBJ_STRING=0,OBJ_FREE,OBJ_OBJECT,OBJ_ARRAY,OBJ_OTHER };
 struct MSLAYOUT DacpObjectData
 {