diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs
index 101978434bd612..bb27891a8c6627 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs
@@ -1,7 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Runtime.Versioning;
 
 namespace System.Runtime.InteropServices.ObjectiveC
@@ -39,6 +41,16 @@ private static partial IntPtr CreateReferenceTrackingHandleInternal(
             out int memInSizeT,
             out IntPtr mem);
 
+        [StackTraceHidden]
+        internal static void ThrowPendingExceptionObject()
+        {
+            Exception? ex = System.StubHelpers.StubHelpers.GetPendingExceptionObject();
+            if (ex is not null)
+            {
+                ExceptionDispatchInfo.Throw(ex);
+            }
+        }
+
         [UnmanagedCallersOnly]
         internal static unsafe void* InvokeUnhandledExceptionPropagation(Exception* pExceptionArg, IntPtr methodDesc, IntPtr* pContext, Exception* pException)
         {
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
index 547458296fd024..1630c59b451f13 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
@@ -22,6 +22,7 @@
 using ILCompiler.ReadyToRun;
 using ILCompiler.Reflection.ReadyToRun;
 using Internal.TypeSystem.Ecma;
+using Internal.TypeSystem.Interop;
 using ILCompiler.ReadyToRun.TypeSystem;
 
 namespace ILCompiler
@@ -701,6 +702,7 @@ public void PrepareForCompilationRetry(MethodWithGCInfo methodToBeRecompiled, IE
         private ManualResetEventSlim _compilationSessionComplete = new ManualResetEventSlim();
         private bool _hasCreatedCompilationThreads = false;
         private bool _hasAddedAsyncReferences = false;
+        private bool _hasAddedObjectiveCMarshalReferences = false;
 
         protected override void ComputeDependencyNodeDependencies(List<DependencyNodeCore<NodeFactory>> obj)
         {
@@ -737,6 +739,9 @@ protected override void ComputeDependencyNodeDependencies(List<DependencyNodeCor
                         if (method.IsAsyncCall() && shouldBeCompiled)
                             AddNecessaryAsyncReferences(method);
 
+                        if (method.IsPInvoke && shouldBeCompiled && MarshalHelpers.ShouldCheckForPendingException(method.Context.Target, method.GetPInvokeMethodMetadata()))
+                            AddNecessaryObjectiveCMarshalReferences(method);
+
                         if (method.IsCompilerGeneratedILBodyForAsync() && shouldBeCompiled)
                             EnsureAsyncThunkTokensAreAvailable(method);
 
@@ -1043,6 +1048,24 @@ private void AddNecessaryAsyncReferences(MethodDesc method)
             _hasAddedAsyncReferences = true;
         }
 
+        private void AddNecessaryObjectiveCMarshalReferences(MethodDesc method)
+        {
+            if (_hasAddedObjectiveCMarshalReferences || TypeSystemContext.SystemModule is null)
+                return;
+
+            MetadataType objectiveCMarshalType = TypeSystemContext.SystemModule.GetType(
+                "System.Runtime.InteropServices.ObjectiveC"u8,
+                "ObjectiveCMarshal"u8,
+                throwIfNotFound: false);
+            if (objectiveCMarshalType is null)
+                return;
+
+            MethodDesc throwPendingExceptionObject = objectiveCMarshalType.GetKnownMethod("ThrowPendingExceptionObject"u8, null);
+            var moduleForNewReferences = ((EcmaMethod)method.GetPrimaryMethodDesc().GetTypicalMethodDefinition()).Module;
+            _tokenManager.EnsureDefTokensAreAvailable([objectiveCMarshalType, throwPendingExceptionObject], moduleForNewReferences, false);
+            _hasAddedObjectiveCMarshalReferences = true;
+        }
+
         public ISymbolNode GetFieldRvaData(FieldDesc field)
         {
             if (!CompilationModuleGroup.ContainsType(field.OwningType.GetTypeDefinition()))
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/Stubs/PInvokeILEmitter.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/Stubs/PInvokeILEmitter.cs
index ed05deb5f23581..ea68c82680da70 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/Stubs/PInvokeILEmitter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/Stubs/PInvokeILEmitter.cs
@@ -56,6 +56,29 @@ private void EmitPInvokeCall(PInvokeILCodeStreams ilCodeStreams)
 
             callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(rawTargetMethod));
 
+            if (MarshalHelpers.ShouldCheckForPendingException(context.Target, _importMetadata))
+            {
+                MetadataType objcMarshalType = context.SystemModule.GetKnownType(
+                    "System.Runtime.InteropServices.ObjectiveC"u8, "ObjectiveCMarshal"u8);
+
+                // Spill the native return value across the pending-exception helper call.
+                ILLocalVariable nativeReturnLocal = (ILLocalVariable)(-1);
+                bool hasNativeReturn = !nativeReturnType.IsVoid;
+                if (hasNativeReturn)
+                {
+                    nativeReturnLocal = emitter.NewLocal(nativeReturnType);
+                    callsiteSetupCodeStream.EmitStLoc(nativeReturnLocal);
+                }
+
+                callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
+                    objcMarshalType.GetKnownMethod("ThrowPendingExceptionObject"u8, null)));
+
+                if (hasNativeReturn)
+                {
+                    callsiteSetupCodeStream.EmitLdLoc(nativeReturnLocal);
+                }
+            }
+
             static PInvokeTargetNativeMethod AllocateTargetNativeMethod(MethodDesc targetMethod, MethodSignature nativeSigArg)
             {
                 var contextMethods = s_contexts.GetOrCreateValue(targetMethod.Context);
@@ -72,9 +95,6 @@ private MethodIL EmitIL()
             if (!_importMetadata.Flags.PreserveSig)
                 throw new NotSupportedException();
 
-            if (MarshalHelpers.ShouldCheckForPendingException(_targetMethod.Context.Target, _importMetadata))
-                throw new NotSupportedException();
-
             if (_targetMethod.IsUnmanagedCallersOnly)
                 throw new NotSupportedException();
 
@@ -142,7 +162,9 @@ public sealed class PInvokeILStubMethodIL : ILStubMethodIL
 
         public PInvokeILStubMethodIL(ILStubMethodIL methodIL) : base(methodIL)
         {
-            IsMarshallingRequired = Marshaller.IsMarshallingRequired(methodIL.OwningMethod);
+            MethodDesc method = methodIL.OwningMethod;
+            IsMarshallingRequired = Marshaller.IsMarshallingRequired(method)
+                || MarshalHelpers.ShouldCheckForPendingException(method.Context.Target, method.GetPInvokeMethodMetadata());
         }
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs
index d827aed4673c78..186ee7fba2a3ba 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs
@@ -117,9 +117,6 @@ public static bool IsMarshallingRequired(MethodDesc targetMethod)
             if (!flags.PreserveSig)
                 return true;
 
-            if (MarshalHelpers.ShouldCheckForPendingException(targetMethod.Context.Target, metadata))
-                return true;
-
             var marshallers = GetMarshallersForMethod(targetMethod);
             for (int i = 0; i < marshallers.Length; i++)
             {
diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h
index 4a36a6518a0446..29795b14a5916e 100644
--- a/src/coreclr/vm/corelib.h
+++ b/src/coreclr/vm/corelib.h
@@ -457,6 +457,7 @@ DEFINE_FIELD_U(_buckets, GCHandleSetObject, _buckets)
 
 #ifdef FEATURE_OBJCMARSHAL
 DEFINE_CLASS(OBJCMARSHAL,    ObjectiveC, ObjectiveCMarshal)
+DEFINE_METHOD(OBJCMARSHAL,   THROW_PENDING_EXCEPTION_OBJECT,         ThrowPendingExceptionObject,            SM_RetVoid)
 DEFINE_METHOD(OBJCMARSHAL,   INVOKEUNHANDLEDEXCEPTIONPROPAGATION,    InvokeUnhandledExceptionPropagation,    SM_PtrException_IntPtr_PtrIntPtr_PtrException_RetVoidPtr)
 #endif // FEATURE_OBJCMARSHAL
 
diff --git a/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.cs b/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.cs
new file mode 100644
index 00000000000000..7f3c113113048b
--- /dev/null
+++ b/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.cs
@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ObjectiveC;
+
+// Validates that blittable objc_msgSend P/Invoke stubs are precompiled into the R2R image
+// (via the crossgen2 --map output) and that the emitted stub actually executes the
+// pending-exception path at runtime.
+public static unsafe class ObjCPInvokeR2RTest
+{
+    [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
+    private static extern IntPtr objc_msgSend(IntPtr receiver, IntPtr selector);
+
+    [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
+    private static extern IntPtr objc_msgSend_2(IntPtr receiver, IntPtr selector, IntPtr arg1);
+
+    [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend_stret")]
+    private static extern void objc_msgSend_stret(IntPtr receiver, IntPtr selector);
+
+    private sealed class PendingException : Exception
+    {
+        public PendingException(string message) : base(message) { }
+    }
+
+    [UnmanagedCallersOnly]
+    private static IntPtr MsgSendCallback(IntPtr inst, IntPtr sel)
+    {
+        ObjectiveCMarshal.SetMessageSendPendingException(new PendingException(nameof(MsgSendCallback)));
+        return IntPtr.Zero;
+    }
+
+    public static int Main()
+    {
+        if (!ValidateMapFile())
+            return 1;
+
+        if (!ValidatePendingExceptionPropagates())
+            return 1;
+
+        Console.WriteLine("PASSED: ObjC P/Invoke stubs are precompiled and the pending-exception path executes.");
+        return 100;
+    }
+
+    private static bool ValidateMapFile()
+    {
+        string mapFile = Path.ChangeExtension(Assembly.GetExecutingAssembly().Location, "map");
+        if (!File.Exists(mapFile))
+        {
+            Console.WriteLine($"FAILED: Map file not found at {mapFile}");
+            return false;
+        }
+
+        // Only MethodWithGCInfo entries prove the stub was compiled into the image.
+        string[] compiledStubs = File.ReadAllLines(mapFile)
+            .Where(l => l.Contains("objc_msgSend") && l.Contains("MethodWithGCInfo"))
+            .ToArray();
+
+        string[] expectedStubs = new[]
+        {
+            "__objc_msgSend ",
+            "__objc_msgSend_2 ",
+            "__objc_msgSend_stret ",
+        };
+
+        bool allFound = true;
+        foreach (string expected in expectedStubs)
+        {
+            bool found = compiledStubs.Any(l => l.Contains(expected));
+            Console.WriteLine($"  {(found ? "OK" : "MISSING")}: {expected.Trim()}");
+            if (!found)
+                allFound = false;
+        }
+
+        if (!allFound)
+            Console.WriteLine("FAILED: Not all objc_msgSend P/Invoke stubs were precompiled into the R2R image.");
+
+        return allFound;
+    }
+
+    private static bool ValidatePendingExceptionPropagates()
+    {
+        IntPtr callback = (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, IntPtr>)&MsgSendCallback;
+        ObjectiveCMarshal.SetMessageSendCallback(MessageSendFunction.MsgSend, callback);
+
+        try
+        {
+            objc_msgSend(IntPtr.Zero, IntPtr.Zero);
+        }
+        catch (PendingException ex) when (ex.Message == nameof(MsgSendCallback))
+        {
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"FAILED: unexpected exception from objc_msgSend: {ex.GetType()} - {ex.Message}");
+            return false;
+        }
+
+        Console.WriteLine("FAILED: objc_msgSend returned without throwing the pending exception.");
+        return false;
+    }
+}
diff --git a/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.csproj b/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.csproj
new file mode 100644
index 00000000000000..1c44495107978a
--- /dev/null
+++ b/src/tests/readytorun/ObjCPInvokeR2R/ObjCPInvokeR2R.csproj
@@ -0,0 +1,62 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RequiresProcessIsolation>true</RequiresProcessIsolation>
+    <ReferenceXUnitWrapperGenerator>false</ReferenceXUnitWrapperGenerator>
+    <CrossGenTest>false</CrossGenTest>
+    <!-- https://github.com/dotnet/runtime/issues/73138 -->
+    <IlasmRoundTripIncompatible>true</IlasmRoundTripIncompatible>
+    <!-- Only run on Apple platforms where ShouldCheckForPendingException recognizes objc_msgSend -->
+    <CLRTestTargetUnsupported Condition="'$(TargetsOSX)' != 'true'">true</CLRTestTargetUnsupported>
+    <!-- Skip when sanitizers are enabled — crossgen2 invocation requires non-sanitized jitinterface -->
+    <CLRTestTargetUnsupported Condition="'$(EnableNativeSanitizers)' != ''">true</CLRTestTargetUnsupported>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="ObjCPInvokeR2R.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(TestLibraryProjectPath)" />
+  </ItemGroup>
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+
+REM ObjC P/Invoke R2R test is macOS-only — batch commands are a no-op placeholder
+echo ObjC P/Invoke R2R test is not supported on Windows
+exit /b 0
+]]></CLRTestBatchPreCommands>
+    <CLRTestBashPreCommands><![CDATA[
+$(CLRTestBashPreCommands)
+
+# Suppress some DOTNET variables for the duration of Crossgen2 execution
+export -n DOTNET_GCName DOTNET_GCStress DOTNET_HeapVerify DOTNET_ReadyToRun
+
+mkdir -p IL_DLLS
+
+if [ ! -f IL_DLLS/ObjCPInvokeR2R.dll ]
+then
+  cp ObjCPInvokeR2R.dll IL_DLLS/ObjCPInvokeR2R.dll
+fi
+if [ ! -f IL_DLLS/ObjCPInvokeR2R.dll ]
+then
+  echo Failed to copy ObjCPInvokeR2R.dll to IL_DLLS
+  exit 1
+fi
+
+"$CORE_ROOT"/crossgen2/crossgen2 --map --inputbubble -r:"$CORE_ROOT"/*.dll -o:ObjCPInvokeR2R.dll IL_DLLS/ObjCPInvokeR2R.dll
+
+__cgExitCode=$?
+if [ $__cgExitCode -ne 0 ]
+then
+  echo Crossgen2 failed with exitcode: $__cgExitCode
+  exit 1
+fi
+if [ ! -f ObjCPInvokeR2R.map ]
+then
+  echo FAILED: crossgen2 did not produce map file
+  exit 1
+fi
+
+export DOTNET_GCName DOTNET_GCStress DOTNET_HeapVerify DOTNET_ReadyToRun
+]]></CLRTestBashPreCommands>
+  </PropertyGroup>
+</Project>