Stop using a mapping table between MethodDesc and InterpMethod

InterpMethod* is used to handle interpreted method execution on mono, but it is not really needed. For CoreCLR we will turn this structure in a header to the compiled IR code, and identify other methods directly by the IR code pointer. The first pointer slot in the IR code will contain a pointer to the InterpMethod containing any other relevant information needed in the method execution.

Author: BrzVlad

src/coreclr/inc/corjit.h

@@ -107,7 +107,6 @@ extern "C" ICorJitCompiler* getJit();
 class ICorInterpreter
 {
     public:
-        virtual void* GetInterpMethod(CORINFO_METHOD_HANDLE methodHnd) = 0;
 };
 
 // #EEToJitInterface

src/coreclr/interpreter/compiler.cpp

@@ -467,13 +467,24 @@ void InterpCompiler::EmitCode()
             ip = EmitCodeIns(ip, ins);
         }
     }
+
+    m_MethodCodeSize = (int32_t)(ip - m_pMethodCode);
 }
 
-void InterpCompiler::PublishInterpMethod(InterpMethod* pMethod)
+InterpMethod* InterpCompiler::CreateInterpMethod()
 {
-    pMethod->pCode = m_pMethodCode;
+    InterpMethod *pMethod = new InterpMethod;
+
     pMethod->allocaSize = m_totalVarsStackSize;
-    pMethod->compiled = true;
+    pMethod->methodHnd = m_methodHnd;
+
+    return pMethod;
+}
+
+int32_t* InterpCompiler::GetCode(int32_t *pCodeSize)
+{
+    *pCodeSize = m_MethodCodeSize;
+    return m_pMethodCode;
 }
 
 InterpCompiler::InterpCompiler(COMP_HANDLE compHnd,
@@ -484,7 +495,7 @@ InterpCompiler::InterpCompiler(COMP_HANDLE compHnd,
     m_methodInfo = methodInfo;
 }
 
-int InterpCompiler::CompileMethod(InterpMethod *pMethod)
+InterpMethod* InterpCompiler::CompileMethod()
 {
     GenerateCode(m_methodInfo);
 
@@ -494,9 +505,7 @@ int InterpCompiler::CompileMethod(InterpMethod *pMethod)
 
     EmitCode();
 
-    PublishInterpMethod(pMethod);
-
-    return CORJIT_OK;
+    return CreateInterpMethod();
 }
 
 int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)

src/coreclr/interpreter/compiler.h

@@ -206,18 +206,21 @@ class InterpCompiler
 
     // Passes
     int32_t* m_pMethodCode;
+    int32_t m_MethodCodeSize; // in int32_t
 
     void OptimizeCode();
     void AllocOffsets();
     int32_t ComputeCodeSize();
     void EmitCode();
     int32_t* EmitCodeIns(int32_t *ip, InterpInst *pIns);
-    void PublishInterpMethod(InterpMethod *pMethod);
+    InterpMethod* CreateInterpMethod();
 public:
 
     InterpCompiler(COMP_HANDLE compHnd, CORINFO_METHOD_INFO* methodInfo);
 
-    int CompileMethod(InterpMethod *pMethod);
+    InterpMethod* CompileMethod();
+
+    int32_t* GetCode(int32_t *pCodeSize);
 };
 
 #endif //_COMPILER_H_

src/coreclr/interpreter/eeinterp.cpp

@@ -17,28 +17,6 @@
 
 #include <vector>
 
-// FIXME We will probably end up not needing this table.
-// If deemed useful, use some hashtable implementation instead.
-std::vector<std::pair<CORINFO_METHOD_HANDLE,InterpMethod*>> g_interpCodeHash;
-
-static InterpMethod* InterpGetInterpMethod(CORINFO_METHOD_HANDLE methodHnd)
-{
-    // FIXME lock for multiple thread access
-    for (size_t i = 0; i < g_interpCodeHash.size(); i++)
-    {
-        if (g_interpCodeHash[i].first == methodHnd)
-        {
-            return g_interpCodeHash[i].second;
-        }
-    }
-
-    InterpMethod* pMethod = new InterpMethod();
-    pMethod->methodHnd = methodHnd;
-
-    g_interpCodeHash.push_back({methodHnd, pMethod});
-    return pMethod;
-}
-
 /*****************************************************************************/
 ICorJitHost* g_interpHost        = nullptr;
 bool         g_interpInitialized = false;
@@ -95,33 +73,36 @@ CorJitResult CILInterp::compileMethod(ICorJitInfo*         compHnd,
         return CORJIT_SKIPPED;
     }
 
-    InterpMethod *pMethod = InterpGetInterpMethod(methodInfo->ftn);
-    if (!pMethod->compiled)
-    {
-        InterpCompiler compiler(compHnd, methodInfo);
-        compiler.CompileMethod(pMethod);
-    }
+    InterpCompiler compiler(compHnd, methodInfo);
+    InterpMethod *pMethod = compiler.CompileMethod();
+
+    int32_t IRCodeSize;
+    int32_t *pIRCode = compiler.GetCode(&IRCodeSize);
 
     // FIXME this shouldn't be here
     compHnd->setMethodAttribs(methodInfo->ftn, CORINFO_FLG_INTERPRETER);
 
+    uint32_t sizeOfCode = sizeof(void*) + IRCodeSize * sizeof(int32_t);
+
     // TODO: get rid of the need to allocate fake unwind info.
     compHnd->reserveUnwindInfo(false /* isFunclet */, false /* isColdCode */ , 8 /* unwindSize */);
     AllocMemArgs args;
-    args.hotCodeSize = 16;
+    args.hotCodeSize = sizeOfCode;
     args.coldCodeSize = 0;
     args.roDataSize = 0;
     args.xcptnsCount = 0;
     args.flag = CORJIT_ALLOCMEM_DEFAULT_CODE_ALIGN;
     compHnd->allocMem(&args);
-    uint8_t *code = (uint8_t*)args.hotCodeBlockRW;
-    *code++ = 1; // fake byte code
+
+    // We store first the InterpMethod pointer as the code header, followed by the actual code
+    *(InterpMethod**)args.hotCodeBlockRW = pMethod;
+    memcpy ((uint8_t*)args.hotCodeBlockRW + sizeof(InterpMethod*), pIRCode, IRCodeSize * sizeof(int32_t));
 
     // TODO: get rid of the need to allocate fake unwind info
     compHnd->allocUnwindInfo((uint8_t*)args.hotCodeBlock, (uint8_t*)args.coldCodeBlock, 0, 1, 0, nullptr, CORJIT_FUNC_ROOT);
 
     *entryAddress = (uint8_t*)args.hotCodeBlock;
-    *nativeSizeOfCode = 1;
+    *nativeSizeOfCode = sizeOfCode;
 
     return CORJIT_OK;
 }
@@ -140,8 +121,3 @@ void CILInterp::getVersionIdentifier(GUID* versionIdentifier)
 void CILInterp::setTargetOS(CORINFO_OS os)
 {
 }
-
-void* InterpManager::GetInterpMethod(CORINFO_METHOD_HANDLE methodHnd)
-{
-    return InterpGetInterpMethod(methodHnd);
-}

src/coreclr/interpreter/interpretershared.h

@@ -20,16 +20,7 @@ typedef enum
 struct InterpMethod
 {
     CORINFO_METHOD_HANDLE methodHnd;
-    int32_t *pCode;
     int32_t allocaSize;
-
-    volatile bool compiled;
-
-    InterpMethod()
-    {
-        pCode = NULL;
-        compiled = false;
-    }
 };
 
 #endif

src/coreclr/vm/interpexec.cpp

@@ -35,8 +35,9 @@ void InterpExecMethod(InterpFrame *pFrame, InterpThreadContext *pThreadContext)
     const int32_t *ip;
     int8_t *stack;
 
-    pThreadContext->pStackPointer = pFrame->pStack + pFrame->pMethod->allocaSize;
-    ip = pFrame->pMethod->pCode;
+    InterpMethod *pMethod = *(InterpMethod**)pFrame->startIp;
+    pThreadContext->pStackPointer = pFrame->pStack + pMethod->allocaSize;
+    ip = pFrame->startIp + sizeof(InterpMethod*) / sizeof(int32_t);
     stack = pFrame->pStack;
 
     while (true)

src/coreclr/vm/interpexec.h

@@ -24,7 +24,7 @@ struct StackVal
 struct InterpFrame
 {
     InterpFrame *pParent;
-    InterpMethod *pMethod;
+    int32_t *startIp; // from start_ip we can obtain InterpMethod and MethodDesc
     int8_t *pStack;
     int8_t *pRetVal;
     int32_t *ip;

src/coreclr/vm/prestub.cpp

@@ -2742,19 +2742,11 @@ extern "C" void STDCALL ExecuteInterpretedMethod(TransitionBlock* pTransitionBlo
 {
     // Argument registers are in the TransitionBlock
     // The stack arguments are right after the pTransitionBlock
-    CodeHeader* pCodeHeader = EEJitManager::GetCodeHeaderFromStartAddress(byteCodeAddr);
-
-    EEJitManager *pManager = ExecutionManager::GetEEJitManager();
-    MethodDesc *pMD = pCodeHeader->GetMethodDesc();
-
-    InterpMethod *pMethod = (InterpMethod*)pManager->m_interpreter->GetInterpMethod((CORINFO_METHOD_HANDLE)pMD);
-    assert(pMethod && pMethod->compiled);
-
     InterpThreadContext *threadContext = InterpGetThreadContext();
     int8_t *sp = threadContext->pStackPointer;
 
     InterpFrame interpFrame = {0};
-    interpFrame.pMethod = pMethod;
+    interpFrame.startIp = (int32_t*)byteCodeAddr;
     interpFrame.pStack = sp;
     interpFrame.pRetVal = sp;