[cdac] SystemV-AMD64 struct-in-register classifier: enable ARGITER + zero-known-issues on Linux x64

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }

src/coreclr/vm/class.h

@@ -613,6 +613,7 @@ class EEClassOptionalFields
  // for MethodTableBuilder and NativeImageDumper, which need raw field-level access.
  friend class EEClass;
  friend class MethodTableBuilder;
+ friend struct ::cdac_data<EEClassOptionalFields>;
 
  //
  // GENERICS RELATED FIELDS.
@@ -1785,6 +1786,14 @@ template<> struct cdac_data<EEClass>
  static constexpr size_t NumThreadStaticFields = offsetof(EEClass, m_NumThreadStaticFields);
  static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
  static constexpr size_t BaseSizePadding = offsetof(EEClass, m_cbBaseSizePadding);
+ static constexpr size_t OptionalFields = offsetof(EEClass, m_rpOptionalFields);
+};
+
+template<> struct cdac_data<EEClassOptionalFields>
+{
+#if defined(UNIX_AMD64_ABI)
+ static constexpr size_t EightByteRegistersInfo = offsetof(EEClassOptionalFields, m_eightByteRegistersInfo);
+#endif // UNIX_AMD64_ABI
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -572,8 +572,27 @@ CDAC_TYPE_FIELD(EEClass, T_UINT16, NumStaticFields, cdac_data<EEClass>::NumStati
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumThreadStaticFields, cdac_data<EEClass>::NumThreadStaticFields)
 CDAC_TYPE_FIELD(EEClass, T_UINT16, NumNonVirtualSlots, cdac_data<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_FIELD(EEClass, T_UINT8, BaseSizePadding, cdac_data<EEClass>::BaseSizePadding)
+CDAC_TYPE_FIELD(EEClass, T_POINTER, OptionalFields, cdac_data<EEClass>::OptionalFields)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(EEClassOptionalFields)
+CDAC_TYPE_INDETERMINATE(EEClassOptionalFields)
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_FIELD(EEClassOptionalFields, TYPE(SystemVEightByteRegistersInfo), EightByteRegistersInfo, cdac_data<EEClassOptionalFields>::EightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+CDAC_TYPE_END(EEClassOptionalFields)
+
+#ifdef UNIX_AMD64_ABI
+CDAC_TYPE_BEGIN(SystemVEightByteRegistersInfo)
+CDAC_TYPE_INDETERMINATE(SystemVEightByteRegistersInfo)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, NumEightBytes, cdac_data<SystemVEightByteRegistersInfo>::NumEightBytes)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification0, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteClassification1, cdac_data<SystemVEightByteRegistersInfo>::EightByteClassification1)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize0, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize0)
+CDAC_TYPE_FIELD(SystemVEightByteRegistersInfo, T_UINT8, EightByteSize1, cdac_data<SystemVEightByteRegistersInfo>::EightByteSize1)
+CDAC_TYPE_END(SystemVEightByteRegistersInfo)
+#endif // UNIX_AMD64_ABI
+
 CDAC_TYPE_BEGIN(GenericsDictInfo)
 CDAC_TYPE_INDETERMINATE(GenericsDictInfo)
 CDAC_TYPE_FIELD(GenericsDictInfo, T_UINT16, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts))

src/coreclr/vm/methodtable.h

@@ -921,6 +921,18 @@ struct SystemVEightByteRegistersInfo
  _ASSERTE(index < NumEightBytes);
  return EightByteSizes[index];
  }
+
+ friend struct ::cdac_data<SystemVEightByteRegistersInfo>;
+};
+
+template<> struct cdac_data<SystemVEightByteRegistersInfo>
+{
+ static constexpr size_t NumEightBytes = offsetof(SystemVEightByteRegistersInfo, NumEightBytes);
+ static constexpr size_t EightByteClassification0 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 0 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteClassification1 = offsetof(SystemVEightByteRegistersInfo, EightByteClassifications) + 1 * sizeof(SystemVClassificationType);
+ static constexpr size_t EightByteSize0 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 0;
+ static constexpr size_t EightByteSize1 = offsetof(SystemVEightByteRegistersInfo, EightByteSizes) + 1;
+ static_assert(CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS == 2, "cdac descriptor exposes exactly two eightbyte slots");
 };
 #endif
 

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/ArgumentLocation.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Internal.JitInterface;
+
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 internal readonly struct ArgumentLocation
@@ -29,4 +31,12 @@ internal readonly struct ArgumentLocation
  // the open generic MethodTable (e.g. Span<T> for a Span<int> arg) so
  // encoders can inspect type structure as a fallback.
  public TypeHandle OpenGenericType { get; init; }
+
+ // SystemV-AMD64 struct passed in registers. Offset is the StructInRegsOffset
+ // sentinel; the encoder consumes SysVEightByteDescriptor + SysVIdxGenReg.
+ public bool IsStructPassedInRegs { get; init; }
+ public SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR SysVEightByteDescriptor { get; init; }
+ // Index of the first general-purpose argument register assigned to this
+ // struct (0 = RDI, 1 = RSI, ...).
+ public int SysVIdxGenReg { get; init; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CallingConvention_1.cs

@@ -8,6 +8,7 @@
 using System.Reflection.Metadata.Ecma335;
 using Internal.CallingConvention;
 using Internal.CorConstants;
+using Internal.JitInterface;
 using Microsoft.Diagnostics.DataContractReader.Contracts.StackWalkHelpers;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -222,7 +223,25 @@ private ArgumentLayout GetArgumentLayout(MethodDescHandle methodDesc)
  }
 
  if (argOffset == TransitionBlock.StructInRegsOffset)
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ {
+ // SystemV-AMD64 struct-in-registers.
+ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR sysvDesc;
+ parameterTypes[argIndex].GetSystemVAmd64PassStructInRegisterDescriptor(out sysvDesc);
+ ArgLocDesc loc = argit.GetArgLoc(argOffset) ?? throw new InvalidOperationException("ArgIterator returned null ArgLocDesc for struct-in-registers argument");
+
+ arguments.Add(new ArgumentLocation
+ {
+ Offset = argOffset,
+ ElementType = elemType,
+ TypeHandle = methodSig.ParameterTypes[argIndex],
+ IsStructPassedInRegs = true,
+ SysVEightByteDescriptor = sysvDesc,
+ SysVIdxGenReg = loc.m_idxGenReg,
+ OpenGenericType = paramInfo[argIndex].OpenGenericType,
+ });
+ argIndex++;
+ continue;
+ }
 
  bool passedByRef = elemType == CdacCorElementType.ValueType
  && transitionBlock.IsArgPassedByRef(parameterTypes[argIndex]);
@@ -602,6 +621,7 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  bool isX86 = arch is RuntimeInfoArchitecture.X86;
 
  int pointerSize = _target.PointerSize;
+ TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  SortedDictionary<int, GCRefMapToken> tokens = new();
  ArgumentLayout enumeration = GetArgumentLayout(methodDesc);
@@ -619,6 +639,33 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  {
  token = GCRefMapToken.VASigCookie;
  }
+ else if (arg.IsStructPassedInRegs)
+ {
+ // Mirrors ArgDestination::ReportPointersFromStructInRegisters
+ // in src/coreclr/vm/argdestination.h.
+ int genRegOffset = tb.OffsetOfArgumentRegisters + arg.SysVIdxGenReg * pointerSize;
+ for (int i = 0; i < arg.SysVEightByteDescriptor.eightByteCount; i++)
+ {
+ SystemVClassificationType cls = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteClassifications0
+ : arg.SysVEightByteDescriptor.eightByteClassifications1;
+ int size = (i == 0)
+ ? arg.SysVEightByteDescriptor.eightByteSizes0
+ : arg.SysVEightByteDescriptor.eightByteSizes1;
+
+ // SSE eightbytes go to XMM regs; don't advance genRegOffset.
+ if (cls == SystemVClassificationType.SystemVClassificationTypeSSE)
+ continue;
+
+ if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerReference)
+ tokens[genRegOffset] = GCRefMapToken.Ref;
+ else if (cls == SystemVClassificationType.SystemVClassificationTypeIntegerByRef)
+ tokens[genRegOffset] = GCRefMapToken.Interior;
+
+ genRegOffset += size;
+ }
+ continue;
+ }
  else if (arg.IsParamType)
  {
  // Resolve InstArgMethodDesc vs InstArgMethodTable on demand
@@ -741,7 +788,6 @@ public MethodAndTypeContextProvider(Target target, ModuleHandle moduleHandle, IR
  // the lowest positions). On non-x86 the mapping is monotonic so we
  // could iterate the offset map directly, but using OffsetFromGCRefMapPos
  // for both keeps the code path uniform.
- TransitionBlock tb = BuildTransitionBlock(runtimeInfo);
 
  // For x86 we need to know how many slot positions exist (we'd otherwise
  // miss high-pos register slots when the offset map's max is on the

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CallingConvention/CdacTypeHandle.cs

@@ -121,7 +121,48 @@ public int GetHomogeneousAggregateElementSize()
 
  public void GetSystemVAmd64PassStructInRegisterDescriptor(out SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor)
  {
- throw new NotImplementedException("SystemV AMD64 struct-in-registers is not yet supported by the cDAC.");
+ descriptor = default;
+ descriptor.passedInRegisters = false;
+
+ if (_typeHandle.IsNull)
+ return;
+
+ // Read the runtime-cached classification from EEClassOptionalFields;
+ // mirrors SystemVRegDescriptorFromSystemVEightByteRegistersInfo in
+ // jitinterface.cpp. Field only populated on UNIX_AMD64_ABI builds.
+ TargetPointer eeClassPtr = Rts.GetClassPointer(_typeHandle);
+ if (eeClassPtr == TargetPointer.Null)
+ return;
+
+ Data.EEClass eeClass = _target.ProcessedData.GetOrAdd<Data.EEClass>(eeClassPtr);
+ if (eeClass.OptionalFields == TargetPointer.Null)
+ return;
+
+ Data.EEClassOptionalFields optFields = _target.ProcessedData.GetOrAdd<Data.EEClassOptionalFields>(eeClass.OptionalFields);
+ if (optFields.EightByteRegistersInfo is not Data.SystemVEightByteRegistersInfo info)
+ return;
+
+ if (info.NumEightBytes == 0)
+ return;
+
+ // Runtime contract: at most CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS (2)
+ // eightbytes. Treat a corrupted / out-of-range count as "not passed in
+ // registers" so downstream loops keyed off eightByteCount can't overrun.
+ if (info.NumEightBytes > 2)
+ return;
+
+ descriptor.passedInRegisters = true;
+ descriptor.eightByteCount = info.NumEightBytes;
+ descriptor.eightByteClassifications0 = (SystemVClassificationType)info.EightByteClassification0;
+ descriptor.eightByteSizes0 = info.EightByteSize0;
+ descriptor.eightByteOffsets0 = 0;
+
+ if (info.NumEightBytes > 1)
+ {
+ descriptor.eightByteClassifications1 = (SystemVClassificationType)info.EightByteClassification1;
+ descriptor.eightByteSizes1 = info.EightByteSize1;
+ descriptor.eightByteOffsets1 = SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR.SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES;
+ }
  }
 
  public FpStructInRegistersInfo GetFpStructInRegistersInfo(Internal.TypeSystem.TargetArchitecture architecture)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/GC/GcScanner.cs

@@ -337,27 +337,6 @@ private TargetPointer FindGCRefMap(TargetPointer indirection)
  /// </summary>
  private void PromoteCallerStack(TargetPointer frameAddress, GcScanContext scanContext)
  {
- IRuntimeInfo runtimeInfo = _target.Contracts.RuntimeInfo;
- RuntimeInfoArchitecture arch = runtimeInfo.GetTargetArchitecture();
- RuntimeInfoOperatingSystem os = runtimeInfo.GetTargetOperatingSystem();
- // Matches the ARGITER stress-test gate in CdacStressTests.cs. Platforms
- // still missing calling-convention coverage (SystemV-AMD64 / RISC-V /
- // LoongArch / WASM) fall through to RecordDeferredFrame.
- // TODO(https://github.com/dotnet/runtime/issues/130008): extend
- // ICallingConvention.TryComputeArgGCRefMapBlob coverage to the
- // remaining targets so this path fires everywhere.
- bool supportedByCallingConvention =
- (os is RuntimeInfoOperatingSystem.Windows
- && arch is RuntimeInfoArchitecture.X86 or RuntimeInfoArchitecture.X64 or RuntimeInfoArchitecture.Arm64)
- || (os is RuntimeInfoOperatingSystem.Unix
- && arch is RuntimeInfoArchitecture.Arm or RuntimeInfoArchitecture.Arm64);
-
- if (!supportedByCallingConvention)
- {
- scanContext.RecordDeferredFrame(frameAddress);
- return;
- }
-
  Data.FramedMethodFrame fmf = _target.ProcessedData.GetOrAdd<Data.FramedMethodFrame>(frameAddress);
  if (fmf.MethodDescPtr == TargetPointer.Null)
  {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClass.cs

@@ -25,4 +25,5 @@ internal sealed partial class EEClass : IData<EEClass>
  [Field] public TargetPointer FieldDescList { get; }
  [Field] public ushort NumNonVirtualSlots { get; }
  [Field] public byte BaseSizePadding { get; }
+ [Field] public TargetPointer OptionalFields { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/EEClassOptionalFields.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.EEClassOptionalFields))]
+internal sealed partial class EEClassOptionalFields : IData<EEClassOptionalFields>
+{
+ [Field] public SystemVEightByteRegistersInfo? EightByteRegistersInfo { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/SystemVEightByteRegistersInfo.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+[CdacType(nameof(DataType.SystemVEightByteRegistersInfo))]
+internal sealed partial class SystemVEightByteRegistersInfo : IData<SystemVEightByteRegistersInfo>
+{
+ // Slots beyond NumEightBytes are undefined.
+ [Field] public byte NumEightBytes { get; }
+ [Field] public byte EightByteClassification0 { get; }
+ [Field] public byte EightByteClassification1 { get; }
+ [Field] public byte EightByteSize0 { get; }
+ [Field] public byte EightByteSize1 { get; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -62,6 +62,8 @@ public enum DataType
  MethodTable,
  DynamicStaticsInfo,
  EEClass,
+ EEClassOptionalFields,
+ SystemVEightByteRegistersInfo,
  CoreLibBinder,
  MethodTableAuxiliaryData,
  GenericsDictInfo,

src/native/managed/cdac/gen/Parser.cs

@@ -357,6 +357,12 @@ private static (FieldReadKind, string?, bool) ClassifyFieldRead(IPropertySymbol
  isNullable = true;
  type = named.TypeArguments[0];
  }
+ else if (ImplementsIData(type) && prop.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ // IData<T>? field: emitter treats it as optional (ContainsKey
+ // guard + default(null) when the descriptor omits the field).
+ isNullable = true;
+ }
 
  string fqn = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 

src/native/managed/cdac/tests/StressTests/CdacStressTestBase.cs

@@ -157,7 +157,8 @@ private async Task<CdacStressResults> RunStressAsync(string debuggeeName, Stress
 
  /// <summary>
  /// Asserts the GCREFS stress run produced a <c>[GC_STATS]</c> summary
- /// with at least one verification and no hard failures.
+ /// with at least one verification, no hard failures, and no deferred
+ /// (known-issue) frames.
  /// </summary>
  internal static void AssertAllPassed(CdacStressResults results, string debuggeeName)
  {
@@ -173,37 +174,13 @@ internal static void AssertAllPassed(CdacStressResults results, string debuggeeN
  "did not initialize correctly.\n" +
  $"Log: {results.LogFilePath}");
 
- if (results.Failed > 0)
+ if (results.Failed > 0 || results.KnownIssues > 0)
  {
  string analysis = results.AnalyzeFailures(maxFailures: 3);
  Assert.Fail(
  $"GCREFS stress test '{debuggeeName}' had {results.Failed} failure(s) " +
- $"out of {results.TotalVerifications} verifications " +
- $"({results.KnownIssues} known issue(s) tolerated).\n" +
- $"Log: {results.LogFilePath}\n\n{analysis}");
- }
-
- // On supported targets every Frame's caller-arg refs are enumerated via
- // the GCRefMap blob synthesized by ICallingConvention -- there should be
- // no deferred frames at all, so any KnownIssue count is a regression.
- // Keep this gate in sync with the ARGITER-support gate in
- // ArgIterStress_AllVerificationsPass below and with the
- // supportedByCallingConvention gate in GcScanner.PromoteCallerStack.
- GetTargetPlatform(out OSPlatform os, out Architecture arch);
- bool requiresZeroKnownIssues =
- (os == OSPlatform.Windows && arch is Architecture.X86 or Architecture.X64 or Architecture.Arm64)
- || (os == OSPlatform.Linux && arch is Architecture.Arm or Architecture.Arm64);
- if (requiresZeroKnownIssues && results.KnownIssues > 0)
- {
- string analysis = results.AnalyzeFailures(maxFailures: 3);
- Assert.Fail(
- $"GCREFS stress test '{debuggeeName}' had {results.KnownIssues} known issue(s) " +
- $"out of {results.TotalVerifications} verifications. " +
- "This platform is expected to enumerate every transition Frame's " +
- "caller-stack refs via ICallingConvention.TryComputeArgGCRefMapBlob with no " +
- "deferred frames. A non-zero KnownIssues count indicates the encoder declined " +
- "a method it should support (e.g. a regression in ComputeArgGCRefMapBlobCore " +
- "or a new code path returning E_NOTIMPL).\n" +
+ $"and {results.KnownIssues} known issue(s) out of " +
+ $"{results.TotalVerifications} verifications.\n" +
  $"Log: {results.LogFilePath}\n\n{analysis}");
  }
  }