[cDAC] Add DacDbi API GetVarArgSig

docs/design/datacontracts/Signature.md

@@ -17,14 +17,22 @@ These tags are used in signatures generated internally by the runtime that are n
 
 ```csharp
 TypeHandle DecodeFieldSignature(BlobHandle blobHandle, ModuleHandle moduleHandle, TypeHandle ctx);
+
+// Returns the address of the first argument of a vararg call relative to the cookie pointer location.
+TargetPointer GetVarArgArgsBase(TargetPointer vaSigCookieAddr);
+
+// Returns the address and length of the raw vararg signature blob held by the cookie.
+void GetVarArgSignature(TargetPointer vaSigCookieAddr, out TargetPointer signatureAddress, out uint signatureLength);
 ```
 
 ## Version 1
 
 Data descriptors used:
 | Data Descriptor Name | Field | Meaning |
 | --- | --- | --- |
-| _none_ |  | |
+| `VASigCookie` | `SizeOfArgs` | Total size in bytes of the pushed argument list. Used on x86 to locate the args base. |
+| `VASigCookie` | `SignaturePointer` | Target address of the raw vararg signature blob. |
+| `VASigCookie` | `SignatureLength` | Length in bytes of the raw vararg signature blob. |
 
 Global variables used:
 | Global Name | Type | Purpose |
@@ -37,6 +45,7 @@ Contracts used:
 | RuntimeTypeSystem |
 | Loader |
 | EcmaMetadata |
+| RuntimeInfo |
 
 Constants:
 | Constant Name | Meaning | Value |
@@ -69,3 +78,33 @@ TypeHandle ISignature.DecodeFieldSignature(BlobHandle blobHandle, ModuleHandle m
 ### Other consumers
 
 `RuntimeSignatureDecoder` is shared infrastructure within the cDAC. Other contracts construct their own decoder and provider directly when they need to decode method or local signatures rather than going through this contract. For example, the [StackWalk](./StackWalk.md) contract uses `RuntimeSignatureDecoder<GcTypeKind, GcSignatureContext>` with a GC-specific provider to classify method parameters during signature-based GC reference scanning.
+
+### Vararg call cookies
+
+`GetVarArgArgsBase` and `GetVarArgSignature` decode a `VASigCookie*` slot pushed by a vararg call site.
+
+```csharp
+TargetPointer ISignature.GetVarArgArgsBase(TargetPointer vaSigCookieAddr)
+{
+    // On x86 the args are pushed below the cookie pointer (stack grows down on the args walk),
+    // so the first argument lies at vaSigCookieAddr + cookie.SizeOfArgs.
+    // On every other platform the first argument follows the cookie pointer in memory
+    // (stack grows up on the args walk), so its address is vaSigCookieAddr + sizeof(VASigCookie*).
+    if (RuntimeInfo.GetTargetArchitecture() == X86)
+    {
+        TargetPointer vaSigCookie = _target.ReadPointer(vaSigCookieAddr);
+        VASigCookie cookie = _target.ProcessedData.GetOrAdd<VASigCookie>(vaSigCookie);
+        return vaSigCookieAddr + cookie.SizeOfArgs;
+    }
+    return vaSigCookieAddr + sizeof(TargetPointer);
+}
+
+void ISignature.GetVarArgSignature(TargetPointer vaSigCookieAddr, out TargetPointer signatureAddress, out uint signatureLength)
+{
+    TargetPointer vaSigCookie = _target.ReadPointer(vaSigCookieAddr);
+    VASigCookie cookie = _target.ProcessedData.GetOrAdd<VASigCookie>(vaSigCookie);
+
+    signatureAddress = cookie.SignaturePointer;
+    signatureLength = cookie.SignatureLength;
+}
+```

src/coreclr/vm/ceeload.h

@@ -351,6 +351,13 @@ struct VASigCookie
     Instantiation   methodInst;
 };
 
+template<>
+struct cdac_data<VASigCookie>
+{
+    static constexpr size_t SignaturePointer = offsetof(VASigCookie, signature) + offsetof(Signature, m_pSig);
+    static constexpr size_t SignatureLength = offsetof(VASigCookie, signature) + offsetof(Signature, m_cbSig);
+};
+
 //
 // VASigCookies are allocated in VASigCookieBlocks to amortize
 // allocation cost and allow proper bookkeeping.

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -417,6 +417,13 @@ CDAC_TYPE_FIELD(ArrayListBlock, T_UINT32, Size, cdac_data<ArrayListBase>::Size)
 CDAC_TYPE_FIELD(ArrayListBlock, T_POINTER, ArrayStart, cdac_data<ArrayListBase>::ArrayStart)
 CDAC_TYPE_END(ArrayListBlock)
 
+CDAC_TYPE_BEGIN(VASigCookie)
+CDAC_TYPE_INDETERMINATE(VASigCookie)
+CDAC_TYPE_FIELD(VASigCookie, T_UINT32, SizeOfArgs, offsetof(VASigCookie, sizeOfArgs))
+CDAC_TYPE_FIELD(VASigCookie, T_POINTER, SignaturePointer, cdac_data<VASigCookie>::SignaturePointer)
+CDAC_TYPE_FIELD(VASigCookie, T_UINT32, SignatureLength, cdac_data<VASigCookie>::SignatureLength)
+CDAC_TYPE_END(VASigCookie)
+
 // RuntimeTypeSystem
 
 CDAC_TYPE_BEGIN(MethodTable)

src/coreclr/vm/siginfo.hpp

@@ -353,6 +353,8 @@ class Signature
     DWORD           GetRawSigLen() const;
 
 private:
+    friend struct ::cdac_data<VASigCookie>;
+
     PCCOR_SIGNATURE m_pSig;
     DWORD           m_cbSig;
 };  // class Signature

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/ISignature.cs

@@ -10,6 +10,8 @@ public interface ISignature : IContract
 {
     static string IContract.Name { get; } = nameof(Signature);
     TypeHandle DecodeFieldSignature(BlobHandle blobHandle, ModuleHandle moduleHandle, TypeHandle ctx) => throw new NotImplementedException();
+    TargetPointer GetVarArgArgsBase(TargetPointer vaSigCookieAddr) => throw new NotImplementedException();
+    void GetVarArgSignature(TargetPointer vaSigCookieAddr, out TargetPointer signatureAddress, out uint signatureLength) => throw new NotImplementedException();
 }
 
 public readonly struct Signature : ISignature

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Signature/Signature_1.cs

@@ -1,7 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Reflection.Metadata;
 using Microsoft.Diagnostics.DataContractReader.SignatureHelpers;
 
@@ -49,4 +51,36 @@ TypeHandle ISignature.DecodeFieldSignature(BlobHandle blobHandle, ModuleHandle m
         RuntimeSignatureDecoder<TypeHandle, TypeHandle> decoder = new(provider, _target, mdReader, ctx);
         return decoder.DecodeFieldSignature(ref blobReader);
     }
+
+    TargetPointer ISignature.GetVarArgArgsBase(TargetPointer vaSigCookieAddr)
+    {
+        // Compute the address of the first argument. On x86 the args are pushed below the cookie
+        // pointer (stack grows down on the args walk), so the first argument lies at
+        //   vaSigCookieAddr + sizeOfArgs.
+        // On all other platforms the first argument follows the cookie pointer in memory
+        // (stack grows up on the args walk), so its address is at
+        //   vaSigCookieAddr + sizeof(VASigCookie*).
+        if (_target.Contracts.RuntimeInfo.GetTargetArchitecture() == RuntimeInfoArchitecture.X86)
+        {
+            Data.VASigCookie cookie = GetCookie(vaSigCookieAddr);
+            return new TargetPointer(vaSigCookieAddr.Value + cookie.SizeOfArgs);
+        }
+
+        return new TargetPointer(vaSigCookieAddr.Value + (ulong)_target.PointerSize);
+    }
+
+    void ISignature.GetVarArgSignature(TargetPointer vaSigCookieAddr, out TargetPointer signatureAddress, out uint signatureLength)
+    {
+        Data.VASigCookie cookie = GetCookie(vaSigCookieAddr);
+
+        signatureAddress = cookie.SignaturePointer;
+        signatureLength = cookie.SignatureLength;
+        Debug.Assert(signatureAddress != TargetPointer.Null || signatureLength == 0,
+            "VASigCookie has a non-zero signature length but a null signature pointer.");
+    }
+    private Data.VASigCookie GetCookie(TargetPointer vaSigCookieAddr)
+    {
+        TargetPointer vaSigCookie = _target.ReadPointer(vaSigCookieAddr);
+        return _target.ProcessedData.GetOrAdd<Data.VASigCookie>(vaSigCookie);
+    }
 }

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

@@ -0,0 +1,23 @@
+// 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;
+
+internal sealed class VASigCookie : IData<VASigCookie>
+{
+    static VASigCookie IData<VASigCookie>.Create(Target target, TargetPointer address)
+        => new VASigCookie(target, address);
+
+    public VASigCookie(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.VASigCookie);
+
+        SizeOfArgs = target.ReadField<uint>(address, type, nameof(SizeOfArgs));
+        SignaturePointer = target.ReadPointerField(address, type, nameof(SignaturePointer));
+        SignatureLength = target.ReadField<uint>(address, type, nameof(SignatureLength));
+    }
+
+    public uint SizeOfArgs { get; init; }
+    public TargetPointer SignaturePointer { get; init; }
+    public uint SignatureLength { get; init; }
+}

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

@@ -181,6 +181,7 @@ public enum DataType
     ComInterfaceEntry,
     InternalComInterfaceDispatch,
     AuxiliarySymbolInfo,
+    VASigCookie,
     CodeRangeMapRangeList,
 
     /* GC Data Types */

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs

@@ -1198,7 +1198,40 @@ public int IsDiagnosticsHiddenOrLCGMethod(ulong vmMethodDesc, int* pRetVal)
     }
 
     public int GetVarArgSig(ulong VASigCookieAddr, ulong* pArgBase, DacDbiTargetBuffer* pRetVal)
-        => LegacyFallbackHelper.CanFallback() && _legacy is not null ? _legacy.GetVarArgSig(VASigCookieAddr, pArgBase, pRetVal) : HResults.E_NOTIMPL;
+    {
+        *pArgBase = 0;
+        *pRetVal = default;
+        int hr = HResults.S_OK;
+        try
+        {
+            Contracts.ISignature signature = _target.Contracts.Signature;
+            TargetPointer argBase = signature.GetVarArgArgsBase(new TargetPointer(VASigCookieAddr));
+            signature.GetVarArgSignature(new TargetPointer(VASigCookieAddr), out TargetPointer sigAddr, out uint sigLen);
+
+            *pArgBase = argBase.Value;
+            *pRetVal = new DacDbiTargetBuffer { pAddress = sigAddr.Value, cbSize = sigLen };
+        }
+        catch (System.Exception ex)
+        {
+            hr = ex.HResult;
+        }
+#if DEBUG
+        if (_legacy is not null)
+        {
+            ulong argBaseLocal;
+            DacDbiTargetBuffer retValLocal = default;
+            int hrLocal = _legacy.GetVarArgSig(VASigCookieAddr, &argBaseLocal, &retValLocal);
+            Debug.ValidateHResult(hr, hrLocal);
+            if (hr == HResults.S_OK)
+            {
+                Debug.Assert(*pArgBase == argBaseLocal, $"cDAC argBase: 0x{*pArgBase:X}, DAC argBase: 0x{argBaseLocal:X}");
+                Debug.Assert(pRetVal->pAddress == retValLocal.pAddress, $"cDAC sigAddr: 0x{pRetVal->pAddress:X}, DAC sigAddr: 0x{retValLocal.pAddress:X}");
+                Debug.Assert(pRetVal->cbSize == retValLocal.cbSize, $"cDAC sigLen: {pRetVal->cbSize}, DAC sigLen: {retValLocal.cbSize}");
+            }
+        }
+#endif
+        return hr;
+    }
 
     public int RequiresAlign8(ulong thExact, Interop.BOOL* pResult)
     {