Add a few sanity tests to ensure new interp functionality mostly works

Minor fixes to ensure tests work. Add support for returns of any type. Add opcode for loading full I4.

Author: BrzVlad

src/coreclr/interpreter/compiler.cpp

@@ -808,6 +808,8 @@ static InterpType GetInterpType(CorInfoType corInfoType)
         case CORINFO_TYPE_VALUECLASS:
         case CORINFO_TYPE_REFANY:
             return InterpTypeVT;
+        case CORINFO_TYPE_VOID:
+            return InterpTypeVoid;
         default:
             assert(0);
             break;
@@ -1629,6 +1631,13 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                 m_pLastIns->SetDVar(m_pStackPointer[-1].var);
                 m_ip += 2;
                 break;
+            case CEE_LDC_I4:
+                AddIns(INTOP_LDC_I4);
+                m_pLastIns->data[0] = getI4LittleEndian(m_ip + 1);
+                PushStackType(StackTypeI4, NULL);
+                m_pLastIns->SetDVar(m_pStackPointer[-1].var);
+                m_ip += 5;
+                break;
             case CEE_LDNULL:
                 AddIns(INTOP_LDNULL);
                 PushStackType(StackTypeO, NULL);
@@ -1677,21 +1686,27 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
             case CEE_RET:
             {
                 CORINFO_SIG_INFO sig = methodInfo->args;
-                if (sig.retType == CORINFO_TYPE_VOID)
+                InterpType retType = GetInterpType(sig.retType);
+
+                if (retType == InterpTypeVoid)
                 {
                     AddIns(INTOP_RET_VOID);
                 }
-                else if (sig.retType == CORINFO_TYPE_INT)
+                else if (retType == InterpTypeVT)
                 {
                     CHECK_STACK(1);
-                    AddIns(INTOP_RET);
+                    AddIns(INTOP_RET_VT);
                     m_pStackPointer--;
-                    m_pLastIns->SetSVar(m_pStackPointer[0].var);
+                    int32_t retVar = m_pStackPointer[0].var;
+                    m_pLastIns->SetSVar(retVar);
+                    m_pLastIns->data[0] = m_pVars[retVar].size;
                 }
                 else
                 {
-                    // FIXME
-                    assert(0);
+                    CHECK_STACK(1);
+                    AddIns(INTOP_RET);
+                    m_pStackPointer--;
+                    m_pLastIns->SetSVar(m_pStackPointer[0].var);
                 }
                 m_ip++;
                 break;

src/coreclr/interpreter/intops.def

@@ -8,6 +8,7 @@
 
 OPDEF(INTOP_NOP, "nop", 1, 0, 0, InterpOpNoArgs)
 OPDEF(INTOP_RET, "ret", 2, 0, 1, InterpOpNoArgs)
+OPDEF(INTOP_RET_VT, "ret.vt", 3, 0, 1, InterpOpInt)
 OPDEF(INTOP_RET_VOID, "ret.void", 1, 0, 0, InterpOpNoArgs)
 
 OPDEF(INTOP_LDC_I4, "ldc.i4", 3, 1, 0, InterpOpInt)

src/coreclr/vm/interpexec.cpp

@@ -64,6 +64,9 @@ void InterpExecMethod(InterpMethodContextFrame *pFrame, InterpThreadContext *pTh
                 // Return stack slot sized value
                 *(int64_t*)pFrame->pRetVal = LOCAL_VAR(ip[1], int64_t);
                 goto EXIT_FRAME;
+            case INTOP_RET_VT:
+                memmove(pFrame->pRetVal, stack + ip[1], ip[2]);
+                goto EXIT_FRAME;
             case INTOP_RET_VOID:
                 goto EXIT_FRAME;
 

src/tests/JIT/interpreter/Interpreter.cs

@@ -15,7 +15,61 @@ static int Main(string[] args)
     [MethodImpl(MethodImplOptions.NoInlining)]
     public static void RunInterpreterTests()
     {
-//        Console.WriteLine("Run interp tests");
+//      Console.WriteLine("Run interp tests");
+        if (SumN(50) != 1275)
+            Environment.FailFast(null);
+        if (Mul4(53, 24, 13, 131) != 2166216)
+            Environment.FailFast(null);
+
+        TestSwitch();
+
+        if (!PowLoop(20, 10, 1661992960))
+            Environment.FailFast(null);
+    }
+
+    public static int Mul4(int a, int b, int c, int d)
+    {
+        return a * b * c * d;
     }
 
+    public static long SumN(int n)
+    {
+        if (n == 1)
+            return 1;
+        return (long)SumN(n - 1) + n;
+    }
+
+    public static int SwitchOp(int a, int b, int op)
+    {
+        switch (op)
+        {
+            case 0:
+                return a + b;
+            case 1:
+                return a - b;
+            case 2:
+                return a * b;
+            default:
+               return 42;
+        }
+    }
+
+    public static void TestSwitch()
+    {
+        int n0 = SwitchOp (20, 6, 0); // 26
+        int n1 = SwitchOp (20, 6, 1); // 14
+        int n2 = SwitchOp (20, 6, 2); // 120
+        int n3 = SwitchOp (20, 6, 3); // 42
+
+        if ((n0 + n1 + n2 + n3) != 202)
+            Environment.FailFast(null);
+    }
+
+    public static bool PowLoop(int n, long nr, int expected)
+    {
+        long ret = 1;
+        for (int i = 0; i < n; i++)
+            ret *= nr;
+        return (int)ret == expected;
+    }
 }