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

src/coreclr/interpreter/compiler.cpp

@@ -2596,6 +2596,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 +3142,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/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/interpexec.cpp

@@ -11,6 +11,110 @@ typedef void* (*HELPER_FTN_PP)(void*);
 
 thread_local InterpThreadContext *t_pThreadContext = NULL;
 
+FrameDataFragment *frame_data_new_fragment(size_t size)
+{
+    if (size < INTERP_STACK_FRAGMENT_SIZE)
+        size = INTERP_STACK_FRAGMENT_SIZE;
+
+    FrameDataFragment *frag = (FrameDataFragment*)malloc(sizeof(FrameDataFragment) + size);
+    if (!frag) return NULL;
+
+    frag->start = (uint8_t*)(frag + 1);
+    frag->end = frag->start + size;
+    frag->pos = frag->start;
+    frag->next = NULL;
+    return frag;
+}
+
+void frame_data_allocator_init(FrameDataAllocator *allocator, size_t size)
+{
+    allocator->first = frame_data_new_fragment(size);
+    assert(allocator->first && "Failed to allocate initial fragment");
+    allocator->current = allocator->first;
+    allocator->infos = NULL;
+    allocator->infos_len = 0;
+    allocator->infos_capacity = 0;
+}
+
+void frame_data_fragment_free(FrameDataFragment *frag)
+{
+    while (frag) {
+        FrameDataFragment *next = frag->next;
+        free(frag);
+        frag = next;
+    }
+}
+
+void frame_data_allocator_destroy(FrameDataAllocator *allocator)
+{
+    assert (allocator->current == allocator->first && allocator->current->pos == allocator->current->start);
+    frame_data_fragment_free(allocator->first);
+
+    free(allocator->infos);
+    allocator->first = allocator->current = NULL;
+    allocator->infos = NULL;
+    allocator->infos_len = allocator->infos_capacity = 0;
+}
+
+void frame_data_push_info(FrameDataAllocator *allocator, InterpreterFrame *frame)
+{
+    if (allocator->infos_len == allocator->infos_capacity) {
+        int new_capacity = allocator->infos_capacity == 0 ? 8 : allocator->infos_capacity * 2;
+        allocator->infos = (FrameDataInfo*)realloc(allocator->infos, new_capacity * sizeof(FrameDataInfo));
+        assert(allocator->infos && "Failed to reallocate frame info");
+        allocator->infos_capacity = new_capacity;
+    }
+
+    FrameDataInfo *info = &allocator->infos[allocator->infos_len++];
+    info->frame = frame;
+    info->frag = allocator->current;
+    info->pos = allocator->current->pos;
+}
+
+void *frame_data_alloc(FrameDataAllocator *allocator, InterpreterFrame *frame, size_t size)
+{
+
+    if (!allocator->infos_len || (allocator->infos_len > 0 && allocator->infos[allocator->infos_len - 1].frame != frame))
+    {
+        frame_data_push_info(allocator, frame);
+    }
+
+    uint8_t *pos = allocator->current->pos;
+
+    if (pos + size > allocator->current->end) {
+        if (allocator->current->next && ((allocator->current->next->start + size) <= allocator->current->next->end))
+        {
+            allocator->current = allocator->current->next;
+            pos = allocator->current->pos = allocator->current->start;
+        }
+        else
+        {
+            frame_data_fragment_free(allocator->current->next);
+            FrameDataFragment *new_frag = frame_data_new_fragment(size);
+            assert(new_frag && "Failed to allocate new fragment");
+            allocator->current->next = new_frag;
+            allocator->current = new_frag;
+
+            pos = new_frag->pos;
+        }
+    }
+
+    void *result = (void*)pos;
+    allocator->current->pos = (uint8_t *)(pos + size);
+    return result;
+}
+
+void frame_data_pop_info(FrameDataAllocator *allocator, InterpreterFrame *pFrame)
+{
+    int top = allocator->infos_len - 1;
+    if (top >= 0 && allocator->infos[top].frame == pFrame)
+    {
+        FrameDataInfo *info = &allocator->infos[--allocator->infos_len];
+        allocator->current = info->frag;
+        allocator->current->pos = info->pos;
+    }
+}
+
 InterpThreadContext* InterpGetThreadContext()
 {
     InterpThreadContext *threadContext = t_pThreadContext;
@@ -21,6 +125,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;
+        frame_data_allocator_init(&threadContext->frameDataAllocator, INTERP_STACK_FRAGMENT_SIZE);
 
         t_pThreadContext = threadContext;
         return threadContext;
@@ -584,7 +689,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 (__builtin_mul_overflow(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 (__builtin_mul_overflow(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 (__builtin_mul_overflow(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 (__builtin_mul_overflow(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 +1256,22 @@ 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)
+                {
+                    mem = frame_data_alloc(&pThreadContext->frameDataAllocator, (InterpreterFrame*)pFrame, ALIGN_UP(len, INTERP_STACK_ALIGNMENT));
+                } else
+                {
+                    mem = NULL;
+                }
+                LOCAL_VAR(ip[1], void*) = mem;
+                ip += 3;
+                break;
+            }
             case INTOP_FAILFAST:
                 assert(0);
                 break;
@@ -1115,6 +1282,8 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
     }
 
 EXIT_FRAME:
+
+    frame_data_pop_info(&pThreadContext->frameDataAllocator, (InterpreterFrame*)pFrame);
     if (pFrame->pParent && pFrame->pParent->ip)
     {
         // Return to the main loop after a non-recursive interpreter call
@@ -1129,6 +1298,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
         goto MAIN_LOOP;
     }
 
+    frame_data_allocator_destroy(&pThreadContext->frameDataAllocator);
     pThreadContext->pStackPointer = pFrame->pStack;
 }
 

src/coreclr/vm/interpexec.h

@@ -7,6 +7,7 @@
 #include "../interpreter/interpretershared.h"
 
 #define INTERP_STACK_SIZE 1024*1024
+#define INTERP_STACK_FRAGMENT_SIZE 4096
 
 struct StackVal
 {
@@ -42,6 +43,33 @@ struct InterpMethodContextFrame
 #endif // DACCESS_COMPILE
 };
 
+struct FrameDataFragment {
+    // Memory region for this fragment
+    uint8_t *start, *end;
+    // Current allocation pointer within this fragment
+    uint8_t *pos;
+    // Pointer to the next fragment
+    FrameDataFragment *next;
+};
+
+struct FrameDataInfo {
+    // Pointer to the frame that this info is associated with
+    InterpreterFrame *frame;
+    // Pointers for restoring the localloc memory:
+    // frag - the current allocation fragment at frame entry
+    // pos - the fragment pointer at frame entry
+    // When the frame returns, we use these to roll back any local allocations
+    FrameDataFragment *frag;
+    uint8_t *pos;
+};
+
+struct FrameDataAllocator {
+    FrameDataFragment *first, *current;
+    FrameDataInfo *infos;
+    int infos_len;
+    int infos_capacity;
+};
+
 struct InterpThreadContext
 {
     int8_t *pStackStart;
@@ -52,6 +80,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 frameDataAllocator;
 };
 
 InterpThreadContext* InterpGetThreadContext();