Implement localloc IL instruction

- Add handler for instruction. Add storage pointers to stack frame to allow dealocation on moethod return.

Author: josesimoes

src/CLR/Core/CLR_RT_StackFrame.cpp

@@ -120,6 +120,14 @@ HRESULT CLR_RT_StackFrame::Push(CLR_RT_Thread *th, const CLR_RT_MethodDef_Instan
                                       //
         // Initialize generic type context storage to invalid
         stack->m_genericTypeSpecStorage.Clear();
+
+        // initialize localloc elements
+        stack->m_localAllocCount = 0;
+        for (CLR_INT32 i = 0; i < CLR_RT_StackFrame::c_Max_Localloc_Count; i++)
+        {
+            stack->m_localAllocs[i] = nullptr;
+        }
+
         //
 #ifndef NANOCLR_NO_IL_INLINE
         stack->m_inlineFrame = nullptr;
@@ -323,6 +331,11 @@ bool CLR_RT_StackFrame::PushInline(
     m_inlineFrame->m_frame.m_call = m_call;
     m_inlineFrame->m_frame.m_evalStack = m_evalStack;
     m_inlineFrame->m_frame.m_evalPos = pThis;
+    m_inlineFrame->m_frame.m_localAllocCount = m_localAllocCount;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        m_inlineFrame->m_frame.m_localAllocs[i] = m_localAllocs[i];
+    }
 
     // increment the evalPos pointer so that we don't corrupt the real stack
     evalPos++;
@@ -338,6 +351,13 @@ bool CLR_RT_StackFrame::PushInline(
     m_IPstart = ip;
     m_IP = ip;
 
+    // initialize localloc for the inline frame
+    m_localAllocCount = 0;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        m_localAllocs[i] = nullptr;
+    }
+
     if (md->localsCount)
     {
         g_CLR_RT_ExecutionEngine.InitializeLocals(m_locals, calleeInst);
@@ -412,6 +432,11 @@ void CLR_RT_StackFrame::RestoreFromInlineStack()
     m_IPstart = m_inlineFrame->m_frame.m_IPStart;
     m_evalStack = m_inlineFrame->m_frame.m_evalStack;
     m_evalStackPos = m_inlineFrame->m_frame.m_evalPos;
+    m_localAllocCount = m_inlineFrame->m_frame.m_localAllocCount;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        m_localAllocs[i] = m_inlineFrame->m_frame.m_localAllocs[i];
+    }
 }
 
 void CLR_RT_StackFrame::RestoreStack(CLR_RT_InlineFrame &frame)
@@ -424,6 +449,11 @@ void CLR_RT_StackFrame::RestoreStack(CLR_RT_InlineFrame &frame)
     m_evalStack = frame.m_evalStack;
     m_evalStackPos = frame.m_evalPos;
     m_evalStackEnd -= m_call.target->localsCount;
+    m_localAllocCount = frame.m_localAllocCount;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        m_localAllocs[i] = frame.m_localAllocs[i];
+    }
 }
 
 void CLR_RT_StackFrame::SaveStack(CLR_RT_InlineFrame &frame)
@@ -435,6 +465,11 @@ void CLR_RT_StackFrame::SaveStack(CLR_RT_InlineFrame &frame)
     frame.m_IPStart = m_IPstart;
     frame.m_evalPos = m_evalStackPos;
     frame.m_evalStack = m_evalStack;
+    frame.m_localAllocCount = m_localAllocCount;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        frame.m_localAllocs[i] = m_localAllocs[i];
+    }
 }
 #endif
 
@@ -822,6 +857,13 @@ void CLR_RT_StackFrame::Pop()
 {
     NATIVE_PROFILE_CLR_CORE();
 
+    // Clear localloc references before popping
+    m_localAllocCount = 0;
+    for (CLR_INT32 i = 0; i < c_Max_Localloc_Count; i++)
+    {
+        m_localAllocs[i] = nullptr;
+    }
+
 #if defined(NANOCLR_PROFILE_NEW_CALLS)
     {
         //

src/CLR/Core/Interpreter.cpp

@@ -4204,6 +4204,41 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
 
                 //----------------------------------------------------------------------------------------------------------//
 
+                OPDEF(CEE_LOCALLOC, "localloc", PopI, PushI, InlineNone, IPrimitive, 2, 0xFE, 0x0F, NEXT)
+                {
+                    CLR_UINT32 size = evalPos[0].NumericByRef().u4;
+
+                    evalPos--;
+                    CHECKSTACK(stack, evalPos);
+
+                    // Create the byte array
+                    CLR_RT_HeapBlock tempArray;
+                    CLR_RT_TypeDef_Index byteType = g_CLR_RT_WellKnownTypes.UInt8;
+
+                    NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(tempArray, size, byteType));
+      
+                    CLR_RT_ProtectFromGC gc(tempArray);
+                    CLR_RT_HeapBlock_Array *array = tempArray.DereferenceArray();
+
+                    // store pointer for allocated array, if enough room
+                    // In localloc:
+                    if (stack->m_localAllocCount >= CLR_RT_StackFrame::c_Max_Localloc_Count)
+                    {
+                        NANOCLR_SET_AND_LEAVE(CLR_E_STACK_OVERFLOW);
+                    }
+
+                    stack->m_localAllocs[stack->m_localAllocCount++] = array;
+
+                    evalPos++;
+                    CHECKSTACK(stack, evalPos);
+
+                    // deviating from ECMA-335: we return the array reference instead of a raw pointer
+                    evalPos[0].SetObjectReference(array);
+                    break;
+                }
+
+                //----------------------------------------------------------------------------------------------------------//
+
                 //////////////////////////////////////////////////////////////////////////////////////////
                 //
                 // These opcodes do nothing...
@@ -4224,7 +4259,6 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                 OPDEF(CEE_INITBLK, "initblk", PopI + PopI + PopI, Push0, InlineNone, IPrimitive, 2, 0xFE, 0x18, NEXT)
                 OPDEF(CEE_CALLI, "calli", VarPop, VarPush, InlineSig, IPrimitive, 1, 0xFF, 0x29, CALL)
                 OPDEF(CEE_CKFINITE, "ckfinite", Pop1, PushR8, InlineNone, IPrimitive, 1, 0xFF, 0xC3, NEXT)
-                OPDEF(CEE_LOCALLOC, "localloc", PopI, PushI, InlineNone, IPrimitive, 2, 0xFE, 0x0F, NEXT)
                 OPDEF(CEE_MKREFANY, "mkrefany", PopI, Push1, InlineType, IPrimitive, 1, 0xFF, 0xC6, NEXT)
                 OPDEF(CEE_REFANYTYPE, "refanytype", Pop1, PushI, InlineNone, IPrimitive, 2, 0xFE, 0x1D, NEXT)
                 OPDEF(CEE_REFANYVAL, "refanyval", Pop1, PushI, InlineType, IPrimitive, 1, 0xFF, 0xC2, NEXT)

src/CLR/Include/nanoCLR_Runtime.h

@@ -2529,6 +2529,9 @@ struct CLR_RT_HeapCluster : public CLR_RT_HeapBlock_Node // EVENT HEAP - NO RELO
 
 //--//
 
+// maximum number of local allocations per stack frame
+#define MAX_LOCALALLOC_COUNT 4
+
 #ifndef NANOCLR_NO_IL_INLINE
 struct CLR_RT_InlineFrame
 {
@@ -2539,6 +2542,8 @@ struct CLR_RT_InlineFrame
     CLR_RT_MethodDef_Instance m_call;
     CLR_PMETADATA m_IP;
     CLR_PMETADATA m_IPStart;
+    CLR_UINT8 m_localAllocCount;
+    CLR_RT_HeapBlock_Array *m_localAllocs[MAX_LOCALALLOC_COUNT];
 };
 
 struct CLR_RT_InlineBuffer
@@ -2562,6 +2567,9 @@ struct CLR_RT_StackFrame : public CLR_RT_HeapBlock_Node // EVENT HEAP - NO RELOC
     static const int c_OverheadForNewObjOrInteropMethod = 2;
     static const int c_MinimumStack = 10;
 
+    // max mumber of local allocations per stack frame
+    static const int c_Max_Localloc_Count = MAX_LOCALALLOC_COUNT;
+
     static const CLR_UINT32 c_MethodKind_Native = 0x00000000;
     static const CLR_UINT32 c_MethodKind_Interpreted = 0x00000001;
     static const CLR_UINT32 c_UNUSED_00000002 = 0x00000002; // c_MethodKind_Jitted
@@ -2663,6 +2671,9 @@ struct CLR_RT_StackFrame : public CLR_RT_HeapBlock_Node // EVENT HEAP - NO RELOC
     bool m_fNativeProfiled;
 #endif
 
+    CLR_UINT8 m_localAllocCount;
+    CLR_RT_HeapBlock_Array *m_localAllocs[c_Max_Localloc_Count];
+
     CLR_RT_HeapBlock m_extension[1];
 
     ////////////////////////////////////////