Basic implementation of mdarray ctors and methods

Author: kg

src/coreclr/interpreter/compiler.cpp

@@ -3008,7 +3008,7 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                 ctorClass = m_compHnd->getMethodClass(ctorMethod);
                 int32_t numArgs = ctorSignature.numArgs;
 
-                // TODO Special case array ctor / string ctor
+                // TODO Special case array ctor. We detect string ctor at execution time
                 m_pStackPointer -= numArgs;
 
                 // Allocate callArgs for the call, this + numArgs + terminator
@@ -3042,11 +3042,15 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                 {
                     AddIns(INTOP_NEWOBJ_VT);
                     m_pLastNewIns->data[1] = (int32_t)ALIGN_UP_TO(vtsize, INTERP_STACK_SLOT_SIZE);
+                    m_pLastNewIns->data[2] = 0;
                 }
                 else
                 {
                     AddIns(INTOP_NEWOBJ);
                     m_pLastNewIns->data[1] = GetDataItemIndex(ctorClass);
+                    m_pLastNewIns->data[2] = (m_compHnd->getArrayRank(ctorClass) > 0)
+                        ? GetDataItemIndexForHelperFtn(CORINFO_HELP_NEW_MDARR)
+                        : 0;
                 }
                 m_pLastNewIns->data[0] = GetMethodDataItemIndex(ctorMethod);
                 m_pLastNewIns->SetSVar(CALL_ARGS_SVAR);

src/coreclr/interpreter/intops.def

@@ -279,7 +279,7 @@ OPDEF(INTOP_LDFLDA, "ldflda", 4, 1, 1, InterpOpInt)
 // Calls
 OPDEF(INTOP_CALL, "call", 4, 1, 1, InterpOpMethodHandle)
 OPDEF(INTOP_CALLVIRT, "callvirt", 4, 1, 1, InterpOpMethodHandle)
-OPDEF(INTOP_NEWOBJ, "newobj", 5, 1, 1, InterpOpMethodHandle)
+OPDEF(INTOP_NEWOBJ, "newobj", 6, 1, 1, InterpOpMethodHandle)
 OPDEF(INTOP_NEWOBJ_VT, "newobj.vt", 5, 1, 1, InterpOpMethodHandle)
 
 OPDEF(INTOP_CALL_HELPER_PP, "call.helper.pp", 5, 1, 0, InterpOpThreeInts)

src/coreclr/vm/interpexec.cpp

@@ -49,6 +49,7 @@ void InvokeCompiledMethod(MethodDesc *pMD, int8_t *pArgs, int8_t *pRet, PCODE pC
 typedef void* (*HELPER_FTN_PP)(void*);
 typedef void* (*HELPER_FTN_BOX_UNBOX)(MethodTable*, void*);
 typedef Object* (*HELPER_FTN_NEWARR)(CORINFO_CLASS_HANDLE, intptr_t);
+typedef Object* (*HELPER_FTN_NEW_MDARR)(CORINFO_CLASS_HANDLE, int, void*);
 
 InterpThreadContext::InterpThreadContext()
 {
@@ -1118,22 +1119,35 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                         // First execution of this call. Ensure target method is compiled and
                         // patch the data item slot with the actual method code.
                         MethodDesc *pMD = (MethodDesc*)(targetMethod & ~INTERP_METHOD_HANDLE_TAG);
-                        PCODE code = pMD->GetNativeCode();
-                        if (!code) {
-                            // This is an optimization to ensure that the stack walk will not have to search
-                            // for the topmost frame in the current InterpExecMethod. It is not required
-                            // for correctness, as the stack walk will find the topmost frame anyway. But it
-                            // would need to seek through the frames to find it.
-                            // An alternative approach would be to update the topmost frame during stack walk
-                            // to make the probability that the next stack walk will need to search only a
-                            // small subset of frames high.
-                            pInterpreterFrame->SetTopInterpMethodContextFrame(pFrame);
-                            GCX_PREEMP();
-                            pMD->PrepareInitialCode(CallerGCMode::Coop);
-                            code = pMD->GetNativeCode();
+                        if (pMD->IsArray() || pMD->IsFCall())
+                        {
+                            // For FCalls and array special methods we can't go through the regular caching path
+                            //  because it will try to do pMD->GetNativeCode() and then crash.
+                            PCODE code = pMD->TryGetMultiCallableAddrOfCode(CORINFO_ACCESS_ANY);
+                            assert(code);
+                            InvokeCompiledMethod(pMD, stack + callArgsOffset, stack + returnOffset, code);
+                            // FIXME: Caching in dataItems somehow
+                            break;
+                        }
+                        else
+                        {
+                            PCODE code = pMD->GetNativeCode();
+                            if (!code) {
+                                // This is an optimization to ensure that the stack walk will not have to search
+                                // for the topmost frame in the current InterpExecMethod. It is not required
+                                // for correctness, as the stack walk will find the topmost frame anyway. But it
+                                // would need to seek through the frames to find it.
+                                // An alternative approach would be to update the topmost frame during stack walk
+                                // to make the probability that the next stack walk will need to search only a
+                                // small subset of frames high.
+                                pInterpreterFrame->SetTopInterpMethodContextFrame(pFrame);
+                                GCX_PREEMP();
+                                pMD->PrepareInitialCode(CallerGCMode::Coop);
+                                code = pMD->GetNativeCode();
+                            }
+                            pMethod->pDataItems[methodSlot] = (void*)code;
+                            targetIp = (const int32_t*)code;
                         }
-                        pMethod->pDataItems[methodSlot] = (void*)code;
-                        targetIp = (const int32_t*)code;
                     }
                     else
                     {
@@ -1204,14 +1218,39 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                         LOCAL_VAR(callArgsOffset, void*) = nullptr; // and zero it too! it might get scanned by the GC.
                         callArgsOffset += sizeof(StackVal);
 
-                        // Get the address of the fcall that implements the ctor
-                        PCODE code = pMD->TryGetMultiCallableAddrOfCode(CORINFO_ACCESS_ANY);
-                        assert(code);
+                        if (pClass->IsArray())
+                        {
+                            // mdarray ctors are implemented via a helper ftn we grabbed at compile time
+                            size_t helperDirectOrIndirect = (size_t)pMethod->pDataItems[ip[5]];
+                            HELPER_FTN_NEW_MDARR helper = nullptr;
+                            if (helperDirectOrIndirect & INTERP_INDIRECT_HELPER_TAG)
+                                helper = *(HELPER_FTN_NEW_MDARR *)(helperDirectOrIndirect & ~INTERP_INDIRECT_HELPER_TAG);
+                            else
+                                helper = (HELPER_FTN_NEW_MDARR)helperDirectOrIndirect;
+                            assert(helper);
+
+                            // mdarray ctor wants an array of ints, we can't pass the callArgsOffset directly since
+                            //  it's technically a stream of intptrs even if each value is an int
+                            int rank = pClass->GetRank();
+                            int dims[8] = { 0 };
+                            assert(rank < 8);
+                            for (int i = 0; i < rank; i++)
+                                dims[i] = LOCAL_VAR(callArgsOffset + (i * sizeof(StackVal)), int);
+
+                            LOCAL_VAR(returnOffset, Object*) = helper((CORINFO_CLASS_HANDLE)pClass, rank, dims);
+                        }
+                        else
+                        {
+                            // Get the address of the fcall that implements the ctor
+                            PCODE code = pMD->TryGetMultiCallableAddrOfCode(CORINFO_ACCESS_ANY);
+                            assert(code);
+
+                            // callArgsOffset now only points to the ctor arguments, which are what the fcall expects.
+                            // returnOffset still points to where the new instance goes, and the fcall will write it there.
+                            InvokeCompiledMethod(pMD, stack + callArgsOffset, stack + returnOffset, code);
+                        }
 
-                        // callArgsOffset now only points to the ctor arguments, which are what the fcall expects.
-                        // returnOffset still points to where the new instance goes, and the fcall will write it there.
-                        InvokeCompiledMethod(pMD, stack + callArgsOffset, stack + returnOffset, code);
-                        ip += 5;
+                        ip += 6;
                         break;
                     }
                     else
@@ -1222,7 +1261,7 @@ void InterpExecMethod(InterpreterFrame *pInterpreterFrame, InterpMethodContextFr
                         LOCAL_VAR(returnOffset, OBJECTREF) = objRef;
                         // Set `this` arg for ctor call
                         LOCAL_VAR(callArgsOffset, OBJECTREF) = objRef;
-                        ip += 5;
+                        ip += 6;
 
                         goto CALL_INTERP_SLOT;
                     }

src/tests/JIT/interpreter/Interpreter.cs

@@ -424,10 +424,9 @@ public static void RunInterpreterTests()
 
         if (!TestLdtoken())
             Environment.FailFast(null);
-        /*
+
         if (!TestMdArray())
             Environment.FailFast(null);
-        */
 
         System.GC.Collect();
     }
@@ -1000,12 +999,38 @@ public static bool TestLdtoken()
 
     public static bool TestMdArray()
     {
-        // FIXME: This generates roughly:
-        // newobj int[,].ctor
-        // ldtoken int[,]
-        // call System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray
-        // The newobj currently fails because int[,].ctor isn't a real method, the interp needs to use getCallInfo to determine how to invoke it
+        /* FIXME: This generates roughly:
+           newobj int[,].ctor
+           ldtoken int[,]
+           call System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray
+           While the newobj now works, the InitializeArray call fails:
+            Assert failure(PID 61692 [0x0000f0fc], Thread: 40872 [0x9fa8]): Consistency check failed:
+            FAILED: (!implSlot.IsNull() || pMT->IsInterface()) && "Valid method implementation was not found."
+
+            CORECLR! CHECK::Trigger + 0x20F (0x00007ffa`807af47f)
+            CORECLR! VirtualCallStubManager::Resolver + 0xFAA (0x00007ffa`80e387fa)
+            CORECLR! VirtualCallStubManager::ResolveWorker + 0xB3C (0x00007ffa`80e36d2c)
+            CORECLR! ExternalMethodFixupWorker + 0xDCC (0x00007ffa`80d5d49c)
+            CORECLR! DelayLoad_MethodCall + 0x71 (0x00007ffa`813a0601)
+            SYSTEM.PRIVATE.CORELIB! <no symbol> + 0x0 (0x00007ffa`77af0098)
+            CORECLR! CallJittedMethodRetVoid + 0x14 (0x00007ffa`8139e7e4)
+        */
+        /*
         int[,] a = {{1, 2}, {3, 4}};
         return a[0, 1] == 2;
+        */
+
+        int[,] a = new int[2,2];
+        if (a[0, 1] != 0)
+            return false;
+
+        a[0, 0] = 1;
+        a[0, 1] = 2;
+        a[1, 0] = 3;
+        a[1, 1] = 4;
+        if (a[0, 1] != 2)
+            return false;
+
+        return true;
     }
 }