[clr-interp] Implement CEE_LOCALLOC and frame data allocator for dynamic stack allocations

src/coreclr/interpreter/compiler.cpp

@@ -815,7 +815,9 @@ InterpMethod* InterpCompiler::CreateInterpMethod()
     for (int i = 0; i < numDataItems; i++)
         pDataItems[i] = m_dataItems.Get(i);
 
-    InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_totalVarsStackSize, pDataItems);
+    bool initLocals = (m_methodInfo->options & CORINFO_OPT_INIT_LOCALS) != 0;
+
+    InterpMethod *pMethod = new InterpMethod(m_methodHnd, m_totalVarsStackSize, pDataItems, initLocals);
 
     return pMethod;
 }
@@ -2596,6 +2598,14 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                 EmitBinaryArithmeticOp(INTOP_MUL_I4);
                 m_ip++;
                 break;
+            case CEE_MUL_OVF:
+                EmitBinaryArithmeticOp(INTOP_MUL_OVF_I4);
+                m_ip++;
+                break;
+            case CEE_MUL_OVF_UN:
+                EmitBinaryArithmeticOp(INTOP_MUL_OVF_UN_I4);
+                m_ip++;
+                break;
             case CEE_DIV:
                 EmitBinaryArithmeticOp(INTOP_DIV_I4);
                 m_ip++;
@@ -3134,6 +3144,25 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                         m_ip += 5;
                         break;
                     }
+                    case CEE_LOCALLOC:
+                        CHECK_STACK(1);
+#if SIZEOF_VOID_P == 8
+                        if (m_pStackPointer[-1].type == StackTypeI8)
+                            EmitConv(m_pStackPointer - 1, NULL, StackTypeI4, INTOP_MOV_8);
+#endif
+                        AddIns(INTOP_LOCALLOC);
+                        m_pStackPointer--;
+                        if (m_pStackPointer != m_pStackBase)
+                        {
+                            m_hasInvalidCode = true;
+                            goto exit_bad_code;
+                        }
+
+                        m_pLastNewIns->SetSVar(m_pStackPointer[0].var);
+                        PushStackType(StackTypeByRef, NULL);
+                        m_pLastNewIns->SetDVar(m_pStackPointer[-1].var);
+                        m_ip++;
+                        break;
                     default:
                         assert(0);
                         break;

src/coreclr/interpreter/interpretershared.h

@@ -18,12 +18,14 @@ struct InterpMethod
     CORINFO_METHOD_HANDLE methodHnd;
     int32_t allocaSize;
     void** pDataItems;
+    uint32_t initLocals : 1;
 
-    InterpMethod(CORINFO_METHOD_HANDLE methodHnd, int32_t allocaSize, void** pDataItems)
+    InterpMethod(CORINFO_METHOD_HANDLE methodHnd, int32_t allocaSize, void** pDataItems, bool initLocals)
     {
         this->methodHnd = methodHnd;
         this->allocaSize = allocaSize;
         this->pDataItems = pDataItems;
+        this->initLocals = initLocals;
     }
 };
 

src/coreclr/interpreter/intops.def

@@ -160,6 +160,12 @@ OPDEF(INTOP_MUL_I8, "mul.i8", 4, 1, 2, InterpOpNoArgs)
 OPDEF(INTOP_MUL_R4, "mul.r4", 4, 1, 2, InterpOpNoArgs)
 OPDEF(INTOP_MUL_R8, "mul.r8", 4, 1, 2, InterpOpNoArgs)
 
+OPDEF(INTOP_MUL_OVF_I4, "mul.ovf.i8", 4, 1, 2, InterpOpNoArgs)
+OPDEF(INTOP_MUL_OVF_I8, "mul.ovf.i8", 4, 1, 2, InterpOpNoArgs)
+
+OPDEF(INTOP_MUL_OVF_UN_I4, "mul.ovf.un.i8", 4, 1, 2, InterpOpNoArgs)
+OPDEF(INTOP_MUL_OVF_UN_I8, "mul.ovf.un.i8", 4, 1, 2, InterpOpNoArgs)
+
 OPDEF(INTOP_DIV_I4, "div.i4", 4, 1, 2, InterpOpNoArgs)
 OPDEF(INTOP_DIV_I8, "div.i8", 4, 1, 2, InterpOpNoArgs)
 OPDEF(INTOP_DIV_R4, "div.r4", 4, 1, 2, InterpOpNoArgs)
@@ -253,6 +259,7 @@ OPDEF(INTOP_NEWOBJ_VT, "newobj.vt", 5, 1, 1, InterpOpMethodToken)
 OPDEF(INTOP_CALL_HELPER_PP, "call.helper.pp", 5, 1, 0, InterpOpThreeInts)
 
 OPDEF(INTOP_ZEROBLK_IMM, "zeroblk.imm", 3, 0, 1, InterpOpInt)
+OPDEF(INTOP_LOCALLOC, "localloc", 3, 1, 1, InterpOpNoArgs)
 OPDEF(INTOP_BREAKPOINT, "breakpoint", 1, 0, 0, InterpOpNoArgs)
 OPDEF(INTOP_FAILFAST, "failfast", 1, 0, 0, InterpOpNoArgs)
 

src/coreclr/vm/CMakeLists.txt

@@ -344,6 +344,7 @@ set(VM_SOURCES_WKS
     interopconverter.cpp
     interoputil.cpp
     interpexec.cpp
+    interpframeallocator.cpp
     invokeutil.cpp
     jithelpers.cpp
     managedmdimport.cpp
@@ -444,6 +445,7 @@ set(VM_HEADERS_WKS
     interoputil.h
     interoputil.inl
     interpexec.h
+    interpframeallocator.h
     invokeutil.h
     managedmdimport.hpp
     marshalnative.h

src/coreclr/vm/interpexec.cpp

@@ -21,6 +21,7 @@ InterpThreadContext* InterpGetThreadContext()
         // FIXME VirtualAlloc/mmap with INTERP_STACK_ALIGNMENT alignment
         threadContext->pStackStart = threadContext->pStackPointer = (int8_t*)malloc(INTERP_STACK_SIZE);
         threadContext->pStackEnd = threadContext->pStackStart + INTERP_STACK_SIZE;
+        threadContext->pFrameDataAllocator = new FrameDataAllocator(INTERP_STACK_FRAGMENT_SIZE);
 
         t_pThreadContext = threadContext;
         return threadContext;
@@ -584,7 +585,53 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                 LOCAL_VAR(ip[1], double) = LOCAL_VAR(ip[2], double) * LOCAL_VAR(ip[3], double);
                 ip += 4;
                 break;
+            case INTOP_MUL_OVF_I4:
+            {
+                int32_t i1 = LOCAL_VAR(ip[2], int32_t);
+                int32_t i2 = LOCAL_VAR(ip[3], int32_t);
+                int32_t i3;
+                if (!ClrSafeInt<int32_t>::multiply(i1, i2, i3))
+                    assert(0); // Interpreter-TODO: OverflowException
+                LOCAL_VAR(ip[1], int32_t) = i3;
+                ip += 4;
+                break;
+            }
+
+            case INTOP_MUL_OVF_I8:
+            {
+                int64_t i1 = LOCAL_VAR(ip[2], int64_t);
+                int64_t i2 = LOCAL_VAR(ip[3], int64_t);
+                int64_t i3;
+                if (!ClrSafeInt<int64_t>::multiply(i1, i2, i3))
+                    assert(0); // Interpreter-TODO: OverflowException
+                LOCAL_VAR(ip[1], int64_t) = i3;
+                ip += 4;
+                break;
+            }
+
+            case INTOP_MUL_OVF_UN_I4:
+            {
+                uint32_t i1 = LOCAL_VAR(ip[2], uint32_t);
+                uint32_t i2 = LOCAL_VAR(ip[3], uint32_t);
+                uint32_t i3;
+                if (!ClrSafeInt<uint32_t>::multiply(i1, i2, i3))
+                    assert(0); // Interpreter-TODO: OverflowException
+                LOCAL_VAR(ip[1], uint32_t) = i3;
+                ip += 4;
+                break;
+            }
 
+            case INTOP_MUL_OVF_UN_I8:
+            {
+                uint64_t i1 = LOCAL_VAR(ip[2], uint64_t);
+                uint64_t i2 = LOCAL_VAR(ip[3], uint64_t);
+                uint64_t i3;
+                if (!ClrSafeInt<uint64_t>::multiply(i1, i2, i3))
+                    assert(0); // Interpreter-TODO: OverflowException
+                LOCAL_VAR(ip[1], uint64_t) = i3;
+                ip += 4;
+                break;
+            }
             case INTOP_DIV_I4:
             {
                 int32_t i1 = LOCAL_VAR(ip[2], int32_t);
@@ -1105,6 +1152,33 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                 memset(LOCAL_VAR(ip[1], void*), 0, ip[2]);
                 ip += 3;
                 break;
+            case INTOP_LOCALLOC:
+            {
+                int32_t len = LOCAL_VAR(ip[2], int32_t);
+                void* mem;
+
+                if (len > 0)
+                {
+                    len = ALIGN_UP(len, INTERP_STACK_ALIGNMENT);
+                    mem = pThreadContext->pFrameDataAllocator->Alloc((InterpreterFrame*)pFrame, len);
+                    if (!mem)
+                    {
+                        // Interpreter-TODO: OutOfMemoryException
+                        assert(0);
+                    }
+
+                    if (pMethod->initLocals)
+                    {
+                        memset(mem, 0, len);
+                    }
+                } else
+                {
+                    mem = NULL;
+                }
+                LOCAL_VAR(ip[1], void*) = mem;
+                ip += 3;
+                break;
+            }
             case INTOP_FAILFAST:
                 assert(0);
                 break;
@@ -1115,6 +1189,9 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
     }
 
 EXIT_FRAME:
+
+    // Interpreter-TODO: Don't run PopInfo on the main return path, Add RET_LOCALLOC instead
+    pThreadContext->pFrameDataAllocator->PopInfo((InterpreterFrame*)pFrame);
     if (pFrame->pParent && pFrame->pParent->ip)
     {
         // Return to the main loop after a non-recursive interpreter call
@@ -1129,6 +1206,8 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
         goto MAIN_LOOP;
     }
 
+    // Interpreter-TODO: FrameDataAllocator is owned by the current thread, free it when the thread exits instead of here
+    delete pThreadContext->pFrameDataAllocator;
     pThreadContext->pStackPointer = pFrame->pStack;
 }
 

src/coreclr/vm/interpexec.h

@@ -5,8 +5,10 @@
 #define _INTERPEXEC_H_
 
 #include "../interpreter/interpretershared.h"
+#include "interpframeallocator.h"
 
 #define INTERP_STACK_SIZE 1024*1024
+#define INTERP_STACK_FRAGMENT_SIZE 4096
 
 struct StackVal
 {
@@ -52,6 +54,9 @@ struct InterpThreadContext
     // stack pointer. It is needed when re-entering interp, to know from which address we can start using
     // stack, and also needed for the GC to be able to scan the stack.
     int8_t *pStackPointer;
+
+    // This is an allocator for the dynamic stack memory
+    FrameDataAllocator *pFrameDataAllocator;
 };
 
 InterpThreadContext* InterpGetThreadContext();

src/coreclr/vm/interpframeallocator.cpp

@@ -0,0 +1,111 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "interpexec.h"
+#include "interpframeallocator.h"
+
+FrameDataFragment::FrameDataFragment(size_t size)
+{
+    if (size < INTERP_STACK_FRAGMENT_SIZE)
+    {
+        size = INTERP_STACK_FRAGMENT_SIZE;
+    }
+
+    start = (uint8_t*)malloc(size);
+    assert(start && "Failed to allocate FrameDataFragment");
+    end = start + size;
+    pos = start;
+    pNext = nullptr;
+}
+
+FrameDataFragment::~FrameDataFragment()
+{
+    free(start);
+}
+
+FrameDataAllocator::FrameDataAllocator(size_t size)
+{
+    pFirst = new FrameDataFragment(size);
+    assert(pFirst && "Failed to allocate initial fragment");
+    pCurrent = pFirst;
+    pInfos = nullptr;
+    infosLen = 0;
+    infosCapacity = 0;
+}
+
+FrameDataAllocator::~FrameDataAllocator()
+{
+    assert(pCurrent == pFirst && pCurrent->pos == pCurrent->start);
+    FreeFragments(pFirst);
+    free(pInfos);
+}
+
+void FrameDataAllocator::FreeFragments(FrameDataFragment *pFrag)
+{
+    while (pFrag)
+    {
+        FrameDataFragment *pNext = pFrag->pNext;
+        delete pFrag;
+        pFrag = pNext;
+    }
+}
+
+void FrameDataAllocator::PushInfo(InterpreterFrame *pFrame)
+{
+    if (infosLen == infosCapacity)
+    {
+        size_t newCapacity = infosCapacity == 0 ? 8 : infosCapacity * 2;
+        pInfos = (FrameDataInfo*)realloc(pInfos, newCapacity * sizeof(FrameDataInfo));
+        assert(pInfos && "Failed to reallocate frame info");
+        infosCapacity = newCapacity;
+    }
+
+    FrameDataInfo *pInfo = &pInfos[infosLen++];
+    pInfo->pFrame = pFrame;
+    pInfo->pFrag = pCurrent;
+    pInfo->pos = pCurrent->pos;
+}
+
+void *FrameDataAllocator::Alloc(InterpreterFrame *pFrame, size_t size)
+{
+    if (!infosLen || (infosLen > 0 && pInfos[infosLen - 1].pFrame != pFrame))
+    {
+        PushInfo(pFrame);
+    }
+
+    uint8_t *pos = pCurrent->pos;
+
+    if (pos + size > pCurrent->end)
+    {
+        if (pCurrent->pNext && ((pCurrent->pNext->start + size) <= pCurrent->pNext->end))
+        {
+            pCurrent = pCurrent->pNext;
+            pos = pCurrent->pos = pCurrent->start;
+        }
+        else
+        {
+            FreeFragments(pCurrent->pNext);
+            FrameDataFragment *pNewFrag = new FrameDataFragment(size);
+            assert(pNewFrag && "Failed to allocate new fragment");
+            pCurrent->pNext = pNewFrag;
+            pCurrent = pNewFrag;
+
+            pos = pNewFrag->pos;
+        }
+    }
+
+    void *result = (void*)pos;
+    pCurrent->pos = (uint8_t*)(pos + size);
+    return result;
+}
+
+void FrameDataAllocator::PopInfo(InterpreterFrame *pFrame)
+{
+    int top = infosLen - 1;
+    if (top >= 0 && pInfos[top].pFrame == pFrame)
+    {
+        FrameDataInfo *pInfo = &pInfos[--infosLen];
+        pCurrent = pInfo->pFrag;
+        pCurrent->pos = pInfo->pos;
+    }
+}