[clr-interp] Add Swift calling convention support to CoreCLR interpreter on arm64

[kotlarmilos]

Description

Swift uses a calling convention that differs from the standard arm64 ABI. This PR extends the CoreCLR interpreter so that it can correctly call Swift functions on arm64. The changes are limited to call stub generation and includes Swift-specific register usage, argument lowering, and return value lowering.

SwiftSelf and SwiftSelf<T>

Swift instance methods pass self in a dedicated register (x20 on arm64) rather than as a regular argument. In ComputeCallStubWorker when SwiftSelf in encountered, it emits routine for loading argument into x20 before the call.

When SwiftSelf<T> is encountered and not lowered according to the Swift value type lowering, it emits routine for loading address of struct into x20 before the call. If struct T can be lowered, it is processed as normal lowered argument as described below.

SwiftError

Swift error is returned via dedicated register (x21 on arm64) when a call returns. It is passed as byref argument where is expected to load error reg into that bytrerf arg when call returns. It is done by:

• The byref argument address is saved at fp + offset
• Before the call, both x21 and the byref slot are initialized to null
• After the call, x21 is copied into scratch register x10
• If x10 is non-null, it points to a Swift error object
• The interpreter checks x10 and loads the error into the argument

SwiftIndirectResult

Swift returns non-lowered structs indirectly via a dedicated register (x8 on arm64). In ComputeCallStubWorker when SwiftIndirectResult in encountered, it emits routine for loading argument into x8 before the call. Then the callee writes the return value to the memory provided in the argument.

Lowering of value types in arguments

Swift lowers structs into individual primitive arguments when they fit within four machine words. Consider the following struct:

[StructLayout(LayoutKind.Sequential, Size = 14)]
struct F3_S4
{
    public nuint F0;  // size = 8, offset = 0
    public float F1;  // size = 4, offset = 8
    public ushort F2; // size = 2, offset = 12
}

A Swift function swiftFunc(int a, F3_S4 b, float c) is lowered to swiftFunc(int a, nuint b_0, float b_1, ushort b_2, float c)

The signature is first rewritten into lowered form. This enables correct register and stack allocation, but introduces a problem. When loading lowered arguments into registers or stack, the standard routines assume 8-byte alignment on the interpreter stack, which is not always true for fields within lowered structs.

For example, the loader routine reads F0 into a register and advances the argument pointer by 8 bytes. It then loads F1 and again advances by 8 bytes (including 4 bytes of padding). This is incorrect because F1 is at offset 8, and F2 is at offset 12

To fix that, new load routines are introduced for Swift-lowered arguments:

• Routines read the field offset from the routine array
• They load from [x9 + offset] without advancing the interpreter argument pointer
• The argument pointer is advanced by the struct size only when the last element of the lowered struct is loaded

Lowering of return value types

Swift lowers struct return values into multiple registers (both GP and FP). This is done by collecting return registers after the call and reconstructing the original struct layout. When a lowered struct return is detected in ComputeCallStubWorker, additional post-call routines are emitted to load the return value into the managed return buffer. To implement this, a new return stub InterpreterStubRetSwiftLowered is introduced. This stub stores the return registers (GP0–GP4 and FP0–FP4) into a contiguous temporary buffer immediately after the call returns.

A new call stub CallJittedMethodRetSwiftLowered is introduced to allow for execution of routines after the target call. Based on the computed lowering, a sequence of post-call routines is emitted. These routines copy each lowered field from the temporary buffer into the return struct at the correct offsets. A SwiftLoweredReturnTerminator routine is added at the end to branch back to the epilog.

Out of scope

x64 and UnmanagedCallersOnly are currently not supported and will be added in a follow-up.

Contributes to #120049

[dotnet-policy-service]

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

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated 8 comments.

[Copilot]

Pull request overview

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

[Copilot]

Pull request overview

Copilot reviewed 10 out of 11 changed files in this pull request and generated no new comments.

[kotlarmilos]

@davidwrighton @janvorli This PR is ready for review, please take a look

[janvorli]

LGTM modulo the comments on adding some ifdefs.

[Copilot]

Pull request overview

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

[kotlarmilos]

/ba-g ios-arm64 failure is #123796