Resume after catch for interpreter via native EH by janvorli · Pull Request #128728 · dotnet/runtime

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli · 2026-05-28T21:08:11Z

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack.

This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

janvorli · 2026-05-28T21:08:23Z

cc: @am11

dotnet-policy-service · 2026-05-28T21:09:36Z

Tagging subscribers to this area: @JulieLeeMSFT, @BrzVlad, @janvorli, @kg
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR changes CoreCLR interpreter resume-after-catch handling to use native C++ exception unwinding instead of the previous libunwind/manual unwind path, adding resume-after-catch handlers at native/managed boundaries and removing stored interpreter stack-pointer state.

Changes:

Adds ResumeAfterCatchException rethrow helpers and install/uninstall macros for native/managed boundary handling.
Updates interpreter, EH, QCall, PInvoke, prestub, VSD, and allocation helper paths to use the new propagation model.
Removes interpreter-frame saved SP plumbing and adjusts Unix UM entry prestub personalities.

Reviewed changes

Copilot reviewed 21 out of 21 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
`src/coreclr/vm/virtualcallstub.cpp`	Wraps VSD resolve workers with resume-after-catch handlers.
`src/coreclr/vm/riscv64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/qcall.h`	Adds resume-after-catch handling around QCalls.
`src/coreclr/vm/prestub.cpp`	Adds handlers around prestub and interpreted-method execution.
`src/coreclr/vm/loongarch64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/jithelpers.cpp`	Wraps throw/rethrow helpers with context-based resume handling.
`src/coreclr/vm/interpexec.h`	Removes obsolete saved-SP comment.
`src/coreclr/vm/interpexec.cpp`	Removes saved-SP tracking and restores coop mode in resume-after-catch catch block.
`src/coreclr/vm/i386/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/gchelpers.cpp`	Wraps failed allocation helper with resume-after-catch handling.
`src/coreclr/vm/frames.h`	Removes interpreter-frame saved SP field/accessors.
`src/coreclr/vm/frames.cpp`	Stops passing saved interpreter SP to floating-point register update.
`src/coreclr/vm/exceptmacros.h`	Defines new resume-after-catch handler macros.
`src/coreclr/vm/exceptionhandling.h`	Declares resume-after-catch rethrow helper.
`src/coreclr/vm/exceptionhandling.cpp`	Implements managed-frame skipping rethrow helpers and wraps hardware EH path.
`src/coreclr/vm/excep.cpp`	Generalizes native-frame propagation path and removes old resume-after-catch unwind helper.
`src/coreclr/vm/eetwain.cpp`	Simplifies interpreter resume-after-catch to throw directly.
`src/coreclr/vm/dllimport.cpp`	Wraps PInvoke import worker with resume-after-catch handling.
`src/coreclr/vm/arm64/stubs.cpp`	Makes arm64 inlined-call-frame interpreter check null-safe.
`src/coreclr/vm/arm64/asmhelpers.S`	Changes UM entry prestub personality to `NoHandler`.
`src/coreclr/vm/amd64/umthunkstub.S`	Changes UM entry prestub personality to `NoHandler`.

janvorli · 2026-05-29T06:31:16Z

The change was created / tested on macOS arm64. There seem to be some issues on other targets that I need to address.

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

It is not worth differentiating them

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

This changes the way resume after catch in interpreted code works. It removes the need to use libunwind and uses C++ exception handling to unwind the stack. This is basically the same way as we use for WASM, except for some extra handling of cases when the ResumeAfterCatchException would flow into managed frames. In those cases, we skip the managed frames using the explicit frames. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fixes regressions after #128728 where C++ throw fails to excecute because it encounters JIT frames. This failed with `terminate called after throwing an instance of 'ResumeAfterCatchException'` on several interpreter libraries tests in interp mode 1. When EH needs to resume execution in the interpreter following a catch, it throws this exception which needs to propagate all the way to the interpreter execution loop. At managed to native boundaries we need to catch this exception and rethrow it below the jitted frames.

Reverts #128728Fixes#129270

This reverts the workaround previously required for the arm32 environment. It is now safe to restore the original behavior, thanks to the native exception handling improvements implemented in PR #128728. --------- Co-authored-by: Jan Kotas <jkotas@microsoft.com>

janvorli self-assigned this May 28, 2026

CopilotAI review requested due to automatic review settings May 28, 2026 21:08

janvorli requested review from BrzVlad and kg as code owners May 28, 2026 21:08

janvorli added the area-CodeGen-Interpreter-coreclr label May 28, 2026

Copilotstarted reviewing on behalf of janvorli May 28, 2026 21:08 View session

CopilotAI reviewed May 28, 2026
View reviewed changes

Comment threadsrc/coreclr/vm/exceptionhandling.cpp Outdated
Comment threadsrc/coreclr/vm/amd64/umthunkstub.S
Comment threadsrc/coreclr/vm/exceptionhandling.cpp Outdated

am11 mentioned this pull request May 28, 2026
Switch InterpreterFrame to deterministic unwinding #125182
Closed

janvorli added 2 commits May 29, 2026 08:34

Fix Linux x64
258c864

janvorli force-pushed the resume-after-catch-via-native-eh branch from 6bdd856 to 258c864Compare May 29, 2026 12:22

This was referenced May 29, 2026
MSBuild crashing in the build #92290
Open
Helix: System.IO.IOException: No space left on device #128758
Open

janvorli mentioned this pull request Jun 1, 2026
[clr-interp] Use struct parameter for InvokeUnmanagedCalliWithTransition #127543
Closed

Windows with CET shadow stack working now
70c9a71

CopilotAI review requested due to automatic review settings June 2, 2026 23:55

Copilotstarted reviewing on behalf of janvorli June 2, 2026 23:55 View session

CopilotAI reviewed Jun 3, 2026
View reviewed changes

Comment threadsrc/coreclr/vm/interpexec.cpp
Comment threadsrc/coreclr/vm/exceptionhandling.cpp

janvorli mentioned this pull request Jun 3, 2026
[ci-scan] Test failure: PInvokeUnhandled assert in runtime-interpreter (GetRegdisplaySP) #128899
Closed

janvorli added 2 commits June 3, 2026 18:46

Make Windows and Unix rethrowing in InterpExecMethod the same
e882465
It is not worth differentiating them

Fix GetSSP call on non-win-amd64
d19ae6f

CopilotAI review requested due to automatic review settings June 3, 2026 17:20

Copilotstarted reviewing on behalf of janvorli June 3, 2026 17:20 View session

Added Windows bug tracking issue link
7724e9b

CopilotAI review requested due to automatic review settings June 8, 2026 19:59

Copilotstarted reviewing on behalf of janvorli June 8, 2026 19:59 View session

CopilotAI reviewed Jun 8, 2026
View reviewed changes

Comment threadsrc/coreclr/vm/exceptmacros.h
Comment threadsrc/coreclr/vm/interpexec.cpp Outdated

Copilot feedback
e5d2f35

This was referenced Jun 9, 2026
[Mono AOT] Failed to compile System.Private.CoreLib.dll.bc #103520
Open
[wasm AOT] error : LLVM ERROR: out of memory #120245
Open
BlazorWasm_CannotAOT_InDebug test failure #125244
Open

janvorli merged commit 4a1d144 into dotnet:mainJun 9, 2026
130 checks passed

janvorli deleted the resume-after-catch-via-native-eh branch June 9, 2026 09:20

dotnet-maestroBot mentioned this pull request Jun 10, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#7160
Closed

clamp03 mentioned this pull request Jun 10, 2026
Restore Bundled Arguments #129224
Merged

github-actionsBot mentioned this pull request Jun 10, 2026
[aw] No-Op Runs #128986
Closed

BrzVlad mentioned this pull request Jun 10, 2026
Add handling of RethrowAfterCatch exception in a few places #129249
Merged

dotnet-maestroBot mentioned this pull request Jun 11, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#7196
Merged

This was referenced Jun 13, 2026
System.Runtime.Tests.ControlledExecutionTests failing with fatal error #129270
Closed
Revert "Resume after catch for interpreter via native EH" #129362
Merged

jkotas added a commit that referenced this pull request Jun 13, 2026
Revert "Resume after catch for interpreter via native EH" (#129362)
7304c88
Reverts #128728Fixes#129270

This was referenced Jun 16, 2026
[ci-scan] Test failure: PInvokeUnhandled assert recurrence in runtime-interpreter (GetRegdisplaySP) #129327
Closed
[ci-scan] Skip PInvokeUnhandled under interpreter (refs #128899) #128930
Closed

dotnet-milestone-botBot added this to the 11.0-preview6 milestone Jun 17, 2026

maestro-local-devBot mentioned this pull request Jun 23, 2026
[dkurepa/Verify] Source code updates from maestro-auth-test/runtime maestro-auth-test/dotnet#260
Open

dhartglassMSFT mentioned this pull request Jul 7, 2026
Test failure: baseservices/callconvs/TestCallingConventions/TestCallingConventions.cmd (AV in NativeLibrary.LoadByName under gcstress0x3) #129541
Closed

eiriktsarpalis pushed a commit that referenced this pull request Jul 15, 2026
Revert "Resume after catch for interpreter via native EH" (#129362)
28281fb
Reverts #128728Fixes#129270

github-actionsBot locked and limited conversation to collaborators Jul 18, 2026