mirror of
https://github.com/icsharpcode/ILSpy.git
synced 2026-10-12 02:15:58 +00:00
Siegfried Pammer
4e2f28109e
The async stepping blob's first field is the compiler-generated catch handler's IL offset plus one, and 0 when there is nothing to record. ILSpy wrote the raw offset, so a consumer decoding it as (value - 1) resolved an address in the middle of an instruction: Mono.Cecil throws ArgumentNullException while reading the body, which is why the reported assembly opened in ILSpy but killed ILLink on every MoveNext it had. CatchHandlerOffset now holds the offset it is named after, or -1 for "none", and BuildBlob applies the bias - the same model the compiler uses. It is recorded only where an escaping exception is unlikely to be observed: an async void method, and an async entry point. Recording it more widely would be worse than recording it nowhere, because an async Task method returns its exception through the Task and the debugger would then break on exceptions user code catches. Measured over csc 1.3.2 to 5.10: async void is handler+1 and a normal async Task is 0 in every version; only async Main changed, from 0 to handler+1 between 2.10 and 3.11. The entry point token names the synchronous '<Main>' shim that exists because the runtime will not take .entrypoint on an async method, so the method to record is the one the shim calls. Reading that call is exact; matching the shim's siblings by name is not, and gets a 'Main' overload beside the real entry point wrong. Both tests compare against the compiler's own PDB for the same assembly, so the blobs describe the same IL and the field compares directly. Assisted-by: Claude:claude-opus-5:Claude Code
69 lines
2.5 KiB
C#
69 lines
2.5 KiB
C#
// Copyright (c) 2019 Daniel Grunwald
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
// software and associated documentation files (the "Software"), to deal in the Software
|
|
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
// to whom the Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all copies or
|
|
// substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
using System;
|
|
using System.Collections.Immutable;
|
|
using System.Reflection.Metadata;
|
|
using System.Reflection.Metadata.Ecma335;
|
|
|
|
namespace ICSharpCode.Decompiler.DebugInfo
|
|
{
|
|
public readonly struct AsyncDebugInfo
|
|
{
|
|
/// <summary>
|
|
/// IL offset of the compiler-generated catch handler whose exceptions the debugger should
|
|
/// report as user-unhandled, or -1 when there is none to record.
|
|
/// </summary>
|
|
public readonly int CatchHandlerOffset;
|
|
public readonly ImmutableArray<Await> Awaits;
|
|
|
|
public AsyncDebugInfo(int catchHandlerOffset, ImmutableArray<Await> awaits)
|
|
{
|
|
this.CatchHandlerOffset = catchHandlerOffset;
|
|
this.Awaits = awaits;
|
|
}
|
|
|
|
public readonly struct Await
|
|
{
|
|
public readonly int YieldOffset;
|
|
public readonly int ResumeOffset;
|
|
|
|
public Await(int yieldOffset, int resumeOffset)
|
|
{
|
|
this.YieldOffset = yieldOffset;
|
|
this.ResumeOffset = resumeOffset;
|
|
}
|
|
}
|
|
|
|
public BlobBuilder BuildBlob(MethodDefinitionHandle moveNext)
|
|
{
|
|
BlobBuilder blob = new BlobBuilder();
|
|
// The field is the handler's offset plus one; 0 is the encoding for "none", which is why
|
|
// a consumer reading it back subtracts one before resolving it to an instruction.
|
|
blob.WriteUInt32((uint)(CatchHandlerOffset + 1));
|
|
foreach (var await in Awaits)
|
|
{
|
|
blob.WriteUInt32((uint)await.YieldOffset);
|
|
blob.WriteUInt32((uint)await.ResumeOffset);
|
|
blob.WriteCompressedInteger(MetadataTokens.GetRowNumber(moveNext));
|
|
}
|
|
return blob;
|
|
}
|
|
}
|
|
}
|