VM: Include generic instantiations in stack frames

src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs

@@ -166,8 +166,7 @@ internal void InitializeSourceInfo(int iSkip, bool fNeedFileInfo, Exception? exc
             if (mh == IntPtr.Zero)
                 return null;
 
-            IRuntimeMethodInfo? mhReal = RuntimeMethodHandle.GetTypicalMethodDefinition(new RuntimeMethodInfoStub(mh, this));
-
+            IRuntimeMethodInfo? mhReal = RuntimeMethodHandle.FromIntPtr(mh).GetMethodInfo();
             return RuntimeType.GetMethodBase(mhReal);
         }
 

src/coreclr/vm/debugdebugger.cpp

@@ -460,14 +460,17 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal,
         int iNumValidFrames = 0;
         for (int i = 0; i < data.cElements; i++)
         {
-            // The managed stacktrace classes always returns typical method definition, so we don't need to bother providing exact instantiation.
-            // Generics::GetExactInstantiationsOfMethodAndItsClassFromCallInformation(data.pElements[i].pFunc, data.pElements[i].pExactGenericArgsToken, &pExactMethod, &thExactType);
             MethodDesc* pFunc = data.pElements[i].pFunc;
-
-            // Strip the instantiation to make sure that the reflection never gets a bad method desc back.
-            if (pFunc->HasMethodInstantiation())
-                pFunc = pFunc->StripMethodInstantiation();
-            _ASSERTE(pFunc->IsRuntimeMethodHandle());
+            PTR_VOID pExactGenericArgsToken = data.pElements[i].pExactGenericArgsToken;
+            if (pFunc->HasClassOrMethodInstantiation() && pFunc->IsSharedByGenericInstantiations())
+            {
+                TypeHandle th;
+                MethodDesc* pConstructedFunc = NULL;
+                if (pExactGenericArgsToken != NULL && Generics::GetExactInstantiationsOfMethodAndItsClassFromCallInformation(pFunc, pExactGenericArgsToken, &th, &pConstructedFunc))
+                {
+                    pFunc = pConstructedFunc;
+                }
+            }
 
             // Method handle
             size_t *pElem = (size_t*)pStackFrameHelper->rgMethodHandle->GetDataPtr();
@@ -1057,7 +1060,8 @@ StackWalkAction DebugStackTrace::GetStackFramesCallback(CrawlFrame* pCf, VOID* d
             dwNativeOffset,
             pFunc,
             ip,
-            flags);
+            flags,
+            GetExactGenericArgsToken(pFunc, pCf->GetRegisterSet(), pCf->GetCodeInfo(), pCf->GetFrame()));
 
     // We'll init the IL offsets outside the TSL lock.
 
@@ -1078,6 +1082,58 @@ StackWalkAction DebugStackTrace::GetStackFramesCallback(CrawlFrame* pCf, VOID* d
 }
 #endif // !DACCESS_COMPILE
 
+PTR_VOID DebugStackTrace::GetExactGenericArgsToken(PTR_MethodDesc pFunc, PREGDISPLAY pRD, EECodeInfo* pCodeInfo, PTR_Frame pFrame)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_TRIGGERS;
+        MODE_COOPERATIVE;
+    }
+    CONTRACTL_END;
+
+    _ASSERTE(pRD != NULL && pCodeInfo != NULL);
+
+    if (!pFunc || !pFunc->IsSharedByGenericInstantiations())
+        return NULL;
+
+    if (pFunc->AcquiresInstMethodTableFromThis())
+    {
+        // objects could be in invalid state at this time
+        // trying to get this here could result in invalid objects
+        return NULL;
+    }
+    else
+    {
+        if (pFrame == NULL)
+        {
+            return pCodeInfo->GetCodeManager()->GetParamTypeArg(pRD, pCodeInfo);
+        }
+        else
+        {
+            if (!pFunc->RequiresInstArg())
+            {
+                return NULL;
+            }
+
+#ifdef FEATURE_INTERPRETER
+            if (pFrame != NULL && pFrame->GetVTablePtr() == InterpreterFrame::GetMethodFrameVPtr())
+            {
+#ifdef DACCESS_COMPILE
+                // TBD: DACize the interpreter.
+                return NULL;
+#else
+                return dac_cast<PTR_InterpreterFrame>(pFrame)->GetInterpreter()->GetParamTypeArg();
+#endif
+            }
+            // Otherwise...
+#endif // FEATURE_INTERPRETER
+
+            return (dac_cast<PTR_FramedMethodFrame>(pFrame))->GetParamTypeArg();
+        }
+    }
+}
+
 void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
                                                   GetStackFramesData *pData,
                                                   PTRARRAYREF * pDynamicMethodArray /*= NULL*/
@@ -1151,22 +1207,30 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
                 // Currently such methods always return an IP of 0, so they're easy
                 // to spot.
                 DWORD dwNativeOffset;
+                PTR_VOID pExactGenericArgsToken = NULL;
 
                 if (cur.ip)
                 {
                     EECodeInfo codeInfo(cur.ip);
                     dwNativeOffset = codeInfo.GetRelOffset();
+                    REGDISPLAY pRD;
+                    CONTEXT ctx = {};
+                    SetIP(&ctx, cur.ip);
+                    SetSP(&ctx, cur.sp);
+                    FillRegDisplay(&pRD, &ctx);
+                    pExactGenericArgsToken = GetExactGenericArgsToken(cur.pFunc, &pRD, &codeInfo, NULL);
                 }
                 else
                 {
                     dwNativeOffset = 0;
                 }
-
+                
                 pData->pElements[i].InitPass1(
                     dwNativeOffset,
                     pMD,
                     (PCODE)cur.ip,
-                    cur.flags);
+                    cur.flags,
+                    pExactGenericArgsToken);
 #ifndef DACCESS_COMPILE
                 pData->pElements[i].InitPass2();
 #endif
@@ -1187,7 +1251,8 @@ void DebugStackTrace::DebugStackTraceElement::InitPass1(
     DWORD dwNativeOffset,
     MethodDesc *pFunc,
     PCODE ip,
-    INT flags
+    INT flags,
+    PTR_VOID pExactGenericArgsToken
 )
 {
     LIMITED_METHOD_CONTRACT;
@@ -1200,6 +1265,7 @@ void DebugStackTrace::DebugStackTraceElement::InitPass1(
     this->dwOffset = dwNativeOffset;
     this->ip = ip;
     this->flags = flags;
+    this->pExactGenericArgsToken = pExactGenericArgsToken;
 }
 
 #ifndef DACCESS_COMPILE

src/coreclr/vm/debugdebugger.h

@@ -99,14 +99,16 @@ class DebugStackTrace
         MethodDesc *pFunc;
         PCODE ip;
         INT flags;          // StackStackElementFlags
+        PTR_VOID pExactGenericArgsToken;
 
         // Initialization done under TSL.
         // This is used when first collecting the stack frame data.
         void InitPass1(
             DWORD dwNativeOffset,
             MethodDesc *pFunc,
             PCODE ip,
-            INT flags       // StackStackElementFlags
+            INT flags,       // StackStackElementFlags
+            PTR_VOID pExactGenericArgsToken
         );
 
         // Initialization done outside the TSL.
@@ -157,6 +159,7 @@ class DebugStackTrace
                   );
 
     static void GetStackFramesFromException(OBJECTREF * e, GetStackFramesData *pData, PTRARRAYREF * pDynamicMethodArray = NULL);
+    static PTR_VOID GetExactGenericArgsToken(PTR_MethodDesc pFunc, PREGDISPLAY pRD, EECodeInfo* pCodeInfo, PTR_Frame pFrame);
 
 #ifndef DACCESS_COMPILE
 // the DAC directly calls GetStackFramesFromException

src/coreclr/vm/jitinterface.cpp

@@ -7684,6 +7684,7 @@ static void getMethodInfoHelper(
                              (ftn->RequiresInstMethodTableArg() ? CORINFO_GENERICS_CTXT_FROM_METHODTABLE : 0) |
                              (ftn->RequiresInstMethodDescArg() ? CORINFO_GENERICS_CTXT_FROM_METHODDESC : 0)));
 
+
     // EEJitManager::ResolveEHClause and CrawlFrame::GetExactGenericInstantiations
     // need to be able to get to CORINFO_GENERICS_CTXT_MASK if there are any
     // catch clauses like "try {} catch(MyException<T> e) {}".
@@ -7692,19 +7693,26 @@ static void getMethodInfoHelper(
 
     if (methInfo->options & CORINFO_GENERICS_CTXT_MASK)
     {
-#if defined(PROFILING_SUPPORTED)
-        BOOL fProfilerRequiresGenericsContextForEnterLeave = FALSE;
+        if (ftn->IsJitOptimizationDisabled())
         {
-            BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
-            if ((&g_profControlBlock)->RequiresGenericsContextForEnterLeave())
-            {
-                fProfilerRequiresGenericsContextForEnterLeave = TRUE;
-            }
-            END_PROFILER_CALLBACK();
+            methInfo->options = CorInfoOptions(methInfo->options|CORINFO_GENERICS_CTXT_KEEP_ALIVE);
         }
-        if (fProfilerRequiresGenericsContextForEnterLeave)
+        else
         {
-            methInfo->options = CorInfoOptions(methInfo->options|CORINFO_GENERICS_CTXT_KEEP_ALIVE);
+#if defined(PROFILING_SUPPORTED)
+            BOOL fProfilerRequiresGenericsContextForEnterLeave = FALSE;
+            {
+                BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
+                if ((&g_profControlBlock)->RequiresGenericsContextForEnterLeave())
+                {
+                    fProfilerRequiresGenericsContextForEnterLeave = TRUE;
+                }
+                END_PROFILER_CALLBACK();
+            }
+            if (fProfilerRequiresGenericsContextForEnterLeave)
+            {
+                methInfo->options = CorInfoOptions(methInfo->options|CORINFO_GENERICS_CTXT_KEEP_ALIVE);
+            }
         }
 #endif // defined(PROFILING_SUPPORTED)
     }

src/libraries/System.Diagnostics.StackTrace/tests/StackFrameTests.cs

@@ -116,8 +116,13 @@ public static IEnumerable<object[]> ToString_TestData()
             yield return new object[] { new StackFrame(), "MoveNext at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
             yield return new object[] { new StackFrame("FileName", 1, 2), "MoveNext at offset {offset} in file:line:column FileName:1:2" + Environment.NewLine };
             yield return new object[] { new StackFrame(int.MaxValue), "<null>" + Environment.NewLine };
-            yield return new object[] { GenericMethod<string>(), "GenericMethod<T> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
-            yield return new object[] { GenericMethod<string, int>(), "GenericMethod<T,U> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
+#if DEBUG
+            yield return new object[] { GenericMethod<string>(), "GenericMethod<String> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
+            yield return new object[] { GenericMethod<string, int>(), "GenericMethod<String,Int32> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
+#else
+            yield return new object[] { GenericMethod<string>(), "GenericMethod<__Canon> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
+            yield return new object[] { GenericMethod<string, int>(), "GenericMethod<__Canon,Int32> at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
+#endif
             yield return new object[] { new ClassWithConstructor().StackFrame, ".ctor at offset {offset} in file:line:column {fileName}:{lineNumber}:{column}" + Environment.NewLine };
         }
 

src/libraries/System.Diagnostics.StackTrace/tests/StackTraceTests.cs

@@ -285,8 +285,13 @@ public static IEnumerable<object[]> ToString_TestData()
             yield return new object[] { NoParameters(), "System.Diagnostics.Tests.StackTraceTests.NoParameters()" };
             yield return new object[] { OneParameter(1), "System.Diagnostics.Tests.StackTraceTests.OneParameter(Int32 x)" };
             yield return new object[] { TwoParameters(1, null), "System.Diagnostics.Tests.StackTraceTests.TwoParameters(Int32 x, String y)" };
-            yield return new object[] { Generic<int>(), "System.Diagnostics.Tests.StackTraceTests.Generic[T]()" };
-            yield return new object[] { Generic<int, string>(), "System.Diagnostics.Tests.StackTraceTests.Generic[T,U]()" };
+#if DEBUG
+            yield return new object[] { Generic<int>(), "System.Diagnostics.Tests.StackTraceTests.Generic[Int32]()" };
+            yield return new object[] { Generic<int, string>(), "System.Diagnostics.Tests.StackTraceTests.Generic[Int32,String]()" };
+#else
+            yield return new object[] { Generic<int>(), "System.Diagnostics.Tests.StackTraceTests.Generic[Int32]()" };
+            yield return new object[] { Generic<int, string>(), "System.Diagnostics.Tests.StackTraceTests.Generic[Int32,__Canon]()" };
+#endif
             yield return new object[] { new ClassWithConstructor().StackTrace, "System.Diagnostics.Tests.StackTraceTests.ClassWithConstructor..ctor()" };
 
             // Methods belonging to the System.Diagnostics namespace are ignored.

src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Environment.StackTrace.cs

@@ -23,7 +23,11 @@ public void StackTraceTest()
             {
                 "System.Tests.EnvironmentStackTrace.StaticFrame(Object obj)",
                 "System.Tests.EnvironmentStackTrace.TestClass..ctor()",
-                "System.Tests.EnvironmentStackTrace.GenericFrame[T1,T2](T1 t1, T2 t2)",
+#if DEBUG
+                "System.Tests.EnvironmentStackTrace.GenericFrame[DateTime,StringBuilder](DateTime t1, StringBuilder t2)",
+#else
+                "System.Tests.EnvironmentStackTrace.GenericFrame[DateTime,__Canon](DateTime t1, __Canon t2)",
+#endif
                 "System.Tests.EnvironmentStackTrace.TestFrame()"
             };