[cDAC] Properly handle reportInteropMD special case (#119825)

* implement RuntimeTypeSystem.HasMDContextArg
* update StackWalk.GetMethodDescPtr to account for special case

Author: max-charlamb

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -155,6 +155,9 @@ partial interface IRuntimeTypeSystem : IContract
     // A IL Stub method is also a StoredSigMethodDesc, and a NoMetadataMethod
     public virtual bool IsILStub(MethodDescHandle methodDesc);
 
+    // Return true if a MethodDesc represents an IL stub with a special MethodDesc context arg
+    public virtual bool HasMDContextArg(MethodDescHandle);
+
     // Return true if a MethodDesc is in a collectible module
     public virtual bool IsCollectibleMethod(MethodDescHandle methodDesc);
 
@@ -882,6 +885,14 @@ And the following enumeration definitions
     {
         IsLCGMethod = 0x00004000,
         IsILStub = 0x00008000,
+        ILStubTypeMask = 0x000007FF,
+    }
+
+    [Flags]
+    internal enum ILStubType : uint
+    {
+        StubPInvokeVarArg = 0x4,
+        StubCLRToCOMInterop = 0x6,
     }
 
     [Flags]
@@ -1155,6 +1166,23 @@ And the various apis are implemented with the following algorithms
         return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsILStub);
     }
 
+    public bool HasMDContextArg(MethodDescHandle method)
+    {
+        MethodDesc methodDesc = _methodDescs[methodDescHandle.Address];
+
+        if (methodDesc.Classification != MethodDescClassification.Dynamic)
+        {
+            return false;
+        }
+
+        uint ExtendedFlags = // Read ExtendedFlags field from StoredSigMethodDesc contract using address methodDescHandle.Address
+        ILStubType ilStubType = (ILStubType)(ExtendedFlags & DynamicMethodDescExtendedFlags.ILStubTypeMask);
+        bool isCLRToCOMStub = ilStubType == ILStubType.StubCLRToCOMInterop;
+        bool isPInvokeVarArgStub = ilStubType == ILStubType.StubPInvokeVarArg;
+
+        return isCLRToCOMStub || isPInvokeVarArgStub;
+    }
+
     public ushort GetSlotNumber(MethodDescHandle methodDesc) => _methodDescs[methodDesc.Addres]._desc.Slot;
 ```
 

docs/design/datacontracts/StackWalk.md

@@ -85,6 +85,7 @@ Contracts used:
 | --- |
 | `ExecutionManager` |
 | `Thread` |
+| `RuntimeTypeSystem` |
 
 
 ### Stackwalk Algorithm
@@ -359,10 +360,21 @@ string GetFrameName(TargetPointer frameIdentifier);
 TargetPointer GetMethodDescPtr(TargetPointer framePtr)
 ```
 
-`GetMethodDescPtr(IStackDataFrameHandle stackDataFrameHandle)` returns the method desc pointer associated with a `IStackDataFrameHandle`. Note this can either be at a capital 'F' frame or a managed frame unlike the above API which works only at capital 'F' frames.
+`GetMethodDescPtr(IStackDataFrameHandle stackDataFrameHandle)` returns the method desc pointer associated with a `IStackDataFrameHandle`. Note there are two major differences between this API and the one above that operates on a TargetPointer.
+* This API can either be at a capital 'F' frame or a managed frame unlike the TargetPointer overload which only works at capital 'F' frames.
+* This API handles the special ReportInteropMD case which happens under the following conditions
+    1. The dataFrame is at an `InlinedCallFrame`
+    2. The dataFrame is in a `SW_SKIPPED_FRAME` state
+    3. The InlinedCallFrame's return address is managed code
+    4. The InlinedCallFrame's return address method has a MDContext arg
+
+  In this case, we report the actual interop MethodDesc. A pointer to the MethodDesc immediately follows the InlinedCallFrame in memory.
 This API is implemeted as follows:
-1. Try to get the current frame address with `GetFrameAddress`. If the address is not null, return `GetMethodDescPtr(<frameAddress>)`.
-2. Check if the current context IP is a managed context using the ExecutionManager contract. If it is a managed contet, use the ExecutionManager context to find the related MethodDesc and return the pointer to it.
+1. Try to get the current frame address `framePtr` with `GetFrameAddress`.
+2. If the address is not null, compute `reportInteropMD` as listed above. Otherwise skip to step 5.
+3. If `reportInteropMD`, dereference the pointer immediately following the InlinedCallFrame and return that value.
+4. If `!reportIteropMD`, return `GetMethodDescPtr(framePtr)`.
+5. Check if the current context IP is a managed context using the ExecutionManager contract. If it is a managed context, use the ExecutionManager context to find the related MethodDesc and return the pointer to it.
 ```csharp
 TargetPointer GetMethodDescPtr(IStackDataFrameHandle stackDataFrameHandle)
 ```

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

@@ -175,6 +175,9 @@ public interface IRuntimeTypeSystem : IContract
     // A IL Stub method is also a StoredSigMethodDesc, and a NoMetadataMethod
     bool IsILStub(MethodDescHandle methodDesc) => throw new NotImplementedException();
 
+    // Return true if a MethodDesc represents an IL stub with a special MethodDesc context arg
+    bool HasMDContextArg(MethodDescHandle methodDesc) => throw new NotImplementedException();
+
     bool IsCollectibleMethod(MethodDescHandle methodDesc) => throw new NotImplementedException();
     bool IsVersionable(MethodDescHandle methodDesc) => throw new NotImplementedException();
 

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

@@ -78,6 +78,14 @@ internal enum DynamicMethodDescExtendedFlags : uint
     {
         IsLCGMethod = 0x00004000,
         IsILStub = 0x00008000,
+        ILStubTypeMask = 0x000007FF,
+    }
+
+    [Flags]
+    internal enum ILStubType : uint
+    {
+        StubPInvokeVarArg = 0x4,
+        StubCLRToCOMInterop = 0x6,
     }
 
     // on MethodDescChunk.FlagsAndTokenRange
@@ -254,6 +262,10 @@ private DynamicMethodDesc(Target target, TargetPointer methodDescPointer)
 
         public bool IsDynamicMethod => ExtendedFlags.HasFlag(DynamicMethodDescExtendedFlags.IsLCGMethod);
         public bool IsILStub => ExtendedFlags.HasFlag(DynamicMethodDescExtendedFlags.IsILStub);
+        public ILStubType ILStubType => (ILStubType)(ExtendedFlags & DynamicMethodDescExtendedFlags.ILStubTypeMask);
+        public bool IsCLRToCOMStub => ILStubType == ILStubType.StubCLRToCOMInterop;
+        public bool IsPInvokeVarArgStub => ILStubType == ILStubType.StubPInvokeVarArg;
+        public bool HasMDContextArg => IsCLRToCOMStub || IsPInvokeVarArgStub;
     }
 
     private sealed class StoredSigMethodDesc : IData<StoredSigMethodDesc>
@@ -904,6 +916,18 @@ public bool IsILStub(MethodDescHandle methodDescHandle)
         return AsDynamicMethodDesc(methodDesc).IsILStub;
     }
 
+    public bool HasMDContextArg(MethodDescHandle methodDescHandle)
+    {
+        MethodDesc methodDesc = _methodDescs[methodDescHandle.Address];
+
+        if (methodDesc.Classification != MethodClassification.Dynamic)
+        {
+            return false;
+        }
+
+        return AsDynamicMethodDesc(methodDesc).HasMDContextArg;
+    }
+
     private MethodTable GetOrCreateMethodTable(MethodDesc methodDesc)
     {
         // Ensures that the method table is valid, created, and cached

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/FrameIterator.cs

@@ -144,7 +144,13 @@ public bool IsInlineCallFrameWithActiveCall()
             return false;
         }
         Data.InlinedCallFrame inlinedCallFrame = target.ProcessedData.GetOrAdd<Data.InlinedCallFrame>(currentFramePointer);
-        return inlinedCallFrame.CallerReturnAddress != 0;
+        return InlinedCallFrameHasActiveCall(inlinedCallFrame);
+    }
+
+    public static bool IsInlinedCallFrame(Target target, TargetPointer framePointer)
+    {
+        Data.Frame frame = target.ProcessedData.GetOrAdd<Data.Frame>(framePointer);
+        return GetFrameType(target, frame.Identifier) == FrameType.InlinedCallFrame;
     }
 
     public static string GetFrameName(Target target, TargetPointer frameIdentifier)
@@ -187,7 +193,7 @@ private IPlatformFrameHandler GetFrameHandler(IPlatformAgnosticContext context)
         };
     }
 
-    public static TargetPointer GetMethodDescPtr(TargetPointer framePtr, Target target)
+    public static TargetPointer GetMethodDescPtr(Target target, TargetPointer framePtr)
     {
         Data.Frame frame = target.ProcessedData.GetOrAdd<Data.Frame>(framePtr);
         FrameType frameType = GetFrameType(target, frame.Identifier);
@@ -231,6 +237,21 @@ public static TargetPointer GetMethodDescPtr(TargetPointer framePtr, Target targ
         }
     }
 
+    public static TargetPointer GetReturnAddress(Target target, TargetPointer framePtr)
+    {
+        Data.Frame frame = target.ProcessedData.GetOrAdd<Data.Frame>(framePtr);
+        FrameType frameType = GetFrameType(target, frame.Identifier);
+        switch (frameType)
+        {
+            case FrameType.InlinedCallFrame:
+                Data.InlinedCallFrame inlinedCallFrame = target.ProcessedData.GetOrAdd<Data.InlinedCallFrame>(frame.Address);
+                return InlinedCallFrameHasActiveCall(inlinedCallFrame) ? inlinedCallFrame.CallerReturnAddress : TargetPointer.Null;
+            default:
+                // NotImplemented for other frame types
+                return TargetPointer.Null;
+        }
+    }
+
     private static bool InlinedCallFrameHasFunction(Data.InlinedCallFrame frame, Target target)
     {
         if (target.PointerSize == 4)

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

@@ -176,23 +176,60 @@ string IStackWalk.GetFrameName(TargetPointer frameIdentifier)
         => FrameIterator.GetFrameName(_target, frameIdentifier);
 
     TargetPointer IStackWalk.GetMethodDescPtr(TargetPointer framePtr)
-        => FrameIterator.GetMethodDescPtr(framePtr, _target);
+        => FrameIterator.GetMethodDescPtr(_target, framePtr);
 
     TargetPointer IStackWalk.GetMethodDescPtr(IStackDataFrameHandle stackDataFrameHandle)
     {
         StackDataFrameHandle handle = AssertCorrectHandle(stackDataFrameHandle);
+        IExecutionManager eman = _target.Contracts.ExecutionManager;
 
         // if we are at a capital F Frame, we can get the method desc from the frame
-        // TODO(cdac): Support special fReportInteropMD case https://github.com/dotnet/runtime/issues/119724
         TargetPointer framePtr = ((IStackWalk)this).GetFrameAddress(handle);
         if (framePtr != TargetPointer.Null)
-            return ((IStackWalk)this).GetMethodDescPtr(framePtr);
+        {
+            // reportInteropMD if
+            // 1) we are an InlinedCallFrame
+            // 2) the StackDataFrame is at a SW_SKIPPED_FRAME state
+            // 3) the return address is managed
+            // 4) the return address method has a MDContext arg
+            bool reportInteropMD = false;
+
+            if (FrameIterator.IsInlinedCallFrame(_target, framePtr) &&
+                handle.State == StackWalkState.SW_SKIPPED_FRAME)
+            {
+                IRuntimeTypeSystem rts = _target.Contracts.RuntimeTypeSystem;
+
+                // FrameIterator.GetReturnAddress is currently only implemented for InlinedCallFrame
+                // This is fine as this check is only needed for that frame type
+                TargetPointer returnAddress = FrameIterator.GetReturnAddress(_target, framePtr);
+                if (eman.GetCodeBlockHandle(returnAddress.Value) is CodeBlockHandle cbh)
+                {
+                    MethodDescHandle returnMethodDesc = rts.GetMethodDescHandle(eman.GetMethodDesc(cbh));
+                    reportInteropMD = rts.HasMDContextArg(returnMethodDesc);
+                }
+            }
+
+            if (reportInteropMD)
+            {
+                // Special reportInteropMD case
+                // This can't be handled in the GetMethodDescPtr(TargetPointer) because it relies on
+                // the state of the stack walk (SW_SKIPPED_FRAME) which is not available there.
+                // The MethodDesc pointer immediately follows the InlinedCallFrame
+                TargetPointer methodDescPtr = framePtr + _target.GetTypeInfo(DataType.InlinedCallFrame).Size
+                    ?? throw new InvalidOperationException("InlinedCallFrame type size is not defined.");
+                return _target.ReadPointer(methodDescPtr);
+            }
+            else
+            {
+                // Standard case
+                return ((IStackWalk)this).GetMethodDescPtr(framePtr);
+            }
+        }
 
         // otherwise try to get the method desc from the IP
         if (!IsManaged(handle.Context.InstructionPointer, out CodeBlockHandle? codeBlockHandle))
             return TargetPointer.Null;
 
-        IExecutionManager eman = _target.Contracts.ExecutionManager;
         return eman.GetMethodDesc(codeBlockHandle.Value);
     }
 

src/native/managed/cdac/mscordaccore_universal/Legacy/ClrDataFrame.cs

@@ -75,12 +75,11 @@ int IXCLRDataFrame.GetMethodInstance(out IXCLRDataMethodInstance? method)
         int hr = HResults.S_OK;
         method = null;
 
+        int hrLocal = HResults.S_OK;
         IXCLRDataMethodInstance? legacyMethod = null;
         if (_legacyImpl is not null)
         {
-            int hrLocal = _legacyImpl.GetMethodInstance(out legacyMethod);
-            if (hrLocal < 0)
-                return hrLocal;
+            hrLocal = _legacyImpl.GetMethodInstance(out legacyMethod);
         }
 
         try
@@ -104,6 +103,13 @@ int IXCLRDataFrame.GetMethodInstance(out IXCLRDataMethodInstance? method)
             hr = ex.HResult;
         }
 
+#if DEBUG
+        if (_legacyImpl is not null)
+        {
+            Debug.Assert(hrLocal == hr, $"cDAC: {hr:x}, DAC: {hrLocal:x}");
+        }
+#endif
+
         return hr;
     }