[interp] Implement basic tailcalls (dotnet#118901)

kg · web-flow · commit 0f21477e08c8 · 2025-08-21T17:26:37.000-07:00
* Add and generate dedicated interpreter opcodes for tail calls
* Implement regular and virtual tail calls from interpreted code to interpreted code
* Other types of tail calls are not yet implemented
diff --git a/src/coreclr/interpreter/compiler.cpp b/src/coreclr/interpreter/compiler.cpp
@@ -1241,7 +1241,7 @@ InterpMethod* InterpCompiler::CreateInterpMethod()
 
     bool unmanagedCallersOnly = corJitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_REVERSE_PINVOKE);
 
-    InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_totalVarsStackSize, pDataItems, initLocals, unmanagedCallersOnly);
+    InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_ILLocalsOffset, m_totalVarsStackSize, pDataItems, initLocals, unmanagedCallersOnly);
 
     return pMethod;
 }
@@ -3082,7 +3082,7 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re
             }
             else if (isCalli)
             {
-                AddIns(INTOP_CALLI);
+                AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);
                 m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);
                 m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, callIFunctionPointerVar);
             }
@@ -3100,6 +3100,11 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re
                     assert(!isPInvoke && !isMarshaledPInvoke);
                     AddIns(INTOP_CALLDELEGATE);
                 }
+                else if (tailcall)
+                {
+                    assert(!isPInvoke && !isMarshaledPInvoke);
+                    AddIns(INTOP_CALL_TAIL);
+                }
                 else
                 {
                     AddIns((isPInvoke && !isMarshaledPInvoke) ? INTOP_CALL_PINVOKE : INTOP_CALL);
@@ -3136,14 +3141,14 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re
 
             calliCookie = m_compHnd->GetCookieForInterpreterCalliSig(&callInfo.sig);
 
-            AddIns(INTOP_CALLI);
+            AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);
             m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);
             m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, codePointerLookupResult);
             break;
         }
         case CORINFO_VIRTUALCALL_VTABLE:
             // Traditional virtual call. In theory we could optimize this to using the vtable
-            AddIns(INTOP_CALLVIRT);
+            AddIns(tailcall ? INTOP_CALLVIRT_TAIL : INTOP_CALLVIRT);
             m_pLastNewIns->data[0] = GetDataItemIndex(callInfo.hMethod);
             break;
 
@@ -3171,13 +3176,13 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re
 
                 calliCookie = m_compHnd->GetCookieForInterpreterCalliSig(&callInfo.sig);
 
-                AddIns(INTOP_CALLI);
+                AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);
                 m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);
                 m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, synthesizedLdvirtftnPtrVar);
             }
             else
             {
-                AddIns(INTOP_CALLVIRT);
+                AddIns(tailcall ? INTOP_CALLVIRT_TAIL : INTOP_CALLVIRT);
                 m_pLastNewIns->data[0] = GetDataItemIndex(callInfo.hMethod);
             }
             break;
diff --git a/src/coreclr/interpreter/interpretershared.h b/src/coreclr/interpreter/interpretershared.h
@@ -30,19 +30,20 @@ struct InterpMethod
     InterpMethod *self;
 #endif
     CORINFO_METHOD_HANDLE methodHnd;
-    int32_t allocaSize;
+    int32_t argsSize, allocaSize;
     void** pDataItems;
     // This stub is used for calling the interpreted method from JITted/AOTed code
     CallStubHeader *pCallStub;
     bool initLocals;
     bool unmanagedCallersOnly;
 
-    InterpMethod(CORINFO_METHOD_HANDLE methodHnd, int32_t allocaSize, void** pDataItems, bool initLocals, bool unmanagedCallersOnly)
+    InterpMethod(CORINFO_METHOD_HANDLE methodHnd, int32_t argsSize, int32_t allocaSize, void** pDataItems, bool initLocals, bool unmanagedCallersOnly)
     {
 #if DEBUG
         this->self = this;
 #endif
         this->methodHnd = methodHnd;
+        this->argsSize = argsSize;
         this->allocaSize = allocaSize;
         this->pDataItems = pDataItems;
         this->initLocals = initLocals;
diff --git a/src/coreclr/interpreter/intops.def b/src/coreclr/interpreter/intops.def
@@ -365,6 +365,11 @@ OPDEF(INTOP_NEWOBJ, "newobj", 5, 1, 1, InterpOpMethodHandle)
 OPDEF(INTOP_NEWOBJ_GENERIC, "newobj.generic", 6, 1, 2, InterpOpMethodHandle)
 OPDEF(INTOP_NEWOBJ_VT, "newobj.vt", 5, 1, 1, InterpOpMethodHandle)
 
+// Tail calls
+OPDEF(INTOP_CALL_TAIL, "call.tail", 4, 1, 1, InterpOpMethodHandle)
+OPDEF(INTOP_CALLI_TAIL, "calli", 5, 1, 2, InterpOpLdPtr)
+OPDEF(INTOP_CALLVIRT_TAIL, "callvirt.tail", 4, 1, 1, InterpOpMethodHandle)
+
 // The following helper call instructions exist in 2 variants, one for normal methods, and one for cases where a shared generic lookup is needed.
 // In the case where a shared generic lookup is needed an extra argument is passed as an svar, which is a pointer to the generic context.
 // If there is a generic context argument it is always the first SVar to the instruction.
diff --git a/src/coreclr/vm/interpexec.cpp b/src/coreclr/vm/interpexec.cpp
@@ -543,6 +543,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
     }
 
     int32_t returnOffset, callArgsOffset, methodSlot;
+    bool isTailcall = false;
     MethodDesc* targetMethod;
 
 MAIN_LOOP:
@@ -1895,8 +1896,10 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                     break;
                 }
 
+                case INTOP_CALLVIRT_TAIL:
                 case INTOP_CALLVIRT:
                 {
+                    isTailcall = (*ip == INTOP_CALLVIRT_TAIL);
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];
@@ -1914,8 +1917,10 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                     goto CALL_INTERP_METHOD;
                 }
 
+                case INTOP_CALLI_TAIL:
                 case INTOP_CALLI:
                 {
+                    isTailcall = (*ip == INTOP_CALLI_TAIL);
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     int32_t calliFunctionPointerVar = ip[3];
@@ -1927,6 +1932,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                     // Save current execution state for when we return from called method
                     pFrame->ip = ip;
 
+                    // Interpreter-FIXME: isTailcall
                     InvokeCalliStub(LOCAL_VAR(calliFunctionPointerVar, PCODE), pCallStub, stack + callArgsOffset, stack + returnOffset);
                     break;
                 }
@@ -1936,6 +1942,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                     // This opcode handles p/invokes that don't use a managed wrapper for marshaling. These
                     //  calls are special in that they need an InlinedCallFrame in order for proper EH to happen
 
+                    isTailcall = false;
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];
@@ -1971,6 +1978,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
 
                 case INTOP_CALLDELEGATE:
                 {
+                    isTailcall = false;
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];
@@ -1996,8 +2004,10 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                     break;
                 }
 
+                case INTOP_CALL_TAIL:
                 case INTOP_CALL:
                 {
+                    isTailcall = (*ip == INTOP_CALL_TAIL);
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];
@@ -2032,24 +2042,44 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                         if (targetIp == NULL)
                         {
                             // If we didn't get the interpreter code pointer setup, then this is a method we need to invoke as a compiled method.
+                            // Interpreter-FIXME: Implement tailcall via helpers, see https://github.com/dotnet/runtime/blob/main/docs/design/features/tailcalls-with-helpers.md
                             InvokeCompiledMethod(targetMethod, stack + callArgsOffset, stack + returnOffset, targetMethod->GetMultiCallableAddrOfCode(CORINFO_ACCESS_ANY));
                             break;
                         }
                     }
 
-                    // Allocate child frame.
+                    if (isTailcall)
                     {
-                        InterpMethodContextFrame *pChildFrame = pFrame->pNext;
-                        if (!pChildFrame)
+                        // Move args from callArgsOffset to start of stack frame.
+                        InterpMethod* pTargetMethod = targetIp->Method;
+                        assert(pTargetMethod->CheckIntegrity());
+                        // It is safe to use memcpy because the source and destination are both on the interp stack, not in the GC heap.
+                        // We need to use the target method's argsSize, not our argsSize, because tail calls (unlike CEE_JMP) can have a
+                        //  different signature from the caller.
+                        memcpy(pFrame->pStack, stack + callArgsOffset, pTargetMethod->argsSize);
+                        // Reuse current stack frame. We discard the call insn's returnOffset because it's not important and tail calls are
+                        //  required to be followed by a ret, so we know nothing is going to read from stack[returnOffset] after the call.
+                        pFrame->ReInit(pFrame->pParent, targetIp, pFrame->pRetVal, pFrame->pStack);
+                    }
+                    else
+                    {
+                        // Save current execution state for when we return from called method
+                        pFrame->ip = ip;
+
+                        // Allocate child frame.
                         {
-                            pChildFrame = (InterpMethodContextFrame*)alloca(sizeof(InterpMethodContextFrame));
-                            pChildFrame->pNext = NULL;
-                            pFrame->pNext = pChildFrame;
+                            InterpMethodContextFrame *pChildFrame = pFrame->pNext;
+                            if (!pChildFrame)
+                            {
+                                pChildFrame = (InterpMethodContextFrame*)alloca(sizeof(InterpMethodContextFrame));
+                                pChildFrame->pNext = NULL;
+                                pFrame->pNext = pChildFrame;
+                            }
+                            pChildFrame->ReInit(pFrame, targetIp, stack + returnOffset, stack + callArgsOffset);
+                            pFrame = pChildFrame;
                         }
-                        pChildFrame->ReInit(pFrame, targetIp, stack + returnOffset, stack + callArgsOffset);
-                        pFrame = pChildFrame;
+                        assert (((size_t)pFrame->pStack % INTERP_STACK_ALIGNMENT) == 0);
                     }
-                    assert (((size_t)pFrame->pStack % INTERP_STACK_ALIGNMENT) == 0);
 
                     // Set execution state for the new frame
                     pMethod = pFrame->startIp->Method;
@@ -2061,6 +2091,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                 }
                 case INTOP_NEWOBJ_GENERIC:
                 {
+                    isTailcall = false;
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[4];
@@ -2079,6 +2110,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                 }
                 case INTOP_NEWOBJ:
                 {
+                    isTailcall = false;
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];
@@ -2110,6 +2142,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                 }
                 case INTOP_NEWOBJ_VT:
                 {
+                    isTailcall = false;
                     returnOffset = ip[1];
                     callArgsOffset = ip[2];
                     methodSlot = ip[3];

Original file line number	Diff line number	Diff line change
`@@ -1241,7 +1241,7 @@ InterpMethod* InterpCompiler::CreateInterpMethod()`
`1241`	`1241`
`1242`	`1242`	`bool unmanagedCallersOnly = corJitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_REVERSE_PINVOKE);`
`1243`	`1243`
`1244`		`- InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_totalVarsStackSize, pDataItems, initLocals, unmanagedCallersOnly);`
	`1244`	`+ InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_ILLocalsOffset, m_totalVarsStackSize, pDataItems, initLocals, unmanagedCallersOnly);`
`1245`	`1245`
`1246`	`1246`	`return pMethod;`
`1247`	`1247`	`}`
`@@ -3082,7 +3082,7 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re`
`3082`	`3082`	`}`
`3083`	`3083`	`else if (isCalli)`
`3084`	`3084`	`{`
`3085`		`- AddIns(INTOP_CALLI);`
	`3085`	`+ AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);`
`3086`	`3086`	`m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);`
`3087`	`3087`	`m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, callIFunctionPointerVar);`
`3088`	`3088`	`}`
`@@ -3100,6 +3100,11 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re`
`3100`	`3100`	`assert(!isPInvoke && !isMarshaledPInvoke);`
`3101`	`3101`	`AddIns(INTOP_CALLDELEGATE);`
`3102`	`3102`	`}`
	`3103`	`+ else if (tailcall)`
	`3104`	`+ {`
	`3105`	`+ assert(!isPInvoke && !isMarshaledPInvoke);`
	`3106`	`+ AddIns(INTOP_CALL_TAIL);`
	`3107`	`+ }`
`3103`	`3108`	`else`
`3104`	`3109`	`{`
`3105`	`3110`	`AddIns((isPInvoke && !isMarshaledPInvoke) ? INTOP_CALL_PINVOKE : INTOP_CALL);`
`@@ -3136,14 +3141,14 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re`
`3136`	`3141`
`3137`	`3142`	`calliCookie = m_compHnd->GetCookieForInterpreterCalliSig(&callInfo.sig);`
`3138`	`3143`
`3139`		`- AddIns(INTOP_CALLI);`
	`3144`	`+ AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);`
`3140`	`3145`	`m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);`
`3141`	`3146`	`m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, codePointerLookupResult);`
`3142`	`3147`	`break;`
`3143`	`3148`	`}`
`3144`	`3149`	`case CORINFO_VIRTUALCALL_VTABLE:`
`3145`	`3150`	`// Traditional virtual call. In theory we could optimize this to using the vtable`
`3146`		`- AddIns(INTOP_CALLVIRT);`
	`3151`	`+ AddIns(tailcall ? INTOP_CALLVIRT_TAIL : INTOP_CALLVIRT);`
`3147`	`3152`	`m_pLastNewIns->data[0] = GetDataItemIndex(callInfo.hMethod);`
`3148`	`3153`	`break;`
`3149`	`3154`
`@@ -3171,13 +3176,13 @@ void InterpCompiler::EmitCall(CORINFO_RESOLVED_TOKEN* pConstrainedToken, bool re`
`3171`	`3176`
`3172`	`3177`	`calliCookie = m_compHnd->GetCookieForInterpreterCalliSig(&callInfo.sig);`
`3173`	`3178`
`3174`		`- AddIns(INTOP_CALLI);`
	`3179`	`+ AddIns(tailcall ? INTOP_CALLI_TAIL : INTOP_CALLI);`
`3175`	`3180`	`m_pLastNewIns->data[0] = GetDataItemIndex(calliCookie);`
`3176`	`3181`	`m_pLastNewIns->SetSVars2(CALL_ARGS_SVAR, synthesizedLdvirtftnPtrVar);`
`3177`	`3182`	`}`
`3178`	`3183`	`else`
`3179`	`3184`	`{`
`3180`		`- AddIns(INTOP_CALLVIRT);`
	`3185`	`+ AddIns(tailcall ? INTOP_CALLVIRT_TAIL : INTOP_CALLVIRT);`
`3181`	`3186`	`m_pLastNewIns->data[0] = GetDataItemIndex(callInfo.hMethod);`
`3182`	`3187`	`}`
`3183`	`3188`	`break;`