Convert funceval to UCO pattern

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Reflection;
+using System.Runtime;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
@@ -674,6 +675,104 @@ internal static unsafe void CallDefaultConstructor(object* pObj, delegate*<objec
                 *pException = ex;
             }
         }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private unsafe struct FuncEvalInvokeArgs
+        {
+            public nint MethodHandle;
+            public nint OwnerType;
+            public object* ThisObj;
+            public object?[]* Args;
+            public int IsNewObj;
+            // Byref-like value types (for example Span<T>) cannot go through heap boxes:
+            // the GC does not track embedded byrefs in boxed payloads. Native funceval
+            // passes raw byrefs in RawByRefs[i] and leaves Args[i] null.
+            public IntPtr* RawByRefs;
+        }
+
+        [UnmanagedCallersOnly]
+        private static unsafe void InvokeFuncEval(FuncEvalInvokeArgs* pInvokeArgs, object* pResult, Exception* pException)
+        {
+            try
+            {
+                RuntimeMethodHandleInternal handle = new RuntimeMethodHandleInternal(pInvokeArgs->MethodHandle);
+                RuntimeType? ownerType = pInvokeArgs->OwnerType != 0
+                    ? RuntimeTypeHandle.GetRuntimeTypeFromHandle(pInvokeArgs->OwnerType)
+                    : null;
+                MethodBase method = RuntimeType.GetMethodBase(ownerType, handle)!;
+
+                object? thisObj = *pInvokeArgs->ThisObj;
+                object?[]? args = *pInvokeArgs->Args;
+                bool isNewObj = pInvokeArgs->IsNewObj != 0;
+
+                // Call RuntimeMethodHandle.InvokeMethod directly instead of public
+                // MethodBase.Invoke:
+                // 1. Public invoke blocks byref-like signatures (ContainsStackPointers).
+                // 2. ConstructorInfo.Invoke forces isConstructor=false, which breaks
+                //    value-type ctor funceval by mutating a temporary copy.
+                Signature sig = method switch
+                {
+                    RuntimeMethodInfo rmi => rmi.Signature,
+                    RuntimeConstructorInfo rci => rci.Signature,
+                    _ => throw new NotSupportedException(),
+                };
+
+                int argCount = args is null ? 0 : args.Length;
+                if (sig.Arguments.Length != argCount)
+                {
+                    throw new TargetParameterCountException();
+                }
+
+                // Build QCall byref arguments (same shape as MethodBaseInvoker):
+                // value types point at boxed payload; reference types point at args[] slots.
+                // Register this unmanaged storage as byrefs so GC can retarget them.
+                IntPtr* pByRefStorage = stackalloc IntPtr[Math.Max(argCount, 1)];
+                NativeMemory.Clear(pByRefStorage, (nuint)Math.Max(argCount, 1) * (nuint)sizeof(IntPtr));
+                GCFrameRegistration regByRefStorage =
+                    new((void**)pByRefStorage, (uint)argCount, areByRefs: true);
+
+                object? result;
+                GCFrameRegistration.RegisterForGCReporting(&regByRefStorage);
+                try
+                {
+                    IntPtr* pRawByRefs = pInvokeArgs->RawByRefs;
+                    for (int i = 0; i < argCount; i++)
+                    {
+                        IntPtr raw = pRawByRefs != null ? pRawByRefs[i] : IntPtr.Zero;
+                        if (raw != IntPtr.Zero)
+                        {
+                            // Native side already provided a stable byref for this arg.
+                            *(IntPtr*)(pByRefStorage + i) = raw;
+                            continue;
+                        }
+
+                        ref object? slot = ref args![i];
+                        if (sig.Arguments[i].IsValueType)
+                        {
+                            // Value-type args are pre-boxed by native ReadAndBoxArgValue.
+                            *(ByReference*)(pByRefStorage + i) = ByReference.Create(ref slot!.GetRawData());
+                        }
+                        else
+                        {
+                            *(ByReference*)(pByRefStorage + i) = ByReference.Create(ref slot);
+                        }
+                    }
+
+                    result = RuntimeMethodHandle.InvokeMethod(thisObj, (void**)pByRefStorage, sig, isConstructor: isNewObj);
+                }
+                finally
+                {
+                    GCFrameRegistration.UnregisterForGCReporting(&regByRefStorage);
+                }
+
+                if (result is not null)
+                    *pResult = result;
+            }
+            catch (Exception ex)
+            {
+                *pException = ex;
+            }
+        }
     }
     // Helper class to assist with unsafe pinning of arbitrary objects.
     // It's used by VM code.
@@ -724,7 +823,7 @@ internal unsafe struct MethodDesc
     internal unsafe struct MethodDescChunk
     {
         public MethodTable* MethodTable;
-        public MethodDescChunk*  Next;
+        public MethodDescChunk* Next;
         public byte Size;        // The size of this chunk minus 1 (in multiples of MethodDesc::ALIGNMENT)
         public byte Count;       // The number of MethodDescs in this chunk minus 1
         public ushort FlagsAndTokenRange;
@@ -1117,11 +1216,11 @@ internal unsafe struct MethodTableAuxiliaryData
         private const uint enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002;  // Whether we have checked the overridden Equals or GetHashCode
         private const uint enum_flag_CanCompareBitsOrUseFastGetHashCode = 0x0004;     // Is any field type or sub field type overridden Equals or GetHashCode
 
-        private const uint enum_flag_Initialized                = 0x0001;
-        private const uint enum_flag_HasCheckedStreamOverride   = 0x0400;
-        private const uint enum_flag_StreamOverriddenRead       = 0x0800;
-        private const uint enum_flag_StreamOverriddenWrite      = 0x1000;
-        private const uint enum_flag_EnsuredInstanceActive      = 0x2000;
+        private const uint enum_flag_Initialized = 0x0001;
+        private const uint enum_flag_HasCheckedStreamOverride = 0x0400;
+        private const uint enum_flag_StreamOverriddenRead = 0x0800;
+        private const uint enum_flag_StreamOverriddenWrite = 0x1000;
+        private const uint enum_flag_EnsuredInstanceActive = 0x2000;
 
 
         public bool HasCheckedCanCompareBitsOrUseFastGetHashCode => (Flags & enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode) != 0;

src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp

@@ -27,7 +27,6 @@
 
 typedef IDacDbiInterface::StackWalkHandle StackWalkHandle;
 
-
 // Persistent data needed to do a stackwalk. This is allocated on the forDbi heap.
 // It can survive across multiple DD calls.
 // However, it has data structures that have raw pointers into the DAC cache, and so it must
@@ -423,6 +422,11 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetStackWalkCurrentFrameInfo(Stac
                         {
                             ftResult = kRuntimeEntryPointFrame;
                         }
+                        // RuntimeHelpers.InvokeFuncEval (managed funceval trampoline)
+                        else if (pMD == g_pInvokeFuncEvalMethodDesc)
+                        {
+                            ftResult = kRuntimeEntryPointFrame;
+                        }
                         else
                         {
                             ftResult = kManagedStackFrame;
@@ -436,8 +440,32 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetStackWalkCurrentFrameInfo(Stac
                     // fall through
                     //
                 case StackFrameIterator::SFITER_SKIPPED_FRAME_FUNCTION:
-                    ftResult = kExplicitFrame;
-                    fInitFrameData = TRUE;
+                    {
+                        // Suppress explicit Frames belonging to the managed funceval trampoline.
+                        // We identify them structurally: the next Frame in the chain is a
+                        // FuncEvalFrame, which means this Frame is scaffolding the trampoline
+                        // (typically the InlinedCallFrame for its inner QCall) erected between
+                        // the user method and the FuncEvalFrame.
+                        Frame *pCurFrame = pIter->m_crawl.GetFrame();
+                        bool isFuncEvalScaffolding = false;
+                        if (pCurFrame != NULL && pCurFrame != FRAME_TOP &&
+                            pCurFrame->GetFrameIdentifier() != FrameIdentifier::FuncEvalFrame)
+                        {
+                            Frame *pNextFrame = pCurFrame->Next();
+                            isFuncEvalScaffolding =
+                                (pNextFrame != NULL && pNextFrame != FRAME_TOP &&
+                                 pNextFrame->GetFrameIdentifier() == FrameIdentifier::FuncEvalFrame);
+                        }
+                        if (isFuncEvalScaffolding)
+                        {
+                            ftResult = kRuntimeEntryPointFrame;
+                        }
+                        else
+                        {
+                            ftResult = kExplicitFrame;
+                            fInitFrameData = TRUE;
+                        }
+                    }
                     break;
 
                 case StackFrameIterator::SFITER_NO_FRAME_TRANSITION:
@@ -530,6 +558,22 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCountOfInternalFrames(VMPTR_Th
             }
 #endif // FEATURE_INTERPRETER
 
+            // Skip explicit Frames belonging to the managed funceval trampoline
+            // (RuntimeHelpers.InvokeFuncEval). They are an implementation detail of
+            // debugger function evaluation and should not appear in the stack shown
+            // to debugger clients. Identified structurally as scaffolding immediately
+            // preceding a FuncEvalFrame.
+            if (pFrame->GetFrameIdentifier() != FrameIdentifier::FuncEvalFrame)
+            {
+                Frame *pNextFrame = pFrame->Next();
+                if (pNextFrame != NULL && pNextFrame != FRAME_TOP &&
+                    pNextFrame->GetFrameIdentifier() == FrameIdentifier::FuncEvalFrame)
+                {
+                    pFrame = pNextFrame;
+                    continue;
+                }
+            }
+
             CorDebugInternalFrameType ift = GetInternalFrameType(pFrame);
             if (ift != STUBFRAME_NONE)
             {
@@ -596,6 +640,19 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateInternalFrames(VMPTR_Thr
             }
 #endif // FEATURE_INTERPRETER
 
+            // Skip explicit Frames belonging to the managed funceval trampoline
+            // (RuntimeHelpers.InvokeFuncEval). See GetCountOfInternalFrames for rationale.
+            if (pFrame->GetFrameIdentifier() != FrameIdentifier::FuncEvalFrame)
+            {
+                Frame *pNextFrame = pFrame->Next();
+                if (pNextFrame != NULL && pNextFrame != FRAME_TOP &&
+                    pNextFrame->GetFrameIdentifier() == FrameIdentifier::FuncEvalFrame)
+                {
+                    pFrame = pNextFrame;
+                    continue;
+                }
+            }
+
             // check if the internal frame is interesting
             frameData.stubFrame.frameType = GetInternalFrameType(pFrame);
             if (frameData.stubFrame.frameType != STUBFRAME_NONE)

src/coreclr/debug/ee/controller.cpp

@@ -6782,6 +6782,12 @@ bool DebuggerStepper::IsInterestingFrame(FrameInfo * pFrame)
         {
             return false;
         }
+
+        // Ignore the managed funceval trampoline (RuntimeHelpers.InvokeFuncEval)
+        if (pFrame->md == g_pInvokeFuncEvalMethodDesc)
+        {
+            return false;
+        }
     }
 
     return true;