Smaller funclet prologs/epilogs (x64)

[jkotas]

• Allow funclets to trash non-volatile registers to make funclet prologs/epilogs smaller
• Restore non-volatile registers before non-filter funclet calls
• Unify funclet ABI between NAOT and non-NAOT

[Copilot]

Pull Request Overview

This PR refactors the funclet prolog/epilog sequences for x64 to reduce their size while unifying the ABI between NAOT and non-NAOT builds.

• Removed redundant saving/restoring of non-volatile registers in funclets
• Updated stack frame allocation and alignment computations
• Adjusted documentation to reflect the revised behavior and design decisions

Reviewed Changes

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

File	Description
src/coreclr/jit/codegenxarch.cpp	Removed EBP and callee-register save/restore logic; updated frame allocation calculation using REG_NA
docs/design/coreclr/botr/clr-abi.md	Revised description of register preservation behavior in funclets

Files not reviewed (4)

• src/coreclr/nativeaot/Runtime/amd64/ExceptionHandling.S: Language not supported
• src/coreclr/nativeaot/Runtime/amd64/ExceptionHandling.asm: Language not supported
• src/coreclr/vm/amd64/AsmHelpers.asm: Language not supported
• src/coreclr/vm/amd64/asmhelpers.S: Language not supported

[jkotas]

@EgorBot -windows_intel -amd

using System.Reflection;
using BenchmarkDotNet.Attributes;

public class Bench
{
    static int x;

    [Benchmark]
    public void Finally()
    {
        try
        {
            try
            {
                try
                {
                    try
                    {
                        try
                        {
                            try
                            {
                                try
                                {
                                    try
                                    {
                                        try
                                        {
                                            try
                                            {
                                                throw new Exception();
                                            }
                                            finally { x++; }
                                        }
                                        finally { x++; }
                                    }
                                    finally { x++; }
                                }
                                finally { x++; }
                            }
                            finally { x++; }
                        }
                        finally { x++; }
                    }
                    finally { x++; }
                }
                finally { x++; }
            }
            finally { x++; }
        }
        catch
        {
        }
    }
}

[jkotas]

@EgorBot -windows_intel -intel

using System.Reflection;
using BenchmarkDotNet.Attributes;

public class Bench
{
    static int x;

    [Benchmark]
    public void Finally()
    {
        try
        {
            try
            {
                try
                {
                    try
                    {
                        try
                        {
                            try
                            {
                                try
                                {
                                    try
                                    {
                                        try
                                        {
                                            try
                                            {
                                                throw new Exception();
                                            }
                                            finally { x++; }
                                        }
                                        finally { x++; }
                                    }
                                    finally { x++; }
                                }
                                finally { x++; }
                            }
                            finally { x++; }
                        }
                        finally { x++; }
                    }
                    finally { x++; }
                }
                finally { x++; }
            }
            finally { x++; }
        }
        catch
        {
        }
    }
}

[jkotas]

@MihuBot

[jkotas]

Perf results summary:

• 0.6% code size improvement on average
• Artificial micro-benchmark to measure the cost of saving and restoring all registers around funclet invocation is very noisy. The results vary between 10% improvement and 5% regression.

[jkotas]

@janvorli @dotnet/jit-contrib PTLA. This PR is for x64 only. I plan to switch other platforms to the unified scheme in subsequent PRs.

[janvorli]

LGTM, thank you!

[BruceForstall]

I suggest running outerloop tests.

[jkotas]

/azp run runtime-coreclr outerloop

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).