Merge branch 'main' into wasm_load_crypto_asset

# Conflicts:
#	src/mono/wasm/runtime/debug.ts

Author: pavelsavara

eng/pipelines/coreclr/jitrollingbuild.yml

@@ -3,6 +3,7 @@ trigger:
   branches:
     include:
     - main
+    - release/*.*
   paths:
     include:
     - src/coreclr/jit/*

src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs

@@ -42,11 +42,6 @@ public static partial class ControlledExecution
         [Obsolete(Obsoletions.ControlledExecutionRunMessage, DiagnosticId = Obsoletions.ControlledExecutionRunDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public static void Run(Action action, CancellationToken cancellationToken)
         {
-            if (!OperatingSystem.IsWindows())
-            {
-                throw new PlatformNotSupportedException();
-            }
-
             ArgumentNullException.ThrowIfNull(action);
 
             // ControlledExecution.Run does not support nested invocations.  If there's one already in flight

src/coreclr/inc/eventtracebase.h

@@ -690,7 +690,11 @@ class CrstBase;
 class BulkTypeEventLogger;
 class TypeHandle;
 class Thread;
-
+template<typename ELEMENT, typename TRAITS>
+class SetSHash;
+template<typename ELEMENT>
+class PtrSetSHashTraits;
+typedef SetSHash<MethodDesc*, PtrSetSHashTraits<MethodDesc*>> MethodDescSet;
 
 // All ETW helpers must be a part of this namespace
 // We have auto-generated macros to directly fire the events
@@ -903,8 +907,8 @@ namespace ETW
         static VOID SendEventsForNgenMethods(Module *pModule, DWORD dwEventOptions);
         static VOID SendMethodJitStartEvent(MethodDesc *pMethodDesc, SString *namespaceOrClassName=NULL, SString *methodName=NULL, SString *methodSignature=NULL);
         static VOID SendMethodILToNativeMapEvent(MethodDesc * pMethodDesc, DWORD dwEventOptions, PCODE pNativeCodeStartAddress, DWORD nativeCodeId, ReJITID ilCodeId);
-        static VOID SendMethodRichDebugInfo(MethodDesc * pMethodDesc, PCODE pNativeCodeStartAddress, DWORD nativeCodeId, ReJITID ilCodeId);
-        static VOID SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptions, BOOL bIsJit, SString *namespaceOrClassName=NULL, SString *methodName=NULL, SString *methodSignature=NULL, PCODE pNativeCodeStartAddress = 0, PrepareCodeConfig *pConfig = NULL);
+        static VOID SendMethodRichDebugInfo(MethodDesc * pMethodDesc, PCODE pNativeCodeStartAddress, DWORD nativeCodeId, ReJITID ilCodeId, MethodDescSet* sentMethodDetailsSet);
+        static VOID SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptions, BOOL bIsJit, SString *namespaceOrClassName=NULL, SString *methodName=NULL, SString *methodSignature=NULL, PCODE pNativeCodeStartAddress = 0, PrepareCodeConfig *pConfig = NULL, MethodDescSet* sentMethodDetailsSet = NULL);
         static VOID SendHelperEvent(ULONGLONG ullHelperStartAddress, ULONG ulHelperSize, LPCWSTR pHelperName);
     public:
         typedef union _MethodStructs
@@ -937,6 +941,7 @@ namespace ETW
         static VOID MethodJitting(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature);
         static VOID MethodJitted(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature, PCODE pNativeCodeStartAddress, PrepareCodeConfig *pConfig);
         static VOID SendMethodDetailsEvent(MethodDesc *pMethodDesc);
+        static VOID SendNonDuplicateMethodDetailsEvent(MethodDesc* pMethodDesc, MethodDescSet* set);
         static VOID StubInitialized(ULONGLONG ullHelperStartAddress, LPCWSTR pHelperName);
         static VOID StubsInitialized(PVOID *pHelperStartAddress, PVOID *pHelperNames, LONG ulNoOfHelpers);
         static VOID MethodRestored(MethodDesc * pMethodDesc);

src/coreclr/inc/nibblestream.h

@@ -159,6 +159,22 @@ class NibbleWriter
         WriteEncodedU32(dw);
     };
 
+    void WriteUnencodedU32(uint32_t x)
+    {
+        CONTRACTL
+        {
+            THROWS;
+            GC_NOTRIGGER;
+        }
+        CONTRACTL_END;
+
+        for (int i = 0; i < 8; i++)
+        {
+            WriteNibble(static_cast<NIBBLE>(x & 0b1111));
+            x >>= 4;
+        }
+    }
+
 protected:
     NIBBLE m_PendingNibble;     // Pending value, not yet written out.
     bool m_fPending;
@@ -288,6 +304,26 @@ class NibbleReader
         return (dw & 1) ? (-x) : (x);
     }
 
+    DWORD ReadUnencodedU32()
+    {
+        CONTRACTL
+        {
+            THROWS;
+            GC_NOTRIGGER;
+            SUPPORTS_DAC;
+        }
+        CONTRACTL_END;
+
+        DWORD result = 0;
+
+        for (int i = 0; i < 8; i++)
+        {
+            result |= static_cast<DWORD>(ReadNibble()) << (i * 4);
+        }
+
+        return result;
+    }
+
 protected:
     PTR_BYTE m_pBuffer;
     size_t m_cBytes; // size of buffer.

src/coreclr/pal/src/exception/seh-unwind.cpp

@@ -558,6 +558,9 @@ void GetContextPointers(unw_cursor_t *cursor, unw_context_t *unwContext, KNONVOL
 // Frame pointer relative offset of a local containing a pointer to the windows style context of a location
 // where a hardware exception occurred.
 int g_hardware_exception_context_locvar_offset = 0;
+// Frame pointer relative offset of a local containing a pointer to the windows style context of a location
+// where an activation signal interrupted the thread.
+int g_inject_activation_context_locvar_offset = 0;
 
 BOOL PAL_VirtualUnwind(CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *contextPointers)
 {
@@ -579,6 +582,18 @@ BOOL PAL_VirtualUnwind(CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *contextP
         return TRUE;
     }
 
+    // Check if the PC is the return address from the InvokeActivationHandler.
+    // If that's the case, extract its local variable containing a pointer to the windows style context of the activation
+    // injection location and return that. This skips the signal handler trampoline that the libunwind
+    // cannot cross on some systems.
+    if ((void*)curPc == g_InvokeActivationHandlerReturnAddress)
+    {
+        CONTEXT* activationContext = (CONTEXT*)(CONTEXTGetFP(context) + g_inject_activation_context_locvar_offset);
+        memcpy_s(context, sizeof(CONTEXT), activationContext, sizeof(CONTEXT));
+
+        return TRUE;
+    }
+
     if ((context->ContextFlags & CONTEXT_EXCEPTION_ACTIVE) != 0)
     {
         // The current frame is a source of hardware exception. Due to the fact that

src/coreclr/pal/src/exception/seh.cpp

@@ -61,6 +61,7 @@ PGET_GCMARKER_EXCEPTION_CODE g_getGcMarkerExceptionCode = NULL;
 // Return address of the SEHProcessException, which is used to enable walking over
 // the signal handler trampoline on some Unixes where the libunwind cannot do that.
 void* g_SEHProcessExceptionReturnAddress = NULL;
+void* g_InvokeActivationHandlerReturnAddress = NULL;
 
 /* Internal function definitions **********************************************/
 

src/coreclr/pal/src/exception/signal.cpp

@@ -73,6 +73,7 @@ typedef void (*SIGFUNC)(int, siginfo_t *, void *);
 static void sigterm_handler(int code, siginfo_t *siginfo, void *context);
 #ifdef INJECT_ACTIVATION_SIGNAL
 static void inject_activation_handler(int code, siginfo_t *siginfo, void *context);
+extern void* g_InvokeActivationHandlerReturnAddress;
 #endif
 
 static void sigill_handler(int code, siginfo_t *siginfo, void *context);
@@ -775,6 +776,29 @@ static void sigterm_handler(int code, siginfo_t *siginfo, void *context)
 }
 
 #ifdef INJECT_ACTIVATION_SIGNAL
+
+/*++
+Function :
+    InvokeActivationHandler
+
+    Invoke the registered activation handler.
+    It also saves the return address (inject_activation_handler) so that PAL_VirtualUnwind can detect that
+    it has reached that method and use the context stored in the winContext there to unwind to the code
+    where the activation was injected. This is necessary on Alpine Linux where the libunwind cannot correctly
+    unwind past the signal frame.
+
+Parameters :
+    Windows style context of the location where the activation was injected
+
+(no return value)
+--*/
+__attribute__((noinline))
+static void InvokeActivationHandler(CONTEXT *pWinContext)
+{
+    g_InvokeActivationHandlerReturnAddress = __builtin_return_address(0);
+    g_activationFunction(pWinContext);
+}
+
 /*++
 Function :
     inject_activation_handler
@@ -803,15 +827,26 @@ static void inject_activation_handler(int code, siginfo_t *siginfo, void *contex
         native_context_t *ucontext = (native_context_t *)context;
 
         CONTEXT winContext;
+        // Pre-populate context with data from current frame, because ucontext doesn't have some data (e.g. SS register)
+        // which is required for restoring context
+        RtlCaptureContext(&winContext);
+
+        ULONG contextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT;
+
+#if defined(HOST_AMD64)
+        contextFlags |= CONTEXT_XSTATE;
+#endif
+
         CONTEXTFromNativeContext(
             ucontext,
             &winContext,
-            CONTEXT_CONTROL | CONTEXT_INTEGER);
+            contextFlags);
 
         if (g_safeActivationCheckFunction(CONTEXTGetPC(&winContext), /* checkingCurrentThread */ TRUE))
         {
+            g_inject_activation_context_locvar_offset = (int)((char*)&winContext - (char*)__builtin_frame_address(0));
             int savedErrNo = errno; // Make sure that errno is not modified
-            g_activationFunction(&winContext);
+            InvokeActivationHandler(&winContext);
             errno = savedErrNo;
 
             // Activation function may have modified the context, so update it.

src/coreclr/pal/src/include/pal/seh.hpp

@@ -148,7 +148,9 @@ CorUnix::PAL_ERROR SEHDisable(CorUnix::CPalThread *pthrCurrent);
 // Offset of the local variable containing pointer to windows style context in the common_signal_handler / PAL_DispatchException function.
 // This offset is relative to the frame pointer.
 extern int g_hardware_exception_context_locvar_offset;
-
+// Offset of the local variable containing pointer to windows style context in the inject_activation_handler.
+// This offset is relative to the frame pointer.
+extern int g_inject_activation_context_locvar_offset;
 
 #endif /* _PAL_SEH_HPP_ */