Add a temporary intrinsic for Environment.FailFast

Because we currently don't have support for interoping between interpreter and jit, in order to signal test failure in interpreter test we will just crash instead.

Author: BrzVlad

src/coreclr/interpreter/compiler.cpp

@@ -1352,6 +1352,31 @@ int32_t InterpCompiler::GetMethodDataItemIndex(CORINFO_METHOD_HANDLE mHandle)
     return GetDataItemIndex((void*)data);
 }
 
+bool InterpCompiler::EmitCallIntrinsics(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO sig)
+{
+    const char *className = NULL;
+    const char *namespaceName = NULL;
+    const char *methodName = m_compHnd->getMethodNameFromMetadata(method, &className, &namespaceName, NULL, 0);
+    int32_t opcode = -1;
+
+    if (namespaceName && !strcmp(namespaceName, "System"))
+    {
+        if (className && !strcmp(className, "Environment"))
+        {
+            if (methodName && !strcmp(methodName, "FailFast"))
+                opcode = INTOP_FAILFAST; // to be removed, not really an intrisic
+        }
+    }
+
+    if (opcode != -1)
+    {
+        AddIns(opcode);
+        return true;
+    }
+
+    return false;
+}
+
 void InterpCompiler::EmitCall(CORINFO_CLASS_HANDLE constrainedClass, bool readonly, bool tailcall)
 {
     uint32_t token = getU4LittleEndian(m_ip + 1);
@@ -1368,6 +1393,12 @@ void InterpCompiler::EmitCall(CORINFO_CLASS_HANDLE constrainedClass, bool readon
     CORINFO_SIG_INFO targetSignature;
     m_compHnd->getMethodSig(targetMethod, &targetSignature);
 
+    if (EmitCallIntrinsics(targetMethod, targetSignature))
+    {
+        m_ip += 5;
+        return;
+    }
+
     // Process sVars
     int numArgs = targetSignature.numArgs + targetSignature.hasThis();
     m_pStackPointer -= numArgs;
@@ -1598,6 +1629,12 @@ int InterpCompiler::GenerateCode(CORINFO_METHOD_INFO* methodInfo)
                 m_pLastIns->SetDVar(m_pStackPointer[-1].var);
                 m_ip += 2;
                 break;
+            case CEE_LDNULL:
+                AddIns(INTOP_LDNULL);
+                PushStackType(StackTypeO, NULL);
+                m_pLastIns->SetDVar(m_pStackPointer[-1].var);
+                m_ip++;
+                break;
 
             case CEE_LDARG_S:
                 EmitLoadVar(m_ip[1]);

src/coreclr/interpreter/compiler.h

@@ -308,6 +308,7 @@ class InterpCompiler
     void    EmitShiftOp(int32_t opBase);
     void    EmitCompareOp(int32_t opBase);
     void    EmitCall(CORINFO_CLASS_HANDLE constrainedClass, bool readonly, bool tailcall);
+    bool    EmitCallIntrinsics(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO sig);
 
     // Var Offset allocator
     TArray<InterpInst*> *m_pActiveCalls;

src/coreclr/interpreter/intops.def

@@ -11,6 +11,8 @@ OPDEF(INTOP_RET, "ret", 2, 0, 1, InterpOpNoArgs)
 OPDEF(INTOP_RET_VOID, "ret.void", 1, 0, 0, InterpOpNoArgs)
 
 OPDEF(INTOP_LDC_I4, "ldc.i4", 3, 1, 0, InterpOpInt)
+OPDEF(INTOP_LDC_I4_0, "ldc.i4.0", 2, 1, 0, InterpOpNoArgs)
+OPDEF(INTOP_LDC_I8_0, "ldc.i8.0", 2, 1, 0, InterpOpNoArgs)
 
 OPDEF(INTOP_MOV_I4_I1, "mov.i4.i1", 3, 1, 1, InterpOpNoArgs)
 OPDEF(INTOP_MOV_I4_U1, "mov.i4.u1", 3, 1, 1, InterpOpNoArgs)
@@ -190,3 +192,5 @@ OPDEF(INTOP_CLT_UN_R8, "clt.un.r8", 4, 1, 2, InterpOpNoArgs)
 
 // Calls
 OPDEF(INTOP_CALL, "call", 4, 1, 1, InterpOpMethodToken)
+
+OPDEF(INTOP_FAILFAST, "failfast", 1, 0, 0, InterpOpNoArgs)

src/coreclr/interpreter/intops.h

@@ -38,8 +38,10 @@ int CEEOpcodeSize(const uint8_t *ip, const uint8_t *codeEnd);
 
 #ifdef TARGET_64BIT
 #define INTOP_MOV_P INTOP_MOV_8
+#define INTOP_LDNULL INTOP_LDC_I8_0
 #else
 #define INTOP_MOV_P INTOP_MOV_4
+#define INTOP_LDNULL INTOP_LDC_I4_0
 #endif
 
 static inline bool InterpOpIsUncondBranch(int32_t opcode)

src/coreclr/vm/interpexec.cpp

@@ -52,6 +52,14 @@ void InterpExecMethod(InterpMethodContextFrame *pFrame, InterpThreadContext *pTh
                 LOCAL_VAR(ip[1], int32_t) = ip[2];
                 ip += 3;
                 break;
+            case INTOP_LDC_I4_0:
+                LOCAL_VAR(ip[1], int32_t) = 0;
+                ip += 2;
+                break;
+            case INTOP_LDC_I8_0:
+                LOCAL_VAR(ip[1], int64_t) = 0;
+                ip += 2;
+                break;
             case INTOP_RET:
                 // Return stack slot sized value
                 *(int64_t*)pFrame->pRetVal = LOCAL_VAR(ip[1], int64_t);
@@ -726,6 +734,9 @@ void InterpExecMethod(InterpMethodContextFrame *pFrame, InterpThreadContext *pTh
                 pThreadContext->pStackPointer = stack + pMethod->allocaSize;
                 break;
             }
+            case INTOP_FAILFAST:
+                assert(0);
+                break;
             default:
                 assert(0);
                 break;