Fold environmentnative into comutilnative and remove GetCurrentTime undef

Co-authored-by: jkotas <[email protected]>

Author: Copilot

src/coreclr/vm/CMakeLists.txt

@@ -320,7 +320,6 @@ set(VM_SOURCES_WKS
     eecontract.cpp
     eepolicy.cpp
     eetoprofinterfaceimpl.cpp
-    environmentnative.cpp
     eventpipeinternal.cpp
     fcall.cpp
     fieldmarshaler.cpp
@@ -436,7 +435,6 @@ set(VM_HEADERS_WKS
     eeprofinterfaces.inl
     eetoprofinterfaceimpl.h
     eetoprofinterfaceimpl.inl
-    environmentnative.h
     eventpipeadapter.h
     eventpipeadaptertypes.h
     eventpipeinternal.h

src/coreclr/vm/comutilnative.cpp

@@ -34,6 +34,11 @@
 #include "finalizerthread.h"
 #include "threadsuspend.h"
 #include <minipal/memorybarrierprocesswide.h>
+#include "string.h"
+#include "sstring.h"
+#include "array.h"
+#include "eepolicy.h"
+#include <minipal/cpuid.h>
 
 #ifdef FEATURE_COMINTEROP
     #include "comcallablewrapper.h"
@@ -564,6 +569,183 @@ FCIMPL3(VOID, Buffer::BulkMoveWithWriteBarrier, void *dst, void *src, size_t byt
 }
 FCIMPLEND
 
+//
+// EnvironmentNative
+//
+extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    // The exit code for the process is communicated in one of two ways.  If the
+    // entrypoint returns an 'int' we take that.  Otherwise we take a latched
+    // process exit code.  This can be modified by the app via setting
+    // Environment's ExitCode property.
+    SetLatchedExitCode(exitcode);
+
+    ForceEEShutdown();
+
+    END_QCALL;
+}
+
+FCIMPL1(VOID,EnvironmentNative::SetExitCode,INT32 exitcode)
+{
+    FCALL_CONTRACT;
+
+    // The exit code for the process is communicated in one of two ways.  If the
+    // entrypoint returns an 'int' we take that.  Otherwise we take a latched
+    // process exit code.  This can be modified by the app via setting
+    // Environment's ExitCode property.
+    SetLatchedExitCode(exitcode);
+}
+FCIMPLEND
+
+FCIMPL0(INT32, EnvironmentNative::GetExitCode)
+{
+    FCALL_CONTRACT;
+
+    // Return whatever has been latched so far.  This is uninitialized to 0.
+    return GetLatchedExitCode();
+}
+FCIMPLEND
+
+extern "C" INT32 QCALLTYPE Environment_GetProcessorCount()
+{
+    QCALL_CONTRACT;
+
+    INT32 processorCount = 0;
+
+    BEGIN_QCALL;
+
+    processorCount = GetCurrentProcessCpuCount();
+
+    END_QCALL;
+
+    return processorCount;
+}
+
+struct FindFailFastCallerStruct {
+    StackCrawlMark* pStackMark;
+    UINT_PTR        retAddress;
+};
+
+// This method is called by the GetMethod function and will crawl backward
+//  up the stack for integer methods.
+static StackWalkAction FindFailFastCallerCallback(CrawlFrame* frame, VOID* data) {
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        MODE_ANY;
+    }
+    CONTRACTL_END;
+
+    FindFailFastCallerStruct* pFindCaller = (FindFailFastCallerStruct*) data;
+
+    // The check here is between the address of a local variable
+    // (the stack mark) and a pointer to the EIP for a frame
+    // (which is actually the pointer to the return address to the
+    // function from the previous frame). So we'll actually notice
+    // which frame the stack mark was in one frame later. This is
+    // fine since we only implement LookForMyCaller.
+    _ASSERTE(*pFindCaller->pStackMark == LookForMyCaller);
+    if (!frame->IsInCalleesFrames(pFindCaller->pStackMark))
+        return SWA_CONTINUE;
+
+    pFindCaller->retAddress = GetControlPC(frame->GetRegisterSet());
+    return SWA_ABORT;
+}
+
+static thread_local int8_t alreadyFailing = 0;
+
+extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    GCX_COOP();
+
+    FindFailFastCallerStruct findCallerData;
+    findCallerData.pStackMark = mark;
+    findCallerData.retAddress = 0;
+    GetThread()->StackWalkFrames(FindFailFastCallerCallback, &findCallerData, FUNCTIONSONLY | QUICKUNWIND);
+
+    if (message == NULL || message[0] == W('\0'))
+    {
+        OutputDebugString(W("CLR: Managed code called FailFast without specifying a reason.\r\n"));
+    }
+    else
+    {
+        OutputDebugString(W("CLR: Managed code called FailFast.\r\n"));
+        OutputDebugString(message);
+        OutputDebugString(W("\r\n"));
+    }
+
+    LPCWSTR argExceptionString = NULL;
+    StackSString msg;
+    // Because Environment_FailFast should kill the process, any subsequent calls are likely nested call from managed while formatting the exception message or the stack trace.
+    // Only collect exception string if this is the first attempt to fail fast on this thread.
+    alreadyFailing++;
+    if (alreadyFailing != 1)
+    {
+        argExceptionString = W("Environment.FailFast called recursively.");
+    }
+    else if (exception.Get() != NULL)
+    {
+        GetExceptionMessage(exception.Get(), msg);
+        argExceptionString = msg.GetUnicode();
+    }
+
+    Thread *pThread = GetThread();
+
+#ifndef TARGET_UNIX
+    // If we have the exception object, then try to setup
+    // the watson bucket if it has any details.
+    // On CoreCLR, Watson may not be enabled. Thus, we should
+    // skip this, if required.
+    if (IsWatsonEnabled())
+    {
+        if ((exception.Get() == NULL) || !SetupWatsonBucketsForFailFast((EXCEPTIONREF)exception.Get()))
+        {
+            PTR_EHWatsonBucketTracker pUEWatsonBucketTracker = pThread->GetExceptionState()->GetUEWatsonBucketTracker();
+            _ASSERTE(pUEWatsonBucketTracker != NULL);
+            pUEWatsonBucketTracker->SaveIpForWatsonBucket(findCallerData.retAddress);
+            pUEWatsonBucketTracker->CaptureUnhandledInfoForWatson(TypeOfReportedError::FatalError, pThread, NULL);
+            if (pUEWatsonBucketTracker->RetrieveWatsonBuckets() == NULL)
+            {
+                pUEWatsonBucketTracker->ClearWatsonBucketDetails();
+            }
+        }
+    }
+#endif // !TARGET_UNIX
+
+    // stash the user-provided exception object. this will be used as
+    // the inner exception object to the FatalExecutionEngineException.
+    if (exception.Get() != NULL)
+        pThread->SetLastThrownObject(exception.Get());
+
+    EEPolicy::HandleFatalError(COR_E_FAILFAST, findCallerData.retAddress, message, NULL, errorSource, argExceptionString);
+
+    END_QCALL;
+}
+
+#if defined(TARGET_X86) || defined(TARGET_AMD64)
+
+extern "C" void QCALLTYPE X86BaseCpuId(int cpuInfo[4], int functionId, int subFunctionId)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    __cpuidex(cpuInfo, functionId, subFunctionId);
+
+    END_QCALL;
+}
+
+#endif // defined(TARGET_X86) || defined(TARGET_AMD64)
+
 //
 // ObjectNative
 //

src/coreclr/vm/comutilnative.h

@@ -24,7 +24,6 @@
 #include "qcall.h"
 #include "windows.h"
 #include "gchelpersnative.h"
-#undef GetCurrentTime
 
 //
 //
@@ -91,6 +90,34 @@ class Buffer
 extern "C" void QCALLTYPE Buffer_Clear(void *dst, size_t length);
 extern "C" void QCALLTYPE Buffer_MemMove(void *dst, void *src, size_t length);
 
+//
+// EnvironmentNative
+//
+class EnvironmentNative
+{
+public:
+    // Functions on the System.Environment class
+    static FCDECL1(VOID,SetExitCode,INT32 exitcode);
+    static FCDECL0(INT32, GetExitCode);
+};
+
+extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode);
+
+extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource);
+
+// Returns the number of logical processors that can be used by managed code
+extern "C" INT32 QCALLTYPE Environment_GetProcessorCount();
+
+#if defined(TARGET_X86) || defined(TARGET_AMD64)
+extern "C" void QCALLTYPE X86BaseCpuId(int cpuInfo[4], int functionId, int subFunctionId);
+#endif // defined(TARGET_X86) || defined(TARGET_AMD64)
+
+extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString);
+
+extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString);
+
+extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString);
+
 //
 // Object
 //

src/coreclr/vm/corelib.cpp

@@ -23,7 +23,6 @@
 #include "commodule.h"
 #include "marshalnative.h"
 #include "nativelibrarynative.h"
-#include "environmentnative.h"
 #include "comutilnative.h"
 #include "comsynchronizable.h"
 #include "floatdouble.h"