Tagged Pointer Prototype

Author: cshung

# Tagged Function Prototype.md

@@ -0,0 +1,69 @@
+# Tagged Function Prototype
+
+The goal of this prototype is to investigate whether or not the tagged function concept is practically feasible in the CoreCLR code base.
+
+## How does the CoreCLR interpreter work today?
+
+This section covers a small portion of how the interpreter integrate with the runtime. It does NOT attempt to explain the full interpreter execution process.
+
+The interpreter work by pretending itself as jitted code, as such, it needs to
+
+1. Convert the incoming arguments from the register/stack to something C++ understands
+2. The control flows to `InterpretMethodBody`, where it interprets the byte code.
+3. Call any other callee as if they are jitted code as well, and
+4. Put thing back on the stack as if it were produced by jitted code.
+
+Step 1 is something require special generated code to do, right now, it is done by `GenerateInterpreterStub`. It is meant to be a tiny routine that take arguments from the stack
+and rewrite the stack so that the values can be consumed by C++.
+
+## What do we want?
+
+We want to get rid of the concept of interpreter stub, and instead, have the caller calling the actual `InterpretMethodBody` directly.
+
+`InterpretMethodBody` requires an `InterpreterMethodInfo` object, which basically is a representation where we can easily access its signature and its byte code.
+
+So the problem is reduced to:
+
+1. Identify a caller that is currently calling using the standard calling convention.
+2. Get that caller to access an `InterpreterMethodInfo` object, and so
+3. Make it calls `InterpretMethodBody` instead.
+
+## Wrong attempts
+
+I tried 3 different approaches to that and only the last one succeed. These wrong attempts are documented just so we don't try the same wrong idea again.
+
+### Idea 1
+
+- Make `GenerateInterpreterStub` return a tagged pointer instead
+
+This approach failed because `GenerateInterpreterStub` is called as part of `ThePreStub`. `ThePreStub` works by leaving the call arguments on the stack, so the incoming call arguments are already on the stack, and we at least need some code to get it back.
+
+### Idea 2
+
+Now we know we must perform call `InterpretMethodBody` earlier then `ThePreStub`, which means `ThePreStub` must be replaced by something else. In fact, how does `ThePreStub` knows what `MethodDesc` to interpret? Upon investigation, I learn about this concept of `Precode`.
+
+Basically, every method has a `Precode`, that is a simple `jmp` instruction the goes somewhere else. This is the first instruction that get executed. To begin with, that instruction jumps to `ThePreStub`, and that instruction is code generated. Given the precode, we can get to the MethodDesc.
+
+What that means is that we need to get rid of the code generation during the Precode generation, which means will no longer have the jmp instruction. Instead, we will put a thing there that allow us to get to the `InterpreterMethodInfo`.
+
+A reasonable choice is to put a pointer to the `InterpreterMethodInfo` object right there. We will tag the least significant bit of it so that we know it is not a normal function entry point.
+
+To be more concrete, the precode is generated during `MethodDesc::EnsureTemporaryEntryPointCore`. We will modify that code so that it translate the `MethodDesc` into an `InterpreterMethodInfo` there and tag it so that we put it into the method table there.
+
+The reason why this approach fails is more subtle. It turns out that the `InterpreterMethodInfo` construction process leveraged the code that supports the JIT to extract the IL, and that code assumed the method tables are also properly constructed, but that's not true at the time `MethodDesc::EnsureTemporaryEntryPointCore` is called. So we must delay the process of `InterpreterMethodInfo` object construction.
+
+## Working approach
+
+### Idea 3
+
+To get around the cyclic dependency issue above, I tagged the MethodDesc pointer instead. By the time we are about to call the function, then we construct the `InterpreterMethodInfo`. This worked.
+
+The down side of this approach, obviously, is that the pointer in the method table is no longer a valid entry point, so anything else that try to call it will lead to an access violation. This will work in a pure interpreted scenario, where the interpreter is the only thing that runs in the process. 
+
+Suppose we also want to let (e.g. ReadyToRun) code to run, that won't work unless we also change the ReadyToRun callers.
+
+The code in this branch demonstrated this concept. It will execute some code under the interpreter (and fail pretty quickly because I haven't implemented everything yet).
+
+### Lowlights
+
+This code is still using dynamic code generation for a couple of things. We are still generating code for GC write barrier, and we are still generating some glue code for pinvoke. Lastly, the call made by the interpreter is not converted to use the new call convention yet. These seems to be solvable problems.

src/coreclr/minipal/Windows/doublemapping.cpp

@@ -184,8 +184,15 @@ void* VMToOSInterface::ReserveDoubleMappedMemory(void *mapperHandle, size_t offs
     return pResult;
 }
 
+extern void andrew_debug();
+
 void *VMToOSInterface::CommitDoubleMappedMemory(void* pStart, size_t size, bool isExecutable)
 {
+    if (isExecutable)
+    {
+        // Whenever this is called, we are generating code.
+        andrew_debug();
+    }
     return VirtualAlloc(pStart, size, MEM_COMMIT, isExecutable ? PAGE_EXECUTE_READ : PAGE_READWRITE);
 }
 

src/coreclr/vm/callhelpers.cpp

@@ -18,6 +18,8 @@
 #include "invokeutil.h"
 #include "argdestination.h"
 
+void andrew_debug();
+
 #if defined(FEATURE_MULTICOREJIT) && defined(_DEBUG)
 
 // Allow system module for Appx
@@ -33,6 +35,10 @@ void AssertMulticoreJitAllowedModule(PCODE pTarget)
 
 #endif
 
+void* ToInterpreterMethodInfo(MethodDesc* pMd);
+
+void CallInterpretMethod(void* interpreterMethodInfo, BYTE* ilArgs);
+
 // For X86, INSTALL_COMPLUS_EXCEPTION_HANDLER grants us sufficient protection to call into
 // managed code.
 //
@@ -60,7 +66,44 @@ void CallDescrWorkerWithHandler(
 
     BEGIN_CALL_TO_MANAGEDEX(fCriticalCall ? EEToManagedCriticalCall : EEToManagedDefault);
 
+#ifdef FEATURE_INTERPRETER
+    uint64_t pCallTarget = (uint64_t)(pCallDescrData->pTarget);
+    if ((pCallTarget & 0x3) == 0x3)
+    {
+        //
+        // Experiment comment:
+        // Step 4: When we call a method, we simply redirect it to use CallInterpretMethod instead
+        // of calling a stub and then redirecting back to call InterpretMethod anyway.
+        // 
+        // That involves first converting the MethodDesc to an InterpreterMethodInfo. We will store
+        // that on the MethodTable slot so we do not do repeated conversion.
+        //
+        MethodDesc* pMD = (MethodDesc*)(pCallTarget & (~0x3));
+            
+        if (pMD->IsIL() && !pMD->IsUnboxingStub())
+        {
+            void* translated = ToInterpreterMethodInfo(pMD);
+            *(pMD->GetAddrOfSlot()) = pCallTarget = (PCODE)translated;
+        }
+    }
+    if ((pCallTarget & 0x3) == 0x1)
+    {
+        //
+        // Experiment comment:
+        // Step 5: Now we have an InterpreterMethodInfo, simply call CallInterpretMethod
+        // 
+        // That involves first converting the MethodDesc to an InterpreterMethodInfo. We will store
+        // that on the MethodTable slot so we do not do repeated conversion.
+        //
+        CallInterpretMethod((void*)(pCallTarget & (~0x1)), (BYTE*)pCallDescrData->pSrc);
+    }
+    else
+    {
+        CallDescrWorker(pCallDescrData);
+    }
+#else
     CallDescrWorker(pCallDescrData);
+#endif
 
     END_CALL_TO_MANAGED();
 }

src/coreclr/vm/ecall.cpp

@@ -88,7 +88,16 @@ void ECall::PopulateManagedStringConstructors()
         MethodDesc* pMD = CoreLibBinder::GetMethod((BinderMethodID)(METHOD__STRING__CTORF_FIRST + i));
         _ASSERTE(pMD != NULL);
 
+#ifdef FEATURE_INTERPRETER
+        // 
+        // Experiment Comment:
+        // Step 3: GetMultiCallableAddrOfCode will eventually try to interpret the entry point
+        // as a Precode. For that, we simply ignore that work.
+        //
+        PCODE pDest = (PCODE)((uint64_t)pMD & 0x03);
+#else
         PCODE pDest = pMD->GetMultiCallableAddrOfCode();
+#endif
 
         ECall::DynamicallyAssignFCallImpl(pDest, ECallCtor_First + i);
     }

src/coreclr/vm/interpreter.cpp

@@ -1692,11 +1692,20 @@ CorJitResult Interpreter::GenerateInterpreterStub(CEEInfo* comp,
 #else
 #error unsupported platform
 #endif
-        stub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetStubHeap());
+        if (false)
+        {
+            stub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetStubHeap());
 
-        *nativeSizeOfCode = static_cast<ULONG>(stub->GetNumCodeBytes());
-        // TODO: manage reference count of interpreter stubs.  Look for examples...
-        *nativeEntry = dac_cast<BYTE*>(stub->GetEntryPoint());
+            *nativeSizeOfCode = static_cast<ULONG>(stub->GetNumCodeBytes());
+            // TODO: manage reference count of interpreter stubs.  Look for examples...
+            *nativeEntry = dac_cast<BYTE*>(stub->GetEntryPoint());
+        }
+        else
+        {
+            // Intentionally avoid generating any code - but it is required
+            // for us to have an unique nativeEntry since it will be part of some hash table
+            *nativeEntry = (BYTE*)(((uint64_t)interpMethInfo) | 0x1);
+        }
     }
 
     // Initialize the arg offset information.
@@ -1773,6 +1782,81 @@ ARG_SLOT Interpreter::ExecuteMethodWrapper(struct InterpreterMethodInfo* interpM
     return retVal;
 }
 
+COR_ILMETHOD_DECODER* CopiedGetAndVerifyMetadataILHeader(MethodDesc* pMD, PrepareCodeConfig* pConfig, COR_ILMETHOD_DECODER* pDecoderMemory)
+{
+    // STANDARD_VM_CONTRACT;
+    _ASSERTE(pMD != NULL);
+    _ASSERTE(!pMD->IsNoMetadata());
+    _ASSERTE(pConfig != NULL);
+    _ASSERTE(pDecoderMemory != NULL);
+
+    COR_ILMETHOD_DECODER* pHeader = NULL;
+    COR_ILMETHOD* ilHeader = pConfig->GetILHeader();
+    if (ilHeader == NULL)
+        return NULL;
+
+    COR_ILMETHOD_DECODER::DecoderStatus status = COR_ILMETHOD_DECODER::FORMAT_ERROR;
+    {
+        // Decoder ctor can AV on a malformed method header
+        AVInRuntimeImplOkayHolder AVOkay;
+        pHeader = new (pDecoderMemory) COR_ILMETHOD_DECODER(ilHeader, pMD->GetMDImport(), &status);
+    }
+
+    if (status == COR_ILMETHOD_DECODER::FORMAT_ERROR)
+        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_BAD_IL);
+
+    return pHeader;
+}
+
+COR_ILMETHOD_DECODER* CopiedGetAndVerifyILHeader(MethodDesc* pMD, PrepareCodeConfig* pConfig, COR_ILMETHOD_DECODER* pIlDecoderMemory)
+{
+    // STANDARD_VM_CONTRACT;
+    _ASSERTE(pMD != NULL);
+    if (pMD->IsIL())
+    {
+        return CopiedGetAndVerifyMetadataILHeader(pMD, pConfig, pIlDecoderMemory);
+    }
+    else if (pMD->IsILStub())
+    {
+        ILStubResolver* pResolver = pMD->AsDynamicMethodDesc()->GetILStubResolver();
+        return pResolver->GetILHeader();
+    }
+
+    _ASSERTE(pMD->IsNoMetadata());
+    return NULL;
+}
+
+void ToMethodInfo(MethodDesc* ftn, COR_ILMETHOD_DECODER* ILHeader, CORINFO_METHOD_INFO* pMethodInfo);
+
+void* ToInterpreterMethodInfo(MethodDesc* pMd)
+{
+    // Given a methodDesc, convert it into an InterpreterMethodInfo
+    GCX_PREEMP();
+    NativeCodeVersion activeCodeVersion(pMd);
+    PrepareCodeConfigBuffer pccb(activeCodeVersion);
+    PrepareCodeConfig* pConfig = pccb.GetConfig();
+    COR_ILMETHOD_DECODER ilDecoderTemp;
+    COR_ILMETHOD_DECODER* pilHeader = CopiedGetAndVerifyILHeader(pMd, pConfig, &ilDecoderTemp);
+    CORINFO_METHOD_INFO methodInfo;
+    ToMethodInfo(pMd, pilHeader, &methodInfo);
+    CEEInfo* jitInfo = new CEEInfo(pMd, true);
+
+    InterpreterMethodInfo* interpreterMethodInfo;
+    BYTE* unusedEntry;
+    uint32_t unusedSize;
+    
+    // The method is modified so that it won't generate code anymore
+    Interpreter::GenerateInterpreterStub(jitInfo, &methodInfo, &unusedEntry, &unusedSize, &interpreterMethodInfo, false);
+    return (void*)(((uint64_t)interpreterMethodInfo) | 0x1);
+}
+
+void CallInterpretMethod(void* interpreterMethodInfo, BYTE* ilArgs)
+{
+    struct InterpreterMethodInfo* interpMethInfo = (struct InterpreterMethodInfo*)interpreterMethodInfo;
+    // TODO, return!
+    Interpreter::InterpretMethodBody(interpMethInfo, true, ilArgs, nullptr);
+}
+
 // TODO: Add GSCookie checks
 
 // static

src/coreclr/vm/interpreter.h

@@ -746,8 +746,10 @@ class Interpreter
     friend float F_CALL_CONV InterpretMethodFloat(InterpreterMethodInfo* methInfo, BYTE* ilArgs, void* stubContext);
     friend double F_CALL_CONV InterpretMethodDouble(InterpreterMethodInfo* methInfo, BYTE* ilArgs, void* stubContext);
 
+public:
     // This will be inlined into the bodies of the methods above
     static inline ARG_SLOT InterpretMethodBody(InterpreterMethodInfo* interpMethInfo, bool directCall, BYTE* ilArgs, void* stubContext);
+private:
 
     // The local frame size of the method being interpreted.
     static size_t GetFrameSize(InterpreterMethodInfo* interpMethInfo);

src/coreclr/vm/jitinterface.cpp

@@ -12885,6 +12885,11 @@ void ThrowExceptionForJit(HRESULT res)
 BOOL g_fAllowRel32 = TRUE;
 #endif
 
+void ToMethodInfo(MethodDesc* ftn, COR_ILMETHOD_DECODER* ILHeader, CORINFO_METHOD_INFO* pMethodInfo)
+{
+    MethodInfoHelperContext cxt{ ftn, ILHeader };
+    getMethodInfoHelper(cxt, pMethodInfo);
+}
 
 // ********************************************************************
 //                  README!!

src/coreclr/vm/method.cpp

@@ -2660,6 +2660,12 @@ MethodDesc* MethodDesc::GetMethodDescFromStubAddr(PCODE addr, BOOL fSpeculative
 
     // Otherwise this must be some kind of precode
     //
+#ifdef FEATURE_INTERPRETER
+    if ((addr & 0x03) == 0x03)
+    {
+        return (MethodDesc*)((addr) & (~0x03));
+    }
+#endif
     PTR_Precode pPrecode = Precode::GetPrecodeFromEntryPoint(addr, fSpeculative);
     PREFIX_ASSUME(fSpeculative || (pPrecode != NULL));
     if (pPrecode != NULL)
@@ -2758,6 +2764,16 @@ void MethodDesc::EnsureTemporaryEntryPointCore(AllocMemTracker *pamTracker)
         GetMethodDescChunk()->DetermineAndSetIsEligibleForTieredCompilation();
         PTR_PCODE pSlot = GetAddrOfSlot();
 
+#ifdef FEATURE_INTERPRETER
+        //
+        // Experiment comment:
+        // Step 1: Whenever we create a MethodDesc, we used to generate a precode for it
+        // This change avoids that and we put in a tagged MethodDesc there instead.
+        //
+        IfFailThrow(EnsureCodeDataExists(pamTracker));
+        // TODO: Interlocked?
+        PCODE tempEntryPoint = m_codeData->TemporaryEntryPoint = (PCODE)((uint64_t)this | 0x3);
+#else
         AllocMemTracker amt;
         AllocMemTracker *pamTrackerPrecode = pamTracker != NULL ? pamTracker : &amt;
         Precode* pPrecode = Precode::Allocate(GetPrecodeType(), this, GetLoaderAllocator(), pamTrackerPrecode);
@@ -2769,6 +2785,7 @@ void MethodDesc::EnsureTemporaryEntryPointCore(AllocMemTracker *pamTracker)
 
         PCODE tempEntryPoint = m_codeData->TemporaryEntryPoint;
         _ASSERTE(tempEntryPoint != (PCODE)NULL);
+#endif
 
         if (*pSlot == (PCODE)NULL)
         {
@@ -2866,16 +2883,26 @@ Precode* MethodDesc::GetOrCreatePrecode()
 
 void MethodDesc::MarkPrecodeAsStableEntrypoint()
 {
+#ifndef FEATURE_INTERPRETER
 #if _DEBUG
     PCODE tempEntry = GetTemporaryEntryPointIfExists();
     _ASSERTE(tempEntry != (PCODE)NULL);
     PrecodeType requiredType = GetPrecodeType();
+    //
+    // Experiment comment:
+    // Step 2: Later on, for various reasons, we might want to know more about the function
+    // Currently, it is done by Precode::GetPrecodeFromEntryPoint, which will obviously not
+    // work because the entry point is no longer a Precode.
+    // 
+    // Depending on what we actually want, this needs to be fixed differently. For example
+    // this is just doing some assertion, we can simply ignore it.
+    //
     PrecodeType availableType = Precode::GetPrecodeFromEntryPoint(tempEntry)->GetType();
     _ASSERTE(requiredType == availableType);
 #endif
     _ASSERTE(!HasPrecode());
     _ASSERTE(RequiresStableEntryPoint());
-
+#endif
     InterlockedUpdateFlags3(enum_flag3_HasStableEntryPoint | enum_flag3_HasPrecode, TRUE);
 }