[NativeAOT] Source to native mapping fix for out-of-order code

[rcj1]

Sometimes code is placed at a higher native offset than the code at IL offsets adjacent to it. Our debugger algorithm deals with this by, during traversal of mappings, setting the IL offset back if one is encountered that is lower than the current IL offset in the traversal. Native AOT does not have this mechanism, which leads to such code being misattributed to higher-than-actual source lines.

This change reproduces this mechanism in NativeAOT by inserting a native sequence point whenever the IL offset drops below the previous offset.

Repro issue (line attribution of DoWork):

using System.Runtime.CompilerServices;

static class Program
{
#line 53
	[MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
	public async static Task Main()
	{
		await DoWork(0);
	}
	[MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
	public async static Task BackgroundWorker1()
	{
		// await Task.Delay(10000);
		// await Task.Yield();
		throw new InvalidOperationException("BackgroundWorker1 exception.");
	}
	[MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
	public async static Task BackgroundWorker2()
	{
		await Task.Delay(10);
		Console.WriteLine("BackgroundWorker2 completed.");
	}
	[MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
	public async static Task BackgroundWorker3()
	{
		await Task.Delay(10);
		Console.WriteLine("BackgroundWorker3 completed.");
	}
	
	[MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
	static async Task DoWork(int i)
	{
		Task worker1 = BackgroundWorker1();
		Task worker2 = BackgroundWorker2();
		Task worker3 = BackgroundWorker3();
		await Task.WhenAll(worker1, worker2, worker3);
		Console.WriteLine("All background workers completed.");
	}
}

Config: Windows x64 Debug, .NET 11.0.100-alpha.1.25618.104, runtime-async on

NativeOffset	0	106	107	107	116	124	124	133	141	141	150	158	169	183	192	205	222	231	244	261	270	283	307	312	357	379	380	387	392	393	420	431	867	878	1067	1096
ILOffset	0	0	1	1	6	7	7	12	13	13	18	19	27	30	35	37	40	45	47	50	55	57	60	65	70	75	76	81	86	87	87	70	87	70	0	87

ILOffset	0	1	7	13	19	76
LineNumber	80	81	82	83	84	85

Before:

NativeOffset	0	106	107	124	141	158	380	1067
LineNumber	80	80	81	82	83	84	85	80

Notice in particular that code after native offset 431, the suspension code for DoWork, is mistakenly attributed to line 85 (Console.WriteLine).

After:

NativeOffset	0	106	107	124	141	158	380	431	878	1067
LineNumber	80	80	81	82	83	84	85	84	84	80

Here we see that 380-431 is attributed to Console.WriteLine, while the suspension code that follows is correctly attributed to the previous line of await.

aot.txt

[dotnet-policy-service]

Tagging subscribers to this area: @agocke, @dotnet/ilc-contrib
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

This PR fixes source-to-native line mapping in NativeAOT for scenarios where code generation results in out-of-order placement—specifically, when code at lower IL offsets appears at higher native offsets. The fix implements a mechanism similar to CoreCLR's debugger algorithm by tracking when IL offsets decrease during native mapping traversal and inserting sequence points accordingly.

Changes:

• Modified GetNativeSequencePoints() to forward-fill sequence point information across all IL offsets between real sequence points
• Added tracking to detect when IL offsets decrease during native mapping traversal, emitting additional sequence points to maintain correct source line attribution
• Introduced IsBackedSequencePoint flag to distinguish between real and propagated sequence points

[MichalStrehovsky]

Thank you! Cc @jakobbotsch