From 2a0dfd7c248962c58d6122b98c4d37a6c709033f Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Tue, 10 Mar 2026 12:03:24 -0700 Subject: [PATCH 01/18] Remove async method inlining restrictions in crossgen2 Remove four restrictions that prevented async methods from being inlined during ReadyToRun compilation: 1. CanInline() rejected IsAsyncThunk()/IsAsyncCall() callees 2. CrossModuleInlineableUncached() rejected async variants/thunks 3. reportInlining() threw when async methods were cross-module inlined 4. InliningInfoNode skipped recording inlining info for async thunks All 69 async tests pass with both crossgen2 and composite R2R modes. Fixes https://github.com/dotnet/runtime/issues/124665 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../DependencyAnalysis/ReadyToRun/InliningInfoNode.cs | 5 ----- .../Compiler/ReadyToRunCodegenCompilation.cs | 6 ------ .../Compiler/ReadyToRunCompilationModuleGroupBase.cs | 4 ---- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 11 ----------- 4 files changed, 26 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs index 49c964cd0149da..e9a76a74d8a8dc 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs @@ -72,11 +72,6 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) continue; } MethodDesc inliner = methodNode.Method; - if (inliner.IsCompilerGeneratedILBodyForAsync()) - { - // Async thunks are restricted from inlining. https://github.com/dotnet/runtime/issues/124665 - continue; - } EcmaMethod inlinerDefinition = (EcmaMethod)inliner.GetPrimaryMethodDesc().GetTypicalMethodDefinition(); if (inlinerDefinition.IsNonVersionable()) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs index 6a6ec431b9dffe..9d2fe7eaa309e3 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs @@ -109,12 +109,6 @@ public bool CanInline(MethodDesc caller, MethodDesc callee) } } - // TODO: Enable async inlining. https://github.com/dotnet/runtime/issues/124665 - if (callee.IsAsyncThunk() || callee.IsAsyncCall()) - { - return false; - } - _nodeFactory.DetectGenericCycles(caller, callee); return NodeFactory.CompilationModuleGroup.CanInline(caller, callee); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs index 96f78ba0309247..7d3b30db219454 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs @@ -520,10 +520,6 @@ private bool CrossModuleInlineableInternal(MethodDesc method) private bool CrossModuleInlineableUncached(MethodDesc method) { - // Async thunks and variants cannot currently be inlined cross module - if (method.IsAsyncVariant() || method.IsAsync || method.IsAsyncThunk()) - return false; - // Defined in corelib MetadataType owningMetadataType = method.OwningType.GetTypeDefinition() as MetadataType; if (owningMetadataType == null) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index c5e2d1f8ca40c3..3f35c1325eed82 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -3306,17 +3306,6 @@ private void reportInliningDecision(CORINFO_METHOD_STRUCT_* inlinerHnd, CORINFO_ var typicalMethod = inlinee.GetTypicalMethodDefinition(); - if ((typicalMethod.IsAsyncVariant() || typicalMethod.IsAsync || typicalMethod.IsCompilerGeneratedILBodyForAsync()) && !_compilation.CompilationModuleGroup.VersionsWithMethodBody(typicalMethod)) - { - // TODO: fix this restriction in runtime async. https://github.com/dotnet/runtime/issues/124665 - // Disable async methods in cross module inlines for now, we need to trigger the CheckILBodyFixupSignature in the right situations, and that hasn't been implemented - // yet. Currently, we'll correctly trigger the _ilBodiesNeeded logic below, but we also need to avoid triggering the ILBodyFixupSignature for the async thunks, but we ALSO need to make - // sure we generate the CheckILBodyFixupSignature for the actual runtime-async body in which case I think the typicalMethod will be an AsyncVariantMethod, which doesn't appear - // to be handled here. This check is here in the place where I believe we actually would behave incorrectly, but we also have a check in CrossModuleInlineable which disallows - // the cross module inline of async methods currently. - throw new Exception("Inlining async methods is not supported in ReadyToRun compilation."); - } - MethodIL methodIL = _compilation.GetMethodIL(typicalMethod); if (methodIL is ILStubMethodIL ilStubMethodIL && ilStubMethodIL.StubILHasGeneratedTokens) { From 124470c5055ec30ebbfb94e367f709505d72a814 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Wed, 25 Mar 2026 15:43:02 -0700 Subject: [PATCH 02/18] Intern AsyncResumptionStub instances to fix sort crash with --opt-cross-module AsyncResumptionStub was created via 'new' per JIT compilation context. When a method was recompiled (e.g. via PrepareForCompilationRetry for cross-module inlining), a second CorInfoImpl created a second AsyncResumptionStub for the same target method. Since NodeCache uses reference equality, both entered the dependency graph as separate MethodWithGCInfo nodes. During sorting, their CompareToImpl returned 0 (they wrap the same target method), tripping the Debug.Assert(result != 0) in TypeSystemComparer.Compare(MethodDesc, MethodDesc). Fix: Add an AsyncResumptionStubHashtable (LockFreeReaderHashtable) to CompilerTypeSystemContext that interns AsyncResumptionStub instances by (targetMethod, owningType). Update all creation sites to use the new GetAsyncResumptionStub() method instead of 'new AsyncResumptionStub(...)'. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../CompilerTypeSystemContext.Async.cs | 39 +++++++++++++++++++ .../IL/ILImporter.Scanner.cs | 2 +- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 2 +- .../JitInterface/CorInfoImpl.RyuJit.cs | 2 +- 4 files changed, 42 insertions(+), 3 deletions(-) diff --git a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs index 53111252b0a235..4f243a53ab38c4 100644 --- a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs +++ b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs @@ -200,6 +200,45 @@ protected override bool CompareValueToValue(AsyncMethodVariant value1, AsyncMeth } private AsyncVariantHashtable _asyncVariantHashtable = new AsyncVariantHashtable(); + public AsyncResumptionStub GetAsyncResumptionStub(MethodDesc targetMethod, TypeDesc owningType) + { + return _asyncResumptionStubHashtable.GetOrCreateValue(new AsyncResumptionStubKey(targetMethod, owningType)); + } + + private readonly struct AsyncResumptionStubKey : System.IEquatable + { + public readonly MethodDesc TargetMethod; + public readonly TypeDesc OwningType; + + public AsyncResumptionStubKey(MethodDesc targetMethod, TypeDesc owningType) + { + TargetMethod = targetMethod; + OwningType = owningType; + } + + public bool Equals(AsyncResumptionStubKey other) + => TargetMethod == other.TargetMethod && OwningType == other.OwningType; + + public override bool Equals(object obj) + => obj is AsyncResumptionStubKey other && Equals(other); + + public override int GetHashCode() + => TargetMethod.GetHashCode(); + } + + private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable + { + protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.TargetMethod.GetHashCode(); + protected override int GetValueHashCode(AsyncResumptionStub value) => value.TargetMethod.GetHashCode(); + protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value) + => key.TargetMethod == value.TargetMethod && key.OwningType == value.OwningType; + protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2) + => value1.TargetMethod == value2.TargetMethod && value1.OwningType == value2.OwningType; + protected override AsyncResumptionStub CreateValueFromKey(AsyncResumptionStubKey key) + => new AsyncResumptionStub(key.TargetMethod, key.OwningType); + } + private AsyncResumptionStubHashtable _asyncResumptionStubHashtable = new AsyncResumptionStubHashtable(); + public MetadataType GetContinuationType(GCPointerMap pointerMap) { return _continuationTypeHashtable.GetOrCreateValue(pointerMap); diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs index a67e3048ce7cdf..42266439e30e0a 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs @@ -460,7 +460,7 @@ private void ImportCall(ILOpcode opcode, int token) const string asyncReason = "Async state machine"; - var resumptionStub = new AsyncResumptionStub(_canonMethod, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); + var resumptionStub = ((CompilerTypeSystemContext)_canonMethod.Context).GetAsyncResumptionStub(_canonMethod, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); _dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(resumptionStub), asyncReason); _dependencies.Add(_factory.ConstructedTypeSymbol(_compilation.TypeSystemContext.ContinuationType), asyncReason); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 58fd3d387ba99a..3ce96b1208ce75 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -502,7 +502,7 @@ private void AddResumptionStubFixup(MethodWithGCInfo compiledStubNode) { if (_asyncResumptionStub is null) { - _asyncResumptionStub = new AsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); + _asyncResumptionStub = ((CompilerTypeSystemContext)MethodBeingCompiled.Context).GetAsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(_asyncResumptionStub)); } diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs index cb3964df10c304..6a5fcc614bf374 100644 --- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs +++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs @@ -57,7 +57,7 @@ private UnboxingMethodDesc getUnboxingThunk(MethodDesc method) private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { - _asyncResumptionStub ??= new AsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); + _asyncResumptionStub ??= ((CompilerTypeSystemContext)MethodBeingCompiled.Context).GetAsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.MethodEntrypoint(_asyncResumptionStub)); return ObjectToHandle(_asyncResumptionStub); From b697bd6209aec9a9113686cc8d242142254f0b48 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Wed, 25 Mar 2026 17:01:10 -0700 Subject: [PATCH 03/18] Address PR feedback: remove casts, delete R2R field, improve hash - Use HashCode.Combine for AsyncResumptionStubKey.GetHashCode and update GetKeyHashCode/GetValueHashCode for consistency - Remove unnecessary (CompilerTypeSystemContext) casts since _compilation.TypeSystemContext already returns the right type - Delete _asyncResumptionStub field from ReadyToRun CorInfoImpl (no longer needed since stubs are cached in the type system context) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Compiler/CompilerTypeSystemContext.Async.cs | 6 +++--- .../tools/Common/JitInterface/CorInfoImpl.cs | 2 ++ .../ILCompiler.Compiler/IL/ILImporter.Scanner.cs | 2 +- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 13 ++++--------- .../JitInterface/CorInfoImpl.RyuJit.cs | 2 +- 5 files changed, 11 insertions(+), 14 deletions(-) diff --git a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs index 4f243a53ab38c4..479eefabcd70b3 100644 --- a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs +++ b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs @@ -223,13 +223,13 @@ public override bool Equals(object obj) => obj is AsyncResumptionStubKey other && Equals(other); public override int GetHashCode() - => TargetMethod.GetHashCode(); + => System.HashCode.Combine(TargetMethod, OwningType); } private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable { - protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.TargetMethod.GetHashCode(); - protected override int GetValueHashCode(AsyncResumptionStub value) => value.TargetMethod.GetHashCode(); + protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.GetHashCode(); + protected override int GetValueHashCode(AsyncResumptionStub value) => System.HashCode.Combine(value.TargetMethod, value.OwningType); protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value) => key.TargetMethod == value.TargetMethod && key.OwningType == value.OwningType; protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2) diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index a8d0f13e5cde23..43a286f7eb4c43 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -703,7 +703,9 @@ private void CompileMethodCleanup() #if !READYTORUN _debugInfo = null; #endif +#if !READYTORUN _asyncResumptionStub = null; +#endif _debugLocInfos = null; _debugVarInfos = null; diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs index 42266439e30e0a..a4ac471ef55321 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs @@ -460,7 +460,7 @@ private void ImportCall(ILOpcode opcode, int token) const string asyncReason = "Async state machine"; - var resumptionStub = ((CompilerTypeSystemContext)_canonMethod.Context).GetAsyncResumptionStub(_canonMethod, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); + AsyncResumptionStub resumptionStub = _compilation.TypeSystemContext.GetAsyncResumptionStub(_canonMethod, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); _dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(resumptionStub), asyncReason); _dependencies.Add(_factory.ConstructedTypeSymbol(_compilation.TypeSystemContext.ContinuationType), asyncReason); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 3ce96b1208ce75..cb670ba2db0cbe 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -477,8 +477,6 @@ unsafe partial class CorInfoImpl private List _ilBodiesNeeded; private Dictionary _preInitedTypes = new Dictionary(); private HashSet _synthesizedPgoDependencies; - private MethodDesc _asyncResumptionStub; - public bool HasColdCode { get; private set; } public CorInfoImpl(ReadyToRunCodegenCompilation compilation) @@ -500,14 +498,11 @@ private void AddResumptionStubFixup(MethodWithGCInfo compiledStubNode) private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { - if (_asyncResumptionStub is null) - { - _asyncResumptionStub = ((CompilerTypeSystemContext)MethodBeingCompiled.Context).GetAsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); - AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(_asyncResumptionStub)); - } + MethodDesc asyncResumptionStub = _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); + AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); - entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.CompiledMethodNode(_asyncResumptionStub)); - return ObjectToHandle(_asyncResumptionStub); + entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); + return ObjectToHandle(asyncResumptionStub); } private static mdToken FindGenericMethodArgTypeSpec(EcmaModule module) diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs index 6a5fcc614bf374..095aa45bfce27e 100644 --- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs +++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs @@ -57,7 +57,7 @@ private UnboxingMethodDesc getUnboxingThunk(MethodDesc method) private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { - _asyncResumptionStub ??= ((CompilerTypeSystemContext)MethodBeingCompiled.Context).GetAsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); + _asyncResumptionStub ??= _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.MethodEntrypoint(_asyncResumptionStub)); return ObjectToHandle(_asyncResumptionStub); From ebed8f82013353dd1453cad8cd09d035d5ce02ab Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Wed, 25 Mar 2026 17:17:59 -0700 Subject: [PATCH 04/18] Remove _asyncResumptionStub field from RyuJit CorInfoImpl Stubs are cached in the type system context hashtable, so the per-compilation field is no longer needed. Also removes the now-unnecessary cleanup in common CorInfoImpl.cs. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs | 4 +--- .../ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs | 7 +++---- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index 43a286f7eb4c43..a7ed29a772cc73 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -703,9 +703,7 @@ private void CompileMethodCleanup() #if !READYTORUN _debugInfo = null; #endif -#if !READYTORUN - _asyncResumptionStub = null; -#endif + _debugLocInfos = null; _debugVarInfos = null; diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs index 095aa45bfce27e..141ca0c60720b6 100644 --- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs +++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs @@ -34,7 +34,6 @@ internal unsafe partial class CorInfoImpl private RyuJitCompilation _compilation; private MethodDebugInformation _debugInfo; - private MethodDesc _asyncResumptionStub; private MethodCodeNode _methodCodeNode; private DebugLocInfo[] _debugLocInfos; private DebugVarInfo[] _debugVarInfos; @@ -57,10 +56,10 @@ private UnboxingMethodDesc getUnboxingThunk(MethodDesc method) private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { - _asyncResumptionStub ??= _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); + MethodDesc asyncResumptionStub = _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType()); - entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.MethodEntrypoint(_asyncResumptionStub)); - return ObjectToHandle(_asyncResumptionStub); + entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.MethodEntrypoint(asyncResumptionStub)); + return ObjectToHandle(asyncResumptionStub); } public void CompileMethod(MethodCodeNode methodCodeNodeNeedingCode, MethodIL methodIL = null) From f4462aa238d116c0705e8afc38d9a3c2539e4fb9 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 09:21:56 -0700 Subject: [PATCH 05/18] Fix extra blank line and guard AddResumptionStubFixup against duplicate calls - Remove extra blank line left in CorInfoImpl.cs cleanup path - Add _resumptionStubFixupAdded bool to prevent duplicate fixups if getAsyncResumptionStub is called multiple times per method Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs | 2 +- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index a7ed29a772cc73..956f19e5e159ad 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -704,7 +704,6 @@ private void CompileMethodCleanup() _debugInfo = null; #endif - _debugLocInfos = null; _debugVarInfos = null; _lastException = null; @@ -718,6 +717,7 @@ private void CompileMethodCleanup() _stashedInlinedMethods.Clear(); _ilBodiesNeeded = null; _synthesizedPgoDependencies = null; + _resumptionStubFixupAdded = false; #endif _instantiationToJitVisibleInstantiation = null; diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index cb670ba2db0cbe..9045396eeb5d53 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -496,10 +496,17 @@ private void AddResumptionStubFixup(MethodWithGCInfo compiledStubNode) _methodCodeNode.Fixups.Add(_compilation.SymbolNodeFactory.ResumptionStubEntryPoint(compiledStubNode)); } + private bool _resumptionStubFixupAdded; + private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { MethodDesc asyncResumptionStub = _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); - AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); + + if (!_resumptionStubFixupAdded) + { + AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); + _resumptionStubFixupAdded = true; + } entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); return ObjectToHandle(asyncResumptionStub); From 437e5a71c371dcf14a3122e2f2f60a40ed9f50d8 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 09:40:41 -0700 Subject: [PATCH 06/18] Remove _resumptionStubFixupAdded guard, rely on existing dedup ResumptionStubEntryPoint is a cached factory (NodeCache) that returns the same node instance for the same input, and GetFixupBlob() already deduplicates at emission time via merge-sort + compaction. This is consistent with how AddPrecodeFixup and other fixup methods work. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs | 1 - .../JitInterface/CorInfoImpl.ReadyToRun.cs | 9 +-------- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index 956f19e5e159ad..b4fde174ed8f6d 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -717,7 +717,6 @@ private void CompileMethodCleanup() _stashedInlinedMethods.Clear(); _ilBodiesNeeded = null; _synthesizedPgoDependencies = null; - _resumptionStubFixupAdded = false; #endif _instantiationToJitVisibleInstantiation = null; diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 9045396eeb5d53..cb670ba2db0cbe 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -496,17 +496,10 @@ private void AddResumptionStubFixup(MethodWithGCInfo compiledStubNode) _methodCodeNode.Fixups.Add(_compilation.SymbolNodeFactory.ResumptionStubEntryPoint(compiledStubNode)); } - private bool _resumptionStubFixupAdded; - private CORINFO_METHOD_STRUCT_* getAsyncResumptionStub(ref void* entryPoint) { MethodDesc asyncResumptionStub = _compilation.TypeSystemContext.GetAsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType); - - if (!_resumptionStubFixupAdded) - { - AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); - _resumptionStubFixupAdded = true; - } + AddResumptionStubFixup(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.CompiledMethodNode(asyncResumptionStub)); return ObjectToHandle(asyncResumptionStub); From 0cbae0133476a6f04aaf185889f6719e4460dfb8 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 10:53:42 -0700 Subject: [PATCH 07/18] Enable cross-module async method inlining in crossgen2 Fix reportInliningDecision to extract EcmaMethod from AsyncMethodVariant using the established GetPrimaryMethodDesc().GetTypicalMethodDefinition() pattern, enabling CheckILBody fixup emission for cross-module async inlinees. Widen _ilBodiesNeeded to List so AsyncMethodVariant is added under its own key, allowing CreateCrossModuleInlineableTokensForILBody to store ManifestModuleWrappedMethodIL under the correct lookup key. This fixes the infinite recompilation loop that occurred when the EcmaMethod key was used instead. Pass ecmaMethod (not typicalMethod) to CrossModuleInlineable and IsNonVersionableWithILTokensThatDoNotNeedTranslation to avoid a latent InvalidCastException when those methods cast GetTypicalMethodDefinition() to EcmaMethod. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ReadyToRun/ILBodyFixupSignature.cs | 5 + .../Compiler/ReadyToRunCodegenCompilation.cs | 7 +- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 34 ++- src/tests/async/async.csproj | 3 + .../async/inline-thunks/helper/helper.cs | 31 ++ .../async/inline-thunks/helper/helper.csproj | 8 + .../async/inline-thunks/inline-thunks.cs | 289 ++++++++++++++++++ .../async/inline-thunks/inline-thunks.csproj | 6 + 8 files changed, 368 insertions(+), 15 deletions(-) create mode 100644 src/tests/async/inline-thunks/helper/helper.cs create mode 100644 src/tests/async/inline-thunks/helper/helper.csproj create mode 100644 src/tests/async/inline-thunks/inline-thunks.cs create mode 100644 src/tests/async/inline-thunks/inline-thunks.csproj diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 45b39e8de77d72..40e2b4867b373d 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -15,6 +15,11 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun { + /// + /// This fixup instructs the runtime to validate that the IL found at runtime matches the hash of the IL computed at compile time. + /// This will use the method IL in metatadata for the EcmaMethod, not what is provided by the ILProvider. Notably, this is different for Async methods, + /// for which the ILProvider used during JIT compilation will return the Task-returning thunk for a runtime-async EcmaMethod. + /// public class ILBodyFixupSignature : Signature, IEquatable { private readonly ReadyToRunFixupKind _fixupKind; diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs index f74ce47a32cf0e..487072488bd146 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs @@ -649,14 +649,19 @@ public bool IsInheritanceChainLayoutFixedInCurrentVersionBubble(TypeDesc type) // The _finishedFirstCompilationRunInPhase2 variable works in concert some checking to ensure that we don't violate any of this model private bool _finishedFirstCompilationRunInPhase2 = false; - public void PrepareForCompilationRetry(MethodWithGCInfo methodToBeRecompiled, IEnumerable methodsThatNeedILBodies) + public void PrepareForCompilationRetry(MethodWithGCInfo methodToBeRecompiled, IEnumerable methodsThatNeedILBodies) { lock (_methodsToRecompile) { _methodsToRecompile.Add(methodToBeRecompiled); if (methodsThatNeedILBodies != null) + { foreach (var method in methodsThatNeedILBodies) + { + Debug.Assert(method.IsMethodDefinition); _methodsWhichNeedMutableILBodies.Add(method); + } + } } } diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 4e82c78b5ead9d..3cae5a603ebf6e 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -474,7 +474,7 @@ unsafe partial class CorInfoImpl private HashSet _inlinedMethods; private UnboxingMethodDescFactory _unboxingThunkFactory = new UnboxingMethodDescFactory(); private List _precodeFixups; - private List _ilBodiesNeeded; + private List _ilBodiesNeeded; private Dictionary _preInitedTypes = new Dictionary(); private HashSet _synthesizedPgoDependencies; public bool HasColdCode { get; private set; } @@ -845,7 +845,7 @@ public void CompileMethod(MethodWithGCInfo methodCodeNodeNeedingCode, Logger log } else { - _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); + _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); _ilBodiesNeeded.Add(ecmaMethod); } } @@ -3338,21 +3338,23 @@ private void reportInliningDecision(CORINFO_METHOD_STRUCT_* inlinerHnd, CORINFO_ { // If a method is implemented by an IL Stub, then we may need to defer creation of the IL body that // we can really emit into the final file. - _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); - _ilBodiesNeeded.Add((EcmaMethod)typicalMethod); + _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); + Debug.Assert(typicalMethod.IsMethodDefinition); + _ilBodiesNeeded.Add(typicalMethod); } - else if (!_compilation.CompilationModuleGroup.VersionsWithMethodBody(typicalMethod) && - typicalMethod is EcmaMethod ecmaMethod) + else if (!_compilation.CompilationModuleGroup.VersionsWithMethodBody(typicalMethod) + && typicalMethod.GetPrimaryMethodDesc().GetTypicalMethodDefinition() is EcmaMethod ecmaMethod) { - // TODO, when we implement the async variant logic we'll need to detect generating the ILBodyFixupSignature here - Debug.Assert(_compilation.CompilationModuleGroup.CrossModuleInlineable(typicalMethod) || - _compilation.CompilationModuleGroup.IsNonVersionableWithILTokensThatDoNotNeedTranslation(typicalMethod)); - bool needsTokenTranslation = !_compilation.CompilationModuleGroup.IsNonVersionableWithILTokensThatDoNotNeedTranslation(typicalMethod); + Debug.Assert(_compilation.CompilationModuleGroup.CrossModuleInlineable(ecmaMethod) || + _compilation.CompilationModuleGroup.IsNonVersionableWithILTokensThatDoNotNeedTranslation(ecmaMethod)); + bool needsTokenTranslation = !_compilation.CompilationModuleGroup.IsNonVersionableWithILTokensThatDoNotNeedTranslation(ecmaMethod); if (needsTokenTranslation) { // This can happen if the method is marked as NonVersionable if there are tokens of interest // or if we are working with a full cross module inline + // The CheckILBodyFixupSignature will use the exact IL in metadata, not what is used by the ReadyToRunILProvider, + // which can be different for runtime-async methods (the ILProvider returns the Task-returning thunk for runtime-async EcmaMethods). ISymbolNode ilBodyNode = _compilation.SymbolNodeFactory.CheckILBodyFixupSignature(ecmaMethod); AddPrecodeFixup(ilBodyNode); } @@ -3363,11 +3365,15 @@ private void reportInliningDecision(CORINFO_METHOD_STRUCT_* inlinerHnd, CORINFO_ // tokens that are useable in compilation, record that information, and once the multi-threaded portion // of the build finishes, it will then compute the IL bodies for those methods, then run the compilation again. - if (needsTokenTranslation && !(methodIL is IMethodTokensAreUseableInCompilation) && methodIL is EcmaMethodIL) + if (needsTokenTranslation && !(methodIL is IMethodTokensAreUseableInCompilation) + && (methodIL is EcmaMethodIL || methodIL is ReadyToRunILProvider.AsyncEcmaMethodIL)) { - // We may have already acquired the right type of MethodIL here, or be working with a method that is an IL Intrinsic - _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); - _ilBodiesNeeded.Add(ecmaMethod); + // We may have already acquired the right type of MethodIL here, or be working with a method that is an IL Intrinsic. + // Add the typicalMethod (which may be an AsyncMethodVariant) so that + // CreateCrossModuleInlineableTokensForILBody stores under the correct key. + _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); + Debug.Assert(typicalMethod.IsMethodDefinition); + _ilBodiesNeeded.Add(typicalMethod); } } } diff --git a/src/tests/async/async.csproj b/src/tests/async/async.csproj index 838e11a3ffe49b..b8d5e51465b8ef 100644 --- a/src/tests/async/async.csproj +++ b/src/tests/async/async.csproj @@ -13,6 +13,9 @@ + + + diff --git a/src/tests/async/inline-thunks/helper/helper.cs b/src/tests/async/inline-thunks/helper/helper.cs new file mode 100644 index 00000000000000..b2da9411c7ff74 --- /dev/null +++ b/src/tests/async/inline-thunks/helper/helper.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; +using System.Threading.Tasks; + +public static class CrossModuleHelper +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static async Task SmallCrossModuleAsync(int x) + { + return x * 3; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static async Task SmallCrossModuleAsyncVoid() + { + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static async ValueTask SmallCrossModuleValueTaskAsync(int x) + { + return x * 3; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int SmallCrossModuleSync(int x) + { + return x * 3; + } +} diff --git a/src/tests/async/inline-thunks/helper/helper.csproj b/src/tests/async/inline-thunks/helper/helper.csproj new file mode 100644 index 00000000000000..5edaa3c7826b83 --- /dev/null +++ b/src/tests/async/inline-thunks/helper/helper.csproj @@ -0,0 +1,8 @@ + + + Library + + + + + diff --git a/src/tests/async/inline-thunks/inline-thunks.cs b/src/tests/async/inline-thunks/inline-thunks.cs new file mode 100644 index 00000000000000..2b86e5b38a3e65 --- /dev/null +++ b/src/tests/async/inline-thunks/inline-thunks.cs @@ -0,0 +1,289 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; +using System.Threading.Tasks; +using Xunit; + +public class InlineThunks +{ + // Test that the task-returning thunk of an async method can be inlined + // into a non-async caller. The caller invokes the async method normally + // (getting back a Task), so the JIT sees the task-returning thunk as the + // callee. With a simplified thunk (no EH), this should be inlineable. + [Fact] + public static void TestInlineTaskReturningThunk() + { + int result = CallAsyncAndGetResult(10).GetAwaiter().GetResult(); + Assert.Equal(20, result); + } + + [Fact] + public static void TestInlineTaskReturningThunkVoid() + { + CallAsyncVoid().GetAwaiter().GetResult(); + } + + [Fact] + public static void TestInlineValueTaskReturningThunk() + { + int result = CallAsyncValueTask(5).GetAwaiter().GetResult(); + Assert.Equal(10, result); + } + + // Test that the async variant (the runtime-async body) of a small method + // can be inlined into an async caller. + [Fact] + public static void TestInlineAsyncVariant() + { + int result = AsyncCallerOfSmallAsync(7).GetAwaiter().GetResult(); + Assert.Equal(14, result); + } + + [Fact] + public static void TestInlineAsyncVariantVoid() + { + AsyncCallerOfSmallAsyncVoid().GetAwaiter().GetResult(); + } + + [Fact] + public static void TestInlineAsyncVariantValueTask() + { + int result = AsyncCallerOfSmallValueTaskAsync(3).GetAwaiter().GetResult(); + Assert.Equal(6, result); + } + + // --- Task-returning thunk inlining targets --- + // These are non-async methods whose bodies should be small enough + // to inline the task-returning thunk of the async callee. + // Each uses a dedicated callee to avoid poisoning the inline cache + // for the async-variant tests below. + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallAsyncAndGetResult(int x) + { + return SmallAsyncForThunk(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallAsyncVoid() + { + return SmallAsyncVoidForThunk(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static ValueTask CallAsyncValueTask(int x) + { + return SmallValueTaskAsyncForThunk(x); + } + + // --- Async variant inlining targets --- + // These are async methods that await small async methods. + // The async variant (runtime-async body) of the callee should be inlineable. + // Each uses a dedicated callee so the inline cache is not poisoned by + // earlier task-returning thunk failures (CALLEE_AWAIT). + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallAsync(int x) + { + return await SmallAsyncForVariant(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallAsyncVoid() + { + await SmallAsyncVoidForVariant(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallValueTaskAsync(int x) + { + return await SmallValueTaskAsyncForVariant(x); + } + + // --- Non-runtime-async (state machine) inlining targets --- + // These callers invoke traditional async state machine methods + // (opted out of runtime async). The thunks generated by Roslyn + // should still be inlineable. + + [Fact] + public static void TestInlineNonRuntimeAsyncNotAwaited() + { + int result = CallNonRuntimeAsync(4).GetAwaiter().GetResult(); + Assert.Equal(8, result); + } + + [Fact] + public static void TestInlineNonRuntimeAsyncAwaited() + { + int result = AwaitNonRuntimeAsync(6).GetAwaiter().GetResult(); + Assert.Equal(12, result); + } + + [Fact] + public static void TestInlineNonRuntimeAsyncValueTaskNotAwaited() + { + int result = CallNonRuntimeValueTaskAsync(9).GetAwaiter().GetResult(); + Assert.Equal(18, result); + } + + [Fact] + public static void TestInlineNonRuntimeAsyncValueTaskAwaited() + { + int result = AwaitNonRuntimeValueTaskAsync(11).GetAwaiter().GetResult(); + Assert.Equal(22, result); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallNonRuntimeAsync(int x) + { + return SmallNonRuntimeAsync(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AwaitNonRuntimeAsync(int x) + { + return await SmallNonRuntimeAsync(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static ValueTask CallNonRuntimeValueTaskAsync(int x) + { + return SmallNonRuntimeValueTaskAsync(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AwaitNonRuntimeValueTaskAsync(int x) + { + return await SmallNonRuntimeValueTaskAsync(x); + } + + // --- Small async methods for task-returning thunk tests --- + // Only called from non-async callers (thunk inlining). + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncForThunk(int x) + { + return x * 2; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncVoidForThunk() + { + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async ValueTask SmallValueTaskAsyncForThunk(int x) + { + return x * 2; + } + + // --- Small async methods for async variant tests --- + // Only called from async callers (variant inlining). + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncForVariant(int x) + { + return x * 2; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncVoidForVariant() + { + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async ValueTask SmallValueTaskAsyncForVariant(int x) + { + return x * 2; + } + + // --- Small async methods (non-runtime-async / traditional state machine) --- + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [RuntimeAsyncMethodGeneration(false)] + private static async Task SmallNonRuntimeAsync(int x) + { + return x * 2; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [RuntimeAsyncMethodGeneration(false)] + private static async ValueTask SmallNonRuntimeValueTaskAsync(int x) + { + return x * 2; + } + + // --- Cross-module async variant inlining --- + // These async callers await small async methods from a separate assembly + // (helper.dll). The async variant of the cross-module callee should be + // inlineable, and the R2R image should contain a CheckILBody fixup. + + [Fact] + public static void TestCrossModuleAsyncVariant() + { + int result = CrossModuleAsyncCaller(5).GetAwaiter().GetResult(); + Assert.Equal(15, result); + } + + [Fact] + public static void TestCrossModuleAsyncVariantVoid() + { + CrossModuleAsyncCallerVoid().GetAwaiter().GetResult(); + } + + [Fact] + public static void TestCrossModuleAsyncVariantValueTask() + { + int result = CrossModuleAsyncCallerValueTask(4).GetAwaiter().GetResult(); + Assert.Equal(12, result); + } + + [Fact] + public static void TestCrossModuleTaskReturningThunk() + { + int result = CrossModuleCallAsync(8).GetAwaiter().GetResult(); + Assert.Equal(24, result); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCaller(int x) + { + return await CrossModuleHelper.SmallCrossModuleAsync(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCallerVoid() + { + await CrossModuleHelper.SmallCrossModuleAsyncVoid(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCallerValueTask(int x) + { + return await CrossModuleHelper.SmallCrossModuleValueTaskAsync(x); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CrossModuleCallAsync(int x) + { + return CrossModuleHelper.SmallCrossModuleAsync(x); + } + + // --- Cross-module sync baseline --- + // Non-async cross-module inline as a baseline to verify cross-module + // inlining infrastructure works independently of async. + + [Fact] + public static void TestCrossModuleSyncBaseline() + { + int result = CrossModuleSyncCaller(7); + Assert.Equal(21, result); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CrossModuleSyncCaller(int x) + { + return CrossModuleHelper.SmallCrossModuleSync(x); + } +} diff --git a/src/tests/async/inline-thunks/inline-thunks.csproj b/src/tests/async/inline-thunks/inline-thunks.csproj new file mode 100644 index 00000000000000..cb168d4988f752 --- /dev/null +++ b/src/tests/async/inline-thunks/inline-thunks.csproj @@ -0,0 +1,6 @@ + + + + + + From de28114496130b35792124b80d6f591c62bb42e6 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 11:08:06 -0700 Subject: [PATCH 08/18] Fix CreateCrossModuleInlineableTokensForILBody ordering for async variants Check IsAsyncVariant() before IsAsync in CreateCrossModuleInlineableTokensForILBody because AsyncMethodVariant delegates IsAsync to its target, so both would be true. The variant needs either the async thunk IL (for compiler-generated) or the AsyncEcmaMethodIL (for runtime-async with MethodImpl flag), not the task-returning thunk. Fix test project SDK from Microsoft.NET.Sdk.IL to Microsoft.NET.Sdk. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../IL/ReadyToRunILProvider.cs | 40 +++++++++++++------ .../async/inline-thunks/helper/helper.csproj | 2 +- .../async/inline-thunks/inline-thunks.csproj | 2 +- 3 files changed, 29 insertions(+), 15 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/ReadyToRunILProvider.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/ReadyToRunILProvider.cs index 5460cad265c0d6..690123979a0742 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/ReadyToRunILProvider.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IL/ReadyToRunILProvider.cs @@ -135,24 +135,38 @@ public void CreateCrossModuleInlineableTokensForILBody(MethodDesc method) Debug.Assert(_manifestMutableModule != null); var wrappedMethodIL = new ManifestModuleWrappedMethodIL(); - if (method.IsAsync) + // Check IsAsyncVariant() before IsAsync because AsyncMethodVariant delegates IsAsync to its target, + // so both would be true. The variant needs the async thunk IL, not the task-returning thunk. + if (method.IsAsyncVariant()) { - Debug.Assert(NeedsTaskReturningThunk(method)); - if (!wrappedMethodIL.Initialize(_manifestMutableModule, GetMethodILForAsyncMethod(method), (EcmaMethod)method, false)) + var amv = (AsyncMethodVariant)method; + if (NeedsAsyncThunk(method)) { - // If we could not initialize the wrapped method IL, we should store a null. - // That will result in the IL code for the method being unavailable for use in - // the compilation, which is version safe. - wrappedMethodIL = null; + if (!wrappedMethodIL.Initialize(_manifestMutableModule, + AsyncThunkILEmitter.EmitAsyncMethodThunk(method, method.GetTargetOfAsyncVariant()), + method, + false)) + { + wrappedMethodIL = null; + } + } + else + { + // The async variant uses real ECMA IL (method has MethodImplAttributes.Async flag). + // Wrap the AsyncEcmaMethodIL for cross-module token translation. + if (!wrappedMethodIL.Initialize(_manifestMutableModule, + new AsyncEcmaMethodIL(amv, EcmaMethodIL.Create(amv.Target)), + method, + false)) + { + wrappedMethodIL = null; + } } } - else if (method.IsAsyncVariant()) + else if (method.IsAsync) { - Debug.Assert(NeedsAsyncThunk(method)); - if (!wrappedMethodIL.Initialize(_manifestMutableModule, - AsyncThunkILEmitter.EmitAsyncMethodThunk(method, method.GetTargetOfAsyncVariant()), - method, - false)) + Debug.Assert(NeedsTaskReturningThunk(method)); + if (!wrappedMethodIL.Initialize(_manifestMutableModule, GetMethodILForAsyncMethod(method), (EcmaMethod)method, false)) { // If we could not initialize the wrapped method IL, we should store a null. // That will result in the IL code for the method being unavailable for use in diff --git a/src/tests/async/inline-thunks/helper/helper.csproj b/src/tests/async/inline-thunks/helper/helper.csproj index 5edaa3c7826b83..2a76e8a13122a0 100644 --- a/src/tests/async/inline-thunks/helper/helper.csproj +++ b/src/tests/async/inline-thunks/helper/helper.csproj @@ -1,4 +1,4 @@ - + Library diff --git a/src/tests/async/inline-thunks/inline-thunks.csproj b/src/tests/async/inline-thunks/inline-thunks.csproj index cb168d4988f752..0c690e7d99c88e 100644 --- a/src/tests/async/inline-thunks/inline-thunks.csproj +++ b/src/tests/async/inline-thunks/inline-thunks.csproj @@ -1,4 +1,4 @@ - + From 284c58dd18aa4d9dfcddde104af207cfbeb614e6 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 11:46:25 -0700 Subject: [PATCH 09/18] Move async inline test to readytorun tree with crossgen2 precommands Move inline-thunks test from src/tests/async/ to src/tests/readytorun/ async-inline-thunks/ so it exercises the --opt-cross-module crossgen2 path in CI. The test csproj uses CLRTestBashPreCommands/CLRTestBatchPreCommands to manually invoke crossgen2 with -O --opt-cross-module:helper, following the pattern established by readytorun/tests/mainv1.csproj. Convert from xunit [Fact] pattern to return-100 pattern used by CLR tests. Import runtime-async props (Features=runtime-async=on) and the RuntimeAsyncMethodGenerationAttribute directly since the test is no longer under the async Directory.Build.props. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/tests/async/async.csproj | 3 - .../async/inline-thunks/inline-thunks.cs | 289 ------------------ .../async/inline-thunks/inline-thunks.csproj | 6 - .../RuntimeAsyncMethodGenerationAttribute.cs | 10 + .../async-inline-thunks.cs | 155 ++++++++++ .../async-inline-thunks.csproj | 105 +++++++ .../async-inline-thunks}/helper/helper.cs | 0 .../async-inline-thunks}/helper/helper.csproj | 2 + 8 files changed, 272 insertions(+), 298 deletions(-) delete mode 100644 src/tests/async/inline-thunks/inline-thunks.cs delete mode 100644 src/tests/async/inline-thunks/inline-thunks.csproj create mode 100644 src/tests/readytorun/async-inline-thunks/RuntimeAsyncMethodGenerationAttribute.cs create mode 100644 src/tests/readytorun/async-inline-thunks/async-inline-thunks.cs create mode 100644 src/tests/readytorun/async-inline-thunks/async-inline-thunks.csproj rename src/tests/{async/inline-thunks => readytorun/async-inline-thunks}/helper/helper.cs (100%) rename src/tests/{async/inline-thunks => readytorun/async-inline-thunks}/helper/helper.csproj (56%) diff --git a/src/tests/async/async.csproj b/src/tests/async/async.csproj index b8d5e51465b8ef..838e11a3ffe49b 100644 --- a/src/tests/async/async.csproj +++ b/src/tests/async/async.csproj @@ -13,9 +13,6 @@ - - - diff --git a/src/tests/async/inline-thunks/inline-thunks.cs b/src/tests/async/inline-thunks/inline-thunks.cs deleted file mode 100644 index 2b86e5b38a3e65..00000000000000 --- a/src/tests/async/inline-thunks/inline-thunks.cs +++ /dev/null @@ -1,289 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Runtime.CompilerServices; -using System.Threading.Tasks; -using Xunit; - -public class InlineThunks -{ - // Test that the task-returning thunk of an async method can be inlined - // into a non-async caller. The caller invokes the async method normally - // (getting back a Task), so the JIT sees the task-returning thunk as the - // callee. With a simplified thunk (no EH), this should be inlineable. - [Fact] - public static void TestInlineTaskReturningThunk() - { - int result = CallAsyncAndGetResult(10).GetAwaiter().GetResult(); - Assert.Equal(20, result); - } - - [Fact] - public static void TestInlineTaskReturningThunkVoid() - { - CallAsyncVoid().GetAwaiter().GetResult(); - } - - [Fact] - public static void TestInlineValueTaskReturningThunk() - { - int result = CallAsyncValueTask(5).GetAwaiter().GetResult(); - Assert.Equal(10, result); - } - - // Test that the async variant (the runtime-async body) of a small method - // can be inlined into an async caller. - [Fact] - public static void TestInlineAsyncVariant() - { - int result = AsyncCallerOfSmallAsync(7).GetAwaiter().GetResult(); - Assert.Equal(14, result); - } - - [Fact] - public static void TestInlineAsyncVariantVoid() - { - AsyncCallerOfSmallAsyncVoid().GetAwaiter().GetResult(); - } - - [Fact] - public static void TestInlineAsyncVariantValueTask() - { - int result = AsyncCallerOfSmallValueTaskAsync(3).GetAwaiter().GetResult(); - Assert.Equal(6, result); - } - - // --- Task-returning thunk inlining targets --- - // These are non-async methods whose bodies should be small enough - // to inline the task-returning thunk of the async callee. - // Each uses a dedicated callee to avoid poisoning the inline cache - // for the async-variant tests below. - - [MethodImpl(MethodImplOptions.NoInlining)] - private static Task CallAsyncAndGetResult(int x) - { - return SmallAsyncForThunk(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static Task CallAsyncVoid() - { - return SmallAsyncVoidForThunk(); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static ValueTask CallAsyncValueTask(int x) - { - return SmallValueTaskAsyncForThunk(x); - } - - // --- Async variant inlining targets --- - // These are async methods that await small async methods. - // The async variant (runtime-async body) of the callee should be inlineable. - // Each uses a dedicated callee so the inline cache is not poisoned by - // earlier task-returning thunk failures (CALLEE_AWAIT). - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task AsyncCallerOfSmallAsync(int x) - { - return await SmallAsyncForVariant(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task AsyncCallerOfSmallAsyncVoid() - { - await SmallAsyncVoidForVariant(); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task AsyncCallerOfSmallValueTaskAsync(int x) - { - return await SmallValueTaskAsyncForVariant(x); - } - - // --- Non-runtime-async (state machine) inlining targets --- - // These callers invoke traditional async state machine methods - // (opted out of runtime async). The thunks generated by Roslyn - // should still be inlineable. - - [Fact] - public static void TestInlineNonRuntimeAsyncNotAwaited() - { - int result = CallNonRuntimeAsync(4).GetAwaiter().GetResult(); - Assert.Equal(8, result); - } - - [Fact] - public static void TestInlineNonRuntimeAsyncAwaited() - { - int result = AwaitNonRuntimeAsync(6).GetAwaiter().GetResult(); - Assert.Equal(12, result); - } - - [Fact] - public static void TestInlineNonRuntimeAsyncValueTaskNotAwaited() - { - int result = CallNonRuntimeValueTaskAsync(9).GetAwaiter().GetResult(); - Assert.Equal(18, result); - } - - [Fact] - public static void TestInlineNonRuntimeAsyncValueTaskAwaited() - { - int result = AwaitNonRuntimeValueTaskAsync(11).GetAwaiter().GetResult(); - Assert.Equal(22, result); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static Task CallNonRuntimeAsync(int x) - { - return SmallNonRuntimeAsync(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task AwaitNonRuntimeAsync(int x) - { - return await SmallNonRuntimeAsync(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static ValueTask CallNonRuntimeValueTaskAsync(int x) - { - return SmallNonRuntimeValueTaskAsync(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task AwaitNonRuntimeValueTaskAsync(int x) - { - return await SmallNonRuntimeValueTaskAsync(x); - } - - // --- Small async methods for task-returning thunk tests --- - // Only called from non-async callers (thunk inlining). - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async Task SmallAsyncForThunk(int x) - { - return x * 2; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async Task SmallAsyncVoidForThunk() - { - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async ValueTask SmallValueTaskAsyncForThunk(int x) - { - return x * 2; - } - - // --- Small async methods for async variant tests --- - // Only called from async callers (variant inlining). - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async Task SmallAsyncForVariant(int x) - { - return x * 2; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async Task SmallAsyncVoidForVariant() - { - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static async ValueTask SmallValueTaskAsyncForVariant(int x) - { - return x * 2; - } - - // --- Small async methods (non-runtime-async / traditional state machine) --- - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - [RuntimeAsyncMethodGeneration(false)] - private static async Task SmallNonRuntimeAsync(int x) - { - return x * 2; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - [RuntimeAsyncMethodGeneration(false)] - private static async ValueTask SmallNonRuntimeValueTaskAsync(int x) - { - return x * 2; - } - - // --- Cross-module async variant inlining --- - // These async callers await small async methods from a separate assembly - // (helper.dll). The async variant of the cross-module callee should be - // inlineable, and the R2R image should contain a CheckILBody fixup. - - [Fact] - public static void TestCrossModuleAsyncVariant() - { - int result = CrossModuleAsyncCaller(5).GetAwaiter().GetResult(); - Assert.Equal(15, result); - } - - [Fact] - public static void TestCrossModuleAsyncVariantVoid() - { - CrossModuleAsyncCallerVoid().GetAwaiter().GetResult(); - } - - [Fact] - public static void TestCrossModuleAsyncVariantValueTask() - { - int result = CrossModuleAsyncCallerValueTask(4).GetAwaiter().GetResult(); - Assert.Equal(12, result); - } - - [Fact] - public static void TestCrossModuleTaskReturningThunk() - { - int result = CrossModuleCallAsync(8).GetAwaiter().GetResult(); - Assert.Equal(24, result); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task CrossModuleAsyncCaller(int x) - { - return await CrossModuleHelper.SmallCrossModuleAsync(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task CrossModuleAsyncCallerVoid() - { - await CrossModuleHelper.SmallCrossModuleAsyncVoid(); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static async Task CrossModuleAsyncCallerValueTask(int x) - { - return await CrossModuleHelper.SmallCrossModuleValueTaskAsync(x); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static Task CrossModuleCallAsync(int x) - { - return CrossModuleHelper.SmallCrossModuleAsync(x); - } - - // --- Cross-module sync baseline --- - // Non-async cross-module inline as a baseline to verify cross-module - // inlining infrastructure works independently of async. - - [Fact] - public static void TestCrossModuleSyncBaseline() - { - int result = CrossModuleSyncCaller(7); - Assert.Equal(21, result); - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static int CrossModuleSyncCaller(int x) - { - return CrossModuleHelper.SmallCrossModuleSync(x); - } -} diff --git a/src/tests/async/inline-thunks/inline-thunks.csproj b/src/tests/async/inline-thunks/inline-thunks.csproj deleted file mode 100644 index 0c690e7d99c88e..00000000000000 --- a/src/tests/async/inline-thunks/inline-thunks.csproj +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/src/tests/readytorun/async-inline-thunks/RuntimeAsyncMethodGenerationAttribute.cs b/src/tests/readytorun/async-inline-thunks/RuntimeAsyncMethodGenerationAttribute.cs new file mode 100644 index 00000000000000..e481c3bcefd748 --- /dev/null +++ b/src/tests/readytorun/async-inline-thunks/RuntimeAsyncMethodGenerationAttribute.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Runtime.CompilerServices; + +[AttributeUsage(AttributeTargets.Method)] +internal class RuntimeAsyncMethodGenerationAttribute(bool runtimeAsync) : Attribute +{ + public bool RuntimeAsync { get; } = runtimeAsync; +} diff --git a/src/tests/readytorun/async-inline-thunks/async-inline-thunks.cs b/src/tests/readytorun/async-inline-thunks/async-inline-thunks.cs new file mode 100644 index 00000000000000..be22f5244fa384 --- /dev/null +++ b/src/tests/readytorun/async-inline-thunks/async-inline-thunks.cs @@ -0,0 +1,155 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.CompilerServices; +using System.Threading.Tasks; + +public class InlineThunks +{ + static bool s_failed; + + static void Check(string testName, int expected, int actual) + { + if (expected != actual) + { + Console.WriteLine($" FAILED: {testName} — expected {expected}, got {actual}"); + s_failed = true; + } + } + + static void CheckNoThrow(string testName, Action action) + { + try + { + action(); + } + catch (Exception ex) + { + Console.WriteLine($" FAILED: {testName} — threw {ex.GetType().Name}: {ex.Message}"); + s_failed = true; + } + } + + public static int Main() + { + // Task-returning thunk inlining (non-async caller → async callee) + Check("TaskReturningThunk", 20, CallAsyncAndGetResult(10).GetAwaiter().GetResult()); + CheckNoThrow("TaskReturningThunkVoid", () => CallAsyncVoid().GetAwaiter().GetResult()); + Check("ValueTaskReturningThunk", 10, CallAsyncValueTask(5).GetAwaiter().GetResult()); + + // Async variant inlining (async caller → async callee) + Check("AsyncVariant", 14, AsyncCallerOfSmallAsync(7).GetAwaiter().GetResult()); + CheckNoThrow("AsyncVariantVoid", () => AsyncCallerOfSmallAsyncVoid().GetAwaiter().GetResult()); + Check("AsyncVariantValueTask", 6, AsyncCallerOfSmallValueTaskAsync(3).GetAwaiter().GetResult()); + + // Non-runtime-async (traditional state machine) inlining + Check("NonRuntimeAsyncNotAwaited", 8, CallNonRuntimeAsync(4).GetAwaiter().GetResult()); + Check("NonRuntimeAsyncAwaited", 12, AwaitNonRuntimeAsync(6).GetAwaiter().GetResult()); + Check("NonRuntimeValueTaskNotAwaited", 18, CallNonRuntimeValueTaskAsync(9).GetAwaiter().GetResult()); + Check("NonRuntimeValueTaskAwaited", 22, AwaitNonRuntimeValueTaskAsync(11).GetAwaiter().GetResult()); + + // Cross-module async inlining (helper.dll) + Check("CrossModuleAsyncVariant", 15, CrossModuleAsyncCaller(5).GetAwaiter().GetResult()); + CheckNoThrow("CrossModuleAsyncVariantVoid", () => CrossModuleAsyncCallerVoid().GetAwaiter().GetResult()); + Check("CrossModuleAsyncVariantValueTask", 12, CrossModuleAsyncCallerValueTask(4).GetAwaiter().GetResult()); + Check("CrossModuleTaskReturningThunk", 24, CrossModuleCallAsync(8).GetAwaiter().GetResult()); + + // Cross-module sync baseline + Check("CrossModuleSyncBaseline", 21, CrossModuleSyncCaller(7)); + + if (!s_failed) + Console.WriteLine("PASSED"); + else + Console.WriteLine("FAILED"); + + return s_failed ? 1 : 100; + } + + // --- Task-returning thunk inlining targets --- + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallAsyncAndGetResult(int x) => SmallAsyncForThunk(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallAsyncVoid() => SmallAsyncVoidForThunk(); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static ValueTask CallAsyncValueTask(int x) => SmallValueTaskAsyncForThunk(x); + + // --- Async variant inlining targets --- + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallAsync(int x) => await SmallAsyncForVariant(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallAsyncVoid() => await SmallAsyncVoidForVariant(); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AsyncCallerOfSmallValueTaskAsync(int x) => await SmallValueTaskAsyncForVariant(x); + + // --- Non-runtime-async callers --- + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CallNonRuntimeAsync(int x) => SmallNonRuntimeAsync(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AwaitNonRuntimeAsync(int x) => await SmallNonRuntimeAsync(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static ValueTask CallNonRuntimeValueTaskAsync(int x) => SmallNonRuntimeValueTaskAsync(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task AwaitNonRuntimeValueTaskAsync(int x) => await SmallNonRuntimeValueTaskAsync(x); + + // --- Small async methods (runtime-async, for thunk tests) --- + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncForThunk(int x) => x * 2; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncVoidForThunk() { } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async ValueTask SmallValueTaskAsyncForThunk(int x) => x * 2; + + // --- Small async methods (runtime-async, for variant tests) --- + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncForVariant(int x) => x * 2; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async Task SmallAsyncVoidForVariant() { } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static async ValueTask SmallValueTaskAsyncForVariant(int x) => x * 2; + + // --- Small async methods (non-runtime-async / traditional state machine) --- + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [RuntimeAsyncMethodGeneration(false)] + private static async Task SmallNonRuntimeAsync(int x) => x * 2; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [RuntimeAsyncMethodGeneration(false)] + private static async ValueTask SmallNonRuntimeValueTaskAsync(int x) => x * 2; + + // --- Cross-module async callers --- + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCaller(int x) => await CrossModuleHelper.SmallCrossModuleAsync(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCallerVoid() => await CrossModuleHelper.SmallCrossModuleAsyncVoid(); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static async Task CrossModuleAsyncCallerValueTask(int x) => await CrossModuleHelper.SmallCrossModuleValueTaskAsync(x); + + [MethodImpl(MethodImplOptions.NoInlining)] + private static Task CrossModuleCallAsync(int x) => CrossModuleHelper.SmallCrossModuleAsync(x); + + // --- Cross-module sync baseline --- + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CrossModuleSyncCaller(int x) => CrossModuleHelper.SmallCrossModuleSync(x); +} diff --git a/src/tests/readytorun/async-inline-thunks/async-inline-thunks.csproj b/src/tests/readytorun/async-inline-thunks/async-inline-thunks.csproj new file mode 100644 index 00000000000000..52eb3c331b841c --- /dev/null +++ b/src/tests/readytorun/async-inline-thunks/async-inline-thunks.csproj @@ -0,0 +1,105 @@ + + + true + false + false + true + $(Features);runtime-async=on + + true + + true + + + + + + + + + + NUL +copy /y async-inline-thunks.dll IL_DLLS\async-inline-thunks.dll +if not exist IL_DLLS\async-inline-thunks.dll ( + echo FAILED to copy async-inline-thunks.dll to IL_DLLS + exit /b 1 +) + +REM Crossgen2 the helper library +%Core_Root%\crossgen2\crossgen2.exe -O -r:%Core_Root%\*.dll -r:%25CD%\IL_DLLS\async-inline-thunks.dll -o:helper.dll helper\helper\helper.dll + +set CrossGenStatus=!ERRORLEVEL! +IF NOT !CrossGenStatus!==0 ( + ECHO Crossgen of helper.dll failed with exitcode - !CrossGenStatus! + Exit /b 1 +) + +REM Crossgen2 the main test with cross-module inlining from helper +%Core_Root%\crossgen2\crossgen2.exe -O --opt-cross-module:helper -r:%Core_Root%\*.dll -r:helper\helper\helper.dll -o:async-inline-thunks.dll IL_DLLS\async-inline-thunks.dll + +set CrossGenStatus=!ERRORLEVEL! +IF NOT !CrossGenStatus!==0 ( + ECHO Crossgen of async-inline-thunks.dll failed with exitcode - !CrossGenStatus! + Exit /b 1 +) + +endlocal +]]> + + + + + + $(OutputPath)/../helper/helper/ + $(OutputPath)/helper/helper + + + + + diff --git a/src/tests/async/inline-thunks/helper/helper.cs b/src/tests/readytorun/async-inline-thunks/helper/helper.cs similarity index 100% rename from src/tests/async/inline-thunks/helper/helper.cs rename to src/tests/readytorun/async-inline-thunks/helper/helper.cs diff --git a/src/tests/async/inline-thunks/helper/helper.csproj b/src/tests/readytorun/async-inline-thunks/helper/helper.csproj similarity index 56% rename from src/tests/async/inline-thunks/helper/helper.csproj rename to src/tests/readytorun/async-inline-thunks/helper/helper.csproj index 2a76e8a13122a0..59894cc101f610 100644 --- a/src/tests/async/inline-thunks/helper/helper.csproj +++ b/src/tests/readytorun/async-inline-thunks/helper/helper.csproj @@ -1,8 +1,10 @@ Library + $(Features);runtime-async=on + From d8f0fc88d98f7d128a66d04d12a3fe714365295c Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 16:18:11 -0700 Subject: [PATCH 10/18] Fix XML doc tag casing and typo in ILBodyFixupSignature Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- inthunk.r2rdump | 6709 +++++++++++++++++ .../ReadyToRun/ILBodyFixupSignature.cs | 6 +- 2 files changed, 6712 insertions(+), 3 deletions(-) create mode 100644 inthunk.r2rdump diff --git a/inthunk.r2rdump b/inthunk.r2rdump new file mode 100644 index 00000000000000..6e644b169acf35 --- /dev/null +++ b/inthunk.r2rdump @@ -0,0 +1,6709 @@ +Filename: /home/jtschuster/src/runtime-async-inline/artifacts/tests/coreclr/linux.x64.Debug/readytorun/async-inline-thunks/async-inline-thunks/async-inline-thunks.dll +OS: Linux +Machine: Amd64 +ImageBase: 0x140000000 + +======================== R2R Methods ======================== + +56 methods + +_______________________________________________ + +void InlineThunks.Check(string, int, int) +Handle: 0x06000001 +Rid: 1 +EntryPointRuntimeFunctionId: 0 +Number of RuntimeFunctions: 1 +Number of fixups: 4 + TableIndex 5, Offset 000F: System.Runtime.CompilerServices.DefaultInterpolatedStringHandler Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 40 Align native GCLayout 0x3 (CHECK_TYPE_LAYOUT) + TableIndex 6, Offset 0000: " FAILED: " (STRING_HANDLE) + TableIndex 6, Offset 0001: " — expected " (STRING_HANDLE) + TableIndex 6, Offset 0002: ", got " (STRING_HANDLE) + +void InlineThunks.Check(string, int, int) +Id: 0 +StartAddress: 0x00011360 +Size: 205 bytes +UnwindRVA: 0x00010850 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000A +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 59 65 02 02 3A 19 4A 20 A2 34 A2 4E 6A 60 A2 7A +00000010: 62 8C A2 A6 6A B8 9A D2 4A E0 02 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x27, IL Offset: 0x0009, Source Types: StackEmpty + Native Offset: 0x30, IL Offset: 0x000d, Source Types: StackEmpty + Native Offset: 0x44, IL Offset: 0x0017, Source Types: StackEmpty + Native Offset: 0x58, IL Offset: 0x0024, Source Types: StackEmpty + Native Offset: 0x65, IL Offset: 0x002d, Source Types: StackEmpty + Native Offset: 0x79, IL Offset: 0x003a, Source Types: StackEmpty + Native Offset: 0x85, IL Offset: 0x0043, Source Types: StackEmpty + Native Offset: 0x99, IL Offset: 0x0050, Source Types: StackEmpty + Native Offset: 0xA6, IL Offset: 0x0059, Source Types: StackEmpty + Native Offset: 0xB9, IL Offset: 0x0066, Source Types: StackEmpty + Native Offset: 0xC2, IL Offset: 0x006d, Source Types: StackEmpty + Native Offset: 0xC2, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x27 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x27 + End Offset: 0x5C + Loc Type: VLT_REG + Register: R14 + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x27 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 1 + Start Offset: 0x27 + End Offset: 0x7D + Loc Type: VLT_REG + Register: RBX + + Variable Number: 2 + Start Offset: 0x0 + End Offset: 0x27 + Loc Type: VLT_REG + Register: RDX + + Variable Number: 2 + Start Offset: 0x27 + End Offset: 0x9D + Loc Type: VLT_REG + Register: R15 + +11360: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11361: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +11363: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +11365: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11366: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +1136a: 48 8d 6c 24 40 lea rbp, [rsp + 64] +1136f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11374: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 +11379: 33 c0 xor eax, eax +1137b: 48 89 45 e0 mov qword ptr [rbp - 32], rax +1137f: 4c 8b f7 mov r14, rdi +11382: 8b de mov ebx, esi +11384: 44 8b fa mov r15d, edx +11387: 41 3b df cmp ebx, r15d +1138a: 0f 84 92 00 00 00 je 0x11422 +11390: 48 8d 7d c0 lea rdi, [rbp - 64] +11394: be 1c 00 00 00 mov esi, 28 +11399: ba 03 00 00 00 mov edx, 3 +1139e: ff 15 2c 40 02 00 call qword ptr [0x353d0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler..ctor(int, int) (METHOD_ENTRY_REF_TOKEN) +113a4: 48 8b 35 25 43 02 00 mov rsi, qword ptr [0x356d0] // " FAILED: " (STRING_HANDLE) +113ab: 48 8b 36 mov rsi, qword ptr [rsi] +113ae: 48 8d 7d c0 lea rdi, [rbp - 64] +113b2: ff 15 28 40 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) +113b8: 48 8d 7d c0 lea rdi, [rbp - 64] +113bc: 49 8b f6 mov rsi, r14 +113bf: ff 15 23 40 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) +113c5: 48 8b 35 0c 43 02 00 mov rsi, qword ptr [0x356d8] // " — expected " (STRING_HANDLE) +113cc: 48 8b 36 mov rsi, qword ptr [rsi] +113cf: 48 8d 7d c0 lea rdi, [rbp - 64] +113d3: ff 15 07 40 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) +113d9: 48 8d 7d c0 lea rdi, [rbp - 64] +113dd: 8b f3 mov esi, ebx +113df: ff 15 b3 40 02 00 call qword ptr [0x35498] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(!!0) (METHOD_ENTRY) +113e5: 48 8b 35 f4 42 02 00 mov rsi, qword ptr [0x356e0] // ", got " (STRING_HANDLE) +113ec: 48 8b 36 mov rsi, qword ptr [rsi] +113ef: 48 8d 7d c0 lea rdi, [rbp - 64] +113f3: ff 15 e7 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) +113f9: 48 8d 7d c0 lea rdi, [rbp - 64] +113fd: 41 8b f7 mov esi, r15d +11400: ff 15 92 40 02 00 call qword ptr [0x35498] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(!!0) (METHOD_ENTRY) +11406: 48 8d 7d c0 lea rdi, [rbp - 64] +1140a: ff 15 c8 3f 02 00 call qword ptr [0x353d8] // string System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear() (METHOD_ENTRY_REF_TOKEN) +11410: 48 8b f8 mov rdi, rax +11413: ff 15 57 3f 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) +11419: ff 15 09 3f 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) +1141f: c6 00 01 mov byte ptr [rax], 1 +11422: 48 83 c4 28 add rsp, 40 +11426: 5b pop rbx +11427: 41 5e pop r14 +11429: 41 5f pop r15 +1142b: 5d pop rbp +1142c: c3 ret + +_______________________________________________ + +void InlineThunks.CheckNoThrow(string, System.Action) +Handle: 0x06000002 +Rid: 2 +EntryPointRuntimeFunctionId: 1 +Number of RuntimeFunctions: 2 +Number of fixups: 5 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000F: System.Runtime.CompilerServices.DefaultInterpolatedStringHandler Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 40 Align native GCLayout 0x3 (CHECK_TYPE_LAYOUT) + TableIndex 6, Offset 0000: " FAILED: " (STRING_HANDLE) + TableIndex 6, Offset 0003: " — threw " (STRING_HANDLE) + TableIndex 6, Offset 0004: ": " (STRING_HANDLE) + +void InlineThunks.CheckNoThrow(string, System.Action) +Id: 1 +StartAddress: 0x00011430 +Size: 46 bytes +UnwindRVA: 0x0001087C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 56 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13060, #clauses = 1 +Flags 00 TryOff 001F (RVA 1144F) TryEnd 0027 (RVA 11457) HndOff 002E (RVA 1145E) HndEnd 00FD (RVA 1152D) ClsFlt 100000C CATCH: System.Exception + +Debug Info + Bounds: +00000000: 0A 75 02 02 F4 15 08 11 14 00 A0 23 00 C1 83 86 +00000010: 08 51 1B A2 50 E4 C4 88 F2 D1 1A 25 CA 4B 1A 9B +00000020: A6 3C 41 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1F, IL Offset: 0x0002, Source Types: StackEmpty + Native Offset: 0x27, IL Offset: 0x007f, Source Types: StackEmpty + Native Offset: 0x27, Epilog, Source Types: StackEmpty + Native Offset: 0x2E, Prolog, Source Types: StackEmpty + Native Offset: 0x2F, IL Offset: 0x000c, Source Types: SourceTypeInvalid + Native Offset: 0x32, IL Offset: 0x000e, Source Types: StackEmpty + Native Offset: 0x46, IL Offset: 0x0018, Source Types: StackEmpty + Native Offset: 0x5A, IL Offset: 0x0025, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002e, Source Types: StackEmpty + Native Offset: 0x7C, IL Offset: 0x003b, Source Types: StackEmpty + Native Offset: 0xA7, IL Offset: 0x004e, Source Types: StackEmpty + Native Offset: 0xBB, IL Offset: 0x005b, Source Types: StackEmpty + Native Offset: 0xD5, IL Offset: 0x0069, Source Types: StackEmpty + Native Offset: 0xE8, IL Offset: 0x0076, Source Types: StackEmpty + Native Offset: 0xF8, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1F + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1F + End Offset: 0x27 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -56 + + Variable Number: 0 + Start Offset: 0x2E + End Offset: 0x62 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -56 + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x23 + Loc Type: VLT_REG + Register: RSI + +11430: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11431: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11432: 48 83 ec 38 sub rsp, 56 + UWOP_ALLOC_SMALL 56 0 + +11436: 48 8d 6c 24 40 lea rbp, [rsp + 64] +1143b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11440: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 +11445: 33 c0 xor eax, eax +11447: 48 89 45 f0 mov qword ptr [rbp - 16], rax +1144b: 48 89 7d c8 mov qword ptr [rbp - 56], rdi +1144f: 48 8b 7e 08 mov rdi, qword ptr [rsi + 8] + RDI is live +11453: ff 56 18 call qword ptr [rsi + 24] + RSI is live + RDI is dead +11456: 90 nop + sp-56 is live +11457: 48 83 c4 38 add rsp, 56 + RDI is live + sp-56 is dead +1145b: 5b pop rbx +1145c: 5d pop rbp +1145d: c3 ret + +void InlineThunks.CheckNoThrow(string, System.Action) +Id: 2 +StartAddress: 0x0001145E +Size: 207 bytes +UnwindRVA: 0x000108D0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1145e: 50 push rax +1145f: 48 8b df mov rbx, rdi + RBX is live +11462: 48 8d 7d d0 lea rdi, [rbp - 48] + RDI is dead +11466: be 15 00 00 00 mov esi, 21 +1146b: ba 03 00 00 00 mov edx, 3 +11470: ff 15 5a 3f 02 00 call qword ptr [0x353d0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler..ctor(int, int) (METHOD_ENTRY_REF_TOKEN) +11476: 48 8b 35 53 42 02 00 mov rsi, qword ptr [0x356d0] // " FAILED: " (STRING_HANDLE) +1147d: 48 8b 36 mov rsi, qword ptr [rsi] + RSI is dead +11480: 48 8d 7d d0 lea rdi, [rbp - 48] +11484: ff 15 56 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) + RSI is live +1148a: 48 8d 7d d0 lea rdi, [rbp - 48] +1148e: 48 8b 75 c8 mov rsi, qword ptr [rbp - 56] + RSI is dead + sp-56 is live +11492: ff 15 50 3f 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) + RSI is dead +11498: 48 8b 35 49 42 02 00 mov rsi, qword ptr [0x356e8] // " — threw " (STRING_HANDLE) +1149f: 48 8b 36 mov rsi, qword ptr [rsi] + RSI is live +114a2: 48 8d 7d d0 lea rdi, [rbp - 48] +114a6: ff 15 34 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) + RSI is dead +114ac: 48 8b fb mov rdi, rbx + RDI is live +114af: 4c 8d 1d 02 3e 02 00 lea r11, [0x352b8] // System.Type System.Exception.GetType() (VIRTUAL_ENTRY) +114b6: 39 3f cmp dword ptr [rdi], edi +114b8: 41 ff 13 call qword ptr [r11] + RDI is dead + RAX is live +114bb: 48 8b f8 mov rdi, rax + RDI is live +114be: 4c 8d 1d 03 3e 02 00 lea r11, [0x352c8] // string System.Reflection.MemberInfo.get_Name() (VIRTUAL_ENTRY) +114c5: 39 3f cmp dword ptr [rdi], edi +114c7: 41 ff 13 call qword ptr [r11] + RDI is dead +114ca: 48 8b f0 mov rsi, rax + RSI is live +114cd: 48 8d 7d d0 lea rdi, [rbp - 48] +114d1: ff 15 11 3f 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) + RAX is dead + RSI is dead +114d7: 48 8b 35 12 42 02 00 mov rsi, qword ptr [0x356f0] // ": " (STRING_HANDLE) +114de: 48 8b 36 mov rsi, qword ptr [rsi] + RSI is live +114e1: 48 8d 7d d0 lea rdi, [rbp - 48] +114e5: ff 15 f5 3e 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) + RSI is dead +114eb: 48 8b fb mov rdi, rbx + RDI is live +114ee: 4c 8d 1d bb 3d 02 00 lea r11, [0x352b0] // string System.Exception.get_Message() (VIRTUAL_ENTRY) +114f5: 41 ff 13 call qword ptr [r11] + RBX is dead + RAX is live + RDI is dead +114f8: 48 8b f0 mov rsi, rax + RSI is live +114fb: 48 8d 7d d0 lea rdi, [rbp - 48] +114ff: ff 15 e3 3e 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) + RSI is dead + RAX is dead +11505: 48 8d 7d d0 lea rdi, [rbp - 48] +11509: ff 15 c9 3e 02 00 call qword ptr [0x353d8] // string System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear() (METHOD_ENTRY_REF_TOKEN) + RAX is live +1150f: 48 8b f8 mov rdi, rax + RDI is live +11512: ff 15 58 3e 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) + RAX is dead + RDI is dead +11518: ff 15 0a 3e 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) + RAX is live +1151e: c6 00 01 mov byte ptr [rax], 1 +11521: 48 8d 05 2f ff ff ff lea rax, [0x11457] + RAX is dead +11528: 48 83 c4 08 add rsp, 8 +1152c: c3 ret + +_______________________________________________ + +int InlineThunks.Main() +Handle: 0x06000003 +Rid: 3 +EntryPointRuntimeFunctionId: 3 +Number of RuntimeFunctions: 1 +Number of fixups: 24 + TableIndex 5, Offset 0003: System.Action (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000B: System.Runtime.CompilerServices.TaskAwaiter`1 (TYPE_HANDLE) + TableIndex 5, Offset 000C: System.Runtime.CompilerServices.ValueTaskAwaiter`1 (TYPE_HANDLE) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0014: System.Runtime.CompilerServices.TaskAwaiter`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0015: System.Runtime.CompilerServices.ValueTaskAwaiter`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 6, Offset 0005: "TaskReturningThunk" (STRING_HANDLE) + TableIndex 6, Offset 0006: "TaskReturningThunkVoid" (STRING_HANDLE) + TableIndex 6, Offset 0007: "ValueTaskReturningThunk" (STRING_HANDLE) + TableIndex 6, Offset 0008: "AsyncVariant" (STRING_HANDLE) + TableIndex 6, Offset 0009: "AsyncVariantVoid" (STRING_HANDLE) + TableIndex 6, Offset 000A: "AsyncVariantValueTask" (STRING_HANDLE) + TableIndex 6, Offset 000B: "NonRuntimeAsyncNotAwaited" (STRING_HANDLE) + TableIndex 6, Offset 000C: "NonRuntimeAsyncAwaited" (STRING_HANDLE) + TableIndex 6, Offset 000D: "NonRuntimeValueTaskNotAwaited" (STRING_HANDLE) + TableIndex 6, Offset 000E: "NonRuntimeValueTaskAwaited" (STRING_HANDLE) + TableIndex 6, Offset 000F: "CrossModuleAsyncVariant" (STRING_HANDLE) + TableIndex 6, Offset 0010: "CrossModuleAsyncVariantVoid" (STRING_HANDLE) + TableIndex 6, Offset 0011: "CrossModuleAsyncVariantValueTask" (STRING_HANDLE) + TableIndex 6, Offset 0012: "CrossModuleTaskReturningThunk" (STRING_HANDLE) + TableIndex 6, Offset 0013: "CrossModuleSyncBaseline" (STRING_HANDLE) + TableIndex 6, Offset 0014: "PASSED" (STRING_HANDLE) + TableIndex 6, Offset 0015: "FAILED" (STRING_HANDLE) + +int InlineThunks.Main() +Id: 3 +StartAddress: 0x00011530 +Size: 1064 bytes +UnwindRVA: 0x000108DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000C +CountOfUnwindCodes: 6 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000C FrameOffset 0x0000 NextOffset 0x0 Op 48 +UnwindCode[2]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op R13(13) +UnwindCode[4]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) + +Debug Info + Bounds: +00000000: 7A 97 01 02 08 40 21 04 E8 A7 04 D0 0C A1 2F 39 +00000010: F4 23 09 56 60 51 06 2F FA D9 46 3F FA A8 D0 27 +00000020: FD 7C A5 9F BF B0 D2 99 32 52 D3 4F 72 FA 49 4F +00000030: 22 05 CA A1 42 49 20 28 88 13 05 01 A3 00 00 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x21, IL Offset: 0x0001, Source Types: StackEmpty + Native Offset: 0x60, IL Offset: 0x0022, Source Types: StackEmpty + Native Offset: 0x94, IL Offset: 0x0040, Source Types: SourceTypeInvalid + Native Offset: 0xF3, IL Offset: 0x006f, Source Types: StackEmpty + Native Offset: 0x132, IL Offset: 0x008f, Source Types: StackEmpty + Native Offset: 0x15D, IL Offset: 0x00ad, Source Types: SourceTypeInvalid + Native Offset: 0x176, IL Offset: 0x00b9, Source Types: StackEmpty + Native Offset: 0x1B5, IL Offset: 0x00d8, Source Types: StackEmpty + Native Offset: 0x1F4, IL Offset: 0x00f7, Source Types: StackEmpty + Native Offset: 0x279, IL Offset: 0x013b, Source Types: StackEmpty + Native Offset: 0x2B8, IL Offset: 0x015c, Source Types: StackEmpty + Native Offset: 0x2F7, IL Offset: 0x017c, Source Types: StackEmpty + Native Offset: 0x322, IL Offset: 0x019a, Source Types: SourceTypeInvalid + Native Offset: 0x33B, IL Offset: 0x01a6, Source Types: StackEmpty + Native Offset: 0x37A, IL Offset: 0x01c6, Source Types: StackEmpty + Native Offset: 0x3B9, IL Offset: 0x01e6, Source Types: StackEmpty + Native Offset: 0x3DB, IL Offset: 0x0202, Source Types: StackEmpty + Native Offset: 0x3E9, IL Offset: 0x0212, Source Types: StackEmpty + Native Offset: 0x3FB, IL Offset: 0x0205, Source Types: StackEmpty + Native Offset: 0x40B, IL Offset: 0x0224, Source Types: StackEmpty + Native Offset: 0x41B, IL Offset: 0x022d, Source Types: StackEmpty + Native Offset: 0x41B, Epilog, Source Types: StackEmpty + +11530: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11531: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +11533: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +11535: 41 55 push r13 + UWOP_PUSH_NONVOL R13(13) 0 + +11537: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11538: 48 83 ec 30 sub rsp, 48 + UWOP_ALLOC_SMALL 48 0 + +1153c: 48 8d 6c 24 50 lea rbp, [rsp + 80] +11541: 33 c0 xor eax, eax +11543: 48 89 45 b8 mov qword ptr [rbp - 72], rax +11547: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +1154c: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 +11551: bf 0a 00 00 00 mov edi, 10 +11556: ff 15 64 3f 02 00 call qword ptr [0x354c0] // System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) (METHOD_ENTRY_DEF_TOKEN) +1155c: 48 8b f8 mov rdi, rax +1155f: 4c 8d 1d 6a 3d 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +11566: 39 3f cmp dword ptr [rdi], edi +11568: 41 ff 13 call qword ptr [r11] +1156b: 48 89 45 d8 mov qword ptr [rbp - 40], rax +1156f: 48 8d 7d d8 lea rdi, [rbp - 40] +11573: ff 15 cf 3e 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +11579: 8b d0 mov edx, eax +1157b: 48 8b 3d 76 41 02 00 mov rdi, qword ptr [0x356f8] // "TaskReturningThunk" (STRING_HANDLE) +11582: 48 8b 3f mov rdi, qword ptr [rdi] +11585: be 14 00 00 00 mov esi, 20 +1158a: ff 15 20 3f 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11590: ff 15 9a 3d 02 00 call qword ptr [0x35330] // InlineThunks+<>c (STATIC_BASE_GC) +11596: 48 8b d8 mov rbx, rax +11599: 48 8b 73 08 mov rsi, qword ptr [rbx + 8] +1159d: 48 8b 05 5c 41 02 00 mov rax, qword ptr [0x35700] // "TaskReturningThunkVoid" (STRING_HANDLE) +115a4: 4c 8b 38 mov r15, qword ptr [rax] +115a7: 48 85 f6 test rsi, rsi +115aa: 75 28 jne 0x115d4 +115ac: 4c 8b 33 mov r14, qword ptr [rbx] +115af: ff 15 83 3d 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) +115b5: 4c 8b e8 mov r13, rax +115b8: 49 8b fd mov rdi, r13 +115bb: 49 8b f6 mov rsi, r14 +115be: ff 15 94 3d 02 00 call qword ptr [0x35358] // void InlineThunks+<>c.
b__3_0() => System.Action (DELEGATE_CTOR) +115c4: 48 8d 7b 08 lea rdi, [rbx + 8] +115c8: 49 8b f5 mov rsi, r13 +115cb: ff 15 2f 3d 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +115d1: 49 8b f5 mov rsi, r13 +115d4: 49 8b ff mov rdi, r15 +115d7: ff 15 db 3e 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) +115dd: bf 05 00 00 00 mov edi, 5 +115e2: ff 15 e8 3e 02 00 call qword ptr [0x354d0] // System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) (METHOD_ENTRY_DEF_TOKEN) +115e8: 48 89 45 c8 mov qword ptr [rbp - 56], rax +115ec: 48 89 55 d0 mov qword ptr [rbp - 48], rdx +115f0: 48 8d 7d c8 lea rdi, [rbp - 56] +115f4: ff 15 06 3e 02 00 call qword ptr [0x35400] // System.Runtime.CompilerServices.ValueTaskAwaiter`1 System.Threading.Tasks.ValueTask`1.GetAwaiter() (METHOD_ENTRY) +115fa: 48 89 45 b8 mov qword ptr [rbp - 72], rax +115fe: 48 89 55 c0 mov qword ptr [rbp - 64], rdx +11602: 48 8d 7d b8 lea rdi, [rbp - 72] +11606: ff 15 44 3e 02 00 call qword ptr [0x35450] // !0 System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult() (METHOD_ENTRY) +1160c: 8b d0 mov edx, eax +1160e: 48 8b 3d f3 40 02 00 mov rdi, qword ptr [0x35708] // "ValueTaskReturningThunk" (STRING_HANDLE) +11615: 48 8b 3f mov rdi, qword ptr [rdi] +11618: be 0a 00 00 00 mov esi, 10 +1161d: ff 15 8d 3e 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11623: bf 07 00 00 00 mov edi, 7 +11628: ff 15 aa 3e 02 00 call qword ptr [0x354d8] // System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) (METHOD_ENTRY_DEF_TOKEN) +1162e: 48 8b f8 mov rdi, rax +11631: 4c 8d 1d 98 3c 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +11638: 39 3f cmp dword ptr [rdi], edi +1163a: 41 ff 13 call qword ptr [r11] +1163d: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11641: 48 8d 7d d8 lea rdi, [rbp - 40] +11645: ff 15 fd 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +1164b: 8b d0 mov edx, eax +1164d: 48 8b 3d bc 40 02 00 mov rdi, qword ptr [0x35710] // "AsyncVariant" (STRING_HANDLE) +11654: 48 8b 3f mov rdi, qword ptr [rdi] +11657: be 0e 00 00 00 mov esi, 14 +1165c: ff 15 4e 3e 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11662: 48 8b 73 10 mov rsi, qword ptr [rbx + 16] +11666: 48 8b 05 ab 40 02 00 mov rax, qword ptr [0x35718] // "AsyncVariantVoid" (STRING_HANDLE) +1166d: 4c 8b 38 mov r15, qword ptr [rax] +11670: 48 85 f6 test rsi, rsi +11673: 75 28 jne 0x1169d +11675: 4c 8b 33 mov r14, qword ptr [rbx] +11678: ff 15 ba 3c 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) +1167e: 4c 8b e8 mov r13, rax +11681: 49 8b fd mov rdi, r13 +11684: 49 8b f6 mov rsi, r14 +11687: ff 15 d3 3c 02 00 call qword ptr [0x35360] // void InlineThunks+<>c.
b__3_1() => System.Action (DELEGATE_CTOR) +1168d: 48 8d 7b 10 lea rdi, [rbx + 16] +11691: 49 8b f5 mov rsi, r13 +11694: ff 15 66 3c 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +1169a: 49 8b f5 mov rsi, r13 +1169d: 49 8b ff mov rdi, r15 +116a0: ff 15 12 3e 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) +116a6: bf 03 00 00 00 mov edi, 3 +116ab: ff 15 37 3e 02 00 call qword ptr [0x354e8] // System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) +116b1: 48 8b f8 mov rdi, rax +116b4: 4c 8d 1d 15 3c 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +116bb: 39 3f cmp dword ptr [rdi], edi +116bd: 41 ff 13 call qword ptr [r11] +116c0: 48 89 45 d8 mov qword ptr [rbp - 40], rax +116c4: 48 8d 7d d8 lea rdi, [rbp - 40] +116c8: ff 15 7a 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +116ce: 8b d0 mov edx, eax +116d0: 48 8b 3d 49 40 02 00 mov rdi, qword ptr [0x35720] // "AsyncVariantValueTask" (STRING_HANDLE) +116d7: 48 8b 3f mov rdi, qword ptr [rdi] +116da: be 06 00 00 00 mov esi, 6 +116df: ff 15 cb 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +116e5: bf 04 00 00 00 mov edi, 4 +116ea: ff 15 00 3e 02 00 call qword ptr [0x354f0] // System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) (METHOD_ENTRY_DEF_TOKEN) +116f0: 48 8b f8 mov rdi, rax +116f3: 4c 8d 1d d6 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +116fa: 39 3f cmp dword ptr [rdi], edi +116fc: 41 ff 13 call qword ptr [r11] +116ff: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11703: 48 8d 7d d8 lea rdi, [rbp - 40] +11707: ff 15 3b 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +1170d: 8b d0 mov edx, eax +1170f: 48 8b 3d 12 40 02 00 mov rdi, qword ptr [0x35728] // "NonRuntimeAsyncNotAwaited" (STRING_HANDLE) +11716: 48 8b 3f mov rdi, qword ptr [rdi] +11719: be 08 00 00 00 mov esi, 8 +1171e: ff 15 8c 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11724: bf 06 00 00 00 mov edi, 6 +11729: ff 15 c9 3d 02 00 call qword ptr [0x354f8] // System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) (METHOD_ENTRY_DEF_TOKEN) +1172f: 48 8b f8 mov rdi, rax +11732: 4c 8d 1d 97 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +11739: 39 3f cmp dword ptr [rdi], edi +1173b: 41 ff 13 call qword ptr [r11] +1173e: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11742: 48 8d 7d d8 lea rdi, [rbp - 40] +11746: ff 15 fc 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +1174c: 8b d0 mov edx, eax +1174e: 48 8b 3d db 3f 02 00 mov rdi, qword ptr [0x35730] // "NonRuntimeAsyncAwaited" (STRING_HANDLE) +11755: 48 8b 3f mov rdi, qword ptr [rdi] +11758: be 0c 00 00 00 mov esi, 12 +1175d: ff 15 4d 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11763: bf 09 00 00 00 mov edi, 9 +11768: ff 15 92 3d 02 00 call qword ptr [0x35500] // System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) +1176e: 48 89 45 c8 mov qword ptr [rbp - 56], rax +11772: 48 89 55 d0 mov qword ptr [rbp - 48], rdx +11776: 48 8d 7d c8 lea rdi, [rbp - 56] +1177a: ff 15 80 3c 02 00 call qword ptr [0x35400] // System.Runtime.CompilerServices.ValueTaskAwaiter`1 System.Threading.Tasks.ValueTask`1.GetAwaiter() (METHOD_ENTRY) +11780: 48 89 45 b8 mov qword ptr [rbp - 72], rax +11784: 48 89 55 c0 mov qword ptr [rbp - 64], rdx +11788: 48 8d 7d b8 lea rdi, [rbp - 72] +1178c: ff 15 be 3c 02 00 call qword ptr [0x35450] // !0 System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult() (METHOD_ENTRY) +11792: 8b d0 mov edx, eax +11794: 48 8b 3d 9d 3f 02 00 mov rdi, qword ptr [0x35738] // "NonRuntimeValueTaskNotAwaited" (STRING_HANDLE) +1179b: 48 8b 3f mov rdi, qword ptr [rdi] +1179e: be 12 00 00 00 mov esi, 18 +117a3: ff 15 07 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +117a9: bf 0b 00 00 00 mov edi, 11 +117ae: ff 15 54 3d 02 00 call qword ptr [0x35508] // System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) +117b4: 48 8b f8 mov rdi, rax +117b7: 4c 8d 1d 12 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +117be: 39 3f cmp dword ptr [rdi], edi +117c0: 41 ff 13 call qword ptr [r11] +117c3: 48 89 45 d8 mov qword ptr [rbp - 40], rax +117c7: 48 8d 7d d8 lea rdi, [rbp - 40] +117cb: ff 15 77 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +117d1: 8b d0 mov edx, eax +117d3: 48 8b 3d 66 3f 02 00 mov rdi, qword ptr [0x35740] // "NonRuntimeValueTaskAwaited" (STRING_HANDLE) +117da: 48 8b 3f mov rdi, qword ptr [rdi] +117dd: be 16 00 00 00 mov esi, 22 +117e2: ff 15 c8 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +117e8: bf 05 00 00 00 mov edi, 5 +117ed: ff 15 35 3d 02 00 call qword ptr [0x35528] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) (METHOD_ENTRY_DEF_TOKEN) +117f3: 48 8b f8 mov rdi, rax +117f6: 4c 8d 1d d3 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +117fd: 39 3f cmp dword ptr [rdi], edi +117ff: 41 ff 13 call qword ptr [r11] +11802: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11806: 48 8d 7d d8 lea rdi, [rbp - 40] +1180a: ff 15 38 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +11810: 8b d0 mov edx, eax +11812: 48 8b 3d 2f 3f 02 00 mov rdi, qword ptr [0x35748] // "CrossModuleAsyncVariant" (STRING_HANDLE) +11819: 48 8b 3f mov rdi, qword ptr [rdi] +1181c: be 0f 00 00 00 mov esi, 15 +11821: ff 15 89 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +11827: 48 8b 73 18 mov rsi, qword ptr [rbx + 24] +1182b: 48 8b 05 1e 3f 02 00 mov rax, qword ptr [0x35750] // "CrossModuleAsyncVariantVoid" (STRING_HANDLE) +11832: 4c 8b 38 mov r15, qword ptr [rax] +11835: 48 85 f6 test rsi, rsi +11838: 75 28 jne 0x11862 +1183a: 4c 8b 33 mov r14, qword ptr [rbx] +1183d: ff 15 f5 3a 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) +11843: 4c 8b e8 mov r13, rax +11846: 49 8b fd mov rdi, r13 +11849: 49 8b f6 mov rsi, r14 +1184c: ff 15 16 3b 02 00 call qword ptr [0x35368] // void InlineThunks+<>c.
b__3_2() => System.Action (DELEGATE_CTOR) +11852: 48 8d 7b 18 lea rdi, [rbx + 24] +11856: 49 8b f5 mov rsi, r13 +11859: ff 15 a1 3a 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +1185f: 49 8b f5 mov rsi, r13 +11862: 49 8b ff mov rdi, r15 +11865: ff 15 4d 3c 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) +1186b: bf 04 00 00 00 mov edi, 4 +11870: ff 15 c2 3c 02 00 call qword ptr [0x35538] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) (METHOD_ENTRY_DEF_TOKEN) +11876: 48 8b f8 mov rdi, rax +11879: 4c 8d 1d 50 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +11880: 39 3f cmp dword ptr [rdi], edi +11882: 41 ff 13 call qword ptr [r11] +11885: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11889: 48 8d 7d d8 lea rdi, [rbp - 40] +1188d: ff 15 b5 3b 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +11893: 8b d0 mov edx, eax +11895: 48 8b 3d bc 3e 02 00 mov rdi, qword ptr [0x35758] // "CrossModuleAsyncVariantValueTask" (STRING_HANDLE) +1189c: 48 8b 3f mov rdi, qword ptr [rdi] +1189f: be 0c 00 00 00 mov esi, 12 +118a4: ff 15 06 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +118aa: bf 08 00 00 00 mov edi, 8 +118af: ff 15 8b 3c 02 00 call qword ptr [0x35540] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) (METHOD_ENTRY_DEF_TOKEN) +118b5: 48 8b f8 mov rdi, rax +118b8: 4c 8d 1d 11 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) +118bf: 39 3f cmp dword ptr [rdi], edi +118c1: 41 ff 13 call qword ptr [r11] +118c4: 48 89 45 d8 mov qword ptr [rbp - 40], rax +118c8: 48 8d 7d d8 lea rdi, [rbp - 40] +118cc: ff 15 76 3b 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) +118d2: 8b d0 mov edx, eax +118d4: 48 8b 3d 85 3e 02 00 mov rdi, qword ptr [0x35760] // "CrossModuleTaskReturningThunk" (STRING_HANDLE) +118db: 48 8b 3f mov rdi, qword ptr [rdi] +118de: be 18 00 00 00 mov esi, 24 +118e3: ff 15 c7 3b 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +118e9: bf 07 00 00 00 mov edi, 7 +118ee: ff 15 54 3c 02 00 call qword ptr [0x35548] // int InlineThunks.CrossModuleSyncCaller(int) (METHOD_ENTRY_DEF_TOKEN) +118f4: 8b d0 mov edx, eax +118f6: 48 8b 3d 6b 3e 02 00 mov rdi, qword ptr [0x35768] // "CrossModuleSyncBaseline" (STRING_HANDLE) +118fd: 48 8b 3f mov rdi, qword ptr [rdi] +11900: be 15 00 00 00 mov esi, 21 +11905: ff 15 a5 3b 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) +1190b: ff 15 17 3a 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) +11911: 48 8b d8 mov rbx, rax +11914: 80 3b 00 cmp byte ptr [rbx], 0 +11917: 74 12 je 0x1192b +11919: 48 8b 3d 58 3e 02 00 mov rdi, qword ptr [0x35778] // "FAILED" (STRING_HANDLE) +11920: 48 8b 3f mov rdi, qword ptr [rdi] +11923: ff 15 47 3a 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) +11929: eb 10 jmp 0x1193b +1192b: 48 8b 3d 3e 3e 02 00 mov rdi, qword ptr [0x35770] // "PASSED" (STRING_HANDLE) +11932: 48 8b 3f mov rdi, qword ptr [rdi] +11935: ff 15 35 3a 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) +1193b: b8 01 00 00 00 mov eax, 1 +11940: b9 64 00 00 00 mov ecx, 100 +11945: 80 3b 00 cmp byte ptr [rbx], 0 +11948: 0f 44 c1 cmove eax, ecx +1194b: 48 83 c4 30 add rsp, 48 +1194f: 5b pop rbx +11950: 41 5d pop r13 +11952: 41 5e pop r14 +11954: 41 5f pop r15 +11956: 5d pop rbp +11957: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) +Handle: 0x06000004 +Rid: 4 +EntryPointRuntimeFunctionId: 4 +Number of RuntimeFunctions: 1 + +System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) +Id: 4 +StartAddress: 0x00011960 +Size: 13 bytes +UnwindRVA: 0x0001097C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +Debug Info + Bounds: +00000000: 23 01 42 CA 32 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x7, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +11960: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +11961: ff 15 a9 3b 02 00 call qword ptr [0x35510] // System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) (METHOD_ENTRY_DEF_TOKEN) +11967: 90 nop +11968: 48 83 c4 08 add rsp, 8 +1196c: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() +Handle: 0x06000005 +Rid: 5 +EntryPointRuntimeFunctionId: 5 +Number of RuntimeFunctions: 1 + +System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() +Id: 5 +StartAddress: 0x00011970 +Size: 13 bytes +UnwindRVA: 0x0001097C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +Debug Info + Bounds: +00000000: 23 01 42 CA 32 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x7, Epilog, Source Types: StackEmpty + +11970: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +11971: ff 15 a1 3b 02 00 call qword ptr [0x35518] // System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() (METHOD_ENTRY_DEF_TOKEN) +11977: 90 nop +11978: 48 83 c4 08 add rsp, 8 +1197c: c3 ret + +_______________________________________________ + +System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) +Handle: 0x06000006 +Rid: 6 +EntryPointRuntimeFunctionId: 6 +Number of RuntimeFunctions: 1 +Number of fixups: 2 + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) +Id: 6 +StartAddress: 0x00011980 +Size: 42 bytes +UnwindRVA: 0x0001098C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0004 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0004 FrameOffset 0x0000 NextOffset 0x0 Op 24 + +Debug Info + Bounds: +00000000: 43 01 02 69 2D 0D + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0xB, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x25, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0xB + Loc Type: VLT_REG + Register: RDI + +11980: 48 83 ec 18 sub rsp, 24 + UWOP_ALLOC_SMALL 24 0 + +11984: 33 c0 xor eax, eax +11986: 48 89 44 24 08 mov qword ptr [rsp + 8], rax +1198b: ff 15 8f 3b 02 00 call qword ptr [0x35520] // System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) (METHOD_ENTRY_DEF_TOKEN) +11991: 48 89 44 24 08 mov qword ptr [rsp + 8], rax +11996: 48 89 54 24 10 mov qword ptr [rsp + 16], rdx +1199b: 48 8b 44 24 08 mov rax, qword ptr [rsp + 8] +119a0: 48 8b 54 24 10 mov rdx, qword ptr [rsp + 16] +119a5: 48 83 c4 18 add rsp, 24 +119a9: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Handle: 0x06000007 +Rid: 7 +EntryPointRuntimeFunctionId: 7 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Id: 7 +StartAddress: 0x000119B0 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13078, #clauses = 2 +Flags 20 TryOff 0028 (RVA 119D8) TryEnd 0045 (RVA 119F5) HndOff 0067 (RVA 11A17) HndEnd 007E (RVA 11A2E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 119D8) TryEnd 0052 (RVA 11A02) HndOff 007E (RVA 11A2E) HndEnd 008F (RVA 11A3F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +119b0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +119b1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +119b2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +119b6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +119bb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +119c0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +119c5: 33 c0 xor eax, eax +119c7: 48 89 45 f0 mov qword ptr [rbp - 16], rax +119cb: 8b df mov ebx, edi +119cd: 48 8d 7d e0 lea rdi, [rbp - 32] +119d1: ff 15 b1 39 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +119d7: 90 nop +119d8: 8b f3 mov esi, ebx +119da: 33 ff xor edi, edi + RDI is live +119dc: ff 15 86 3b 02 00 call qword ptr [0x35568] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) (METHOD_ENTRY) + RDI is dead + RCX is live +119e2: 48 85 c9 test rcx, rcx +119e5: 75 0e jne 0x119f5 +119e7: 8b f8 mov edi, eax +119e9: ff 15 69 3a 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +119ef: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +119f3: eb 0d jmp 0x11a02 + sp-40 is dead + RAX is dead +119f5: ff 15 6d 3a 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +119fb: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +119ff: eb 01 jmp 0x11a02 + RAX is dead +11a01: 90 nop +11a02: 48 8d 7d e0 lea rdi, [rbp - 32] +11a06: ff 15 84 39 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11a0c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +11a10: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +11a14: 5b pop rbx +11a15: 5d pop rbp +11a16: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Id: 8 +StartAddress: 0x00011A17 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11a17: 50 push rax +11a18: ff 15 5a 3a 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11a1e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11a22: 48 8d 05 d8 ff ff ff lea rax, [0x11a01] + RAX is dead +11a29: 48 83 c4 08 add rsp, 8 + sp-40 is dead +11a2d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Id: 9 +StartAddress: 0x00011A2E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11a2e: 50 push rax +11a2f: 48 8d 7d e0 lea rdi, [rbp - 32] +11a33: ff 15 57 39 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11a39: 90 nop +11a3a: 48 83 c4 08 add rsp, 8 +11a3e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Handle: 0x06000008 +Rid: 8 +EntryPointRuntimeFunctionId: 10 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Id: 10 +StartAddress: 0x00011A40 +Size: 95 bytes +UnwindRVA: 0x000109F4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 + +EH info @ 130A8, #clauses = 2 +Flags 20 TryOff 0025 (RVA 11A65) TryEnd 003E (RVA 11A7E) HndOff 005F (RVA 11A9F) HndEnd 0076 (RVA 11AB6) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0025 (RVA 11A65) TryEnd 004B (RVA 11A8B) HndOff 0076 (RVA 11AB6) HndEnd 0087 (RVA 11AC7) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 +00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty + Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x4A, NoMapping, Source Types: StackEmpty + Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty + Native Offset: 0x59, Epilog, Source Types: StackEmpty + Native Offset: 0x5F, Prolog, Source Types: StackEmpty + Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid + Native Offset: 0x71, Epilog, Source Types: StackEmpty + Native Offset: 0x76, Prolog, Source Types: StackEmpty + Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty + Native Offset: 0x82, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x3C + End Offset: 0x3E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x48 + End Offset: 0x59 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x6A + End Offset: 0x76 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + +11a40: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11a41: 48 83 ec 20 sub rsp, 32 + UWOP_ALLOC_SMALL 32 0 + +11a45: 48 8d 6c 24 20 lea rbp, [rsp + 32] +11a4a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11a4f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 +11a54: 33 c0 xor eax, eax +11a56: 48 89 45 f8 mov qword ptr [rbp - 8], rax +11a5a: 48 8d 7d e8 lea rdi, [rbp - 24] +11a5e: ff 15 24 39 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11a64: 90 nop +11a65: 33 ff xor edi, edi + RDI is live +11a67: ff 15 03 3b 02 00 call qword ptr [0x35570] // [ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() (METHOD_ENTRY) + RDI is dead + RCX is live +11a6d: 48 85 c9 test rcx, rcx +11a70: 75 0c jne 0x11a7e +11a72: ff 15 08 39 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) + RAX is live + RCX is dead +11a78: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11a7c: eb 0d jmp 0x11a8b + RAX is dead + sp-32 is dead +11a7e: ff 15 14 39 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) + RAX is live +11a84: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11a88: eb 01 jmp 0x11a8b + RAX is dead +11a8a: 90 nop +11a8b: 48 8d 7d e8 lea rdi, [rbp - 24] +11a8f: ff 15 fb 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11a95: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] + RAX is live +11a99: 48 83 c4 20 add rsp, 32 + RAX is dead + RDI is live + sp-32 is dead +11a9d: 5d pop rbp +11a9e: c3 ret + +System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Id: 11 +StartAddress: 0x00011A9F +Size: 23 bytes +UnwindRVA: 0x00010A2C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11a9f: 50 push rax +11aa0: ff 15 fa 38 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) + RAX is live + RDI is dead +11aa6: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11aaa: 48 8d 05 d9 ff ff ff lea rax, [0x11a8a] + RAX is dead +11ab1: 48 83 c4 08 add rsp, 8 + sp-32 is dead +11ab5: c3 ret + +System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Id: 12 +StartAddress: 0x00011AB6 +Size: 17 bytes +UnwindRVA: 0x00010A38 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11ab6: 50 push rax +11ab7: 48 8d 7d e8 lea rdi, [rbp - 24] +11abb: ff 15 cf 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11ac1: 90 nop +11ac2: 48 83 c4 08 add rsp, 8 +11ac6: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Handle: 0x06000009 +Rid: 9 +EntryPointRuntimeFunctionId: 13 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Id: 13 +StartAddress: 0x00011AD0 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 130D8, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11AF8) TryEnd 0045 (RVA 11B15) HndOff 0067 (RVA 11B37) HndEnd 007E (RVA 11B4E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11AF8) TryEnd 0052 (RVA 11B22) HndOff 007E (RVA 11B4E) HndEnd 008F (RVA 11B5F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +11ad0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11ad1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11ad2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11ad6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11adb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11ae0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +11ae5: 33 c0 xor eax, eax +11ae7: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11aeb: 8b df mov ebx, edi +11aed: 48 8d 7d e0 lea rdi, [rbp - 32] +11af1: ff 15 91 38 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11af7: 90 nop +11af8: 8b f3 mov esi, ebx +11afa: 33 ff xor edi, edi + RDI is live +11afc: ff 15 76 3a 02 00 call qword ptr [0x35578] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) (METHOD_ENTRY) + RDI is dead + RCX is live +11b02: 48 85 c9 test rcx, rcx +11b05: 75 0e jne 0x11b15 +11b07: 8b f8 mov edi, eax +11b09: ff 15 49 39 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11b0f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11b13: eb 0d jmp 0x11b22 + sp-40 is dead + RAX is dead +11b15: ff 15 4d 39 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11b1b: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11b1f: eb 01 jmp 0x11b22 + RAX is dead +11b21: 90 nop +11b22: 48 8d 7d e0 lea rdi, [rbp - 32] +11b26: ff 15 64 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11b2c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +11b30: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +11b34: 5b pop rbx +11b35: 5d pop rbp +11b36: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Id: 14 +StartAddress: 0x00011B37 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11b37: 50 push rax +11b38: ff 15 3a 39 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11b3e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11b42: 48 8d 05 d8 ff ff ff lea rax, [0x11b21] + RAX is dead +11b49: 48 83 c4 08 add rsp, 8 + sp-40 is dead +11b4d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Id: 15 +StartAddress: 0x00011B4E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11b4e: 50 push rax +11b4f: 48 8d 7d e0 lea rdi, [rbp - 32] +11b53: ff 15 37 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11b59: 90 nop +11b5a: 48 83 c4 08 add rsp, 8 +11b5e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) +Handle: 0x0600000A +Rid: 10 +EntryPointRuntimeFunctionId: 16 +Number of RuntimeFunctions: 1 +Number of fixups: 7 + TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) + TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) + TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) + +System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) +Id: 16 +StartAddress: 0x00011B60 +Size: 160 bytes +UnwindRVA: 0x00010A44 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0007 +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op 8 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 73 01 02 48 14 2B 10 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x14, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x95, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x14 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x14 + End Offset: 0x47 + Loc Type: VLT_REG + Register: RBX + +11b60: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11b61: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +11b63: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +11b65: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11b66: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +11b67: 48 8d 6c 24 20 lea rbp, [rsp + 32] +11b6c: 33 c0 xor eax, eax +11b6e: 48 89 45 e0 mov qword ptr [rbp - 32], rax +11b72: 8b df mov ebx, edi +11b74: ff 15 ce 37 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) +11b7a: 48 89 45 e0 mov qword ptr [rbp - 32], rax +11b7e: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] +11b82: ff 15 80 38 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) +11b88: 4c 8b 35 09 3b 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) +11b8f: 4b 8d 3c 37 lea rdi, [r15 + r14] +11b93: 48 8b f0 mov rsi, rax +11b96: ff 15 64 37 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +11b9c: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +11ba0: 48 8b 35 f9 3a 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) +11ba7: 89 1c 37 mov dword ptr [rdi + rsi], ebx +11baa: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +11bae: 48 8b 35 db 3a 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) +11bb5: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +11bbc: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +11bc0: 40 38 3f cmp byte ptr [rdi], dil +11bc3: 49 8b fe mov rdi, r14 +11bc6: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +11bca: 48 8b 35 07 3a 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) +11bd1: 48 8d 55 e0 lea rdx, [rbp - 32] +11bd5: ff 15 c5 38 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) +11bdb: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +11bdf: 40 38 3f cmp byte ptr [rdi], dil +11be2: 49 8b fe mov rdi, r14 +11be5: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +11be9: ff 15 21 38 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) +11bef: 33 c9 xor ecx, ecx +11bf1: 48 89 4d e0 mov qword ptr [rbp - 32], rcx +11bf5: 48 83 c4 08 add rsp, 8 +11bf9: 5b pop rbx +11bfa: 41 5e pop r14 +11bfc: 41 5f pop r15 +11bfe: 5d pop rbp +11bff: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Handle: 0x0600000B +Rid: 11 +EntryPointRuntimeFunctionId: 17 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 17 +StartAddress: 0x00011C00 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13108, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11C28) TryEnd 0045 (RVA 11C45) HndOff 0067 (RVA 11C67) HndEnd 007E (RVA 11C7E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11C28) TryEnd 0052 (RVA 11C52) HndOff 007E (RVA 11C7E) HndEnd 008F (RVA 11C8F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +11c00: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11c01: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11c02: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11c06: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11c0b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11c10: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +11c15: 33 c0 xor eax, eax +11c17: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11c1b: 8b df mov ebx, edi +11c1d: 48 8d 7d e0 lea rdi, [rbp - 32] +11c21: ff 15 61 37 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11c27: 90 nop +11c28: 8b f3 mov esi, ebx +11c2a: 33 ff xor edi, edi + RDI is live +11c2c: ff 15 4e 39 02 00 call qword ptr [0x35580] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) (METHOD_ENTRY) + RDI is dead + RCX is live +11c32: 48 85 c9 test rcx, rcx +11c35: 75 0e jne 0x11c45 +11c37: 8b f8 mov edi, eax +11c39: ff 15 19 38 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11c3f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11c43: eb 0d jmp 0x11c52 + sp-40 is dead + RAX is dead +11c45: ff 15 1d 38 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11c4b: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11c4f: eb 01 jmp 0x11c52 + RAX is dead +11c51: 90 nop +11c52: 48 8d 7d e0 lea rdi, [rbp - 32] +11c56: ff 15 34 37 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11c5c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +11c60: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +11c64: 5b pop rbx +11c65: 5d pop rbp +11c66: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 18 +StartAddress: 0x00011C67 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11c67: 50 push rax +11c68: ff 15 0a 38 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11c6e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11c72: 48 8d 05 d8 ff ff ff lea rax, [0x11c51] + RAX is dead +11c79: 48 83 c4 08 add rsp, 8 + sp-40 is dead +11c7d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 19 +StartAddress: 0x00011C7E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11c7e: 50 push rax +11c7f: 48 8d 7d e0 lea rdi, [rbp - 32] +11c83: ff 15 07 37 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11c89: 90 nop +11c8a: 48 83 c4 08 add rsp, 8 +11c8e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) +Handle: 0x0600000C +Rid: 12 +EntryPointRuntimeFunctionId: 20 +Number of RuntimeFunctions: 1 +Number of fixups: 9 + TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) + TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) + +System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) +Id: 20 +StartAddress: 0x00011C90 +Size: 200 bytes +UnwindRVA: 0x00010A64 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000A +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 73 01 02 48 21 8B 13 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x21, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xBD, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x21 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x21 + End Offset: 0x5F + Loc Type: VLT_REG + Register: RBX + +11c90: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11c91: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +11c93: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +11c95: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11c96: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11c9a: 48 8d 6c 24 40 lea rbp, [rsp + 64] +11c9f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11ca4: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 +11ca9: 33 c0 xor eax, eax +11cab: 48 89 45 e0 mov qword ptr [rbp - 32], rax +11caf: 8b df mov ebx, edi +11cb1: ff 15 99 36 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) +11cb7: 48 89 45 d0 mov qword ptr [rbp - 48], rax +11cbb: 4c 8b 7d d0 mov r15, qword ptr [rbp - 48] +11cbf: ff 15 63 37 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) +11cc5: 48 89 45 c0 mov qword ptr [rbp - 64], rax +11cc9: 48 89 55 c8 mov qword ptr [rbp - 56], rdx +11ccd: 4c 8b 35 dc 39 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) +11cd4: 4b 8d 3c 37 lea rdi, [r15 + r14] +11cd8: 48 8d 75 c0 lea rsi, [rbp - 64] +11cdc: ff 15 26 36 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) +11ce2: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] +11ce4: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +11ce8: 48 8b 35 c9 39 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) +11cef: 89 1c 37 mov dword ptr [rdi + rsi], ebx +11cf2: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +11cf6: 48 8b 35 ab 39 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) +11cfd: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +11d04: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +11d08: 40 38 3f cmp byte ptr [rdi], dil +11d0b: 49 8b fe mov rdi, r14 +11d0e: 48 03 7d d0 add rdi, qword ptr [rbp - 48] +11d12: 48 8b 35 c7 38 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) +11d19: 48 8d 55 d0 lea rdx, [rbp - 48] +11d1d: ff 15 85 37 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) +11d23: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +11d27: 40 38 3f cmp byte ptr [rdi], dil +11d2a: 49 8b fe mov rdi, r14 +11d2d: 48 03 7d d0 add rdi, qword ptr [rbp - 48] +11d31: ff 15 09 37 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) +11d37: 48 89 45 d8 mov qword ptr [rbp - 40], rax +11d3b: 48 89 55 e0 mov qword ptr [rbp - 32], rdx +11d3f: 33 c0 xor eax, eax +11d41: 48 89 45 d0 mov qword ptr [rbp - 48], rax +11d45: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] +11d49: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] +11d4d: 48 83 c4 28 add rsp, 40 +11d51: 5b pop rbx +11d52: 41 5e pop r14 +11d54: 41 5f pop r15 +11d56: 5d pop rbp +11d57: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Handle: 0x0600000D +Rid: 13 +EntryPointRuntimeFunctionId: 21 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 21 +StartAddress: 0x00011D60 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13138, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11D88) TryEnd 0045 (RVA 11DA5) HndOff 0067 (RVA 11DC7) HndEnd 007E (RVA 11DDE) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11D88) TryEnd 0052 (RVA 11DB2) HndOff 007E (RVA 11DDE) HndEnd 008F (RVA 11DEF) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +11d60: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11d61: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11d62: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11d66: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11d6b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11d70: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +11d75: 33 c0 xor eax, eax +11d77: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11d7b: 8b df mov ebx, edi +11d7d: 48 8d 7d e0 lea rdi, [rbp - 32] +11d81: ff 15 01 36 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11d87: 90 nop +11d88: 8b f3 mov esi, ebx +11d8a: 33 ff xor edi, edi + RDI is live +11d8c: ff 15 f6 37 02 00 call qword ptr [0x35588] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) (METHOD_ENTRY) + RDI is dead + RCX is live +11d92: 48 85 c9 test rcx, rcx +11d95: 75 0e jne 0x11da5 +11d97: 8b f8 mov edi, eax +11d99: ff 15 b9 36 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11d9f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11da3: eb 0d jmp 0x11db2 + sp-40 is dead + RAX is dead +11da5: ff 15 bd 36 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11dab: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11daf: eb 01 jmp 0x11db2 + RAX is dead +11db1: 90 nop +11db2: 48 8d 7d e0 lea rdi, [rbp - 32] +11db6: ff 15 d4 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11dbc: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +11dc0: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +11dc4: 5b pop rbx +11dc5: 5d pop rbp +11dc6: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 22 +StartAddress: 0x00011DC7 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11dc7: 50 push rax +11dc8: ff 15 aa 36 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11dce: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11dd2: 48 8d 05 d8 ff ff ff lea rax, [0x11db1] + RAX is dead +11dd9: 48 83 c4 08 add rsp, 8 + sp-40 is dead +11ddd: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 23 +StartAddress: 0x00011DDE +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11dde: 50 push rax +11ddf: 48 8d 7d e0 lea rdi, [rbp - 32] +11de3: ff 15 a7 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11de9: 90 nop +11dea: 48 83 c4 08 add rsp, 8 +11dee: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Handle: 0x0600000E +Rid: 14 +EntryPointRuntimeFunctionId: 24 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Id: 24 +StartAddress: 0x00011DF0 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13168, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11E18) TryEnd 0045 (RVA 11E35) HndOff 0067 (RVA 11E57) HndEnd 007E (RVA 11E6E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11E18) TryEnd 0052 (RVA 11E42) HndOff 007E (RVA 11E6E) HndEnd 008F (RVA 11E7F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +11df0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11df1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11df2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11df6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11dfb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11e00: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +11e05: 33 c0 xor eax, eax +11e07: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11e0b: 8b df mov ebx, edi +11e0d: 48 8d 7d e0 lea rdi, [rbp - 32] +11e11: ff 15 71 35 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11e17: 90 nop +11e18: 8b f3 mov esi, ebx +11e1a: 33 ff xor edi, edi + RDI is live +11e1c: ff 15 6e 37 02 00 call qword ptr [0x35590] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) (METHOD_ENTRY) + RDI is dead + RCX is live +11e22: 48 85 c9 test rcx, rcx +11e25: 75 0e jne 0x11e35 +11e27: 8b f8 mov edi, eax +11e29: ff 15 29 36 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11e2f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11e33: eb 0d jmp 0x11e42 + sp-40 is dead + RAX is dead +11e35: ff 15 2d 36 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11e3b: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11e3f: eb 01 jmp 0x11e42 + RAX is dead +11e41: 90 nop +11e42: 48 8d 7d e0 lea rdi, [rbp - 32] +11e46: ff 15 44 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11e4c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +11e50: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +11e54: 5b pop rbx +11e55: 5d pop rbp +11e56: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Id: 25 +StartAddress: 0x00011E57 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11e57: 50 push rax +11e58: ff 15 1a 36 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11e5e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11e62: 48 8d 05 d8 ff ff ff lea rax, [0x11e41] + RAX is dead +11e69: 48 83 c4 08 add rsp, 8 + sp-40 is dead +11e6d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Id: 26 +StartAddress: 0x00011E6E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11e6e: 50 push rax +11e6f: 48 8d 7d e0 lea rdi, [rbp - 32] +11e73: ff 15 17 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11e79: 90 nop +11e7a: 48 83 c4 08 add rsp, 8 +11e7e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Handle: 0x0600000F +Rid: 15 +EntryPointRuntimeFunctionId: 27 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Id: 27 +StartAddress: 0x00011E80 +Size: 95 bytes +UnwindRVA: 0x000109F4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 + +EH info @ 13198, #clauses = 2 +Flags 20 TryOff 0025 (RVA 11EA5) TryEnd 003E (RVA 11EBE) HndOff 005F (RVA 11EDF) HndEnd 0076 (RVA 11EF6) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0025 (RVA 11EA5) TryEnd 004B (RVA 11ECB) HndOff 0076 (RVA 11EF6) HndEnd 0087 (RVA 11F07) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 +00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty + Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x4A, NoMapping, Source Types: StackEmpty + Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty + Native Offset: 0x59, Epilog, Source Types: StackEmpty + Native Offset: 0x5F, Prolog, Source Types: StackEmpty + Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid + Native Offset: 0x71, Epilog, Source Types: StackEmpty + Native Offset: 0x76, Prolog, Source Types: StackEmpty + Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty + Native Offset: 0x82, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x3C + End Offset: 0x3E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x48 + End Offset: 0x59 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x6A + End Offset: 0x76 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + +11e80: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11e81: 48 83 ec 20 sub rsp, 32 + UWOP_ALLOC_SMALL 32 0 + +11e85: 48 8d 6c 24 20 lea rbp, [rsp + 32] +11e8a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11e8f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 +11e94: 33 c0 xor eax, eax +11e96: 48 89 45 f8 mov qword ptr [rbp - 8], rax +11e9a: 48 8d 7d e8 lea rdi, [rbp - 24] +11e9e: ff 15 e4 34 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11ea4: 90 nop +11ea5: 33 ff xor edi, edi + RDI is live +11ea7: ff 15 eb 36 02 00 call qword ptr [0x35598] // [ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() (METHOD_ENTRY) + RDI is dead + RCX is live +11ead: 48 85 c9 test rcx, rcx +11eb0: 75 0c jne 0x11ebe +11eb2: ff 15 c8 34 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) + RAX is live + RCX is dead +11eb8: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11ebc: eb 0d jmp 0x11ecb + RAX is dead + sp-32 is dead +11ebe: ff 15 d4 34 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) + RAX is live +11ec4: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11ec8: eb 01 jmp 0x11ecb + RAX is dead +11eca: 90 nop +11ecb: 48 8d 7d e8 lea rdi, [rbp - 24] +11ecf: ff 15 bb 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11ed5: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] + RAX is live +11ed9: 48 83 c4 20 add rsp, 32 + RAX is dead + RDI is live + sp-32 is dead +11edd: 5d pop rbp +11ede: c3 ret + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Id: 28 +StartAddress: 0x00011EDF +Size: 23 bytes +UnwindRVA: 0x00010A2C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11edf: 50 push rax +11ee0: ff 15 ba 34 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) + RAX is live + RDI is dead +11ee6: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +11eea: 48 8d 05 d9 ff ff ff lea rax, [0x11eca] + RAX is dead +11ef1: 48 83 c4 08 add rsp, 8 + sp-32 is dead +11ef5: c3 ret + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Id: 29 +StartAddress: 0x00011EF6 +Size: 17 bytes +UnwindRVA: 0x00010A38 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11ef6: 50 push rax +11ef7: 48 8d 7d e8 lea rdi, [rbp - 24] +11efb: ff 15 8f 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11f01: 90 nop +11f02: 48 83 c4 08 add rsp, 8 +11f06: c3 ret + +_______________________________________________ + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Handle: 0x06000010 +Rid: 16 +EntryPointRuntimeFunctionId: 30 +Number of RuntimeFunctions: 3 +Number of fixups: 4 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Id: 30 +StartAddress: 0x00011F10 +Size: 115 bytes +UnwindRVA: 0x00010A88 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 131C8, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11F38) TryEnd 0049 (RVA 11F59) HndOff 0073 (RVA 11F83) HndEnd 008E (RVA 11F9E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11F38) TryEnd 005A (RVA 11F6A) HndOff 008E (RVA 11F9E) HndEnd 009F (RVA 11FAF) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 79 65 02 02 EA 06 5A 16 52 24 3A 05 0A 86 52 96 +00000010: 42 00 3A 02 08 5A AA 00 2A 02 0A 86 52 94 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x59, NoMapping, Source Types: StackEmpty + Native Offset: 0x5A, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x64, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x6C, Epilog, Source Types: StackEmpty + Native Offset: 0x73, Prolog, Source Types: StackEmpty + Native Offset: 0x74, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x89, Epilog, Source Types: StackEmpty + Native Offset: 0x8E, Prolog, Source Types: StackEmpty + Native Offset: 0x8F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x99, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x9A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x47 + End Offset: 0x49 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + + Variable Number: 2 + Start Offset: 0x57 + End Offset: 0x64 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + + Variable Number: 2 + Start Offset: 0x82 + End Offset: 0x8E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + +11f10: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11f11: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11f12: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11f16: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11f1b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11f20: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 +11f25: 33 c0 xor eax, eax +11f27: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11f2b: 8b df mov ebx, edi +11f2d: 48 8d 7d d0 lea rdi, [rbp - 48] +11f31: ff 15 51 34 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11f37: 90 nop +11f38: 8b f3 mov esi, ebx +11f3a: 33 ff xor edi, edi + RDI is live +11f3c: ff 15 5e 36 02 00 call qword ptr [0x355a0] // [ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) (METHOD_ENTRY) + RCX is live + RDI is dead +11f42: 48 85 c9 test rcx, rcx +11f45: 75 12 jne 0x11f59 +11f47: 8b f8 mov edi, eax +11f49: ff 15 11 35 02 00 call qword ptr [0x35460] // System.Threading.Tasks.ValueTask`1 System.Threading.Tasks.ValueTask.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11f4f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +11f53: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +11f57: eb 11 jmp 0x11f6a + RAX is dead +11f59: ff 15 11 35 02 00 call qword ptr [0x35470] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeValueTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11f5f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +11f63: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +11f67: eb 01 jmp 0x11f6a + RAX is dead +11f69: 90 nop +11f6a: 48 8d 7d d0 lea rdi, [rbp - 48] +11f6e: ff 15 1c 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11f74: 48 8b 45 e8 mov rax, qword ptr [rbp - 24] + RAX is live +11f78: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] +11f7c: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live +11f80: 5b pop rbx +11f81: 5d pop rbp +11f82: c3 ret + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Id: 31 +StartAddress: 0x00011F83 +Size: 27 bytes +UnwindRVA: 0x00010ABC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11f83: 50 push rax +11f84: ff 15 f6 34 02 00 call qword ptr [0x35480] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.ValueTaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +11f8a: 48 89 45 e8 mov qword ptr [rbp - 24], rax +11f8e: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +11f92: 48 8d 05 d0 ff ff ff lea rax, [0x11f69] + RAX is dead +11f99: 48 83 c4 08 add rsp, 8 +11f9d: c3 ret + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Id: 32 +StartAddress: 0x00011F9E +Size: 17 bytes +UnwindRVA: 0x00010AC8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +11f9e: 50 push rax +11f9f: 48 8d 7d d0 lea rdi, [rbp - 48] +11fa3: ff 15 e7 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +11fa9: 90 nop +11faa: 48 83 c4 08 add rsp, 8 +11fae: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Handle: 0x06000011 +Rid: 17 +EntryPointRuntimeFunctionId: 33 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Id: 33 +StartAddress: 0x00011FB0 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 131F8, #clauses = 2 +Flags 20 TryOff 0028 (RVA 11FD8) TryEnd 0045 (RVA 11FF5) HndOff 0067 (RVA 12017) HndEnd 007E (RVA 1202E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 11FD8) TryEnd 0052 (RVA 12002) HndOff 007E (RVA 1202E) HndEnd 008F (RVA 1203F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +11fb0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +11fb1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +11fb2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +11fb6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +11fbb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +11fc0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +11fc5: 33 c0 xor eax, eax +11fc7: 48 89 45 f0 mov qword ptr [rbp - 16], rax +11fcb: 8b df mov ebx, edi +11fcd: 48 8d 7d e0 lea rdi, [rbp - 32] +11fd1: ff 15 b1 33 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +11fd7: 90 nop +11fd8: 8b f3 mov esi, ebx +11fda: 33 ff xor edi, edi + RDI is live +11fdc: ff 15 c6 35 02 00 call qword ptr [0x355a8] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) (METHOD_ENTRY) + RDI is dead + RCX is live +11fe2: 48 85 c9 test rcx, rcx +11fe5: 75 0e jne 0x11ff5 +11fe7: 8b f8 mov edi, eax +11fe9: ff 15 69 34 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +11fef: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11ff3: eb 0d jmp 0x12002 + sp-40 is dead + RAX is dead +11ff5: ff 15 6d 34 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +11ffb: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +11fff: eb 01 jmp 0x12002 + RAX is dead +12001: 90 nop +12002: 48 8d 7d e0 lea rdi, [rbp - 32] +12006: ff 15 84 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +1200c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +12010: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +12014: 5b pop rbx +12015: 5d pop rbp +12016: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Id: 34 +StartAddress: 0x00012017 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12017: 50 push rax +12018: ff 15 5a 34 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +1201e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +12022: 48 8d 05 d8 ff ff ff lea rax, [0x12001] + RAX is dead +12029: 48 83 c4 08 add rsp, 8 + sp-40 is dead +1202d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Id: 35 +StartAddress: 0x0001202E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1202e: 50 push rax +1202f: 48 8d 7d e0 lea rdi, [rbp - 32] +12033: ff 15 57 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12039: 90 nop +1203a: 48 83 c4 08 add rsp, 8 +1203e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Handle: 0x06000012 +Rid: 18 +EntryPointRuntimeFunctionId: 36 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Id: 36 +StartAddress: 0x00012040 +Size: 95 bytes +UnwindRVA: 0x000109F4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 + +EH info @ 13228, #clauses = 2 +Flags 20 TryOff 0025 (RVA 12065) TryEnd 003E (RVA 1207E) HndOff 005F (RVA 1209F) HndEnd 0076 (RVA 120B6) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0025 (RVA 12065) TryEnd 004B (RVA 1208B) HndOff 0076 (RVA 120B6) HndEnd 0087 (RVA 120C7) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 +00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty + Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x4A, NoMapping, Source Types: StackEmpty + Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty + Native Offset: 0x59, Epilog, Source Types: StackEmpty + Native Offset: 0x5F, Prolog, Source Types: StackEmpty + Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid + Native Offset: 0x71, Epilog, Source Types: StackEmpty + Native Offset: 0x76, Prolog, Source Types: StackEmpty + Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty + Native Offset: 0x82, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x3C + End Offset: 0x3E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x48 + End Offset: 0x59 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x6A + End Offset: 0x76 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + +12040: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12041: 48 83 ec 20 sub rsp, 32 + UWOP_ALLOC_SMALL 32 0 + +12045: 48 8d 6c 24 20 lea rbp, [rsp + 32] +1204a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +1204f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 +12054: 33 c0 xor eax, eax +12056: 48 89 45 f8 mov qword ptr [rbp - 8], rax +1205a: 48 8d 7d e8 lea rdi, [rbp - 24] +1205e: ff 15 24 33 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +12064: 90 nop +12065: 33 ff xor edi, edi + RDI is live +12067: ff 15 43 35 02 00 call qword ptr [0x355b0] // [ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() (METHOD_ENTRY) + RDI is dead + RCX is live +1206d: 48 85 c9 test rcx, rcx +12070: 75 0c jne 0x1207e +12072: ff 15 08 33 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) + RAX is live + RCX is dead +12078: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +1207c: eb 0d jmp 0x1208b + RAX is dead + sp-32 is dead +1207e: ff 15 14 33 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) + RAX is live +12084: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +12088: eb 01 jmp 0x1208b + RAX is dead +1208a: 90 nop +1208b: 48 8d 7d e8 lea rdi, [rbp - 24] +1208f: ff 15 fb 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12095: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] + RAX is live +12099: 48 83 c4 20 add rsp, 32 + RAX is dead + RDI is live + sp-32 is dead +1209d: 5d pop rbp +1209e: c3 ret + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Id: 37 +StartAddress: 0x0001209F +Size: 23 bytes +UnwindRVA: 0x00010A2C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1209f: 50 push rax +120a0: ff 15 fa 32 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) + RAX is live + RDI is dead +120a6: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +120aa: 48 8d 05 d9 ff ff ff lea rax, [0x1208a] + RAX is dead +120b1: 48 83 c4 08 add rsp, 8 + sp-32 is dead +120b5: c3 ret + +System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Id: 38 +StartAddress: 0x000120B6 +Size: 17 bytes +UnwindRVA: 0x00010A38 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +120b6: 50 push rax +120b7: 48 8d 7d e8 lea rdi, [rbp - 24] +120bb: ff 15 cf 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +120c1: 90 nop +120c2: 48 83 c4 08 add rsp, 8 +120c6: c3 ret + +_______________________________________________ + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Handle: 0x06000013 +Rid: 19 +EntryPointRuntimeFunctionId: 39 +Number of RuntimeFunctions: 3 +Number of fixups: 4 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Id: 39 +StartAddress: 0x000120D0 +Size: 115 bytes +UnwindRVA: 0x00010A88 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13258, #clauses = 2 +Flags 20 TryOff 0028 (RVA 120F8) TryEnd 0049 (RVA 12119) HndOff 0073 (RVA 12143) HndEnd 008E (RVA 1215E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 120F8) TryEnd 005A (RVA 1212A) HndOff 008E (RVA 1215E) HndEnd 009F (RVA 1216F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 79 65 02 02 EA 06 5A 16 52 24 3A 05 0A 86 52 96 +00000010: 42 00 3A 02 08 5A AA 00 2A 02 0A 86 52 94 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x59, NoMapping, Source Types: StackEmpty + Native Offset: 0x5A, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x64, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x6C, Epilog, Source Types: StackEmpty + Native Offset: 0x73, Prolog, Source Types: StackEmpty + Native Offset: 0x74, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x89, Epilog, Source Types: StackEmpty + Native Offset: 0x8E, Prolog, Source Types: StackEmpty + Native Offset: 0x8F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x99, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x9A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x47 + End Offset: 0x49 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + + Variable Number: 2 + Start Offset: 0x57 + End Offset: 0x64 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + + Variable Number: 2 + Start Offset: 0x82 + End Offset: 0x8E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -24 + +120d0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +120d1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +120d2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +120d6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +120db: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +120e0: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 +120e5: 33 c0 xor eax, eax +120e7: 48 89 45 f0 mov qword ptr [rbp - 16], rax +120eb: 8b df mov ebx, edi +120ed: 48 8d 7d d0 lea rdi, [rbp - 48] +120f1: ff 15 91 32 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +120f7: 90 nop +120f8: 8b f3 mov esi, ebx +120fa: 33 ff xor edi, edi + RDI is live +120fc: ff 15 b6 34 02 00 call qword ptr [0x355b8] // [ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) (METHOD_ENTRY) + RCX is live + RDI is dead +12102: 48 85 c9 test rcx, rcx +12105: 75 12 jne 0x12119 +12107: 8b f8 mov edi, eax +12109: ff 15 51 33 02 00 call qword ptr [0x35460] // System.Threading.Tasks.ValueTask`1 System.Threading.Tasks.ValueTask.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +1210f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12113: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +12117: eb 11 jmp 0x1212a + RAX is dead +12119: ff 15 51 33 02 00 call qword ptr [0x35470] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeValueTaskReturningThunk() (METHOD_ENTRY) + RAX is live +1211f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12123: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +12127: eb 01 jmp 0x1212a + RAX is dead +12129: 90 nop +1212a: 48 8d 7d d0 lea rdi, [rbp - 48] +1212e: ff 15 5c 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12134: 48 8b 45 e8 mov rax, qword ptr [rbp - 24] + RAX is live +12138: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] +1213c: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live +12140: 5b pop rbx +12141: 5d pop rbp +12142: c3 ret + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Id: 40 +StartAddress: 0x00012143 +Size: 27 bytes +UnwindRVA: 0x00010ABC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12143: 50 push rax +12144: ff 15 36 33 02 00 call qword ptr [0x35480] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.ValueTaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +1214a: 48 89 45 e8 mov qword ptr [rbp - 24], rax +1214e: 48 89 55 f0 mov qword ptr [rbp - 16], rdx +12152: 48 8d 05 d0 ff ff ff lea rax, [0x12129] + RAX is dead +12159: 48 83 c4 08 add rsp, 8 +1215d: c3 ret + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Id: 41 +StartAddress: 0x0001215E +Size: 17 bytes +UnwindRVA: 0x00010AC8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1215e: 50 push rax +1215f: 48 8d 7d d0 lea rdi, [rbp - 48] +12163: ff 15 27 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12169: 90 nop +1216a: 48 83 c4 08 add rsp, 8 +1216e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.SmallNonRuntimeAsync(int) +Handle: 0x06000014 +Rid: 20 +EntryPointRuntimeFunctionId: 42 +Number of RuntimeFunctions: 1 +Number of fixups: 7 + TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) + TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) + TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) + +System.Threading.Tasks.Task`1 InlineThunks.SmallNonRuntimeAsync(int) +Id: 42 +StartAddress: 0x00012170 +Size: 155 bytes +UnwindRVA: 0x00010AD4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0007 +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op 8 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 09 54 02 01 28 22 95 C8 53 72 9B A4 A8 FF 8A 02 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x14, IL Offset: 0x0005, Source Types: SourceTypeInvalid + Native Offset: 0x1E, IL Offset: 0x0006, Source Types: StackEmpty + Native Offset: 0x3C, IL Offset: 0x0011, Source Types: StackEmpty + Native Offset: 0x4A, IL Offset: 0x0018, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x001f, Source Types: StackEmpty + Native Offset: 0x7B, IL Offset: 0x002c, Source Types: StackEmpty + Native Offset: 0x8F, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x14 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x14 + End Offset: 0x47 + Loc Type: VLT_REG + Register: RBX + +12170: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12171: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12173: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +12175: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12176: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +12177: 48 8d 6c 24 20 lea rbp, [rsp + 32] +1217c: 33 c0 xor eax, eax +1217e: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12182: 8b df mov ebx, edi +12184: ff 15 be 31 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) +1218a: 48 89 45 e0 mov qword ptr [rbp - 32], rax +1218e: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] +12192: ff 15 70 32 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) +12198: 4c 8b 35 f9 34 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) +1219f: 4b 8d 3c 37 lea rdi, [r15 + r14] +121a3: 48 8b f0 mov rsi, rax +121a6: ff 15 54 31 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +121ac: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +121b0: 48 8b 35 e9 34 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) +121b7: 89 1c 37 mov dword ptr [rdi + rsi], ebx +121ba: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +121be: 48 8b 35 cb 34 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) +121c5: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +121cc: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +121d0: 40 38 3f cmp byte ptr [rdi], dil +121d3: 49 8b fe mov rdi, r14 +121d6: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +121da: 48 8b 35 f7 33 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) +121e1: 48 8d 55 e0 lea rdx, [rbp - 32] +121e5: ff 15 b5 32 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) +121eb: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +121ef: 40 38 3f cmp byte ptr [rdi], dil +121f2: 49 8b fe mov rdi, r14 +121f5: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +121f9: ff 15 11 32 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) +121ff: 90 nop +12200: 48 83 c4 08 add rsp, 8 +12204: 5b pop rbx +12205: 41 5e pop r14 +12207: 41 5f pop r15 +12209: 5d pop rbp +1220a: c3 ret + +_______________________________________________ + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallNonRuntimeValueTaskAsync(int) +Handle: 0x06000015 +Rid: 21 +EntryPointRuntimeFunctionId: 43 +Number of RuntimeFunctions: 1 +Number of fixups: 9 + TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) + TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) + +System.Threading.Tasks.ValueTask`1 InlineThunks.SmallNonRuntimeValueTaskAsync(int) +Id: 43 +StartAddress: 0x00012210 +Size: 194 bytes +UnwindRVA: 0x00010AF4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000A +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 09 55 02 02 84 88 94 44 29 25 67 93 24 EA 7B 45 +00000010: 02 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x21, IL Offset: 0x0005, Source Types: SourceTypeInvalid + Native Offset: 0x2B, IL Offset: 0x0006, Source Types: StackEmpty + Native Offset: 0x54, IL Offset: 0x0011, Source Types: StackEmpty + Native Offset: 0x62, IL Offset: 0x0018, Source Types: StackEmpty + Native Offset: 0x74, IL Offset: 0x001f, Source Types: StackEmpty + Native Offset: 0x93, IL Offset: 0x002c, Source Types: StackEmpty + Native Offset: 0xB7, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x21 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x21 + End Offset: 0x5F + Loc Type: VLT_REG + Register: RBX + +12210: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12211: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12213: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +12215: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12216: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +1221a: 48 8d 6c 24 40 lea rbp, [rsp + 64] +1221f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12224: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 +12229: 33 c0 xor eax, eax +1222b: 48 89 45 e0 mov qword ptr [rbp - 32], rax +1222f: 8b df mov ebx, edi +12231: ff 15 19 31 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) +12237: 48 89 45 e0 mov qword ptr [rbp - 32], rax +1223b: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] +1223f: ff 15 e3 31 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) +12245: 48 89 45 d0 mov qword ptr [rbp - 48], rax +12249: 48 89 55 d8 mov qword ptr [rbp - 40], rdx +1224d: 4c 8b 35 5c 34 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) +12254: 4b 8d 3c 37 lea rdi, [r15 + r14] +12258: 48 8d 75 d0 lea rsi, [rbp - 48] +1225c: ff 15 a6 30 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) +12262: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] +12264: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +12268: 48 8b 35 49 34 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) +1226f: 89 1c 37 mov dword ptr [rdi + rsi], ebx +12272: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +12276: 48 8b 35 2b 34 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) +1227d: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +12284: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +12288: 40 38 3f cmp byte ptr [rdi], dil +1228b: 49 8b fe mov rdi, r14 +1228e: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +12292: 48 8b 35 47 33 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) +12299: 48 8d 55 e0 lea rdx, [rbp - 32] +1229d: ff 15 05 32 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) +122a3: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] +122a7: 40 38 3f cmp byte ptr [rdi], dil +122aa: 49 8b fe mov rdi, r14 +122ad: 48 03 7d e0 add rdi, qword ptr [rbp - 32] +122b1: ff 15 89 31 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) +122b7: 48 89 45 c0 mov qword ptr [rbp - 64], rax +122bb: 48 89 55 c8 mov qword ptr [rbp - 56], rdx +122bf: 48 8b 45 c0 mov rax, qword ptr [rbp - 64] +122c3: 48 8b 55 c8 mov rdx, qword ptr [rbp - 56] +122c7: 48 83 c4 28 add rsp, 40 +122cb: 5b pop rbx +122cc: 41 5e pop r14 +122ce: 41 5f pop r15 +122d0: 5d pop rbp +122d1: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Handle: 0x06000016 +Rid: 22 +EntryPointRuntimeFunctionId: 44 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Id: 44 +StartAddress: 0x000122E0 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13288, #clauses = 2 +Flags 20 TryOff 0028 (RVA 12308) TryEnd 0045 (RVA 12325) HndOff 0067 (RVA 12347) HndEnd 007E (RVA 1235E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 12308) TryEnd 0052 (RVA 12332) HndOff 007E (RVA 1235E) HndEnd 008F (RVA 1236F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +122e0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +122e1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +122e2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +122e6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +122eb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +122f0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +122f5: 33 c0 xor eax, eax +122f7: 48 89 45 f0 mov qword ptr [rbp - 16], rax +122fb: 8b df mov ebx, edi +122fd: 48 8d 7d e0 lea rdi, [rbp - 32] +12301: ff 15 81 30 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +12307: 90 nop +12308: 8b f3 mov esi, ebx +1230a: 33 ff xor edi, edi + RDI is live +1230c: ff 15 ae 32 02 00 call qword ptr [0x355c0] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) (METHOD_ENTRY) + RDI is dead + RCX is live +12312: 48 85 c9 test rcx, rcx +12315: 75 0e jne 0x12325 +12317: 8b f8 mov edi, eax +12319: ff 15 39 31 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +1231f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +12323: eb 0d jmp 0x12332 + sp-40 is dead + RAX is dead +12325: ff 15 3d 31 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +1232b: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +1232f: eb 01 jmp 0x12332 + RAX is dead +12331: 90 nop +12332: 48 8d 7d e0 lea rdi, [rbp - 32] +12336: ff 15 54 30 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +1233c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +12340: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +12344: 5b pop rbx +12345: 5d pop rbp +12346: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Id: 45 +StartAddress: 0x00012347 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12347: 50 push rax +12348: ff 15 2a 31 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +1234e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +12352: 48 8d 05 d8 ff ff ff lea rax, [0x12331] + RAX is dead +12359: 48 83 c4 08 add rsp, 8 + sp-40 is dead +1235d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Id: 46 +StartAddress: 0x0001235E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1235e: 50 push rax +1235f: 48 8d 7d e0 lea rdi, [rbp - 32] +12363: ff 15 27 30 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12369: 90 nop +1236a: 48 83 c4 08 add rsp, 8 +1236e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Handle: 0x06000017 +Rid: 23 +EntryPointRuntimeFunctionId: 47 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Id: 47 +StartAddress: 0x00012370 +Size: 95 bytes +UnwindRVA: 0x000109F4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 + +EH info @ 132B8, #clauses = 2 +Flags 20 TryOff 0025 (RVA 12395) TryEnd 003E (RVA 123AE) HndOff 005F (RVA 123CF) HndEnd 0076 (RVA 123E6) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0025 (RVA 12395) TryEnd 004B (RVA 123BB) HndOff 0076 (RVA 123E6) HndEnd 0087 (RVA 123F7) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 +00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty + Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x4A, NoMapping, Source Types: StackEmpty + Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty + Native Offset: 0x59, Epilog, Source Types: StackEmpty + Native Offset: 0x5F, Prolog, Source Types: StackEmpty + Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid + Native Offset: 0x71, Epilog, Source Types: StackEmpty + Native Offset: 0x76, Prolog, Source Types: StackEmpty + Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty + Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty + Native Offset: 0x82, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x3C + End Offset: 0x3E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x48 + End Offset: 0x59 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + + Variable Number: 0 + Start Offset: 0x6A + End Offset: 0x76 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -32 + +12370: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12371: 48 83 ec 20 sub rsp, 32 + UWOP_ALLOC_SMALL 32 0 + +12375: 48 8d 6c 24 20 lea rbp, [rsp + 32] +1237a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +1237f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 +12384: 33 c0 xor eax, eax +12386: 48 89 45 f8 mov qword ptr [rbp - 8], rax +1238a: 48 8d 7d e8 lea rdi, [rbp - 24] +1238e: ff 15 f4 2f 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +12394: 90 nop +12395: 33 ff xor edi, edi + RDI is live +12397: ff 15 2b 32 02 00 call qword ptr [0x355c8] // [ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() (METHOD_ENTRY) + RDI is dead + RCX is live +1239d: 48 85 c9 test rcx, rcx +123a0: 75 0c jne 0x123ae +123a2: ff 15 d8 2f 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) + RAX is live + RCX is dead +123a8: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +123ac: eb 0d jmp 0x123bb + RAX is dead + sp-32 is dead +123ae: ff 15 e4 2f 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) + RAX is live +123b4: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +123b8: eb 01 jmp 0x123bb + RAX is dead +123ba: 90 nop +123bb: 48 8d 7d e8 lea rdi, [rbp - 24] +123bf: ff 15 cb 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +123c5: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] + RAX is live +123c9: 48 83 c4 20 add rsp, 32 + RAX is dead + RDI is live + sp-32 is dead +123cd: 5d pop rbp +123ce: c3 ret + +System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Id: 48 +StartAddress: 0x000123CF +Size: 23 bytes +UnwindRVA: 0x00010A2C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +123cf: 50 push rax +123d0: ff 15 ca 2f 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) + RAX is live + RDI is dead +123d6: 48 89 45 e0 mov qword ptr [rbp - 32], rax + sp-32 is live +123da: 48 8d 05 d9 ff ff ff lea rax, [0x123ba] + RAX is dead +123e1: 48 83 c4 08 add rsp, 8 + sp-32 is dead +123e5: c3 ret + +System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Id: 49 +StartAddress: 0x000123E6 +Size: 17 bytes +UnwindRVA: 0x00010A38 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +123e6: 50 push rax +123e7: 48 8d 7d e8 lea rdi, [rbp - 24] +123eb: ff 15 9f 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +123f1: 90 nop +123f2: 48 83 c4 08 add rsp, 8 +123f6: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Handle: 0x06000018 +Rid: 24 +EntryPointRuntimeFunctionId: 50 +Number of RuntimeFunctions: 3 +Number of fixups: 2 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Id: 50 +StartAddress: 0x00012400 +Size: 103 bytes +UnwindRVA: 0x000109A0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 132E8, #clauses = 2 +Flags 20 TryOff 0028 (RVA 12428) TryEnd 0045 (RVA 12445) HndOff 0067 (RVA 12467) HndEnd 007E (RVA 1247E) ClsFlt 0000 CATCH: System.Exception +Flags 04 TryOff 0028 (RVA 12428) TryEnd 0052 (RVA 12452) HndOff 007E (RVA 1247E) HndEnd 008F (RVA 1248F) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 +00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 +00000020: 0A 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty + Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty + Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty + Native Offset: 0x51, NoMapping, Source Types: StackEmpty + Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty + Native Offset: 0x60, Epilog, Source Types: StackEmpty + Native Offset: 0x67, Prolog, Source Types: StackEmpty + Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid + Native Offset: 0x79, Epilog, Source Types: StackEmpty + Native Offset: 0x7E, Prolog, Source Types: StackEmpty + Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty + Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty + Native Offset: 0x8A, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x28 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x32 + End Offset: 0x37 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 2 + Start Offset: 0x43 + End Offset: 0x45 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x4F + End Offset: 0x60 + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + + Variable Number: 2 + Start Offset: 0x72 + End Offset: 0x7E + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -40 + +12400: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12401: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12402: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +12406: 48 8d 6c 24 30 lea rbp, [rsp + 48] +1240b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12410: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +12415: 33 c0 xor eax, eax +12417: 48 89 45 f0 mov qword ptr [rbp - 16], rax +1241b: 8b df mov ebx, edi +1241d: 48 8d 7d e0 lea rdi, [rbp - 32] +12421: ff 15 61 2f 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) +12427: 90 nop +12428: 8b f3 mov esi, ebx +1242a: 33 ff xor edi, edi + RDI is live +1242c: ff 15 9e 31 02 00 call qword ptr [0x355d0] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) (METHOD_ENTRY) + RDI is dead + RCX is live +12432: 48 85 c9 test rcx, rcx +12435: 75 0e jne 0x12445 +12437: 8b f8 mov edi, eax +12439: ff 15 19 30 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) + RAX is live + RCX is dead +1243f: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +12443: eb 0d jmp 0x12452 + sp-40 is dead + RAX is dead +12445: ff 15 1d 30 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) + RAX is live +1244b: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +1244f: eb 01 jmp 0x12452 + RAX is dead +12451: 90 nop +12452: 48 8d 7d e0 lea rdi, [rbp - 32] +12456: ff 15 34 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +1245c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] + RAX is live +12460: 48 83 c4 28 add rsp, 40 + RAX is dead + RDI is live + sp-40 is dead +12464: 5b pop rbx +12465: 5d pop rbp +12466: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Id: 51 +StartAddress: 0x00012467 +Size: 23 bytes +UnwindRVA: 0x000109DC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12467: 50 push rax +12468: ff 15 0a 30 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) + RAX is live + RDI is dead +1246e: 48 89 45 d8 mov qword ptr [rbp - 40], rax + sp-40 is live +12472: 48 8d 05 d8 ff ff ff lea rax, [0x12451] + RAX is dead +12479: 48 83 c4 08 add rsp, 8 + sp-40 is dead +1247d: c3 ret + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Id: 52 +StartAddress: 0x0001247E +Size: 17 bytes +UnwindRVA: 0x000109E8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1247e: 50 push rax +1247f: 48 8d 7d e0 lea rdi, [rbp - 32] +12483: ff 15 07 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) +12489: 90 nop +1248a: 48 83 c4 08 add rsp, 8 +1248e: c3 ret + +_______________________________________________ + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) +Handle: 0x06000019 +Rid: 25 +EntryPointRuntimeFunctionId: 53 +Number of RuntimeFunctions: 1 + +System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) +Id: 53 +StartAddress: 0x00012490 +Size: 13 bytes +UnwindRVA: 0x0001097C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +Debug Info + Bounds: +00000000: 23 01 42 CA 32 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x7, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +12490: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +12491: ff 15 61 2f 02 00 call qword ptr [0x353f8] // System.Threading.Tasks.Task`1 CrossModuleHelper.SmallCrossModuleAsync(int) (METHOD_ENTRY_REF_TOKEN) +12497: 90 nop +12498: 48 83 c4 08 add rsp, 8 +1249c: c3 ret + +_______________________________________________ + +int InlineThunks.CrossModuleSyncCaller(int) +Handle: 0x0600001A +Rid: 26 +EntryPointRuntimeFunctionId: 54 +Number of RuntimeFunctions: 1 +Number of fixups: 1 + TableIndex 0, Offset 0003: int CrossModuleHelper.SmallCrossModuleSync(int) (CHECK_IL_BODY) + +int InlineThunks.CrossModuleSyncCaller(int) +Id: 54 +StartAddress: 0x000124A0 +Size: 4 bytes +UnwindRVA: 0x00010B18 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 13 01 22 B1 06 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x3, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +124a0: 8d 04 7f lea eax, [rdi + 2*rdi] +124a3: c3 ret + +_______________________________________________ + +void InlineThunks..ctor() +Handle: 0x0600001B +Rid: 27 +EntryPointRuntimeFunctionId: 55 +Number of RuntimeFunctions: 1 + +void InlineThunks..ctor() +Id: 55 +StartAddress: 0x000124B0 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 02 00 52 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +124b0: c3 ret + +_______________________________________________ + +void System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute..ctor(bool) +Handle: 0x0600001C +Rid: 28 +EntryPointRuntimeFunctionId: 56 +Number of RuntimeFunctions: 1 +Number of fixups: 1 + TableIndex 5, Offset 000D: System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) + +void System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute..ctor(bool) +Id: 56 +StartAddress: 0x000124C0 +Size: 24 bytes +UnwindRVA: 0x00010B30 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +Debug Info + Bounds: +00000000: 35 04 82 A0 18 5A 25 8B 02 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xC, IL Offset: 0x0007, Source Types: StackEmpty + Native Offset: 0x12, IL Offset: 0x000e, Source Types: StackEmpty + Native Offset: 0x12, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0xC + Loc Type: VLT_REG + Register: RDI + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x8 + Loc Type: VLT_REG + Register: RSI + +124c0: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +124c1: 48 8b 05 78 31 02 00 mov rax, qword ptr [0x35640] // System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) +124c8: 40 88 34 07 mov byte ptr [rdi + rax], sil +124cc: ff 15 a6 2e 02 00 call qword ptr [0x35378] // void System.Attribute..ctor() (METHOD_ENTRY_REF_TOKEN) +124d2: 90 nop +124d3: 48 83 c4 08 add rsp, 8 +124d7: c3 ret + +_______________________________________________ + +bool System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute.get_RuntimeAsync() +Handle: 0x0600001D +Rid: 29 +EntryPointRuntimeFunctionId: 57 +Number of RuntimeFunctions: 1 +Number of fixups: 1 + TableIndex 5, Offset 000D: System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) + +bool System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute.get_RuntimeAsync() +Id: 57 +StartAddress: 0x000124E0 +Size: 12 bytes +UnwindRVA: 0x00010B40 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 33 01 82 04 6B 01 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xB, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x7 + Loc Type: VLT_REG + Register: RDI + +124e0: 48 8b 05 59 31 02 00 mov rax, qword ptr [0x35640] // System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) +124e7: 0f b6 04 07 movzx eax, byte ptr [rdi + rax] +124eb: c3 ret + +_______________________________________________ + +void InlineThunks+<>c..cctor() +Handle: 0x0600001E +Rid: 30 +EntryPointRuntimeFunctionId: 58 +Number of RuntimeFunctions: 1 +Number of fixups: 1 + TableIndex 5, Offset 0005: InlineThunks+<>c (TYPE_HANDLE) + +void InlineThunks+<>c..cctor() +Id: 58 +StartAddress: 0x000124F0 +Size: 31 bytes +UnwindRVA: 0x00010B4C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) + +Debug Info + Bounds: +00000000: 45 03 02 A1 30 48 28 D9 02 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xA, IL Offset: 0x0005, Source Types: SourceTypeInvalid + Native Offset: 0x1C, IL Offset: 0x000a, Source Types: StackEmpty + Native Offset: 0x1C, Epilog, Source Types: StackEmpty + +124f0: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +124f1: ff 15 49 2e 02 00 call qword ptr [0x35340] // InlineThunks+<>c (NEW_OBJECT) +124f7: 48 8b d8 mov rbx, rax +124fa: ff 15 30 2e 02 00 call qword ptr [0x35330] // InlineThunks+<>c (STATIC_BASE_GC) +12500: 48 8b f8 mov rdi, rax +12503: 48 8b f3 mov rsi, rbx +12506: ff 15 f4 2d 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +1250c: 90 nop +1250d: 5b pop rbx +1250e: c3 ret + +_______________________________________________ + +void InlineThunks+<>c..ctor() +Handle: 0x0600001F +Rid: 31 +EntryPointRuntimeFunctionId: 59 +Number of RuntimeFunctions: 1 + +void InlineThunks+<>c..ctor() +Id: 59 +StartAddress: 0x00012510 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 02 00 52 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +12510: c3 ret + +_______________________________________________ + +void InlineThunks+<>c.
b__3_0() +Handle: 0x06000020 +Rid: 32 +EntryPointRuntimeFunctionId: 60 +Number of RuntimeFunctions: 1 +Number of fixups: 2 + TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) + TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +void InlineThunks+<>c.
b__3_0() +Id: 60 +StartAddress: 0x00012520 +Size: 58 bytes +UnwindRVA: 0x00010B60 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 + +Debug Info + Bounds: +00000000: 45 04 02 41 70 28 3B 29 2B 00 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty + Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty + Native Offset: 0x33, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x10 + Loc Type: VLT_REG + Register: RDI + +12520: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12521: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12525: 48 8d 6c 24 10 lea rbp, [rsp + 16] +1252a: 33 c0 xor eax, eax +1252c: 48 89 45 f8 mov qword ptr [rbp - 8], rax +12530: ff 15 92 2f 02 00 call qword ptr [0x354c8] // System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() (METHOD_ENTRY_DEF_TOKEN) +12536: 48 8b f8 mov rdi, rax +12539: 4c 8d 1d 80 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) +12540: 39 3f cmp dword ptr [rdi], edi +12542: 41 ff 13 call qword ptr [r11] +12545: 48 89 45 f8 mov qword ptr [rbp - 8], rax +12549: 48 8d 7d f8 lea rdi, [rbp - 8] +1254d: ff 15 9d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) +12553: 90 nop +12554: 48 83 c4 10 add rsp, 16 +12558: 5d pop rbp +12559: c3 ret + +_______________________________________________ + +void InlineThunks+<>c.
b__3_1() +Handle: 0x06000021 +Rid: 33 +EntryPointRuntimeFunctionId: 61 +Number of RuntimeFunctions: 1 +Number of fixups: 2 + TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) + TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +void InlineThunks+<>c.
b__3_1() +Id: 61 +StartAddress: 0x00012560 +Size: 58 bytes +UnwindRVA: 0x00010B60 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 + +Debug Info + Bounds: +00000000: 45 04 02 41 70 28 3B 29 2B 00 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty + Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty + Native Offset: 0x33, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x10 + Loc Type: VLT_REG + Register: RDI + +12560: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12561: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12565: 48 8d 6c 24 10 lea rbp, [rsp + 16] +1256a: 33 c0 xor eax, eax +1256c: 48 89 45 f8 mov qword ptr [rbp - 8], rax +12570: ff 15 6a 2f 02 00 call qword ptr [0x354e0] // System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() (METHOD_ENTRY_DEF_TOKEN) +12576: 48 8b f8 mov rdi, rax +12579: 4c 8d 1d 40 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) +12580: 39 3f cmp dword ptr [rdi], edi +12582: 41 ff 13 call qword ptr [r11] +12585: 48 89 45 f8 mov qword ptr [rbp - 8], rax +12589: 48 8d 7d f8 lea rdi, [rbp - 8] +1258d: ff 15 5d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) +12593: 90 nop +12594: 48 83 c4 10 add rsp, 16 +12598: 5d pop rbp +12599: c3 ret + +_______________________________________________ + +void InlineThunks+<>c.
b__3_2() +Handle: 0x06000022 +Rid: 34 +EntryPointRuntimeFunctionId: 62 +Number of RuntimeFunctions: 1 +Number of fixups: 2 + TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) + TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + +void InlineThunks+<>c.
b__3_2() +Id: 62 +StartAddress: 0x000125A0 +Size: 58 bytes +UnwindRVA: 0x00010B60 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 + +Debug Info + Bounds: +00000000: 45 04 02 41 70 28 3B 29 2B 00 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty + Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty + Native Offset: 0x33, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x10 + Loc Type: VLT_REG + Register: RDI + +125a0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +125a1: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +125a5: 48 8d 6c 24 10 lea rbp, [rsp + 16] +125aa: 33 c0 xor eax, eax +125ac: 48 89 45 f8 mov qword ptr [rbp - 8], rax +125b0: ff 15 7a 2f 02 00 call qword ptr [0x35530] // System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() (METHOD_ENTRY_DEF_TOKEN) +125b6: 48 8b f8 mov rdi, rax +125b9: 4c 8d 1d 00 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) +125c0: 39 3f cmp dword ptr [rdi], edi +125c2: 41 ff 13 call qword ptr [r11] +125c5: 48 89 45 f8 mov qword ptr [rbp - 8], rax +125c9: 48 8d 7d f8 lea rdi, [rbp - 8] +125cd: ff 15 1d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) +125d3: 90 nop +125d4: 48 83 c4 10 add rsp, 16 +125d8: 5d pop rbp +125d9: c3 ret + +_______________________________________________ + +void InlineThunks+d__20..ctor() +Handle: 0x06000023 +Rid: 35 +EntryPointRuntimeFunctionId: 63 +Number of RuntimeFunctions: 1 + +void InlineThunks+d__20..ctor() +Id: 63 +StartAddress: 0x000125E0 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 02 00 52 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +125e0: c3 ret + +_______________________________________________ + +void InlineThunks+d__20.MoveNext() +Handle: 0x06000024 +Rid: 36 +EntryPointRuntimeFunctionId: 64 +Number of RuntimeFunctions: 2 +Number of fixups: 4 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) + +void InlineThunks+d__20.MoveNext() +Id: 64 +StartAddress: 0x000125F0 +Size: 62 bytes +UnwindRVA: 0x00010B74 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0003 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op 8 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13318, #clauses = 1 +Flags 00 TryOff 0016 (RVA 12606) TryEnd 0022 (RVA 12612) HndOff 003E (RVA 1262E) HndEnd 006D (RVA 1265D) ClsFlt 100000C CATCH: System.Exception + +Debug Info + Bounds: +00000000: 49 64 02 01 B1 81 94 42 AC A5 53 53 13 0A 00 84 +00000010: 02 08 15 0D 8B A4 47 14 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0xC, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x16, IL Offset: 0x0007, Source Types: StackEmpty + Native Offset: 0x22, IL Offset: 0x002a, Source Types: StackEmpty + Native Offset: 0x29, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x36, IL Offset: 0x003f, Source Types: StackEmpty + Native Offset: 0x36, Epilog, Source Types: StackEmpty + Native Offset: 0x3E, Prolog, Source Types: StackEmpty + Native Offset: 0x3F, IL Offset: 0x0012, Source Types: SourceTypeInvalid + Native Offset: 0x42, IL Offset: 0x0013, Source Types: StackEmpty + Native Offset: 0x54, IL Offset: 0x001b, Source Types: StackEmpty + Native Offset: 0x68, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x29 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x3E + End Offset: 0x4D + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -16 + + Variable Number: 0 + Start Offset: 0x4D + End Offset: 0x54 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 2 + Start Offset: 0x22 + End Offset: 0x30 + Loc Type: VLT_REG + Register: RSI + +125f0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +125f1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +125f2: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +125f3: 48 8d 6c 24 10 lea rbp, [rsp + 16] +125f8: 48 89 7d f0 mov qword ptr [rbp - 16], rdi +125fc: 40 38 3f cmp byte ptr [rdi], dil +125ff: 48 8b 1d 8a 30 02 00 mov rbx, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) +12606: 48 8b 35 93 30 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) +1260d: 8b 34 37 mov esi, dword ptr [rdi + rsi] +12610: 03 f6 add esi, esi +12612: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 +12619: 48 03 3d 78 30 02 00 add rdi, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + RDI is live + RDI is live + sp-16 is live +12620: ff 15 f2 2d 02 00 call qword ptr [0x35418] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetResult(!0) (METHOD_ENTRY) + RDI is dead +12626: 90 nop +12627: 48 83 c4 08 add rsp, 8 + RDI is dead + sp-16 is dead +1262b: 5b pop rbx +1262c: 5d pop rbp +1262d: c3 ret + +void InlineThunks+d__20.MoveNext() +Id: 65 +StartAddress: 0x0001262E +Size: 47 bytes +UnwindRVA: 0x00010BA4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1262e: 50 push rax +1262f: 48 8b f7 mov rsi, rdi + RSI is live +12632: 48 8b 1d 57 30 02 00 mov rbx, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) +12639: 48 8b 7d f0 mov rdi, qword ptr [rbp - 16] +1263d: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 +12644: 48 03 3d 4d 30 02 00 add rdi, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + RDI is live + RDI is dead + sp-16 is dead +1264b: ff 15 cf 2d 02 00 call qword ptr [0x35420] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(System.Exception) (METHOD_ENTRY) + RDI is dead + RSI is dead +12651: 48 8d 05 ce ff ff ff lea rax, [0x12626] +12658: 48 83 c4 08 add rsp, 8 +1265c: c3 ret + +_______________________________________________ + +void InlineThunks+d__20.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +Handle: 0x06000025 +Rid: 37 +EntryPointRuntimeFunctionId: 66 +Number of RuntimeFunctions: 1 + +void InlineThunks+d__20.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +Id: 66 +StartAddress: 0x00012660 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 03 01 92 2C 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RSI + +12660: c3 ret + +_______________________________________________ + +void InlineThunks+d__21..ctor() +Handle: 0x06000026 +Rid: 38 +EntryPointRuntimeFunctionId: 67 +Number of RuntimeFunctions: 1 + +void InlineThunks+d__21..ctor() +Id: 67 +StartAddress: 0x00012670 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 02 00 52 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + +12670: c3 ret + +_______________________________________________ + +void InlineThunks+d__21.MoveNext() +Handle: 0x06000027 +Rid: 39 +EntryPointRuntimeFunctionId: 68 +Number of RuntimeFunctions: 2 +Number of fixups: 4 + TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) + TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) + +void InlineThunks+d__21.MoveNext() +Id: 68 +StartAddress: 0x00012680 +Size: 62 bytes +UnwindRVA: 0x00010B74 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0003 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op 8 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13330, #clauses = 1 +Flags 00 TryOff 0016 (RVA 12696) TryEnd 0022 (RVA 126A2) HndOff 003E (RVA 126BE) HndEnd 006D (RVA 126ED) ClsFlt 100000C CATCH: System.Exception + +Debug Info + Bounds: +00000000: 49 64 02 01 B1 81 94 42 AC A5 53 53 13 0A 00 84 +00000010: 02 08 15 0D 8B A4 47 14 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0xC, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x16, IL Offset: 0x0007, Source Types: StackEmpty + Native Offset: 0x22, IL Offset: 0x002a, Source Types: StackEmpty + Native Offset: 0x29, IL Offset: 0x0032, Source Types: StackEmpty + Native Offset: 0x36, IL Offset: 0x003f, Source Types: StackEmpty + Native Offset: 0x36, Epilog, Source Types: StackEmpty + Native Offset: 0x3E, Prolog, Source Types: StackEmpty + Native Offset: 0x3F, IL Offset: 0x0012, Source Types: SourceTypeInvalid + Native Offset: 0x42, IL Offset: 0x0013, Source Types: StackEmpty + Native Offset: 0x54, IL Offset: 0x001b, Source Types: StackEmpty + Native Offset: 0x68, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x29 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 0 + Start Offset: 0x3E + End Offset: 0x4D + Loc Type: VLT_STK + Base Register: RBP + Stack Offset: -16 + + Variable Number: 0 + Start Offset: 0x4D + End Offset: 0x54 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 2 + Start Offset: 0x22 + End Offset: 0x30 + Loc Type: VLT_REG + Register: RSI + +12680: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12681: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12682: 50 push rax + UWOP_ALLOC_SMALL 8 0 + +12683: 48 8d 6c 24 10 lea rbp, [rsp + 16] +12688: 48 89 7d f0 mov qword ptr [rbp - 16], rdi +1268c: 40 38 3f cmp byte ptr [rdi], dil +1268f: 48 8b 1d 12 30 02 00 mov rbx, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) +12696: 48 8b 35 1b 30 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) +1269d: 8b 34 37 mov esi, dword ptr [rdi + rsi] +126a0: 03 f6 add esi, esi +126a2: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 +126a9: 48 03 3d 00 30 02 00 add rdi, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + RDI is live + RDI is live + sp-16 is live +126b0: ff 15 7a 2d 02 00 call qword ptr [0x35430] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(!0) (METHOD_ENTRY) + RDI is dead +126b6: 90 nop +126b7: 48 83 c4 08 add rsp, 8 + RDI is dead + sp-16 is dead +126bb: 5b pop rbx +126bc: 5d pop rbp +126bd: c3 ret + +void InlineThunks+d__21.MoveNext() +Id: 69 +StartAddress: 0x000126BE +Size: 47 bytes +UnwindRVA: 0x00010BA4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +126be: 50 push rax +126bf: 48 8b f7 mov rsi, rdi + RSI is live +126c2: 48 8b 1d df 2f 02 00 mov rbx, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) +126c9: 48 8b 7d f0 mov rdi, qword ptr [rbp - 16] +126cd: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 +126d4: 48 03 3d d5 2f 02 00 add rdi, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + RDI is live + RDI is dead + sp-16 is dead +126db: ff 15 57 2d 02 00 call qword ptr [0x35438] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception) (METHOD_ENTRY) + RDI is dead + RSI is dead +126e1: 48 8d 05 ce ff ff ff lea rax, [0x126b6] +126e8: 48 83 c4 08 add rsp, 8 +126ec: c3 ret + +_______________________________________________ + +void InlineThunks+d__21.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +Handle: 0x06000028 +Rid: 40 +EntryPointRuntimeFunctionId: 70 +Number of RuntimeFunctions: 1 + +void InlineThunks+d__21.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +Id: 70 +StartAddress: 0x000126F0 +Size: 1 bytes +UnwindRVA: 0x00010B24 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0000 +CountOfUnwindCodes: 0 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 + +Debug Info + Bounds: +00000000: 03 01 92 2C 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: StackEmpty + Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x1 + Loc Type: VLT_REG + Register: RSI + +126f0: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Handle: 0x0600000F +Rid: 15 +EntryPointRuntimeFunctionId: 84 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() +Id: 84 +StartAddress: 0x00012CD0 +Size: 72 bytes +UnwindRVA: 0x00010D74 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 24 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 62 00 02 54 10 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x41, Epilog, Source Types: StackEmpty + +12cd0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12cd1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12cd2: 48 83 ec 18 sub rsp, 24 + UWOP_ALLOC_SMALL 24 0 + +12cd6: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12cdb: 33 c0 xor eax, eax +12cdd: 48 89 45 f0 mov qword ptr [rbp - 16], rax +12ce1: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12ce5: 48 8b df mov rbx, rdi +12ce8: 48 8d 7d f0 lea rdi, [rbp - 16] +12cec: 48 8d 75 e8 lea rsi, [rbp - 24] +12cf0: ff 15 c2 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12cf6: 48 85 db test rbx, rbx +12cf9: 40 0f 95 c7 setne dil +12cfd: 40 0f b6 ff movzx edi, dil +12d01: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] +12d05: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] +12d09: ff 15 b1 26 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12d0f: 33 c9 xor ecx, ecx +12d11: 48 83 c4 18 add rsp, 24 +12d15: 5b pop rbx +12d16: 5d pop rbp +12d17: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Handle: 0x06000007 +Rid: 7 +EntryPointRuntimeFunctionId: 73 +Number of RuntimeFunctions: 2 + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Id: 73 +StartAddress: 0x00012740 +Size: 123 bytes +UnwindRVA: 0x00010BC4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13348, #clauses = 1 +Flags 04 TryOff 0034 (RVA 12774) TryEnd 0055 (RVA 12795) HndOff 007B (RVA 127BB) HndEnd 009D (RVA 127DD) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 66 01 02 24 E1 9A A8 0F 3A A4 0E + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x55, NoMapping, Source Types: StackEmpty + Native Offset: 0x74, Epilog, Source Types: StackEmpty + Native Offset: 0x7B, Prolog, Source Types: StackEmpty + Native Offset: 0x98, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x25 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x25 + End Offset: 0x42 + Loc Type: VLT_REG + Register: RBX + +12740: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12741: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12742: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +12746: 48 8d 6c 24 30 lea rbp, [rsp + 48] +1274b: 33 c0 xor eax, eax +1274d: 48 89 45 d8 mov qword ptr [rbp - 40], rax +12751: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12756: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +1275b: 48 89 45 f0 mov qword ptr [rbp - 16], rax +1275f: 48 89 7d d0 mov qword ptr [rbp - 48], rdi +12763: 8b de mov ebx, esi +12765: 48 8d 7d f0 lea rdi, [rbp - 16] +12769: 48 8d 75 e8 lea rsi, [rbp - 24] +1276d: ff 15 45 2c 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12773: 90 nop +12774: 48 8d 7d e0 lea rdi, [rbp - 32] +12778: 48 8d 75 d8 lea rsi, [rbp - 40] +1277c: ff 15 36 2c 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12782: 03 db add ebx, ebx +12784: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live +12788: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +1278c: 33 ff xor edi, edi +1278e: ff 15 2c 2c 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12794: 90 nop +12795: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +1279a: 40 0f 95 c7 setne dil +1279e: 40 0f b6 ff movzx edi, dil +127a2: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +127a6: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +127aa: ff 15 10 2c 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +127b0: 8b c3 mov eax, ebx +127b2: 33 c9 xor ecx, ecx +127b4: 48 83 c4 28 add rsp, 40 + sp-48 is live +127b8: 5b pop rbx +127b9: 5d pop rbp +127ba: c3 ret + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) +Id: 74 +StartAddress: 0x000127BB +Size: 34 bytes +UnwindRVA: 0x00010BF8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +127bb: 50 push rax +127bc: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +127c1: 40 0f 95 c7 setne dil +127c5: 40 0f b6 ff movzx edi, dil +127c9: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +127cd: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +127d1: ff 15 e9 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +127d7: 90 nop +127d8: 48 83 c4 08 add rsp, 8 +127dc: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Handle: 0x06000012 +Rid: 18 +EntryPointRuntimeFunctionId: 87 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() +Id: 87 +StartAddress: 0x00012DE0 +Size: 72 bytes +UnwindRVA: 0x00010D74 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 24 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +Debug Info + Bounds: +00000000: 62 00 02 54 10 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x41, Epilog, Source Types: StackEmpty + +12de0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12de1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12de2: 48 83 ec 18 sub rsp, 24 + UWOP_ALLOC_SMALL 24 0 + +12de6: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12deb: 33 c0 xor eax, eax +12ded: 48 89 45 f0 mov qword ptr [rbp - 16], rax +12df1: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12df5: 48 8b df mov rbx, rdi +12df8: 48 8d 7d f0 lea rdi, [rbp - 16] +12dfc: 48 8d 75 e8 lea rsi, [rbp - 24] +12e00: ff 15 b2 25 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12e06: 48 85 db test rbx, rbx +12e09: 40 0f 95 c7 setne dil +12e0d: 40 0f b6 ff movzx edi, dil +12e11: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] +12e15: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] +12e19: ff 15 a1 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12e1f: 33 c9 xor ecx, ecx +12e21: 48 83 c4 18 add rsp, 24 +12e25: 5b pop rbx +12e26: 5d pop rbp +12e27: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Handle: 0x0600000D +Rid: 13 +EntryPointRuntimeFunctionId: 81 +Number of RuntimeFunctions: 2 +Number of fixups: 11 + TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) + TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) + TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) + TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0016: System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) + TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) + TableIndex 5, Offset 001E: (RESUMPTION_STUB RVA[0x12720]) + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 81 +StartAddress: 0x00012AB0 +Size: 406 bytes +UnwindRVA: 0x00010CC8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000A +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 72 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 133A8, #clauses = 1 +Flags 04 TryOff 0045 (RVA 12AF5) TryEnd 00F0 (RVA 12BA0) HndOff 0196 (RVA 12C46) HndEnd 01B8 (RVA 12C68) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 19 37 02 08 15 8D 56 45 1F C0 85 D4 15 70 21 A5 +00000010: 11 EA 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x45, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xF0, NoMapping, Source Types: StackEmpty + Native Offset: 0x10F, Epilog, Source Types: StackEmpty + Native Offset: 0x11A, IL Offset: 0x0006, Source Types: Async + Native Offset: 0x171, Epilog, Source Types: StackEmpty + Native Offset: 0x17C, IL Offset: 0x0006, Source Types: Async + Native Offset: 0x196, Prolog, Source Types: StackEmpty + Native Offset: 0x1B3, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x2D + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x2D + End Offset: 0x83 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0xEB + End Offset: 0x10B + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x191 + End Offset: 0x196 + Loc Type: VLT_REG + Register: RBX + +12ab0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12ab1: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12ab3: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +12ab5: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12ab6: 48 83 ec 48 sub rsp, 72 + UWOP_ALLOC_SMALL 72 0 + +12aba: 48 8d 6c 24 60 lea rbp, [rsp + 96] +12abf: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12ac4: c5 7e 7f 45 b0 vmovdqu ymmword ptr [rbp - 80], ymm8 +12ac9: c5 79 7f 45 d0 vmovdqa xmmword ptr [rbp - 48], xmm8 +12ace: 33 c0 xor eax, eax +12ad0: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12ad4: 48 89 7d a8 mov qword ptr [rbp - 88], rdi +12ad8: 48 8b d7 mov rdx, rdi +12adb: 8b de mov ebx, esi +12add: 48 85 d2 test rdx, rdx +12ae0: 0f 85 46 01 00 00 jne 0x12c2c +12ae6: 48 8d 7d e0 lea rdi, [rbp - 32] +12aea: 48 8d 75 d8 lea rsi, [rbp - 40] +12aee: ff 15 c4 28 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is live +12af4: 90 nop +12af5: ff 15 55 28 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) + RAX is live +12afb: 48 89 45 c0 mov qword ptr [rbp - 64], rax +12aff: 4c 8b 7d c0 mov r15, qword ptr [rbp - 64] + R15 is live +12b03: ff 15 1f 29 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) +12b09: 48 89 45 b0 mov qword ptr [rbp - 80], rax +12b0d: 48 89 55 b8 mov qword ptr [rbp - 72], rdx +12b11: 4c 8b 35 98 2b 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) +12b18: 4b 8d 3c 37 lea rdi, [r15 + r14] + RDI is live +12b1c: 48 8d 75 b0 lea rsi, [rbp - 80] + RSI is live +12b20: ff 15 e2 27 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) + RAX is dead + R15 is dead +12b26: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] +12b28: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] + RDI is dead + RDI is live +12b2c: 48 8b 35 85 2b 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) + RSI is dead +12b33: 89 1c 37 mov dword ptr [rdi + rsi], ebx +12b36: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] +12b3a: 48 8b 35 67 2b 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) +12b41: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +12b48: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] +12b4c: 40 38 3f cmp byte ptr [rdi], dil +12b4f: 49 8b fe mov rdi, r14 + RDI is dead +12b52: 48 03 7d c0 add rdi, qword ptr [rbp - 64] + RDI is live +12b56: 48 8b 35 83 2a 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) +12b5d: 48 8d 55 c0 lea rdx, [rbp - 64] +12b61: ff 15 41 29 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) + RDI is dead +12b67: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] + RDI is live +12b6b: 40 38 3f cmp byte ptr [rdi], dil +12b6e: 49 8b fe mov rdi, r14 + RDI is dead +12b71: 48 03 7d c0 add rdi, qword ptr [rbp - 64] + RDI is live +12b75: ff 15 c5 28 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) + RDI is dead + RAX is live +12b7b: 48 89 45 c8 mov qword ptr [rbp - 56], rax +12b7f: 48 89 55 d0 mov qword ptr [rbp - 48], rdx +12b83: 33 f6 xor esi, esi + RSI is live +12b85: 48 89 75 c0 mov qword ptr [rbp - 64], rsi +12b89: 48 8b 75 c8 mov rsi, qword ptr [rbp - 56] +12b8d: 48 8b 55 d0 mov rdx, qword ptr [rbp - 48] +12b91: 33 ff xor edi, edi + RDI is live +12b93: ff 15 f7 28 02 00 call qword ptr [0x35490] // !!0 System.Runtime.CompilerServices.AsyncHelpers.Await(System.Threading.Tasks.ValueTask`1) (METHOD_ENTRY) + RAX is dead + RCX is live + RSI is dead + RDI is dead +12b99: 8b d8 mov ebx, eax +12b9b: 48 85 c9 test rcx, rcx +12b9e: 75 2a jne 0x12bca + RCX is dead +12ba0: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 +12ba5: 40 0f 95 c7 setne dil +12ba9: 40 0f b6 ff movzx edi, dil +12bad: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12bb1: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live + sp-88 is dead +12bb5: ff 15 05 28 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12bbb: 8b c3 mov eax, ebx +12bbd: 33 c9 xor ecx, ecx +12bbf: 48 83 c4 48 add rsp, 72 + RCX is live + sp-88 is live +12bc3: 5b pop rbx +12bc4: 41 5e pop r14 +12bc6: 41 5f pop r15 +12bc8: 5d pop rbp +12bc9: c3 ret +12bca: 48 8b 35 b7 2a 02 00 mov rsi, qword ptr [0x35688] // System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) +12bd1: 48 8b f9 mov rdi, rcx + RDI is live +12bd4: ff 15 46 27 02 00 call qword ptr [0x35320] // ALLOC_CONTINUATION (HELPER) + RCX is dead + RAX is live + RDI is dead +12bda: 48 8b d8 mov rbx, rax + RBX is live +12bdd: 48 8d 05 0c 33 02 00 lea rax, [0x35ef0] +12be4: 48 89 43 10 mov qword ptr [rbx + 16], rax +12be8: 48 c7 43 18 80 00 00 00 mov qword ptr [rbx + 24], 128 +12bf0: ff 15 b2 27 02 00 call qword ptr [0x353a8] // System.Threading.ExecutionContext System.Runtime.CompilerServices.AsyncHelpers.CaptureExecutionContext() (METHOD_ENTRY_REF_TOKEN) + RAX is dead +12bf6: 48 8d 7b 28 lea rdi, [rbx + 40] + RDI is live +12bfa: 48 8b f0 mov rsi, rax + RSI is live +12bfd: ff 15 fd 26 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) + RAX is live + RSI is dead + RDI is dead +12c03: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 +12c08: 40 0f 95 c7 setne dil +12c0c: 40 0f b6 ff movzx edi, dil +12c10: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12c14: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live + sp-88 is dead +12c18: ff 15 aa 27 02 00 call qword ptr [0x353c8] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContextsOnSuspension(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12c1e: 48 8b cb mov rcx, rbx + RCX is live +12c21: 48 83 c4 48 add rsp, 72 + sp-88 is live + RCX is dead + RBX is dead +12c25: 5b pop rbx +12c26: 41 5e pop r14 +12c28: 41 5f pop r15 +12c2a: 5d pop rbp +12c2b: c3 ret +12c2c: 48 8b 55 a8 mov rdx, qword ptr [rbp - 88] + RDX is live +12c30: 48 8b 7a 28 mov rdi, qword ptr [rdx + 40] + RDI is live +12c34: ff 15 76 27 02 00 call qword ptr [0x353b0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreExecutionContext(System.Threading.ExecutionContext) (METHOD_ENTRY_REF_TOKEN) + RDI is dead + RDX is dead +12c3a: 48 8b 55 a8 mov rdx, qword ptr [rbp - 88] + RDX is live +12c3e: 8b 5a 20 mov ebx, dword ptr [rdx + 32] +12c41: e9 5a ff ff ff jmp 0x12ba0 + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 82 +StartAddress: 0x00012C46 +Size: 34 bytes +UnwindRVA: 0x00010D4C +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + + RDX is dead +12c46: 50 push rax +12c47: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 +12c4c: 40 0f 95 c7 setne dil +12c50: 40 0f b6 ff movzx edi, dil +12c54: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12c58: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live + sp-88 is dead +12c5c: ff 15 5e 27 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RSI is dead + RDX is dead +12c62: 90 nop +12c63: 48 83 c4 08 add rsp, 8 +12c67: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Handle: 0x06000013 +Rid: 19 +EntryPointRuntimeFunctionId: 88 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) +Id: 88 +StartAddress: 0x00012E30 +Size: 85 bytes +UnwindRVA: 0x00010D58 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0008 +CountOfUnwindCodes: 4 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 +UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) + +Debug Info + Bounds: +00000000: 62 00 02 14 13 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4C, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x2B + Loc Type: VLT_REG + Register: R15 + +12e30: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12e31: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12e33: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12e34: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12e38: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12e3d: 33 c0 xor eax, eax +12e3f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12e43: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12e47: 48 8b df mov rbx, rdi +12e4a: 44 8b fe mov r15d, esi +12e4d: 48 8d 7d e8 lea rdi, [rbp - 24] +12e51: 48 8d 75 e0 lea rsi, [rbp - 32] +12e55: ff 15 5d 25 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12e5b: 45 03 ff add r15d, r15d +12e5e: 48 85 db test rbx, rbx +12e61: 40 0f 95 c7 setne dil +12e65: 40 0f b6 ff movzx edi, dil +12e69: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] +12e6d: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] +12e71: ff 15 49 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12e77: 41 8b c7 mov eax, r15d +12e7a: 33 c9 xor ecx, ecx +12e7c: 48 83 c4 10 add rsp, 16 +12e80: 5b pop rbx +12e81: 41 5f pop r15 +12e83: 5d pop rbp +12e84: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Handle: 0x06000017 +Rid: 23 +EntryPointRuntimeFunctionId: 91 +Number of RuntimeFunctions: 2 +Number of fixups: 1 + TableIndex 0, Offset 0001: System.Threading.Tasks.Task CrossModuleHelper.SmallCrossModuleAsyncVoid() (CHECK_IL_BODY) + +[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Id: 91 +StartAddress: 0x00012F30 +Size: 105 bytes +UnwindRVA: 0x00010C04 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 48 + +EH info @ 133D8, #clauses = 1 +Flags 04 TryOff 0027 (RVA 12F57) TryEnd 0046 (RVA 12F76) HndOff 0069 (RVA 12F99) HndEnd 008B (RVA 12FBB) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 65 01 02 24 A3 EA 20 43 EA 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x46, NoMapping, Source Types: StackEmpty + Native Offset: 0x63, Epilog, Source Types: StackEmpty + Native Offset: 0x69, Prolog, Source Types: StackEmpty + Native Offset: 0x86, Epilog, Source Types: StackEmpty + +12f30: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12f31: 48 83 ec 30 sub rsp, 48 + UWOP_ALLOC_SMALL 48 0 + +12f35: 48 8d 6c 24 30 lea rbp, [rsp + 48] +12f3a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12f3f: c5 7e 7f 45 e0 vmovdqu ymmword ptr [rbp - 32], ymm8 +12f44: 48 89 7d d8 mov qword ptr [rbp - 40], rdi +12f48: 48 8d 7d f8 lea rdi, [rbp - 8] +12f4c: 48 8d 75 f0 lea rsi, [rbp - 16] +12f50: ff 15 62 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12f56: 90 nop +12f57: 48 8d 7d e8 lea rdi, [rbp - 24] +12f5b: 48 8d 75 e0 lea rsi, [rbp - 32] +12f5f: ff 15 53 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12f65: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] + RDX is live +12f69: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] + RSI is live +12f6d: 33 ff xor edi, edi +12f6f: ff 15 4b 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12f75: 90 nop +12f76: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 +12f7b: 40 0f 95 c7 setne dil +12f7f: 40 0f b6 ff movzx edi, dil +12f83: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] + RSI is live +12f87: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] + RDX is live + sp-40 is dead +12f8b: ff 15 2f 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12f91: 33 c9 xor ecx, ecx +12f93: 48 83 c4 30 add rsp, 48 + sp-40 is live +12f97: 5d pop rbp +12f98: c3 ret + +[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() +Id: 92 +StartAddress: 0x00012F99 +Size: 34 bytes +UnwindRVA: 0x00010C34 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12f99: 50 push rax +12f9a: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 +12f9f: 40 0f 95 c7 setne dil +12fa3: 40 0f b6 ff movzx edi, dil +12fa7: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] + RSI is live +12fab: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] + RDX is live + sp-40 is dead +12faf: ff 15 0b 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12fb5: 90 nop +12fb6: 48 83 c4 08 add rsp, 8 +12fba: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Handle: 0x06000011 +Rid: 17 +EntryPointRuntimeFunctionId: 86 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) +Id: 86 +StartAddress: 0x00012D80 +Size: 85 bytes +UnwindRVA: 0x00010D58 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0008 +CountOfUnwindCodes: 4 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 +UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) + +Debug Info + Bounds: +00000000: 62 00 02 14 13 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4C, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x2B + Loc Type: VLT_REG + Register: R15 + +12d80: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12d81: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12d83: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12d84: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12d88: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12d8d: 33 c0 xor eax, eax +12d8f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12d93: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12d97: 48 8b df mov rbx, rdi +12d9a: 44 8b fe mov r15d, esi +12d9d: 48 8d 7d e8 lea rdi, [rbp - 24] +12da1: 48 8d 75 e0 lea rsi, [rbp - 32] +12da5: ff 15 0d 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12dab: 45 03 ff add r15d, r15d +12dae: 48 85 db test rbx, rbx +12db1: 40 0f 95 c7 setne dil +12db5: 40 0f b6 ff movzx edi, dil +12db9: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] +12dbd: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] +12dc1: ff 15 f9 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12dc7: 41 8b c7 mov eax, r15d +12dca: 33 c9 xor ecx, ecx +12dcc: 48 83 c4 10 add rsp, 16 +12dd0: 5b pop rbx +12dd1: 41 5f pop r15 +12dd3: 5d pop rbp +12dd4: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Handle: 0x0600000E +Rid: 14 +EntryPointRuntimeFunctionId: 83 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) +Id: 83 +StartAddress: 0x00012C70 +Size: 85 bytes +UnwindRVA: 0x00010D58 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0008 +CountOfUnwindCodes: 4 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 +UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) + +Debug Info + Bounds: +00000000: 62 00 02 14 13 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4C, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x2B + Loc Type: VLT_REG + Register: R15 + +12c70: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12c71: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12c73: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12c74: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12c78: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12c7d: 33 c0 xor eax, eax +12c7f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12c83: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12c87: 48 8b df mov rbx, rdi +12c8a: 44 8b fe mov r15d, esi +12c8d: 48 8d 7d e8 lea rdi, [rbp - 24] +12c91: 48 8d 75 e0 lea rsi, [rbp - 32] +12c95: ff 15 1d 27 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12c9b: 45 03 ff add r15d, r15d +12c9e: 48 85 db test rbx, rbx +12ca1: 40 0f 95 c7 setne dil +12ca5: 40 0f b6 ff movzx edi, dil +12ca9: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] +12cad: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] +12cb1: ff 15 09 27 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12cb7: 41 8b c7 mov eax, r15d +12cba: 33 c9 xor ecx, ecx +12cbc: 48 83 c4 10 add rsp, 16 +12cc0: 5b pop rbx +12cc1: 41 5f pop r15 +12cc3: 5d pop rbp +12cc4: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Handle: 0x06000010 +Rid: 16 +EntryPointRuntimeFunctionId: 85 +Number of RuntimeFunctions: 1 + +[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) +Id: 85 +StartAddress: 0x00012D20 +Size: 85 bytes +UnwindRVA: 0x00010D58 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0008 +CountOfUnwindCodes: 4 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 +UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) + +Debug Info + Bounds: +00000000: 62 00 02 14 13 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4C, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x1D + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x1D + End Offset: 0x2B + Loc Type: VLT_REG + Register: R15 + +12d20: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12d21: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12d23: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12d24: 48 83 ec 10 sub rsp, 16 + UWOP_ALLOC_SMALL 16 0 + +12d28: 48 8d 6c 24 20 lea rbp, [rsp + 32] +12d2d: 33 c0 xor eax, eax +12d2f: 48 89 45 e8 mov qword ptr [rbp - 24], rax +12d33: 48 89 45 e0 mov qword ptr [rbp - 32], rax +12d37: 48 8b df mov rbx, rdi +12d3a: 44 8b fe mov r15d, esi +12d3d: 48 8d 7d e8 lea rdi, [rbp - 24] +12d41: 48 8d 75 e0 lea rsi, [rbp - 32] +12d45: ff 15 6d 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12d4b: 45 03 ff add r15d, r15d +12d4e: 48 85 db test rbx, rbx +12d51: 40 0f 95 c7 setne dil +12d55: 40 0f b6 ff movzx edi, dil +12d59: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] +12d5d: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] +12d61: ff 15 59 26 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12d67: 41 8b c7 mov eax, r15d +12d6a: 33 c9 xor ecx, ecx +12d6c: 48 83 c4 10 add rsp, 16 +12d70: 5b pop rbx +12d71: 41 5f pop r15 +12d73: 5d pop rbp +12d74: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Handle: 0x0600000B +Rid: 11 +EntryPointRuntimeFunctionId: 79 +Number of RuntimeFunctions: 2 +Number of fixups: 9 + TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) + TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) + TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) + TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) + TableIndex 5, Offset 0016: System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) + TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) + TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) + TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) + TableIndex 5, Offset 001D: (RESUMPTION_STUB RVA[0x12700]) + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 79 +StartAddress: 0x00012910 +Size: 372 bytes +UnwindRVA: 0x00010C40 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x000A +CountOfUnwindCodes: 5 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) +UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13390, #clauses = 1 +Flags 04 TryOff 003D (RVA 1294D) TryEnd 00CE (RVA 129DE) HndOff 0174 (RVA 12A84) HndEnd 0196 (RVA 12AA6) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 19 37 02 08 F5 8C 22 45 1F C0 85 D4 15 70 21 A5 +00000010: 11 EA 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x3D, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0xCE, NoMapping, Source Types: StackEmpty + Native Offset: 0xED, Epilog, Source Types: StackEmpty + Native Offset: 0xF8, IL Offset: 0x0006, Source Types: Async + Native Offset: 0x14F, Epilog, Source Types: StackEmpty + Native Offset: 0x15A, IL Offset: 0x0006, Source Types: Async + Native Offset: 0x174, Prolog, Source Types: StackEmpty + Native Offset: 0x191, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x25 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x25 + End Offset: 0x70 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0xC9 + End Offset: 0xE9 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 1 + Start Offset: 0x16F + End Offset: 0x174 + Loc Type: VLT_REG + Register: RBX + +12910: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12911: 41 57 push r15 + UWOP_PUSH_NONVOL R15(15) 0 + +12913: 41 56 push r14 + UWOP_PUSH_NONVOL R14(14) 0 + +12915: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12916: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +1291a: 48 8d 6c 24 40 lea rbp, [rsp + 64] +1291f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12924: c5 79 7f 45 d0 vmovdqa xmmword ptr [rbp - 48], xmm8 +12929: 33 c0 xor eax, eax +1292b: 48 89 45 e0 mov qword ptr [rbp - 32], rax +1292f: 48 89 7d c8 mov qword ptr [rbp - 56], rdi +12933: 8b de mov ebx, esi +12935: 48 85 ff test rdi, rdi +12938: 0f 85 2c 01 00 00 jne 0x12a6a +1293e: 48 8d 7d e0 lea rdi, [rbp - 32] + RDI is live +12942: 48 8d 75 d8 lea rsi, [rbp - 40] +12946: ff 15 6c 2a 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +1294c: 90 nop +1294d: ff 15 f5 29 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) + RAX is live +12953: 48 89 45 d0 mov qword ptr [rbp - 48], rax +12957: 4c 8b 7d d0 mov r15, qword ptr [rbp - 48] + R15 is live +1295b: ff 15 a7 2a 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) +12961: 4c 8b 35 30 2d 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) +12968: 4b 8d 3c 37 lea rdi, [r15 + r14] + RDI is live +1296c: 48 8b f0 mov rsi, rax + RSI is live +1296f: ff 15 8b 29 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) +12975: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] + RDI is live +12979: 48 8b 35 20 2d 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) +12980: 89 1c 37 mov dword ptr [rdi + rsi], ebx +12983: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +12987: 48 8b 35 02 2d 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) +1298e: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 +12995: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] +12999: 40 38 3f cmp byte ptr [rdi], dil +1299c: 49 8b fe mov rdi, r14 + RDI is dead +1299f: 48 03 7d d0 add rdi, qword ptr [rbp - 48] + RDI is dead +129a3: 48 8b 35 2e 2c 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) +129aa: 48 8d 55 d0 lea rdx, [rbp - 48] +129ae: ff 15 ec 2a 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) + RDI is live +129b4: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] + RDI is live +129b8: 40 38 3f cmp byte ptr [rdi], dil +129bb: 49 8b fe mov rdi, r14 + RDI is dead +129be: 48 03 7d d0 add rdi, qword ptr [rbp - 48] + RDI is live +129c2: ff 15 48 2a 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) + RDI is dead + RAX is live +129c8: 48 8b f0 mov rsi, rax + RSI is live +129cb: 33 ff xor edi, edi + RDI is live +129cd: 48 89 7d d0 mov qword ptr [rbp - 48], rdi + RAX is dead + RDI is dead +129d1: ff 15 b1 2a 02 00 call qword ptr [0x35488] // !!0 System.Runtime.CompilerServices.AsyncHelpers.Await(System.Threading.Tasks.Task`1) (METHOD_ENTRY) + RCX is live + RSI is dead +129d7: 8b d8 mov ebx, eax +129d9: 48 85 c9 test rcx, rcx +129dc: 75 2a jne 0x12a08 + RCX is dead +129de: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 +129e3: 40 0f 95 c7 setne dil +129e7: 40 0f b6 ff movzx edi, dil +129eb: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +129ef: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live + sp-56 is dead +129f3: ff 15 c7 29 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RSI is dead + RDX is dead +129f9: 8b c3 mov eax, ebx +129fb: 33 c9 xor ecx, ecx +129fd: 48 83 c4 28 add rsp, 40 + sp-56 is live + RCX is live +12a01: 5b pop rbx +12a02: 41 5e pop r14 +12a04: 41 5f pop r15 +12a06: 5d pop rbp +12a07: c3 ret +12a08: 48 8b 35 79 2c 02 00 mov rsi, qword ptr [0x35688] // System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) +12a0f: 48 8b f9 mov rdi, rcx + RDI is live +12a12: ff 15 08 29 02 00 call qword ptr [0x35320] // ALLOC_CONTINUATION (HELPER) + RCX is dead + RAX is live + RDI is dead +12a18: 48 8b d8 mov rbx, rax + RBX is live +12a1b: 48 8d 05 be 34 02 00 lea rax, [0x35ee0] + RAX is dead +12a22: 48 89 43 10 mov qword ptr [rbx + 16], rax +12a26: 48 c7 43 18 80 00 00 00 mov qword ptr [rbx + 24], 128 +12a2e: ff 15 74 29 02 00 call qword ptr [0x353a8] // System.Threading.ExecutionContext System.Runtime.CompilerServices.AsyncHelpers.CaptureExecutionContext() (METHOD_ENTRY_REF_TOKEN) + RAX is live +12a34: 48 8d 7b 28 lea rdi, [rbx + 40] + RDI is live +12a38: 48 8b f0 mov rsi, rax + RSI is live +12a3b: ff 15 bf 28 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) + RAX is dead + RSI is dead + RDI is dead +12a41: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 +12a46: 40 0f 95 c7 setne dil +12a4a: 40 0f b6 ff movzx edi, dil +12a4e: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12a52: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + sp-56 is dead + RDX is live +12a56: ff 15 6c 29 02 00 call qword ptr [0x353c8] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContextsOnSuspension(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RSI is dead + RDX is dead +12a5c: 48 8b cb mov rcx, rbx + RCX is live +12a5f: 48 83 c4 28 add rsp, 40 + RCX is dead + RBX is dead + sp-56 is live +12a63: 5b pop rbx +12a64: 41 5e pop r14 +12a66: 41 5f pop r15 +12a68: 5d pop rbp +12a69: c3 ret +12a6a: 48 8b 7d c8 mov rdi, qword ptr [rbp - 56] + RDI is live +12a6e: 48 8b 7f 28 mov rdi, qword ptr [rdi + 40] +12a72: ff 15 38 29 02 00 call qword ptr [0x353b0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreExecutionContext(System.Threading.ExecutionContext) (METHOD_ENTRY_REF_TOKEN) + RDI is dead +12a78: 48 8b 7d c8 mov rdi, qword ptr [rbp - 56] + RDI is live +12a7c: 8b 5f 20 mov ebx, dword ptr [rdi + 32] +12a7f: e9 5a ff ff ff jmp 0x129de + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 80 +StartAddress: 0x00012A84 +Size: 34 bytes +UnwindRVA: 0x00010CBC +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + + RDI is dead +12a84: 50 push rax +12a85: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 +12a8a: 40 0f 95 c7 setne dil +12a8e: 40 0f b6 ff movzx edi, dil +12a92: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12a96: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live + sp-56 is dead +12a9a: ff 15 20 29 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12aa0: 90 nop +12aa1: 48 83 c4 08 add rsp, 8 +12aa5: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Handle: 0x06000009 +Rid: 9 +EntryPointRuntimeFunctionId: 77 +Number of RuntimeFunctions: 2 + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Id: 77 +StartAddress: 0x00012870 +Size: 123 bytes +UnwindRVA: 0x00010BC4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 13378, #clauses = 1 +Flags 04 TryOff 0034 (RVA 128A4) TryEnd 0055 (RVA 128C5) HndOff 007B (RVA 128EB) HndEnd 009D (RVA 1290D) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 66 01 02 24 E1 9A A8 0F 3A A4 0E + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x55, NoMapping, Source Types: StackEmpty + Native Offset: 0x74, Epilog, Source Types: StackEmpty + Native Offset: 0x7B, Prolog, Source Types: StackEmpty + Native Offset: 0x98, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x25 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x25 + End Offset: 0x42 + Loc Type: VLT_REG + Register: RBX + +12870: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12871: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12872: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +12876: 48 8d 6c 24 30 lea rbp, [rsp + 48] +1287b: 33 c0 xor eax, eax +1287d: 48 89 45 d8 mov qword ptr [rbp - 40], rax +12881: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12886: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +1288b: 48 89 45 f0 mov qword ptr [rbp - 16], rax +1288f: 48 89 7d d0 mov qword ptr [rbp - 48], rdi +12893: 8b de mov ebx, esi +12895: 48 8d 7d f0 lea rdi, [rbp - 16] +12899: 48 8d 75 e8 lea rsi, [rbp - 24] +1289d: ff 15 15 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +128a3: 90 nop +128a4: 48 8d 7d e0 lea rdi, [rbp - 32] +128a8: 48 8d 75 d8 lea rsi, [rbp - 40] +128ac: ff 15 06 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +128b2: 03 db add ebx, ebx +128b4: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live +128b8: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +128bc: 33 ff xor edi, edi +128be: ff 15 fc 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +128c4: 90 nop +128c5: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +128ca: 40 0f 95 c7 setne dil +128ce: 40 0f b6 ff movzx edi, dil +128d2: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +128d6: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +128da: ff 15 e0 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +128e0: 8b c3 mov eax, ebx +128e2: 33 c9 xor ecx, ecx +128e4: 48 83 c4 28 add rsp, 40 + sp-48 is live +128e8: 5b pop rbx +128e9: 5d pop rbp +128ea: c3 ret + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) +Id: 78 +StartAddress: 0x000128EB +Size: 34 bytes +UnwindRVA: 0x00010BF8 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +128eb: 50 push rax +128ec: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +128f1: 40 0f 95 c7 setne dil +128f5: 40 0f b6 ff movzx edi, dil +128f9: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +128fd: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +12901: ff 15 b9 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12907: 90 nop +12908: 48 83 c4 08 add rsp, 8 +1290c: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Handle: 0x06000018 +Rid: 24 +EntryPointRuntimeFunctionId: 93 +Number of RuntimeFunctions: 2 +Number of fixups: 1 + TableIndex 0, Offset 0002: System.Threading.Tasks.ValueTask`1 CrossModuleHelper.SmallCrossModuleValueTaskAsync(int) (CHECK_IL_BODY) + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Id: 93 +StartAddress: 0x00012FC0 +Size: 124 bytes +UnwindRVA: 0x00010D90 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 133F0, #clauses = 1 +Flags 04 TryOff 0034 (RVA 12FF4) TryEnd 0056 (RVA 13016) HndOff 007C (RVA 1303C) HndEnd 009E (RVA 1305E) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 66 01 02 24 E1 A2 A8 0F 3A A4 0E + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x56, NoMapping, Source Types: StackEmpty + Native Offset: 0x75, Epilog, Source Types: StackEmpty + Native Offset: 0x7C, Prolog, Source Types: StackEmpty + Native Offset: 0x99, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x25 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x25 + End Offset: 0x42 + Loc Type: VLT_REG + Register: RBX + +12fc0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12fc1: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12fc2: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +12fc6: 48 8d 6c 24 30 lea rbp, [rsp + 48] +12fcb: 33 c0 xor eax, eax +12fcd: 48 89 45 d8 mov qword ptr [rbp - 40], rax +12fd1: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12fd6: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +12fdb: 48 89 45 f0 mov qword ptr [rbp - 16], rax +12fdf: 48 89 7d d0 mov qword ptr [rbp - 48], rdi +12fe3: 8b de mov ebx, esi +12fe5: 48 8d 7d f0 lea rdi, [rbp - 16] +12fe9: 48 8d 75 e8 lea rsi, [rbp - 24] +12fed: ff 15 c5 23 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12ff3: 90 nop +12ff4: 48 8d 7d e0 lea rdi, [rbp - 32] +12ff8: 48 8d 75 d8 lea rsi, [rbp - 40] +12ffc: ff 15 b6 23 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +13002: 8d 1c 5b lea ebx, [rbx + 2*rbx] +13005: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live +13009: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +1300d: 33 ff xor edi, edi +1300f: ff 15 ab 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +13015: 90 nop +13016: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +1301b: 40 0f 95 c7 setne dil +1301f: 40 0f b6 ff movzx edi, dil +13023: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +13027: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +1302b: ff 15 8f 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +13031: 8b c3 mov eax, ebx +13033: 33 c9 xor ecx, ecx +13035: 48 83 c4 28 add rsp, 40 + sp-48 is live +13039: 5b pop rbx +1303a: 5d pop rbp +1303b: c3 ret + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) +Id: 94 +StartAddress: 0x0001303C +Size: 34 bytes +UnwindRVA: 0x00010DC4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +1303c: 50 push rax +1303d: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +13042: 40 0f 95 c7 setne dil +13046: 40 0f b6 ff movzx edi, dil +1304a: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +1304e: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +13052: ff 15 68 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +13058: 90 nop +13059: 48 83 c4 08 add rsp, 8 +1305d: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Handle: 0x06000016 +Rid: 22 +EntryPointRuntimeFunctionId: 89 +Number of RuntimeFunctions: 2 +Number of fixups: 1 + TableIndex 0, Offset 0000: System.Threading.Tasks.Task`1 CrossModuleHelper.SmallCrossModuleAsync(int) (CHECK_IL_BODY) + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Id: 89 +StartAddress: 0x00012E90 +Size: 124 bytes +UnwindRVA: 0x00010D90 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0006 +CountOfUnwindCodes: 3 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 +UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) + +EH info @ 133C0, #clauses = 1 +Flags 04 TryOff 0034 (RVA 12EC4) TryEnd 0056 (RVA 12EE6) HndOff 007C (RVA 12F0C) HndEnd 009E (RVA 12F2E) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 66 01 02 24 E1 A2 A8 0F 3A A4 0E + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty + Native Offset: 0x56, NoMapping, Source Types: StackEmpty + Native Offset: 0x75, Epilog, Source Types: StackEmpty + Native Offset: 0x7C, Prolog, Source Types: StackEmpty + Native Offset: 0x99, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x25 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 0 + Start Offset: 0x25 + End Offset: 0x42 + Loc Type: VLT_REG + Register: RBX + +12e90: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +12e91: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12e92: 48 83 ec 28 sub rsp, 40 + UWOP_ALLOC_SMALL 40 0 + +12e96: 48 8d 6c 24 30 lea rbp, [rsp + 48] +12e9b: 33 c0 xor eax, eax +12e9d: 48 89 45 d8 mov qword ptr [rbp - 40], rax +12ea1: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +12ea6: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 +12eab: 48 89 45 f0 mov qword ptr [rbp - 16], rax +12eaf: 48 89 7d d0 mov qword ptr [rbp - 48], rdi +12eb3: 8b de mov ebx, esi +12eb5: 48 8d 7d f0 lea rdi, [rbp - 16] +12eb9: 48 8d 75 e8 lea rsi, [rbp - 24] +12ebd: ff 15 f5 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12ec3: 90 nop +12ec4: 48 8d 7d e0 lea rdi, [rbp - 32] +12ec8: 48 8d 75 d8 lea rsi, [rbp - 40] +12ecc: ff 15 e6 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12ed2: 8d 1c 5b lea ebx, [rbx + 2*rbx] +12ed5: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] + RDX is live +12ed9: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] + RSI is live +12edd: 33 ff xor edi, edi +12edf: ff 15 db 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12ee5: 90 nop +12ee6: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +12eeb: 40 0f 95 c7 setne dil +12eef: 40 0f b6 ff movzx edi, dil +12ef3: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +12ef7: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +12efb: ff 15 bf 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12f01: 8b c3 mov eax, ebx +12f03: 33 c9 xor ecx, ecx +12f05: 48 83 c4 28 add rsp, 40 + sp-48 is live +12f09: 5b pop rbx +12f0a: 5d pop rbp +12f0b: c3 ret + +[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) +Id: 90 +StartAddress: 0x00012F0C +Size: 34 bytes +UnwindRVA: 0x00010DC4 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12f0c: 50 push rax +12f0d: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 +12f12: 40 0f 95 c7 setne dil +12f16: 40 0f b6 ff movzx edi, dil +12f1a: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] + RSI is live +12f1e: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] + RDX is live + sp-48 is dead +12f22: ff 15 98 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12f28: 90 nop +12f29: 48 83 c4 08 add rsp, 8 +12f2d: c3 ret + +_______________________________________________ + +[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Handle: 0x06000008 +Rid: 8 +EntryPointRuntimeFunctionId: 75 +Number of RuntimeFunctions: 2 + +[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Id: 75 +StartAddress: 0x000127E0 +Size: 105 bytes +UnwindRVA: 0x00010C04 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0005 +CountOfUnwindCodes: 2 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 48 + +EH info @ 13360, #clauses = 1 +Flags 04 TryOff 0027 (RVA 12807) TryEnd 0046 (RVA 12826) HndOff 0069 (RVA 12849) HndEnd 008B (RVA 1286B) ClsFlt 0000 FAULT + +Debug Info + Bounds: +00000000: 65 01 02 24 A3 EA 20 43 EA 00 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x46, NoMapping, Source Types: StackEmpty + Native Offset: 0x63, Epilog, Source Types: StackEmpty + Native Offset: 0x69, Prolog, Source Types: StackEmpty + Native Offset: 0x86, Epilog, Source Types: StackEmpty + +127e0: 55 push rbp + UWOP_PUSH_NONVOL RBP(5) 0 + +127e1: 48 83 ec 30 sub rsp, 48 + UWOP_ALLOC_SMALL 48 0 + +127e5: 48 8d 6c 24 30 lea rbp, [rsp + 48] +127ea: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 +127ef: c5 7e 7f 45 e0 vmovdqu ymmword ptr [rbp - 32], ymm8 +127f4: 48 89 7d d8 mov qword ptr [rbp - 40], rdi +127f8: 48 8d 7d f8 lea rdi, [rbp - 8] +127fc: 48 8d 75 f0 lea rsi, [rbp - 16] +12800: ff 15 b2 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12806: 90 nop +12807: 48 8d 7d e8 lea rdi, [rbp - 24] +1280b: 48 8d 75 e0 lea rsi, [rbp - 32] +1280f: ff 15 a3 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) +12815: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] + RDX is live +12819: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] + RSI is live +1281d: 33 ff xor edi, edi +1281f: ff 15 9b 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12825: 90 nop +12826: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 +1282b: 40 0f 95 c7 setne dil +1282f: 40 0f b6 ff movzx edi, dil +12833: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] + RSI is live +12837: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] + RDX is live + sp-40 is dead +1283b: ff 15 7f 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12841: 33 c9 xor ecx, ecx +12843: 48 83 c4 30 add rsp, 48 + sp-40 is live +12847: 5d pop rbp +12848: c3 ret + +[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() +Id: 76 +StartAddress: 0x00012849 +Size: 34 bytes +UnwindRVA: 0x00010C34 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 + +12849: 50 push rax +1284a: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 +1284f: 40 0f 95 c7 setne dil +12853: 40 0f b6 ff movzx edi, dil +12857: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] + RSI is live +1285b: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] + RDX is live + sp-40 is dead +1285f: ff 15 5b 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) + RDX is dead + RSI is dead +12865: 90 nop +12866: 48 83 c4 08 add rsp, 8 +1286a: c3 ret + +_______________________________________________ + +[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Handle: 0x0600000D +Rid: 13 +EntryPointRuntimeFunctionId: 72 +Number of RuntimeFunctions: 1 + +[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) +Id: 72 +StartAddress: 0x00012720 +Size: 23 bytes +UnwindRVA: 0x00010BB0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) + +Debug Info + Bounds: +00000000: 26 05 42 20 46 BA A7 92 D2 AA 01 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4, IL Offset: 0x000e, Source Types: StackEmpty + Native Offset: 0xB, IL Offset: 0x001b, Source Types: StackEmpty + Native Offset: 0x10, IL Offset: 0x0021, Source Types: StackEmpty + Native Offset: 0x12, IL Offset: 0x0028, Source Types: StackEmpty + Native Offset: 0x15, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x4 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x4 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 1 + Start Offset: 0x4 + End Offset: 0x10 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 3 + Start Offset: 0xB + End Offset: 0x10 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 4 + Start Offset: 0xB + End Offset: 0x12 + Loc Type: VLT_REG + Register: RCX + +12720: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12721: 48 8b de mov rbx, rsi +12724: 33 f6 xor esi, esi +12726: e8 85 03 00 00 call 0x12ab0 +1272b: 48 85 c9 test rcx, rcx +1272e: 75 02 jne 0x12732 +12730: 89 03 mov dword ptr [rbx], eax +12732: 48 8b c1 mov rax, rcx +12735: 5b pop rbx +12736: c3 ret + +_______________________________________________ + +[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Handle: 0x0600000B +Rid: 11 +EntryPointRuntimeFunctionId: 71 +Number of RuntimeFunctions: 1 + +[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) +Id: 71 +StartAddress: 0x00012700 +Size: 23 bytes +UnwindRVA: 0x00010BB0 +Version: 1 +Flags: 0x03 EHANDLER UHANDLER +SizeOfProlog: 0x0001 +CountOfUnwindCodes: 1 +FrameRegister: None +FrameOffset: 0x0 +PersonalityRVA: 0x13408 +UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) + +Debug Info + Bounds: +00000000: 26 05 42 20 46 BA A7 92 D2 AA 01 + Native Offset: 0x0, Prolog, Source Types: StackEmpty + Native Offset: 0x4, IL Offset: 0x000e, Source Types: StackEmpty + Native Offset: 0xB, IL Offset: 0x001b, Source Types: StackEmpty + Native Offset: 0x10, IL Offset: 0x0021, Source Types: StackEmpty + Native Offset: 0x12, IL Offset: 0x0028, Source Types: StackEmpty + Native Offset: 0x15, Epilog, Source Types: StackEmpty + + Variable Locations: + Variable Number: 0 + Start Offset: 0x0 + End Offset: 0x4 + Loc Type: VLT_REG + Register: RDI + + Variable Number: 1 + Start Offset: 0x0 + End Offset: 0x4 + Loc Type: VLT_REG + Register: RSI + + Variable Number: 1 + Start Offset: 0x4 + End Offset: 0x10 + Loc Type: VLT_REG + Register: RBX + + Variable Number: 3 + Start Offset: 0xB + End Offset: 0x10 + Loc Type: VLT_REG + Register: RAX + + Variable Number: 4 + Start Offset: 0xB + End Offset: 0x12 + Loc Type: VLT_REG + Register: RCX + +12700: 53 push rbx + UWOP_PUSH_NONVOL RBX(3) 0 + +12701: 48 8b de mov rbx, rsi +12704: 33 f6 xor esi, esi +12706: e8 05 02 00 00 call 0x12910 +1270b: 48 85 c9 test rcx, rcx +1270e: 75 02 jne 0x12712 +12710: 89 03 mov dword ptr [rbx], eax +12712: 48 8b c1 mov rax, rcx +12715: 5b pop rbx +12716: c3 ret + +=========== Eager fixup counts across all methods =========== + + Fixup | Count + TypeHandle | 43 + Check_TypeLayout | 34 + FieldOffset | 24 + StringHandle | 23 + MethodDictionary | 6 + Check_IL_Body | 4 + FieldBaseOffset | 2 + ContinuationLayout | 2 +ResumptionStubEntryPoint | 2 +-------------------------------- + Total | 140 + +============================================================= + diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 40e2b4867b373d..8ac6d562fcad72 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -15,11 +15,11 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun { - /// + /// /// This fixup instructs the runtime to validate that the IL found at runtime matches the hash of the IL computed at compile time. - /// This will use the method IL in metatadata for the EcmaMethod, not what is provided by the ILProvider. Notably, this is different for Async methods, + /// This will use the method IL in metadata for the EcmaMethod, not what is provided by the ILProvider. Notably, this is different for Async methods, /// for which the ILProvider used during JIT compilation will return the Task-returning thunk for a runtime-async EcmaMethod. - /// + /// public class ILBodyFixupSignature : Signature, IEquatable { private readonly ReadyToRunFixupKind _fixupKind; From f508c7092b226f84406cf481af32580f62163266 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Thu, 26 Mar 2026 16:33:23 -0700 Subject: [PATCH 11/18] Remove accidentally committed r2rdump file Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- inthunk.r2rdump | 6709 ----------------------------------------------- 1 file changed, 6709 deletions(-) delete mode 100644 inthunk.r2rdump diff --git a/inthunk.r2rdump b/inthunk.r2rdump deleted file mode 100644 index 6e644b169acf35..00000000000000 --- a/inthunk.r2rdump +++ /dev/null @@ -1,6709 +0,0 @@ -Filename: /home/jtschuster/src/runtime-async-inline/artifacts/tests/coreclr/linux.x64.Debug/readytorun/async-inline-thunks/async-inline-thunks/async-inline-thunks.dll -OS: Linux -Machine: Amd64 -ImageBase: 0x140000000 - -======================== R2R Methods ======================== - -56 methods - -_______________________________________________ - -void InlineThunks.Check(string, int, int) -Handle: 0x06000001 -Rid: 1 -EntryPointRuntimeFunctionId: 0 -Number of RuntimeFunctions: 1 -Number of fixups: 4 - TableIndex 5, Offset 000F: System.Runtime.CompilerServices.DefaultInterpolatedStringHandler Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 40 Align native GCLayout 0x3 (CHECK_TYPE_LAYOUT) - TableIndex 6, Offset 0000: " FAILED: " (STRING_HANDLE) - TableIndex 6, Offset 0001: " — expected " (STRING_HANDLE) - TableIndex 6, Offset 0002: ", got " (STRING_HANDLE) - -void InlineThunks.Check(string, int, int) -Id: 0 -StartAddress: 0x00011360 -Size: 205 bytes -UnwindRVA: 0x00010850 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000A -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 59 65 02 02 3A 19 4A 20 A2 34 A2 4E 6A 60 A2 7A -00000010: 62 8C A2 A6 6A B8 9A D2 4A E0 02 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x27, IL Offset: 0x0009, Source Types: StackEmpty - Native Offset: 0x30, IL Offset: 0x000d, Source Types: StackEmpty - Native Offset: 0x44, IL Offset: 0x0017, Source Types: StackEmpty - Native Offset: 0x58, IL Offset: 0x0024, Source Types: StackEmpty - Native Offset: 0x65, IL Offset: 0x002d, Source Types: StackEmpty - Native Offset: 0x79, IL Offset: 0x003a, Source Types: StackEmpty - Native Offset: 0x85, IL Offset: 0x0043, Source Types: StackEmpty - Native Offset: 0x99, IL Offset: 0x0050, Source Types: StackEmpty - Native Offset: 0xA6, IL Offset: 0x0059, Source Types: StackEmpty - Native Offset: 0xB9, IL Offset: 0x0066, Source Types: StackEmpty - Native Offset: 0xC2, IL Offset: 0x006d, Source Types: StackEmpty - Native Offset: 0xC2, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x27 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x27 - End Offset: 0x5C - Loc Type: VLT_REG - Register: R14 - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x27 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 1 - Start Offset: 0x27 - End Offset: 0x7D - Loc Type: VLT_REG - Register: RBX - - Variable Number: 2 - Start Offset: 0x0 - End Offset: 0x27 - Loc Type: VLT_REG - Register: RDX - - Variable Number: 2 - Start Offset: 0x27 - End Offset: 0x9D - Loc Type: VLT_REG - Register: R15 - -11360: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11361: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -11363: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -11365: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11366: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -1136a: 48 8d 6c 24 40 lea rbp, [rsp + 64] -1136f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11374: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 -11379: 33 c0 xor eax, eax -1137b: 48 89 45 e0 mov qword ptr [rbp - 32], rax -1137f: 4c 8b f7 mov r14, rdi -11382: 8b de mov ebx, esi -11384: 44 8b fa mov r15d, edx -11387: 41 3b df cmp ebx, r15d -1138a: 0f 84 92 00 00 00 je 0x11422 -11390: 48 8d 7d c0 lea rdi, [rbp - 64] -11394: be 1c 00 00 00 mov esi, 28 -11399: ba 03 00 00 00 mov edx, 3 -1139e: ff 15 2c 40 02 00 call qword ptr [0x353d0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler..ctor(int, int) (METHOD_ENTRY_REF_TOKEN) -113a4: 48 8b 35 25 43 02 00 mov rsi, qword ptr [0x356d0] // " FAILED: " (STRING_HANDLE) -113ab: 48 8b 36 mov rsi, qword ptr [rsi] -113ae: 48 8d 7d c0 lea rdi, [rbp - 64] -113b2: ff 15 28 40 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) -113b8: 48 8d 7d c0 lea rdi, [rbp - 64] -113bc: 49 8b f6 mov rsi, r14 -113bf: ff 15 23 40 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) -113c5: 48 8b 35 0c 43 02 00 mov rsi, qword ptr [0x356d8] // " — expected " (STRING_HANDLE) -113cc: 48 8b 36 mov rsi, qword ptr [rsi] -113cf: 48 8d 7d c0 lea rdi, [rbp - 64] -113d3: ff 15 07 40 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) -113d9: 48 8d 7d c0 lea rdi, [rbp - 64] -113dd: 8b f3 mov esi, ebx -113df: ff 15 b3 40 02 00 call qword ptr [0x35498] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(!!0) (METHOD_ENTRY) -113e5: 48 8b 35 f4 42 02 00 mov rsi, qword ptr [0x356e0] // ", got " (STRING_HANDLE) -113ec: 48 8b 36 mov rsi, qword ptr [rsi] -113ef: 48 8d 7d c0 lea rdi, [rbp - 64] -113f3: ff 15 e7 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) -113f9: 48 8d 7d c0 lea rdi, [rbp - 64] -113fd: 41 8b f7 mov esi, r15d -11400: ff 15 92 40 02 00 call qword ptr [0x35498] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(!!0) (METHOD_ENTRY) -11406: 48 8d 7d c0 lea rdi, [rbp - 64] -1140a: ff 15 c8 3f 02 00 call qword ptr [0x353d8] // string System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear() (METHOD_ENTRY_REF_TOKEN) -11410: 48 8b f8 mov rdi, rax -11413: ff 15 57 3f 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) -11419: ff 15 09 3f 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) -1141f: c6 00 01 mov byte ptr [rax], 1 -11422: 48 83 c4 28 add rsp, 40 -11426: 5b pop rbx -11427: 41 5e pop r14 -11429: 41 5f pop r15 -1142b: 5d pop rbp -1142c: c3 ret - -_______________________________________________ - -void InlineThunks.CheckNoThrow(string, System.Action) -Handle: 0x06000002 -Rid: 2 -EntryPointRuntimeFunctionId: 1 -Number of RuntimeFunctions: 2 -Number of fixups: 5 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000F: System.Runtime.CompilerServices.DefaultInterpolatedStringHandler Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 40 Align native GCLayout 0x3 (CHECK_TYPE_LAYOUT) - TableIndex 6, Offset 0000: " FAILED: " (STRING_HANDLE) - TableIndex 6, Offset 0003: " — threw " (STRING_HANDLE) - TableIndex 6, Offset 0004: ": " (STRING_HANDLE) - -void InlineThunks.CheckNoThrow(string, System.Action) -Id: 1 -StartAddress: 0x00011430 -Size: 46 bytes -UnwindRVA: 0x0001087C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 56 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13060, #clauses = 1 -Flags 00 TryOff 001F (RVA 1144F) TryEnd 0027 (RVA 11457) HndOff 002E (RVA 1145E) HndEnd 00FD (RVA 1152D) ClsFlt 100000C CATCH: System.Exception - -Debug Info - Bounds: -00000000: 0A 75 02 02 F4 15 08 11 14 00 A0 23 00 C1 83 86 -00000010: 08 51 1B A2 50 E4 C4 88 F2 D1 1A 25 CA 4B 1A 9B -00000020: A6 3C 41 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1F, IL Offset: 0x0002, Source Types: StackEmpty - Native Offset: 0x27, IL Offset: 0x007f, Source Types: StackEmpty - Native Offset: 0x27, Epilog, Source Types: StackEmpty - Native Offset: 0x2E, Prolog, Source Types: StackEmpty - Native Offset: 0x2F, IL Offset: 0x000c, Source Types: SourceTypeInvalid - Native Offset: 0x32, IL Offset: 0x000e, Source Types: StackEmpty - Native Offset: 0x46, IL Offset: 0x0018, Source Types: StackEmpty - Native Offset: 0x5A, IL Offset: 0x0025, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002e, Source Types: StackEmpty - Native Offset: 0x7C, IL Offset: 0x003b, Source Types: StackEmpty - Native Offset: 0xA7, IL Offset: 0x004e, Source Types: StackEmpty - Native Offset: 0xBB, IL Offset: 0x005b, Source Types: StackEmpty - Native Offset: 0xD5, IL Offset: 0x0069, Source Types: StackEmpty - Native Offset: 0xE8, IL Offset: 0x0076, Source Types: StackEmpty - Native Offset: 0xF8, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1F - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1F - End Offset: 0x27 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -56 - - Variable Number: 0 - Start Offset: 0x2E - End Offset: 0x62 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -56 - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x23 - Loc Type: VLT_REG - Register: RSI - -11430: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11431: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11432: 48 83 ec 38 sub rsp, 56 - UWOP_ALLOC_SMALL 56 0 - -11436: 48 8d 6c 24 40 lea rbp, [rsp + 64] -1143b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11440: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 -11445: 33 c0 xor eax, eax -11447: 48 89 45 f0 mov qword ptr [rbp - 16], rax -1144b: 48 89 7d c8 mov qword ptr [rbp - 56], rdi -1144f: 48 8b 7e 08 mov rdi, qword ptr [rsi + 8] - RDI is live -11453: ff 56 18 call qword ptr [rsi + 24] - RSI is live - RDI is dead -11456: 90 nop - sp-56 is live -11457: 48 83 c4 38 add rsp, 56 - RDI is live - sp-56 is dead -1145b: 5b pop rbx -1145c: 5d pop rbp -1145d: c3 ret - -void InlineThunks.CheckNoThrow(string, System.Action) -Id: 2 -StartAddress: 0x0001145E -Size: 207 bytes -UnwindRVA: 0x000108D0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1145e: 50 push rax -1145f: 48 8b df mov rbx, rdi - RBX is live -11462: 48 8d 7d d0 lea rdi, [rbp - 48] - RDI is dead -11466: be 15 00 00 00 mov esi, 21 -1146b: ba 03 00 00 00 mov edx, 3 -11470: ff 15 5a 3f 02 00 call qword ptr [0x353d0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler..ctor(int, int) (METHOD_ENTRY_REF_TOKEN) -11476: 48 8b 35 53 42 02 00 mov rsi, qword ptr [0x356d0] // " FAILED: " (STRING_HANDLE) -1147d: 48 8b 36 mov rsi, qword ptr [rsi] - RSI is dead -11480: 48 8d 7d d0 lea rdi, [rbp - 48] -11484: ff 15 56 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) - RSI is live -1148a: 48 8d 7d d0 lea rdi, [rbp - 48] -1148e: 48 8b 75 c8 mov rsi, qword ptr [rbp - 56] - RSI is dead - sp-56 is live -11492: ff 15 50 3f 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) - RSI is dead -11498: 48 8b 35 49 42 02 00 mov rsi, qword ptr [0x356e8] // " — threw " (STRING_HANDLE) -1149f: 48 8b 36 mov rsi, qword ptr [rsi] - RSI is live -114a2: 48 8d 7d d0 lea rdi, [rbp - 48] -114a6: ff 15 34 3f 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) - RSI is dead -114ac: 48 8b fb mov rdi, rbx - RDI is live -114af: 4c 8d 1d 02 3e 02 00 lea r11, [0x352b8] // System.Type System.Exception.GetType() (VIRTUAL_ENTRY) -114b6: 39 3f cmp dword ptr [rdi], edi -114b8: 41 ff 13 call qword ptr [r11] - RDI is dead - RAX is live -114bb: 48 8b f8 mov rdi, rax - RDI is live -114be: 4c 8d 1d 03 3e 02 00 lea r11, [0x352c8] // string System.Reflection.MemberInfo.get_Name() (VIRTUAL_ENTRY) -114c5: 39 3f cmp dword ptr [rdi], edi -114c7: 41 ff 13 call qword ptr [r11] - RDI is dead -114ca: 48 8b f0 mov rsi, rax - RSI is live -114cd: 48 8d 7d d0 lea rdi, [rbp - 48] -114d1: ff 15 11 3f 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) - RAX is dead - RSI is dead -114d7: 48 8b 35 12 42 02 00 mov rsi, qword ptr [0x356f0] // ": " (STRING_HANDLE) -114de: 48 8b 36 mov rsi, qword ptr [rsi] - RSI is live -114e1: 48 8d 7d d0 lea rdi, [rbp - 48] -114e5: ff 15 f5 3e 02 00 call qword ptr [0x353e0] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(string) (METHOD_ENTRY_REF_TOKEN) - RSI is dead -114eb: 48 8b fb mov rdi, rbx - RDI is live -114ee: 4c 8d 1d bb 3d 02 00 lea r11, [0x352b0] // string System.Exception.get_Message() (VIRTUAL_ENTRY) -114f5: 41 ff 13 call qword ptr [r11] - RBX is dead - RAX is live - RDI is dead -114f8: 48 8b f0 mov rsi, rax - RSI is live -114fb: 48 8d 7d d0 lea rdi, [rbp - 48] -114ff: ff 15 e3 3e 02 00 call qword ptr [0x353e8] // void System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(string) (METHOD_ENTRY_REF_TOKEN) - RSI is dead - RAX is dead -11505: 48 8d 7d d0 lea rdi, [rbp - 48] -11509: ff 15 c9 3e 02 00 call qword ptr [0x353d8] // string System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear() (METHOD_ENTRY_REF_TOKEN) - RAX is live -1150f: 48 8b f8 mov rdi, rax - RDI is live -11512: ff 15 58 3e 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) - RAX is dead - RDI is dead -11518: ff 15 0a 3e 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) - RAX is live -1151e: c6 00 01 mov byte ptr [rax], 1 -11521: 48 8d 05 2f ff ff ff lea rax, [0x11457] - RAX is dead -11528: 48 83 c4 08 add rsp, 8 -1152c: c3 ret - -_______________________________________________ - -int InlineThunks.Main() -Handle: 0x06000003 -Rid: 3 -EntryPointRuntimeFunctionId: 3 -Number of RuntimeFunctions: 1 -Number of fixups: 24 - TableIndex 5, Offset 0003: System.Action (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000B: System.Runtime.CompilerServices.TaskAwaiter`1 (TYPE_HANDLE) - TableIndex 5, Offset 000C: System.Runtime.CompilerServices.ValueTaskAwaiter`1 (TYPE_HANDLE) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0014: System.Runtime.CompilerServices.TaskAwaiter`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0015: System.Runtime.CompilerServices.ValueTaskAwaiter`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 6, Offset 0005: "TaskReturningThunk" (STRING_HANDLE) - TableIndex 6, Offset 0006: "TaskReturningThunkVoid" (STRING_HANDLE) - TableIndex 6, Offset 0007: "ValueTaskReturningThunk" (STRING_HANDLE) - TableIndex 6, Offset 0008: "AsyncVariant" (STRING_HANDLE) - TableIndex 6, Offset 0009: "AsyncVariantVoid" (STRING_HANDLE) - TableIndex 6, Offset 000A: "AsyncVariantValueTask" (STRING_HANDLE) - TableIndex 6, Offset 000B: "NonRuntimeAsyncNotAwaited" (STRING_HANDLE) - TableIndex 6, Offset 000C: "NonRuntimeAsyncAwaited" (STRING_HANDLE) - TableIndex 6, Offset 000D: "NonRuntimeValueTaskNotAwaited" (STRING_HANDLE) - TableIndex 6, Offset 000E: "NonRuntimeValueTaskAwaited" (STRING_HANDLE) - TableIndex 6, Offset 000F: "CrossModuleAsyncVariant" (STRING_HANDLE) - TableIndex 6, Offset 0010: "CrossModuleAsyncVariantVoid" (STRING_HANDLE) - TableIndex 6, Offset 0011: "CrossModuleAsyncVariantValueTask" (STRING_HANDLE) - TableIndex 6, Offset 0012: "CrossModuleTaskReturningThunk" (STRING_HANDLE) - TableIndex 6, Offset 0013: "CrossModuleSyncBaseline" (STRING_HANDLE) - TableIndex 6, Offset 0014: "PASSED" (STRING_HANDLE) - TableIndex 6, Offset 0015: "FAILED" (STRING_HANDLE) - -int InlineThunks.Main() -Id: 3 -StartAddress: 0x00011530 -Size: 1064 bytes -UnwindRVA: 0x000108DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000C -CountOfUnwindCodes: 6 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000C FrameOffset 0x0000 NextOffset 0x0 Op 48 -UnwindCode[2]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op R13(13) -UnwindCode[4]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) - -Debug Info - Bounds: -00000000: 7A 97 01 02 08 40 21 04 E8 A7 04 D0 0C A1 2F 39 -00000010: F4 23 09 56 60 51 06 2F FA D9 46 3F FA A8 D0 27 -00000020: FD 7C A5 9F BF B0 D2 99 32 52 D3 4F 72 FA 49 4F -00000030: 22 05 CA A1 42 49 20 28 88 13 05 01 A3 00 00 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x21, IL Offset: 0x0001, Source Types: StackEmpty - Native Offset: 0x60, IL Offset: 0x0022, Source Types: StackEmpty - Native Offset: 0x94, IL Offset: 0x0040, Source Types: SourceTypeInvalid - Native Offset: 0xF3, IL Offset: 0x006f, Source Types: StackEmpty - Native Offset: 0x132, IL Offset: 0x008f, Source Types: StackEmpty - Native Offset: 0x15D, IL Offset: 0x00ad, Source Types: SourceTypeInvalid - Native Offset: 0x176, IL Offset: 0x00b9, Source Types: StackEmpty - Native Offset: 0x1B5, IL Offset: 0x00d8, Source Types: StackEmpty - Native Offset: 0x1F4, IL Offset: 0x00f7, Source Types: StackEmpty - Native Offset: 0x279, IL Offset: 0x013b, Source Types: StackEmpty - Native Offset: 0x2B8, IL Offset: 0x015c, Source Types: StackEmpty - Native Offset: 0x2F7, IL Offset: 0x017c, Source Types: StackEmpty - Native Offset: 0x322, IL Offset: 0x019a, Source Types: SourceTypeInvalid - Native Offset: 0x33B, IL Offset: 0x01a6, Source Types: StackEmpty - Native Offset: 0x37A, IL Offset: 0x01c6, Source Types: StackEmpty - Native Offset: 0x3B9, IL Offset: 0x01e6, Source Types: StackEmpty - Native Offset: 0x3DB, IL Offset: 0x0202, Source Types: StackEmpty - Native Offset: 0x3E9, IL Offset: 0x0212, Source Types: StackEmpty - Native Offset: 0x3FB, IL Offset: 0x0205, Source Types: StackEmpty - Native Offset: 0x40B, IL Offset: 0x0224, Source Types: StackEmpty - Native Offset: 0x41B, IL Offset: 0x022d, Source Types: StackEmpty - Native Offset: 0x41B, Epilog, Source Types: StackEmpty - -11530: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11531: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -11533: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -11535: 41 55 push r13 - UWOP_PUSH_NONVOL R13(13) 0 - -11537: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11538: 48 83 ec 30 sub rsp, 48 - UWOP_ALLOC_SMALL 48 0 - -1153c: 48 8d 6c 24 50 lea rbp, [rsp + 80] -11541: 33 c0 xor eax, eax -11543: 48 89 45 b8 mov qword ptr [rbp - 72], rax -11547: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -1154c: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 -11551: bf 0a 00 00 00 mov edi, 10 -11556: ff 15 64 3f 02 00 call qword ptr [0x354c0] // System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) (METHOD_ENTRY_DEF_TOKEN) -1155c: 48 8b f8 mov rdi, rax -1155f: 4c 8d 1d 6a 3d 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -11566: 39 3f cmp dword ptr [rdi], edi -11568: 41 ff 13 call qword ptr [r11] -1156b: 48 89 45 d8 mov qword ptr [rbp - 40], rax -1156f: 48 8d 7d d8 lea rdi, [rbp - 40] -11573: ff 15 cf 3e 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -11579: 8b d0 mov edx, eax -1157b: 48 8b 3d 76 41 02 00 mov rdi, qword ptr [0x356f8] // "TaskReturningThunk" (STRING_HANDLE) -11582: 48 8b 3f mov rdi, qword ptr [rdi] -11585: be 14 00 00 00 mov esi, 20 -1158a: ff 15 20 3f 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11590: ff 15 9a 3d 02 00 call qword ptr [0x35330] // InlineThunks+<>c (STATIC_BASE_GC) -11596: 48 8b d8 mov rbx, rax -11599: 48 8b 73 08 mov rsi, qword ptr [rbx + 8] -1159d: 48 8b 05 5c 41 02 00 mov rax, qword ptr [0x35700] // "TaskReturningThunkVoid" (STRING_HANDLE) -115a4: 4c 8b 38 mov r15, qword ptr [rax] -115a7: 48 85 f6 test rsi, rsi -115aa: 75 28 jne 0x115d4 -115ac: 4c 8b 33 mov r14, qword ptr [rbx] -115af: ff 15 83 3d 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) -115b5: 4c 8b e8 mov r13, rax -115b8: 49 8b fd mov rdi, r13 -115bb: 49 8b f6 mov rsi, r14 -115be: ff 15 94 3d 02 00 call qword ptr [0x35358] // void InlineThunks+<>c.
b__3_0() => System.Action (DELEGATE_CTOR) -115c4: 48 8d 7b 08 lea rdi, [rbx + 8] -115c8: 49 8b f5 mov rsi, r13 -115cb: ff 15 2f 3d 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -115d1: 49 8b f5 mov rsi, r13 -115d4: 49 8b ff mov rdi, r15 -115d7: ff 15 db 3e 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) -115dd: bf 05 00 00 00 mov edi, 5 -115e2: ff 15 e8 3e 02 00 call qword ptr [0x354d0] // System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) (METHOD_ENTRY_DEF_TOKEN) -115e8: 48 89 45 c8 mov qword ptr [rbp - 56], rax -115ec: 48 89 55 d0 mov qword ptr [rbp - 48], rdx -115f0: 48 8d 7d c8 lea rdi, [rbp - 56] -115f4: ff 15 06 3e 02 00 call qword ptr [0x35400] // System.Runtime.CompilerServices.ValueTaskAwaiter`1 System.Threading.Tasks.ValueTask`1.GetAwaiter() (METHOD_ENTRY) -115fa: 48 89 45 b8 mov qword ptr [rbp - 72], rax -115fe: 48 89 55 c0 mov qword ptr [rbp - 64], rdx -11602: 48 8d 7d b8 lea rdi, [rbp - 72] -11606: ff 15 44 3e 02 00 call qword ptr [0x35450] // !0 System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult() (METHOD_ENTRY) -1160c: 8b d0 mov edx, eax -1160e: 48 8b 3d f3 40 02 00 mov rdi, qword ptr [0x35708] // "ValueTaskReturningThunk" (STRING_HANDLE) -11615: 48 8b 3f mov rdi, qword ptr [rdi] -11618: be 0a 00 00 00 mov esi, 10 -1161d: ff 15 8d 3e 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11623: bf 07 00 00 00 mov edi, 7 -11628: ff 15 aa 3e 02 00 call qword ptr [0x354d8] // System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) (METHOD_ENTRY_DEF_TOKEN) -1162e: 48 8b f8 mov rdi, rax -11631: 4c 8d 1d 98 3c 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -11638: 39 3f cmp dword ptr [rdi], edi -1163a: 41 ff 13 call qword ptr [r11] -1163d: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11641: 48 8d 7d d8 lea rdi, [rbp - 40] -11645: ff 15 fd 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -1164b: 8b d0 mov edx, eax -1164d: 48 8b 3d bc 40 02 00 mov rdi, qword ptr [0x35710] // "AsyncVariant" (STRING_HANDLE) -11654: 48 8b 3f mov rdi, qword ptr [rdi] -11657: be 0e 00 00 00 mov esi, 14 -1165c: ff 15 4e 3e 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11662: 48 8b 73 10 mov rsi, qword ptr [rbx + 16] -11666: 48 8b 05 ab 40 02 00 mov rax, qword ptr [0x35718] // "AsyncVariantVoid" (STRING_HANDLE) -1166d: 4c 8b 38 mov r15, qword ptr [rax] -11670: 48 85 f6 test rsi, rsi -11673: 75 28 jne 0x1169d -11675: 4c 8b 33 mov r14, qword ptr [rbx] -11678: ff 15 ba 3c 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) -1167e: 4c 8b e8 mov r13, rax -11681: 49 8b fd mov rdi, r13 -11684: 49 8b f6 mov rsi, r14 -11687: ff 15 d3 3c 02 00 call qword ptr [0x35360] // void InlineThunks+<>c.
b__3_1() => System.Action (DELEGATE_CTOR) -1168d: 48 8d 7b 10 lea rdi, [rbx + 16] -11691: 49 8b f5 mov rsi, r13 -11694: ff 15 66 3c 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -1169a: 49 8b f5 mov rsi, r13 -1169d: 49 8b ff mov rdi, r15 -116a0: ff 15 12 3e 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) -116a6: bf 03 00 00 00 mov edi, 3 -116ab: ff 15 37 3e 02 00 call qword ptr [0x354e8] // System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) -116b1: 48 8b f8 mov rdi, rax -116b4: 4c 8d 1d 15 3c 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -116bb: 39 3f cmp dword ptr [rdi], edi -116bd: 41 ff 13 call qword ptr [r11] -116c0: 48 89 45 d8 mov qword ptr [rbp - 40], rax -116c4: 48 8d 7d d8 lea rdi, [rbp - 40] -116c8: ff 15 7a 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -116ce: 8b d0 mov edx, eax -116d0: 48 8b 3d 49 40 02 00 mov rdi, qword ptr [0x35720] // "AsyncVariantValueTask" (STRING_HANDLE) -116d7: 48 8b 3f mov rdi, qword ptr [rdi] -116da: be 06 00 00 00 mov esi, 6 -116df: ff 15 cb 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -116e5: bf 04 00 00 00 mov edi, 4 -116ea: ff 15 00 3e 02 00 call qword ptr [0x354f0] // System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) (METHOD_ENTRY_DEF_TOKEN) -116f0: 48 8b f8 mov rdi, rax -116f3: 4c 8d 1d d6 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -116fa: 39 3f cmp dword ptr [rdi], edi -116fc: 41 ff 13 call qword ptr [r11] -116ff: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11703: 48 8d 7d d8 lea rdi, [rbp - 40] -11707: ff 15 3b 3d 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -1170d: 8b d0 mov edx, eax -1170f: 48 8b 3d 12 40 02 00 mov rdi, qword ptr [0x35728] // "NonRuntimeAsyncNotAwaited" (STRING_HANDLE) -11716: 48 8b 3f mov rdi, qword ptr [rdi] -11719: be 08 00 00 00 mov esi, 8 -1171e: ff 15 8c 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11724: bf 06 00 00 00 mov edi, 6 -11729: ff 15 c9 3d 02 00 call qword ptr [0x354f8] // System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) (METHOD_ENTRY_DEF_TOKEN) -1172f: 48 8b f8 mov rdi, rax -11732: 4c 8d 1d 97 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -11739: 39 3f cmp dword ptr [rdi], edi -1173b: 41 ff 13 call qword ptr [r11] -1173e: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11742: 48 8d 7d d8 lea rdi, [rbp - 40] -11746: ff 15 fc 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -1174c: 8b d0 mov edx, eax -1174e: 48 8b 3d db 3f 02 00 mov rdi, qword ptr [0x35730] // "NonRuntimeAsyncAwaited" (STRING_HANDLE) -11755: 48 8b 3f mov rdi, qword ptr [rdi] -11758: be 0c 00 00 00 mov esi, 12 -1175d: ff 15 4d 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11763: bf 09 00 00 00 mov edi, 9 -11768: ff 15 92 3d 02 00 call qword ptr [0x35500] // System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) -1176e: 48 89 45 c8 mov qword ptr [rbp - 56], rax -11772: 48 89 55 d0 mov qword ptr [rbp - 48], rdx -11776: 48 8d 7d c8 lea rdi, [rbp - 56] -1177a: ff 15 80 3c 02 00 call qword ptr [0x35400] // System.Runtime.CompilerServices.ValueTaskAwaiter`1 System.Threading.Tasks.ValueTask`1.GetAwaiter() (METHOD_ENTRY) -11780: 48 89 45 b8 mov qword ptr [rbp - 72], rax -11784: 48 89 55 c0 mov qword ptr [rbp - 64], rdx -11788: 48 8d 7d b8 lea rdi, [rbp - 72] -1178c: ff 15 be 3c 02 00 call qword ptr [0x35450] // !0 System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult() (METHOD_ENTRY) -11792: 8b d0 mov edx, eax -11794: 48 8b 3d 9d 3f 02 00 mov rdi, qword ptr [0x35738] // "NonRuntimeValueTaskNotAwaited" (STRING_HANDLE) -1179b: 48 8b 3f mov rdi, qword ptr [rdi] -1179e: be 12 00 00 00 mov esi, 18 -117a3: ff 15 07 3d 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -117a9: bf 0b 00 00 00 mov edi, 11 -117ae: ff 15 54 3d 02 00 call qword ptr [0x35508] // System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) (METHOD_ENTRY_DEF_TOKEN) -117b4: 48 8b f8 mov rdi, rax -117b7: 4c 8d 1d 12 3b 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -117be: 39 3f cmp dword ptr [rdi], edi -117c0: 41 ff 13 call qword ptr [r11] -117c3: 48 89 45 d8 mov qword ptr [rbp - 40], rax -117c7: 48 8d 7d d8 lea rdi, [rbp - 40] -117cb: ff 15 77 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -117d1: 8b d0 mov edx, eax -117d3: 48 8b 3d 66 3f 02 00 mov rdi, qword ptr [0x35740] // "NonRuntimeValueTaskAwaited" (STRING_HANDLE) -117da: 48 8b 3f mov rdi, qword ptr [rdi] -117dd: be 16 00 00 00 mov esi, 22 -117e2: ff 15 c8 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -117e8: bf 05 00 00 00 mov edi, 5 -117ed: ff 15 35 3d 02 00 call qword ptr [0x35528] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) (METHOD_ENTRY_DEF_TOKEN) -117f3: 48 8b f8 mov rdi, rax -117f6: 4c 8d 1d d3 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -117fd: 39 3f cmp dword ptr [rdi], edi -117ff: 41 ff 13 call qword ptr [r11] -11802: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11806: 48 8d 7d d8 lea rdi, [rbp - 40] -1180a: ff 15 38 3c 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -11810: 8b d0 mov edx, eax -11812: 48 8b 3d 2f 3f 02 00 mov rdi, qword ptr [0x35748] // "CrossModuleAsyncVariant" (STRING_HANDLE) -11819: 48 8b 3f mov rdi, qword ptr [rdi] -1181c: be 0f 00 00 00 mov esi, 15 -11821: ff 15 89 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -11827: 48 8b 73 18 mov rsi, qword ptr [rbx + 24] -1182b: 48 8b 05 1e 3f 02 00 mov rax, qword ptr [0x35750] // "CrossModuleAsyncVariantVoid" (STRING_HANDLE) -11832: 4c 8b 38 mov r15, qword ptr [rax] -11835: 48 85 f6 test rsi, rsi -11838: 75 28 jne 0x11862 -1183a: 4c 8b 33 mov r14, qword ptr [rbx] -1183d: ff 15 f5 3a 02 00 call qword ptr [0x35338] // System.Action (NEW_OBJECT) -11843: 4c 8b e8 mov r13, rax -11846: 49 8b fd mov rdi, r13 -11849: 49 8b f6 mov rsi, r14 -1184c: ff 15 16 3b 02 00 call qword ptr [0x35368] // void InlineThunks+<>c.
b__3_2() => System.Action (DELEGATE_CTOR) -11852: 48 8d 7b 18 lea rdi, [rbx + 24] -11856: 49 8b f5 mov rsi, r13 -11859: ff 15 a1 3a 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -1185f: 49 8b f5 mov rsi, r13 -11862: 49 8b ff mov rdi, r15 -11865: ff 15 4d 3c 02 00 call qword ptr [0x354b8] // void InlineThunks.CheckNoThrow(string, System.Action) (METHOD_ENTRY_DEF_TOKEN) -1186b: bf 04 00 00 00 mov edi, 4 -11870: ff 15 c2 3c 02 00 call qword ptr [0x35538] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) (METHOD_ENTRY_DEF_TOKEN) -11876: 48 8b f8 mov rdi, rax -11879: 4c 8d 1d 50 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -11880: 39 3f cmp dword ptr [rdi], edi -11882: 41 ff 13 call qword ptr [r11] -11885: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11889: 48 8d 7d d8 lea rdi, [rbp - 40] -1188d: ff 15 b5 3b 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -11893: 8b d0 mov edx, eax -11895: 48 8b 3d bc 3e 02 00 mov rdi, qword ptr [0x35758] // "CrossModuleAsyncVariantValueTask" (STRING_HANDLE) -1189c: 48 8b 3f mov rdi, qword ptr [rdi] -1189f: be 0c 00 00 00 mov esi, 12 -118a4: ff 15 06 3c 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -118aa: bf 08 00 00 00 mov edi, 8 -118af: ff 15 8b 3c 02 00 call qword ptr [0x35540] // System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) (METHOD_ENTRY_DEF_TOKEN) -118b5: 48 8b f8 mov rdi, rax -118b8: 4c 8d 1d 11 3a 02 00 lea r11, [0x352d0] // System.Runtime.CompilerServices.TaskAwaiter`1 System.Threading.Tasks.Task`1.GetAwaiter() (VIRTUAL_ENTRY) -118bf: 39 3f cmp dword ptr [rdi], edi -118c1: 41 ff 13 call qword ptr [r11] -118c4: 48 89 45 d8 mov qword ptr [rbp - 40], rax -118c8: 48 8d 7d d8 lea rdi, [rbp - 40] -118cc: ff 15 76 3b 02 00 call qword ptr [0x35448] // !0 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() (METHOD_ENTRY) -118d2: 8b d0 mov edx, eax -118d4: 48 8b 3d 85 3e 02 00 mov rdi, qword ptr [0x35760] // "CrossModuleTaskReturningThunk" (STRING_HANDLE) -118db: 48 8b 3f mov rdi, qword ptr [rdi] -118de: be 18 00 00 00 mov esi, 24 -118e3: ff 15 c7 3b 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -118e9: bf 07 00 00 00 mov edi, 7 -118ee: ff 15 54 3c 02 00 call qword ptr [0x35548] // int InlineThunks.CrossModuleSyncCaller(int) (METHOD_ENTRY_DEF_TOKEN) -118f4: 8b d0 mov edx, eax -118f6: 48 8b 3d 6b 3e 02 00 mov rdi, qword ptr [0x35768] // "CrossModuleSyncBaseline" (STRING_HANDLE) -118fd: 48 8b 3f mov rdi, qword ptr [rdi] -11900: be 15 00 00 00 mov esi, 21 -11905: ff 15 a5 3b 02 00 call qword ptr [0x354b0] // void InlineThunks.Check(string, int, int) (METHOD_ENTRY_DEF_TOKEN) -1190b: ff 15 17 3a 02 00 call qword ptr [0x35328] // InlineThunks (STATIC_BASE_NON_GC) -11911: 48 8b d8 mov rbx, rax -11914: 80 3b 00 cmp byte ptr [rbx], 0 -11917: 74 12 je 0x1192b -11919: 48 8b 3d 58 3e 02 00 mov rdi, qword ptr [0x35778] // "FAILED" (STRING_HANDLE) -11920: 48 8b 3f mov rdi, qword ptr [rdi] -11923: ff 15 47 3a 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) -11929: eb 10 jmp 0x1193b -1192b: 48 8b 3d 3e 3e 02 00 mov rdi, qword ptr [0x35770] // "PASSED" (STRING_HANDLE) -11932: 48 8b 3f mov rdi, qword ptr [rdi] -11935: ff 15 35 3a 02 00 call qword ptr [0x35370] // void System.Console.WriteLine(string) (METHOD_ENTRY_REF_TOKEN) -1193b: b8 01 00 00 00 mov eax, 1 -11940: b9 64 00 00 00 mov ecx, 100 -11945: 80 3b 00 cmp byte ptr [rbx], 0 -11948: 0f 44 c1 cmove eax, ecx -1194b: 48 83 c4 30 add rsp, 48 -1194f: 5b pop rbx -11950: 41 5d pop r13 -11952: 41 5e pop r14 -11954: 41 5f pop r15 -11956: 5d pop rbp -11957: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) -Handle: 0x06000004 -Rid: 4 -EntryPointRuntimeFunctionId: 4 -Number of RuntimeFunctions: 1 - -System.Threading.Tasks.Task`1 InlineThunks.CallAsyncAndGetResult(int) -Id: 4 -StartAddress: 0x00011960 -Size: 13 bytes -UnwindRVA: 0x0001097C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -Debug Info - Bounds: -00000000: 23 01 42 CA 32 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x7, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -11960: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -11961: ff 15 a9 3b 02 00 call qword ptr [0x35510] // System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) (METHOD_ENTRY_DEF_TOKEN) -11967: 90 nop -11968: 48 83 c4 08 add rsp, 8 -1196c: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() -Handle: 0x06000005 -Rid: 5 -EntryPointRuntimeFunctionId: 5 -Number of RuntimeFunctions: 1 - -System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() -Id: 5 -StartAddress: 0x00011970 -Size: 13 bytes -UnwindRVA: 0x0001097C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -Debug Info - Bounds: -00000000: 23 01 42 CA 32 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x7, Epilog, Source Types: StackEmpty - -11970: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -11971: ff 15 a1 3b 02 00 call qword ptr [0x35518] // System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() (METHOD_ENTRY_DEF_TOKEN) -11977: 90 nop -11978: 48 83 c4 08 add rsp, 8 -1197c: c3 ret - -_______________________________________________ - -System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) -Handle: 0x06000006 -Rid: 6 -EntryPointRuntimeFunctionId: 6 -Number of RuntimeFunctions: 1 -Number of fixups: 2 - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.ValueTask`1 InlineThunks.CallAsyncValueTask(int) -Id: 6 -StartAddress: 0x00011980 -Size: 42 bytes -UnwindRVA: 0x0001098C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0004 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0004 FrameOffset 0x0000 NextOffset 0x0 Op 24 - -Debug Info - Bounds: -00000000: 43 01 02 69 2D 0D - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0xB, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x25, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0xB - Loc Type: VLT_REG - Register: RDI - -11980: 48 83 ec 18 sub rsp, 24 - UWOP_ALLOC_SMALL 24 0 - -11984: 33 c0 xor eax, eax -11986: 48 89 44 24 08 mov qword ptr [rsp + 8], rax -1198b: ff 15 8f 3b 02 00 call qword ptr [0x35520] // System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) (METHOD_ENTRY_DEF_TOKEN) -11991: 48 89 44 24 08 mov qword ptr [rsp + 8], rax -11996: 48 89 54 24 10 mov qword ptr [rsp + 16], rdx -1199b: 48 8b 44 24 08 mov rax, qword ptr [rsp + 8] -119a0: 48 8b 54 24 10 mov rdx, qword ptr [rsp + 16] -119a5: 48 83 c4 18 add rsp, 24 -119a9: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Handle: 0x06000007 -Rid: 7 -EntryPointRuntimeFunctionId: 7 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Id: 7 -StartAddress: 0x000119B0 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13078, #clauses = 2 -Flags 20 TryOff 0028 (RVA 119D8) TryEnd 0045 (RVA 119F5) HndOff 0067 (RVA 11A17) HndEnd 007E (RVA 11A2E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 119D8) TryEnd 0052 (RVA 11A02) HndOff 007E (RVA 11A2E) HndEnd 008F (RVA 11A3F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -119b0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -119b1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -119b2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -119b6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -119bb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -119c0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -119c5: 33 c0 xor eax, eax -119c7: 48 89 45 f0 mov qword ptr [rbp - 16], rax -119cb: 8b df mov ebx, edi -119cd: 48 8d 7d e0 lea rdi, [rbp - 32] -119d1: ff 15 b1 39 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -119d7: 90 nop -119d8: 8b f3 mov esi, ebx -119da: 33 ff xor edi, edi - RDI is live -119dc: ff 15 86 3b 02 00 call qword ptr [0x35568] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) (METHOD_ENTRY) - RDI is dead - RCX is live -119e2: 48 85 c9 test rcx, rcx -119e5: 75 0e jne 0x119f5 -119e7: 8b f8 mov edi, eax -119e9: ff 15 69 3a 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -119ef: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -119f3: eb 0d jmp 0x11a02 - sp-40 is dead - RAX is dead -119f5: ff 15 6d 3a 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -119fb: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -119ff: eb 01 jmp 0x11a02 - RAX is dead -11a01: 90 nop -11a02: 48 8d 7d e0 lea rdi, [rbp - 32] -11a06: ff 15 84 39 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11a0c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -11a10: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -11a14: 5b pop rbx -11a15: 5d pop rbp -11a16: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Id: 8 -StartAddress: 0x00011A17 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11a17: 50 push rax -11a18: ff 15 5a 3a 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11a1e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11a22: 48 8d 05 d8 ff ff ff lea rax, [0x11a01] - RAX is dead -11a29: 48 83 c4 08 add rsp, 8 - sp-40 is dead -11a2d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Id: 9 -StartAddress: 0x00011A2E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11a2e: 50 push rax -11a2f: 48 8d 7d e0 lea rdi, [rbp - 32] -11a33: ff 15 57 39 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11a39: 90 nop -11a3a: 48 83 c4 08 add rsp, 8 -11a3e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Handle: 0x06000008 -Rid: 8 -EntryPointRuntimeFunctionId: 10 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Id: 10 -StartAddress: 0x00011A40 -Size: 95 bytes -UnwindRVA: 0x000109F4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 - -EH info @ 130A8, #clauses = 2 -Flags 20 TryOff 0025 (RVA 11A65) TryEnd 003E (RVA 11A7E) HndOff 005F (RVA 11A9F) HndEnd 0076 (RVA 11AB6) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0025 (RVA 11A65) TryEnd 004B (RVA 11A8B) HndOff 0076 (RVA 11AB6) HndEnd 0087 (RVA 11AC7) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 -00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty - Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x4A, NoMapping, Source Types: StackEmpty - Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty - Native Offset: 0x59, Epilog, Source Types: StackEmpty - Native Offset: 0x5F, Prolog, Source Types: StackEmpty - Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid - Native Offset: 0x71, Epilog, Source Types: StackEmpty - Native Offset: 0x76, Prolog, Source Types: StackEmpty - Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty - Native Offset: 0x82, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x3C - End Offset: 0x3E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x48 - End Offset: 0x59 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x6A - End Offset: 0x76 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - -11a40: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11a41: 48 83 ec 20 sub rsp, 32 - UWOP_ALLOC_SMALL 32 0 - -11a45: 48 8d 6c 24 20 lea rbp, [rsp + 32] -11a4a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11a4f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 -11a54: 33 c0 xor eax, eax -11a56: 48 89 45 f8 mov qword ptr [rbp - 8], rax -11a5a: 48 8d 7d e8 lea rdi, [rbp - 24] -11a5e: ff 15 24 39 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11a64: 90 nop -11a65: 33 ff xor edi, edi - RDI is live -11a67: ff 15 03 3b 02 00 call qword ptr [0x35570] // [ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() (METHOD_ENTRY) - RDI is dead - RCX is live -11a6d: 48 85 c9 test rcx, rcx -11a70: 75 0c jne 0x11a7e -11a72: ff 15 08 39 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) - RAX is live - RCX is dead -11a78: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11a7c: eb 0d jmp 0x11a8b - RAX is dead - sp-32 is dead -11a7e: ff 15 14 39 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) - RAX is live -11a84: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11a88: eb 01 jmp 0x11a8b - RAX is dead -11a8a: 90 nop -11a8b: 48 8d 7d e8 lea rdi, [rbp - 24] -11a8f: ff 15 fb 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11a95: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] - RAX is live -11a99: 48 83 c4 20 add rsp, 32 - RAX is dead - RDI is live - sp-32 is dead -11a9d: 5d pop rbp -11a9e: c3 ret - -System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Id: 11 -StartAddress: 0x00011A9F -Size: 23 bytes -UnwindRVA: 0x00010A2C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11a9f: 50 push rax -11aa0: ff 15 fa 38 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) - RAX is live - RDI is dead -11aa6: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11aaa: 48 8d 05 d9 ff ff ff lea rax, [0x11a8a] - RAX is dead -11ab1: 48 83 c4 08 add rsp, 8 - sp-32 is dead -11ab5: c3 ret - -System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Id: 12 -StartAddress: 0x00011AB6 -Size: 17 bytes -UnwindRVA: 0x00010A38 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11ab6: 50 push rax -11ab7: 48 8d 7d e8 lea rdi, [rbp - 24] -11abb: ff 15 cf 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11ac1: 90 nop -11ac2: 48 83 c4 08 add rsp, 8 -11ac6: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Handle: 0x06000009 -Rid: 9 -EntryPointRuntimeFunctionId: 13 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Id: 13 -StartAddress: 0x00011AD0 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 130D8, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11AF8) TryEnd 0045 (RVA 11B15) HndOff 0067 (RVA 11B37) HndEnd 007E (RVA 11B4E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11AF8) TryEnd 0052 (RVA 11B22) HndOff 007E (RVA 11B4E) HndEnd 008F (RVA 11B5F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -11ad0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11ad1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11ad2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11ad6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11adb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11ae0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -11ae5: 33 c0 xor eax, eax -11ae7: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11aeb: 8b df mov ebx, edi -11aed: 48 8d 7d e0 lea rdi, [rbp - 32] -11af1: ff 15 91 38 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11af7: 90 nop -11af8: 8b f3 mov esi, ebx -11afa: 33 ff xor edi, edi - RDI is live -11afc: ff 15 76 3a 02 00 call qword ptr [0x35578] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) (METHOD_ENTRY) - RDI is dead - RCX is live -11b02: 48 85 c9 test rcx, rcx -11b05: 75 0e jne 0x11b15 -11b07: 8b f8 mov edi, eax -11b09: ff 15 49 39 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11b0f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11b13: eb 0d jmp 0x11b22 - sp-40 is dead - RAX is dead -11b15: ff 15 4d 39 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11b1b: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11b1f: eb 01 jmp 0x11b22 - RAX is dead -11b21: 90 nop -11b22: 48 8d 7d e0 lea rdi, [rbp - 32] -11b26: ff 15 64 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11b2c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -11b30: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -11b34: 5b pop rbx -11b35: 5d pop rbp -11b36: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Id: 14 -StartAddress: 0x00011B37 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11b37: 50 push rax -11b38: ff 15 3a 39 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11b3e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11b42: 48 8d 05 d8 ff ff ff lea rax, [0x11b21] - RAX is dead -11b49: 48 83 c4 08 add rsp, 8 - sp-40 is dead -11b4d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Id: 15 -StartAddress: 0x00011B4E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11b4e: 50 push rax -11b4f: 48 8d 7d e0 lea rdi, [rbp - 32] -11b53: ff 15 37 38 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11b59: 90 nop -11b5a: 48 83 c4 08 add rsp, 8 -11b5e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) -Handle: 0x0600000A -Rid: 10 -EntryPointRuntimeFunctionId: 16 -Number of RuntimeFunctions: 1 -Number of fixups: 7 - TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) - TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) - TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) - -System.Threading.Tasks.Task`1 InlineThunks.CallNonRuntimeAsync(int) -Id: 16 -StartAddress: 0x00011B60 -Size: 160 bytes -UnwindRVA: 0x00010A44 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0007 -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op 8 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 73 01 02 48 14 2B 10 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x14, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x95, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x14 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x14 - End Offset: 0x47 - Loc Type: VLT_REG - Register: RBX - -11b60: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11b61: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -11b63: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -11b65: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11b66: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -11b67: 48 8d 6c 24 20 lea rbp, [rsp + 32] -11b6c: 33 c0 xor eax, eax -11b6e: 48 89 45 e0 mov qword ptr [rbp - 32], rax -11b72: 8b df mov ebx, edi -11b74: ff 15 ce 37 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) -11b7a: 48 89 45 e0 mov qword ptr [rbp - 32], rax -11b7e: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] -11b82: ff 15 80 38 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) -11b88: 4c 8b 35 09 3b 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) -11b8f: 4b 8d 3c 37 lea rdi, [r15 + r14] -11b93: 48 8b f0 mov rsi, rax -11b96: ff 15 64 37 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -11b9c: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -11ba0: 48 8b 35 f9 3a 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) -11ba7: 89 1c 37 mov dword ptr [rdi + rsi], ebx -11baa: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -11bae: 48 8b 35 db 3a 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) -11bb5: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -11bbc: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -11bc0: 40 38 3f cmp byte ptr [rdi], dil -11bc3: 49 8b fe mov rdi, r14 -11bc6: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -11bca: 48 8b 35 07 3a 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) -11bd1: 48 8d 55 e0 lea rdx, [rbp - 32] -11bd5: ff 15 c5 38 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) -11bdb: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -11bdf: 40 38 3f cmp byte ptr [rdi], dil -11be2: 49 8b fe mov rdi, r14 -11be5: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -11be9: ff 15 21 38 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) -11bef: 33 c9 xor ecx, ecx -11bf1: 48 89 4d e0 mov qword ptr [rbp - 32], rcx -11bf5: 48 83 c4 08 add rsp, 8 -11bf9: 5b pop rbx -11bfa: 41 5e pop r14 -11bfc: 41 5f pop r15 -11bfe: 5d pop rbp -11bff: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Handle: 0x0600000B -Rid: 11 -EntryPointRuntimeFunctionId: 17 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 17 -StartAddress: 0x00011C00 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13108, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11C28) TryEnd 0045 (RVA 11C45) HndOff 0067 (RVA 11C67) HndEnd 007E (RVA 11C7E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11C28) TryEnd 0052 (RVA 11C52) HndOff 007E (RVA 11C7E) HndEnd 008F (RVA 11C8F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -11c00: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11c01: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11c02: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11c06: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11c0b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11c10: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -11c15: 33 c0 xor eax, eax -11c17: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11c1b: 8b df mov ebx, edi -11c1d: 48 8d 7d e0 lea rdi, [rbp - 32] -11c21: ff 15 61 37 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11c27: 90 nop -11c28: 8b f3 mov esi, ebx -11c2a: 33 ff xor edi, edi - RDI is live -11c2c: ff 15 4e 39 02 00 call qword ptr [0x35580] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) (METHOD_ENTRY) - RDI is dead - RCX is live -11c32: 48 85 c9 test rcx, rcx -11c35: 75 0e jne 0x11c45 -11c37: 8b f8 mov edi, eax -11c39: ff 15 19 38 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11c3f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11c43: eb 0d jmp 0x11c52 - sp-40 is dead - RAX is dead -11c45: ff 15 1d 38 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11c4b: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11c4f: eb 01 jmp 0x11c52 - RAX is dead -11c51: 90 nop -11c52: 48 8d 7d e0 lea rdi, [rbp - 32] -11c56: ff 15 34 37 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11c5c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -11c60: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -11c64: 5b pop rbx -11c65: 5d pop rbp -11c66: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 18 -StartAddress: 0x00011C67 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11c67: 50 push rax -11c68: ff 15 0a 38 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11c6e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11c72: 48 8d 05 d8 ff ff ff lea rax, [0x11c51] - RAX is dead -11c79: 48 83 c4 08 add rsp, 8 - sp-40 is dead -11c7d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 19 -StartAddress: 0x00011C7E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11c7e: 50 push rax -11c7f: 48 8d 7d e0 lea rdi, [rbp - 32] -11c83: ff 15 07 37 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11c89: 90 nop -11c8a: 48 83 c4 08 add rsp, 8 -11c8e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) -Handle: 0x0600000C -Rid: 12 -EntryPointRuntimeFunctionId: 20 -Number of RuntimeFunctions: 1 -Number of fixups: 9 - TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) - TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) - -System.Threading.Tasks.ValueTask`1 InlineThunks.CallNonRuntimeValueTaskAsync(int) -Id: 20 -StartAddress: 0x00011C90 -Size: 200 bytes -UnwindRVA: 0x00010A64 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000A -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 73 01 02 48 21 8B 13 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x21, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xBD, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x21 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x21 - End Offset: 0x5F - Loc Type: VLT_REG - Register: RBX - -11c90: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11c91: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -11c93: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -11c95: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11c96: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11c9a: 48 8d 6c 24 40 lea rbp, [rsp + 64] -11c9f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11ca4: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 -11ca9: 33 c0 xor eax, eax -11cab: 48 89 45 e0 mov qword ptr [rbp - 32], rax -11caf: 8b df mov ebx, edi -11cb1: ff 15 99 36 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) -11cb7: 48 89 45 d0 mov qword ptr [rbp - 48], rax -11cbb: 4c 8b 7d d0 mov r15, qword ptr [rbp - 48] -11cbf: ff 15 63 37 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) -11cc5: 48 89 45 c0 mov qword ptr [rbp - 64], rax -11cc9: 48 89 55 c8 mov qword ptr [rbp - 56], rdx -11ccd: 4c 8b 35 dc 39 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) -11cd4: 4b 8d 3c 37 lea rdi, [r15 + r14] -11cd8: 48 8d 75 c0 lea rsi, [rbp - 64] -11cdc: ff 15 26 36 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) -11ce2: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] -11ce4: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -11ce8: 48 8b 35 c9 39 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) -11cef: 89 1c 37 mov dword ptr [rdi + rsi], ebx -11cf2: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -11cf6: 48 8b 35 ab 39 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) -11cfd: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -11d04: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -11d08: 40 38 3f cmp byte ptr [rdi], dil -11d0b: 49 8b fe mov rdi, r14 -11d0e: 48 03 7d d0 add rdi, qword ptr [rbp - 48] -11d12: 48 8b 35 c7 38 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) -11d19: 48 8d 55 d0 lea rdx, [rbp - 48] -11d1d: ff 15 85 37 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) -11d23: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -11d27: 40 38 3f cmp byte ptr [rdi], dil -11d2a: 49 8b fe mov rdi, r14 -11d2d: 48 03 7d d0 add rdi, qword ptr [rbp - 48] -11d31: ff 15 09 37 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) -11d37: 48 89 45 d8 mov qword ptr [rbp - 40], rax -11d3b: 48 89 55 e0 mov qword ptr [rbp - 32], rdx -11d3f: 33 c0 xor eax, eax -11d41: 48 89 45 d0 mov qword ptr [rbp - 48], rax -11d45: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] -11d49: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] -11d4d: 48 83 c4 28 add rsp, 40 -11d51: 5b pop rbx -11d52: 41 5e pop r14 -11d54: 41 5f pop r15 -11d56: 5d pop rbp -11d57: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Handle: 0x0600000D -Rid: 13 -EntryPointRuntimeFunctionId: 21 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 21 -StartAddress: 0x00011D60 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13138, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11D88) TryEnd 0045 (RVA 11DA5) HndOff 0067 (RVA 11DC7) HndEnd 007E (RVA 11DDE) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11D88) TryEnd 0052 (RVA 11DB2) HndOff 007E (RVA 11DDE) HndEnd 008F (RVA 11DEF) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -11d60: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11d61: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11d62: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11d66: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11d6b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11d70: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -11d75: 33 c0 xor eax, eax -11d77: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11d7b: 8b df mov ebx, edi -11d7d: 48 8d 7d e0 lea rdi, [rbp - 32] -11d81: ff 15 01 36 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11d87: 90 nop -11d88: 8b f3 mov esi, ebx -11d8a: 33 ff xor edi, edi - RDI is live -11d8c: ff 15 f6 37 02 00 call qword ptr [0x35588] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) (METHOD_ENTRY) - RDI is dead - RCX is live -11d92: 48 85 c9 test rcx, rcx -11d95: 75 0e jne 0x11da5 -11d97: 8b f8 mov edi, eax -11d99: ff 15 b9 36 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11d9f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11da3: eb 0d jmp 0x11db2 - sp-40 is dead - RAX is dead -11da5: ff 15 bd 36 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11dab: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11daf: eb 01 jmp 0x11db2 - RAX is dead -11db1: 90 nop -11db2: 48 8d 7d e0 lea rdi, [rbp - 32] -11db6: ff 15 d4 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11dbc: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -11dc0: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -11dc4: 5b pop rbx -11dc5: 5d pop rbp -11dc6: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 22 -StartAddress: 0x00011DC7 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11dc7: 50 push rax -11dc8: ff 15 aa 36 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11dce: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11dd2: 48 8d 05 d8 ff ff ff lea rax, [0x11db1] - RAX is dead -11dd9: 48 83 c4 08 add rsp, 8 - sp-40 is dead -11ddd: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 23 -StartAddress: 0x00011DDE -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11dde: 50 push rax -11ddf: 48 8d 7d e0 lea rdi, [rbp - 32] -11de3: ff 15 a7 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11de9: 90 nop -11dea: 48 83 c4 08 add rsp, 8 -11dee: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Handle: 0x0600000E -Rid: 14 -EntryPointRuntimeFunctionId: 24 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Id: 24 -StartAddress: 0x00011DF0 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13168, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11E18) TryEnd 0045 (RVA 11E35) HndOff 0067 (RVA 11E57) HndEnd 007E (RVA 11E6E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11E18) TryEnd 0052 (RVA 11E42) HndOff 007E (RVA 11E6E) HndEnd 008F (RVA 11E7F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -11df0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11df1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11df2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11df6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11dfb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11e00: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -11e05: 33 c0 xor eax, eax -11e07: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11e0b: 8b df mov ebx, edi -11e0d: 48 8d 7d e0 lea rdi, [rbp - 32] -11e11: ff 15 71 35 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11e17: 90 nop -11e18: 8b f3 mov esi, ebx -11e1a: 33 ff xor edi, edi - RDI is live -11e1c: ff 15 6e 37 02 00 call qword ptr [0x35590] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) (METHOD_ENTRY) - RDI is dead - RCX is live -11e22: 48 85 c9 test rcx, rcx -11e25: 75 0e jne 0x11e35 -11e27: 8b f8 mov edi, eax -11e29: ff 15 29 36 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11e2f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11e33: eb 0d jmp 0x11e42 - sp-40 is dead - RAX is dead -11e35: ff 15 2d 36 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11e3b: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11e3f: eb 01 jmp 0x11e42 - RAX is dead -11e41: 90 nop -11e42: 48 8d 7d e0 lea rdi, [rbp - 32] -11e46: ff 15 44 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11e4c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -11e50: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -11e54: 5b pop rbx -11e55: 5d pop rbp -11e56: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Id: 25 -StartAddress: 0x00011E57 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11e57: 50 push rax -11e58: ff 15 1a 36 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11e5e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11e62: 48 8d 05 d8 ff ff ff lea rax, [0x11e41] - RAX is dead -11e69: 48 83 c4 08 add rsp, 8 - sp-40 is dead -11e6d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Id: 26 -StartAddress: 0x00011E6E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11e6e: 50 push rax -11e6f: 48 8d 7d e0 lea rdi, [rbp - 32] -11e73: ff 15 17 35 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11e79: 90 nop -11e7a: 48 83 c4 08 add rsp, 8 -11e7e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Handle: 0x0600000F -Rid: 15 -EntryPointRuntimeFunctionId: 27 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Id: 27 -StartAddress: 0x00011E80 -Size: 95 bytes -UnwindRVA: 0x000109F4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 - -EH info @ 13198, #clauses = 2 -Flags 20 TryOff 0025 (RVA 11EA5) TryEnd 003E (RVA 11EBE) HndOff 005F (RVA 11EDF) HndEnd 0076 (RVA 11EF6) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0025 (RVA 11EA5) TryEnd 004B (RVA 11ECB) HndOff 0076 (RVA 11EF6) HndEnd 0087 (RVA 11F07) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 -00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty - Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x4A, NoMapping, Source Types: StackEmpty - Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty - Native Offset: 0x59, Epilog, Source Types: StackEmpty - Native Offset: 0x5F, Prolog, Source Types: StackEmpty - Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid - Native Offset: 0x71, Epilog, Source Types: StackEmpty - Native Offset: 0x76, Prolog, Source Types: StackEmpty - Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty - Native Offset: 0x82, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x3C - End Offset: 0x3E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x48 - End Offset: 0x59 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x6A - End Offset: 0x76 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - -11e80: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11e81: 48 83 ec 20 sub rsp, 32 - UWOP_ALLOC_SMALL 32 0 - -11e85: 48 8d 6c 24 20 lea rbp, [rsp + 32] -11e8a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11e8f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 -11e94: 33 c0 xor eax, eax -11e96: 48 89 45 f8 mov qword ptr [rbp - 8], rax -11e9a: 48 8d 7d e8 lea rdi, [rbp - 24] -11e9e: ff 15 e4 34 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11ea4: 90 nop -11ea5: 33 ff xor edi, edi - RDI is live -11ea7: ff 15 eb 36 02 00 call qword ptr [0x35598] // [ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() (METHOD_ENTRY) - RDI is dead - RCX is live -11ead: 48 85 c9 test rcx, rcx -11eb0: 75 0c jne 0x11ebe -11eb2: ff 15 c8 34 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) - RAX is live - RCX is dead -11eb8: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11ebc: eb 0d jmp 0x11ecb - RAX is dead - sp-32 is dead -11ebe: ff 15 d4 34 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) - RAX is live -11ec4: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11ec8: eb 01 jmp 0x11ecb - RAX is dead -11eca: 90 nop -11ecb: 48 8d 7d e8 lea rdi, [rbp - 24] -11ecf: ff 15 bb 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11ed5: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] - RAX is live -11ed9: 48 83 c4 20 add rsp, 32 - RAX is dead - RDI is live - sp-32 is dead -11edd: 5d pop rbp -11ede: c3 ret - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Id: 28 -StartAddress: 0x00011EDF -Size: 23 bytes -UnwindRVA: 0x00010A2C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11edf: 50 push rax -11ee0: ff 15 ba 34 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) - RAX is live - RDI is dead -11ee6: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -11eea: 48 8d 05 d9 ff ff ff lea rax, [0x11eca] - RAX is dead -11ef1: 48 83 c4 08 add rsp, 8 - sp-32 is dead -11ef5: c3 ret - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Id: 29 -StartAddress: 0x00011EF6 -Size: 17 bytes -UnwindRVA: 0x00010A38 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11ef6: 50 push rax -11ef7: 48 8d 7d e8 lea rdi, [rbp - 24] -11efb: ff 15 8f 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11f01: 90 nop -11f02: 48 83 c4 08 add rsp, 8 -11f06: c3 ret - -_______________________________________________ - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Handle: 0x06000010 -Rid: 16 -EntryPointRuntimeFunctionId: 30 -Number of RuntimeFunctions: 3 -Number of fixups: 4 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Id: 30 -StartAddress: 0x00011F10 -Size: 115 bytes -UnwindRVA: 0x00010A88 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 131C8, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11F38) TryEnd 0049 (RVA 11F59) HndOff 0073 (RVA 11F83) HndEnd 008E (RVA 11F9E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11F38) TryEnd 005A (RVA 11F6A) HndOff 008E (RVA 11F9E) HndEnd 009F (RVA 11FAF) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 79 65 02 02 EA 06 5A 16 52 24 3A 05 0A 86 52 96 -00000010: 42 00 3A 02 08 5A AA 00 2A 02 0A 86 52 94 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x59, NoMapping, Source Types: StackEmpty - Native Offset: 0x5A, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x64, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x6C, Epilog, Source Types: StackEmpty - Native Offset: 0x73, Prolog, Source Types: StackEmpty - Native Offset: 0x74, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x89, Epilog, Source Types: StackEmpty - Native Offset: 0x8E, Prolog, Source Types: StackEmpty - Native Offset: 0x8F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x99, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x9A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x47 - End Offset: 0x49 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - - Variable Number: 2 - Start Offset: 0x57 - End Offset: 0x64 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - - Variable Number: 2 - Start Offset: 0x82 - End Offset: 0x8E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - -11f10: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11f11: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11f12: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11f16: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11f1b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11f20: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 -11f25: 33 c0 xor eax, eax -11f27: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11f2b: 8b df mov ebx, edi -11f2d: 48 8d 7d d0 lea rdi, [rbp - 48] -11f31: ff 15 51 34 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11f37: 90 nop -11f38: 8b f3 mov esi, ebx -11f3a: 33 ff xor edi, edi - RDI is live -11f3c: ff 15 5e 36 02 00 call qword ptr [0x355a0] // [ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) (METHOD_ENTRY) - RCX is live - RDI is dead -11f42: 48 85 c9 test rcx, rcx -11f45: 75 12 jne 0x11f59 -11f47: 8b f8 mov edi, eax -11f49: ff 15 11 35 02 00 call qword ptr [0x35460] // System.Threading.Tasks.ValueTask`1 System.Threading.Tasks.ValueTask.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11f4f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -11f53: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -11f57: eb 11 jmp 0x11f6a - RAX is dead -11f59: ff 15 11 35 02 00 call qword ptr [0x35470] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeValueTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11f5f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -11f63: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -11f67: eb 01 jmp 0x11f6a - RAX is dead -11f69: 90 nop -11f6a: 48 8d 7d d0 lea rdi, [rbp - 48] -11f6e: ff 15 1c 34 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11f74: 48 8b 45 e8 mov rax, qword ptr [rbp - 24] - RAX is live -11f78: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] -11f7c: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live -11f80: 5b pop rbx -11f81: 5d pop rbp -11f82: c3 ret - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Id: 31 -StartAddress: 0x00011F83 -Size: 27 bytes -UnwindRVA: 0x00010ABC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11f83: 50 push rax -11f84: ff 15 f6 34 02 00 call qword ptr [0x35480] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.ValueTaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -11f8a: 48 89 45 e8 mov qword ptr [rbp - 24], rax -11f8e: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -11f92: 48 8d 05 d0 ff ff ff lea rax, [0x11f69] - RAX is dead -11f99: 48 83 c4 08 add rsp, 8 -11f9d: c3 ret - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Id: 32 -StartAddress: 0x00011F9E -Size: 17 bytes -UnwindRVA: 0x00010AC8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -11f9e: 50 push rax -11f9f: 48 8d 7d d0 lea rdi, [rbp - 48] -11fa3: ff 15 e7 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -11fa9: 90 nop -11faa: 48 83 c4 08 add rsp, 8 -11fae: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Handle: 0x06000011 -Rid: 17 -EntryPointRuntimeFunctionId: 33 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Id: 33 -StartAddress: 0x00011FB0 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 131F8, #clauses = 2 -Flags 20 TryOff 0028 (RVA 11FD8) TryEnd 0045 (RVA 11FF5) HndOff 0067 (RVA 12017) HndEnd 007E (RVA 1202E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 11FD8) TryEnd 0052 (RVA 12002) HndOff 007E (RVA 1202E) HndEnd 008F (RVA 1203F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -11fb0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -11fb1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -11fb2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -11fb6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -11fbb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -11fc0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -11fc5: 33 c0 xor eax, eax -11fc7: 48 89 45 f0 mov qword ptr [rbp - 16], rax -11fcb: 8b df mov ebx, edi -11fcd: 48 8d 7d e0 lea rdi, [rbp - 32] -11fd1: ff 15 b1 33 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -11fd7: 90 nop -11fd8: 8b f3 mov esi, ebx -11fda: 33 ff xor edi, edi - RDI is live -11fdc: ff 15 c6 35 02 00 call qword ptr [0x355a8] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) (METHOD_ENTRY) - RDI is dead - RCX is live -11fe2: 48 85 c9 test rcx, rcx -11fe5: 75 0e jne 0x11ff5 -11fe7: 8b f8 mov edi, eax -11fe9: ff 15 69 34 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -11fef: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11ff3: eb 0d jmp 0x12002 - sp-40 is dead - RAX is dead -11ff5: ff 15 6d 34 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -11ffb: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -11fff: eb 01 jmp 0x12002 - RAX is dead -12001: 90 nop -12002: 48 8d 7d e0 lea rdi, [rbp - 32] -12006: ff 15 84 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -1200c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -12010: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -12014: 5b pop rbx -12015: 5d pop rbp -12016: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Id: 34 -StartAddress: 0x00012017 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12017: 50 push rax -12018: ff 15 5a 34 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -1201e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -12022: 48 8d 05 d8 ff ff ff lea rax, [0x12001] - RAX is dead -12029: 48 83 c4 08 add rsp, 8 - sp-40 is dead -1202d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Id: 35 -StartAddress: 0x0001202E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1202e: 50 push rax -1202f: 48 8d 7d e0 lea rdi, [rbp - 32] -12033: ff 15 57 33 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12039: 90 nop -1203a: 48 83 c4 08 add rsp, 8 -1203e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Handle: 0x06000012 -Rid: 18 -EntryPointRuntimeFunctionId: 36 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Id: 36 -StartAddress: 0x00012040 -Size: 95 bytes -UnwindRVA: 0x000109F4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 - -EH info @ 13228, #clauses = 2 -Flags 20 TryOff 0025 (RVA 12065) TryEnd 003E (RVA 1207E) HndOff 005F (RVA 1209F) HndEnd 0076 (RVA 120B6) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0025 (RVA 12065) TryEnd 004B (RVA 1208B) HndOff 0076 (RVA 120B6) HndEnd 0087 (RVA 120C7) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 -00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty - Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x4A, NoMapping, Source Types: StackEmpty - Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty - Native Offset: 0x59, Epilog, Source Types: StackEmpty - Native Offset: 0x5F, Prolog, Source Types: StackEmpty - Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid - Native Offset: 0x71, Epilog, Source Types: StackEmpty - Native Offset: 0x76, Prolog, Source Types: StackEmpty - Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty - Native Offset: 0x82, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x3C - End Offset: 0x3E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x48 - End Offset: 0x59 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x6A - End Offset: 0x76 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - -12040: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12041: 48 83 ec 20 sub rsp, 32 - UWOP_ALLOC_SMALL 32 0 - -12045: 48 8d 6c 24 20 lea rbp, [rsp + 32] -1204a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -1204f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 -12054: 33 c0 xor eax, eax -12056: 48 89 45 f8 mov qword ptr [rbp - 8], rax -1205a: 48 8d 7d e8 lea rdi, [rbp - 24] -1205e: ff 15 24 33 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -12064: 90 nop -12065: 33 ff xor edi, edi - RDI is live -12067: ff 15 43 35 02 00 call qword ptr [0x355b0] // [ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() (METHOD_ENTRY) - RDI is dead - RCX is live -1206d: 48 85 c9 test rcx, rcx -12070: 75 0c jne 0x1207e -12072: ff 15 08 33 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) - RAX is live - RCX is dead -12078: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -1207c: eb 0d jmp 0x1208b - RAX is dead - sp-32 is dead -1207e: ff 15 14 33 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) - RAX is live -12084: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -12088: eb 01 jmp 0x1208b - RAX is dead -1208a: 90 nop -1208b: 48 8d 7d e8 lea rdi, [rbp - 24] -1208f: ff 15 fb 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12095: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] - RAX is live -12099: 48 83 c4 20 add rsp, 32 - RAX is dead - RDI is live - sp-32 is dead -1209d: 5d pop rbp -1209e: c3 ret - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Id: 37 -StartAddress: 0x0001209F -Size: 23 bytes -UnwindRVA: 0x00010A2C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1209f: 50 push rax -120a0: ff 15 fa 32 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) - RAX is live - RDI is dead -120a6: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -120aa: 48 8d 05 d9 ff ff ff lea rax, [0x1208a] - RAX is dead -120b1: 48 83 c4 08 add rsp, 8 - sp-32 is dead -120b5: c3 ret - -System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Id: 38 -StartAddress: 0x000120B6 -Size: 17 bytes -UnwindRVA: 0x00010A38 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -120b6: 50 push rax -120b7: 48 8d 7d e8 lea rdi, [rbp - 24] -120bb: ff 15 cf 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -120c1: 90 nop -120c2: 48 83 c4 08 add rsp, 8 -120c6: c3 ret - -_______________________________________________ - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Handle: 0x06000013 -Rid: 19 -EntryPointRuntimeFunctionId: 39 -Number of RuntimeFunctions: 3 -Number of fixups: 4 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Id: 39 -StartAddress: 0x000120D0 -Size: 115 bytes -UnwindRVA: 0x00010A88 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13258, #clauses = 2 -Flags 20 TryOff 0028 (RVA 120F8) TryEnd 0049 (RVA 12119) HndOff 0073 (RVA 12143) HndEnd 008E (RVA 1215E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 120F8) TryEnd 005A (RVA 1212A) HndOff 008E (RVA 1215E) HndEnd 009F (RVA 1216F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 79 65 02 02 EA 06 5A 16 52 24 3A 05 0A 86 52 96 -00000010: 42 00 3A 02 08 5A AA 00 2A 02 0A 86 52 94 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x59, NoMapping, Source Types: StackEmpty - Native Offset: 0x5A, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x64, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x6C, Epilog, Source Types: StackEmpty - Native Offset: 0x73, Prolog, Source Types: StackEmpty - Native Offset: 0x74, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x89, Epilog, Source Types: StackEmpty - Native Offset: 0x8E, Prolog, Source Types: StackEmpty - Native Offset: 0x8F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x99, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x9A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x47 - End Offset: 0x49 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - - Variable Number: 2 - Start Offset: 0x57 - End Offset: 0x64 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - - Variable Number: 2 - Start Offset: 0x82 - End Offset: 0x8E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -24 - -120d0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -120d1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -120d2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -120d6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -120db: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -120e0: c5 7e 7f 45 d0 vmovdqu ymmword ptr [rbp - 48], ymm8 -120e5: 33 c0 xor eax, eax -120e7: 48 89 45 f0 mov qword ptr [rbp - 16], rax -120eb: 8b df mov ebx, edi -120ed: 48 8d 7d d0 lea rdi, [rbp - 48] -120f1: ff 15 91 32 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -120f7: 90 nop -120f8: 8b f3 mov esi, ebx -120fa: 33 ff xor edi, edi - RDI is live -120fc: ff 15 b6 34 02 00 call qword ptr [0x355b8] // [ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) (METHOD_ENTRY) - RCX is live - RDI is dead -12102: 48 85 c9 test rcx, rcx -12105: 75 12 jne 0x12119 -12107: 8b f8 mov edi, eax -12109: ff 15 51 33 02 00 call qword ptr [0x35460] // System.Threading.Tasks.ValueTask`1 System.Threading.Tasks.ValueTask.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -1210f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12113: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -12117: eb 11 jmp 0x1212a - RAX is dead -12119: ff 15 51 33 02 00 call qword ptr [0x35470] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeValueTaskReturningThunk() (METHOD_ENTRY) - RAX is live -1211f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12123: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -12127: eb 01 jmp 0x1212a - RAX is dead -12129: 90 nop -1212a: 48 8d 7d d0 lea rdi, [rbp - 48] -1212e: ff 15 5c 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12134: 48 8b 45 e8 mov rax, qword ptr [rbp - 24] - RAX is live -12138: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] -1213c: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live -12140: 5b pop rbx -12141: 5d pop rbp -12142: c3 ret - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Id: 40 -StartAddress: 0x00012143 -Size: 27 bytes -UnwindRVA: 0x00010ABC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12143: 50 push rax -12144: ff 15 36 33 02 00 call qword ptr [0x35480] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncHelpers.ValueTaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -1214a: 48 89 45 e8 mov qword ptr [rbp - 24], rax -1214e: 48 89 55 f0 mov qword ptr [rbp - 16], rdx -12152: 48 8d 05 d0 ff ff ff lea rax, [0x12129] - RAX is dead -12159: 48 83 c4 08 add rsp, 8 -1215d: c3 ret - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Id: 41 -StartAddress: 0x0001215E -Size: 17 bytes -UnwindRVA: 0x00010AC8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1215e: 50 push rax -1215f: 48 8d 7d d0 lea rdi, [rbp - 48] -12163: ff 15 27 32 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12169: 90 nop -1216a: 48 83 c4 08 add rsp, 8 -1216e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.SmallNonRuntimeAsync(int) -Handle: 0x06000014 -Rid: 20 -EntryPointRuntimeFunctionId: 42 -Number of RuntimeFunctions: 1 -Number of fixups: 7 - TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) - TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) - TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) - -System.Threading.Tasks.Task`1 InlineThunks.SmallNonRuntimeAsync(int) -Id: 42 -StartAddress: 0x00012170 -Size: 155 bytes -UnwindRVA: 0x00010AD4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0007 -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0007 FrameOffset 0x0000 NextOffset 0x0 Op 8 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 09 54 02 01 28 22 95 C8 53 72 9B A4 A8 FF 8A 02 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x14, IL Offset: 0x0005, Source Types: SourceTypeInvalid - Native Offset: 0x1E, IL Offset: 0x0006, Source Types: StackEmpty - Native Offset: 0x3C, IL Offset: 0x0011, Source Types: StackEmpty - Native Offset: 0x4A, IL Offset: 0x0018, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x001f, Source Types: StackEmpty - Native Offset: 0x7B, IL Offset: 0x002c, Source Types: StackEmpty - Native Offset: 0x8F, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x14 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x14 - End Offset: 0x47 - Loc Type: VLT_REG - Register: RBX - -12170: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12171: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12173: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -12175: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12176: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -12177: 48 8d 6c 24 20 lea rbp, [rsp + 32] -1217c: 33 c0 xor eax, eax -1217e: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12182: 8b df mov ebx, edi -12184: ff 15 be 31 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) -1218a: 48 89 45 e0 mov qword ptr [rbp - 32], rax -1218e: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] -12192: ff 15 70 32 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) -12198: 4c 8b 35 f9 34 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) -1219f: 4b 8d 3c 37 lea rdi, [r15 + r14] -121a3: 48 8b f0 mov rsi, rax -121a6: ff 15 54 31 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -121ac: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -121b0: 48 8b 35 e9 34 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) -121b7: 89 1c 37 mov dword ptr [rdi + rsi], ebx -121ba: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -121be: 48 8b 35 cb 34 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) -121c5: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -121cc: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -121d0: 40 38 3f cmp byte ptr [rdi], dil -121d3: 49 8b fe mov rdi, r14 -121d6: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -121da: 48 8b 35 f7 33 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) -121e1: 48 8d 55 e0 lea rdx, [rbp - 32] -121e5: ff 15 b5 32 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) -121eb: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -121ef: 40 38 3f cmp byte ptr [rdi], dil -121f2: 49 8b fe mov rdi, r14 -121f5: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -121f9: ff 15 11 32 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) -121ff: 90 nop -12200: 48 83 c4 08 add rsp, 8 -12204: 5b pop rbx -12205: 41 5e pop r14 -12207: 41 5f pop r15 -12209: 5d pop rbp -1220a: c3 ret - -_______________________________________________ - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallNonRuntimeValueTaskAsync(int) -Handle: 0x06000015 -Rid: 21 -EntryPointRuntimeFunctionId: 43 -Number of RuntimeFunctions: 1 -Number of fixups: 9 - TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) - TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) - -System.Threading.Tasks.ValueTask`1 InlineThunks.SmallNonRuntimeValueTaskAsync(int) -Id: 43 -StartAddress: 0x00012210 -Size: 194 bytes -UnwindRVA: 0x00010AF4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000A -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 09 55 02 02 84 88 94 44 29 25 67 93 24 EA 7B 45 -00000010: 02 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x21, IL Offset: 0x0005, Source Types: SourceTypeInvalid - Native Offset: 0x2B, IL Offset: 0x0006, Source Types: StackEmpty - Native Offset: 0x54, IL Offset: 0x0011, Source Types: StackEmpty - Native Offset: 0x62, IL Offset: 0x0018, Source Types: StackEmpty - Native Offset: 0x74, IL Offset: 0x001f, Source Types: StackEmpty - Native Offset: 0x93, IL Offset: 0x002c, Source Types: StackEmpty - Native Offset: 0xB7, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x21 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x21 - End Offset: 0x5F - Loc Type: VLT_REG - Register: RBX - -12210: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12211: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12213: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -12215: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12216: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -1221a: 48 8d 6c 24 40 lea rbp, [rsp + 64] -1221f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12224: c5 7e 7f 45 c0 vmovdqu ymmword ptr [rbp - 64], ymm8 -12229: 33 c0 xor eax, eax -1222b: 48 89 45 e0 mov qword ptr [rbp - 32], rax -1222f: 8b df mov ebx, edi -12231: ff 15 19 31 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) -12237: 48 89 45 e0 mov qword ptr [rbp - 32], rax -1223b: 4c 8b 7d e0 mov r15, qword ptr [rbp - 32] -1223f: ff 15 e3 31 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) -12245: 48 89 45 d0 mov qword ptr [rbp - 48], rax -12249: 48 89 55 d8 mov qword ptr [rbp - 40], rdx -1224d: 4c 8b 35 5c 34 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) -12254: 4b 8d 3c 37 lea rdi, [r15 + r14] -12258: 48 8d 75 d0 lea rsi, [rbp - 48] -1225c: ff 15 a6 30 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) -12262: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] -12264: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -12268: 48 8b 35 49 34 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) -1226f: 89 1c 37 mov dword ptr [rdi + rsi], ebx -12272: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -12276: 48 8b 35 2b 34 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) -1227d: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -12284: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -12288: 40 38 3f cmp byte ptr [rdi], dil -1228b: 49 8b fe mov rdi, r14 -1228e: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -12292: 48 8b 35 47 33 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) -12299: 48 8d 55 e0 lea rdx, [rbp - 32] -1229d: ff 15 05 32 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) -122a3: 48 8b 7d e0 mov rdi, qword ptr [rbp - 32] -122a7: 40 38 3f cmp byte ptr [rdi], dil -122aa: 49 8b fe mov rdi, r14 -122ad: 48 03 7d e0 add rdi, qword ptr [rbp - 32] -122b1: ff 15 89 31 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) -122b7: 48 89 45 c0 mov qword ptr [rbp - 64], rax -122bb: 48 89 55 c8 mov qword ptr [rbp - 56], rdx -122bf: 48 8b 45 c0 mov rax, qword ptr [rbp - 64] -122c3: 48 8b 55 c8 mov rdx, qword ptr [rbp - 56] -122c7: 48 83 c4 28 add rsp, 40 -122cb: 5b pop rbx -122cc: 41 5e pop r14 -122ce: 41 5f pop r15 -122d0: 5d pop rbp -122d1: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Handle: 0x06000016 -Rid: 22 -EntryPointRuntimeFunctionId: 44 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Id: 44 -StartAddress: 0x000122E0 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13288, #clauses = 2 -Flags 20 TryOff 0028 (RVA 12308) TryEnd 0045 (RVA 12325) HndOff 0067 (RVA 12347) HndEnd 007E (RVA 1235E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 12308) TryEnd 0052 (RVA 12332) HndOff 007E (RVA 1235E) HndEnd 008F (RVA 1236F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -122e0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -122e1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -122e2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -122e6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -122eb: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -122f0: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -122f5: 33 c0 xor eax, eax -122f7: 48 89 45 f0 mov qword ptr [rbp - 16], rax -122fb: 8b df mov ebx, edi -122fd: 48 8d 7d e0 lea rdi, [rbp - 32] -12301: ff 15 81 30 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -12307: 90 nop -12308: 8b f3 mov esi, ebx -1230a: 33 ff xor edi, edi - RDI is live -1230c: ff 15 ae 32 02 00 call qword ptr [0x355c0] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) (METHOD_ENTRY) - RDI is dead - RCX is live -12312: 48 85 c9 test rcx, rcx -12315: 75 0e jne 0x12325 -12317: 8b f8 mov edi, eax -12319: ff 15 39 31 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -1231f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -12323: eb 0d jmp 0x12332 - sp-40 is dead - RAX is dead -12325: ff 15 3d 31 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -1232b: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -1232f: eb 01 jmp 0x12332 - RAX is dead -12331: 90 nop -12332: 48 8d 7d e0 lea rdi, [rbp - 32] -12336: ff 15 54 30 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -1233c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -12340: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -12344: 5b pop rbx -12345: 5d pop rbp -12346: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Id: 45 -StartAddress: 0x00012347 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12347: 50 push rax -12348: ff 15 2a 31 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -1234e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -12352: 48 8d 05 d8 ff ff ff lea rax, [0x12331] - RAX is dead -12359: 48 83 c4 08 add rsp, 8 - sp-40 is dead -1235d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Id: 46 -StartAddress: 0x0001235E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1235e: 50 push rax -1235f: 48 8d 7d e0 lea rdi, [rbp - 32] -12363: ff 15 27 30 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12369: 90 nop -1236a: 48 83 c4 08 add rsp, 8 -1236e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Handle: 0x06000017 -Rid: 23 -EntryPointRuntimeFunctionId: 47 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Id: 47 -StartAddress: 0x00012370 -Size: 95 bytes -UnwindRVA: 0x000109F4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 32 - -EH info @ 132B8, #clauses = 2 -Flags 20 TryOff 0025 (RVA 12395) TryEnd 003E (RVA 123AE) HndOff 005F (RVA 123CF) HndEnd 0076 (RVA 123E6) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0025 (RVA 12395) TryEnd 004B (RVA 123BB) HndOff 0076 (RVA 123E6) HndEnd 0087 (RVA 123F7) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 E9 81 D6 42 08 A2 F2 11 AB 89 09 14 -00000010: 80 52 48 11 80 4C 00 41 A5 08 50 09 28 00 A5 8E -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1A, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x25, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x2D, IL Offset: 0x000d, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x001c, Source Types: StackEmpty - Native Offset: 0x3E, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x4A, NoMapping, Source Types: StackEmpty - Native Offset: 0x4B, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x55, IL Offset: 0x0045, Source Types: StackEmpty - Native Offset: 0x59, Epilog, Source Types: StackEmpty - Native Offset: 0x5F, Prolog, Source Types: StackEmpty - Native Offset: 0x60, IL Offset: 0x0027, Source Types: SourceTypeInvalid - Native Offset: 0x71, Epilog, Source Types: StackEmpty - Native Offset: 0x76, Prolog, Source Types: StackEmpty - Native Offset: 0x77, IL Offset: 0x003d, Source Types: StackEmpty - Native Offset: 0x81, IL Offset: 0x0044, Source Types: StackEmpty - Native Offset: 0x82, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x3C - End Offset: 0x3E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x48 - End Offset: 0x59 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - - Variable Number: 0 - Start Offset: 0x6A - End Offset: 0x76 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -32 - -12370: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12371: 48 83 ec 20 sub rsp, 32 - UWOP_ALLOC_SMALL 32 0 - -12375: 48 8d 6c 24 20 lea rbp, [rsp + 32] -1237a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -1237f: c5 7a 7f 45 e8 vmovdqu xmmword ptr [rbp - 24], xmm8 -12384: 33 c0 xor eax, eax -12386: 48 89 45 f8 mov qword ptr [rbp - 8], rax -1238a: 48 8d 7d e8 lea rdi, [rbp - 24] -1238e: ff 15 f4 2f 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -12394: 90 nop -12395: 33 ff xor edi, edi - RDI is live -12397: ff 15 2b 32 02 00 call qword ptr [0x355c8] // [ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() (METHOD_ENTRY) - RDI is dead - RCX is live -1239d: 48 85 c9 test rcx, rcx -123a0: 75 0c jne 0x123ae -123a2: ff 15 d8 2f 02 00 call qword ptr [0x35380] // System.Threading.Tasks.Task System.Threading.Tasks.Task.get_CompletedTask() (METHOD_ENTRY_REF_TOKEN) - RAX is live - RCX is dead -123a8: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -123ac: eb 0d jmp 0x123bb - RAX is dead - sp-32 is dead -123ae: ff 15 e4 2f 02 00 call qword ptr [0x35398] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY_REF_TOKEN) - RAX is live -123b4: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -123b8: eb 01 jmp 0x123bb - RAX is dead -123ba: 90 nop -123bb: 48 8d 7d e8 lea rdi, [rbp - 24] -123bf: ff 15 cb 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -123c5: 48 8b 45 e0 mov rax, qword ptr [rbp - 32] - RAX is live -123c9: 48 83 c4 20 add rsp, 32 - RAX is dead - RDI is live - sp-32 is dead -123cd: 5d pop rbp -123ce: c3 ret - -System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Id: 48 -StartAddress: 0x000123CF -Size: 23 bytes -UnwindRVA: 0x00010A2C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -123cf: 50 push rax -123d0: ff 15 ca 2f 02 00 call qword ptr [0x353a0] // System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY_REF_TOKEN) - RAX is live - RDI is dead -123d6: 48 89 45 e0 mov qword ptr [rbp - 32], rax - sp-32 is live -123da: 48 8d 05 d9 ff ff ff lea rax, [0x123ba] - RAX is dead -123e1: 48 83 c4 08 add rsp, 8 - sp-32 is dead -123e5: c3 ret - -System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Id: 49 -StartAddress: 0x000123E6 -Size: 17 bytes -UnwindRVA: 0x00010A38 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -123e6: 50 push rax -123e7: 48 8d 7d e8 lea rdi, [rbp - 24] -123eb: ff 15 9f 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -123f1: 90 nop -123f2: 48 83 c4 08 add rsp, 8 -123f6: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Handle: 0x06000018 -Rid: 24 -EntryPointRuntimeFunctionId: 50 -Number of RuntimeFunctions: 3 -Number of fixups: 2 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 000E: System.Runtime.CompilerServices.ExecutionAndSyncBlockStore Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 24 Align native GCLayout 0x7 (CHECK_TYPE_LAYOUT) - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Id: 50 -StartAddress: 0x00012400 -Size: 103 bytes -UnwindRVA: 0x000109A0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 132E8, #clauses = 2 -Flags 20 TryOff 0028 (RVA 12428) TryEnd 0045 (RVA 12445) HndOff 0067 (RVA 12467) HndEnd 007E (RVA 1247E) ClsFlt 0000 CATCH: System.Exception -Flags 04 TryOff 0028 (RVA 12428) TryEnd 0052 (RVA 12452) HndOff 007E (RVA 1247E) HndEnd 008F (RVA 1248F) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 1A 64 02 01 F5 81 D6 42 4A A2 12 92 C3 89 09 14 -00000010: 86 52 4B 11 80 4E 00 A1 A5 08 50 09 28 0C A5 94 -00000020: 0A 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x28, IL Offset: 0x0008, Source Types: StackEmpty - Native Offset: 0x32, IL Offset: 0x000f, Source Types: StackEmpty - Native Offset: 0x37, IL Offset: 0x001e, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0035, Source Types: StackEmpty - Native Offset: 0x51, NoMapping, Source Types: StackEmpty - Native Offset: 0x52, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x5C, IL Offset: 0x0048, Source Types: StackEmpty - Native Offset: 0x60, Epilog, Source Types: StackEmpty - Native Offset: 0x67, Prolog, Source Types: StackEmpty - Native Offset: 0x68, IL Offset: 0x002a, Source Types: SourceTypeInvalid - Native Offset: 0x79, Epilog, Source Types: StackEmpty - Native Offset: 0x7E, Prolog, Source Types: StackEmpty - Native Offset: 0x7F, IL Offset: 0x0040, Source Types: StackEmpty - Native Offset: 0x89, IL Offset: 0x0047, Source Types: StackEmpty - Native Offset: 0x8A, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x28 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x32 - End Offset: 0x37 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 2 - Start Offset: 0x43 - End Offset: 0x45 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x4F - End Offset: 0x60 - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - - Variable Number: 2 - Start Offset: 0x72 - End Offset: 0x7E - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -40 - -12400: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12401: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12402: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -12406: 48 8d 6c 24 30 lea rbp, [rsp + 48] -1240b: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12410: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -12415: 33 c0 xor eax, eax -12417: 48 89 45 f0 mov qword ptr [rbp - 16], rax -1241b: 8b df mov ebx, edi -1241d: 48 8d 7d e0 lea rdi, [rbp - 32] -12421: ff 15 61 2f 02 00 call qword ptr [0x35388] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Push() (METHOD_ENTRY_REF_TOKEN) -12427: 90 nop -12428: 8b f3 mov esi, ebx -1242a: 33 ff xor edi, edi - RDI is live -1242c: ff 15 9e 31 02 00 call qword ptr [0x355d0] // [ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) (METHOD_ENTRY) - RDI is dead - RCX is live -12432: 48 85 c9 test rcx, rcx -12435: 75 0e jne 0x12445 -12437: 8b f8 mov edi, eax -12439: ff 15 19 30 02 00 call qword ptr [0x35458] // System.Threading.Tasks.Task`1 System.Threading.Tasks.Task.FromResult(!!0) (METHOD_ENTRY) - RAX is live - RCX is dead -1243f: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -12443: eb 0d jmp 0x12452 - sp-40 is dead - RAX is dead -12445: ff 15 1d 30 02 00 call qword ptr [0x35468] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.FinalizeTaskReturningThunk() (METHOD_ENTRY) - RAX is live -1244b: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -1244f: eb 01 jmp 0x12452 - RAX is dead -12451: 90 nop -12452: 48 8d 7d e0 lea rdi, [rbp - 32] -12456: ff 15 34 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -1245c: 48 8b 45 d8 mov rax, qword ptr [rbp - 40] - RAX is live -12460: 48 83 c4 28 add rsp, 40 - RAX is dead - RDI is live - sp-40 is dead -12464: 5b pop rbx -12465: 5d pop rbp -12466: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Id: 51 -StartAddress: 0x00012467 -Size: 23 bytes -UnwindRVA: 0x000109DC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12467: 50 push rax -12468: ff 15 0a 30 02 00 call qword ptr [0x35478] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncHelpers.TaskFromException(System.Exception) (METHOD_ENTRY) - RAX is live - RDI is dead -1246e: 48 89 45 d8 mov qword ptr [rbp - 40], rax - sp-40 is live -12472: 48 8d 05 d8 ff ff ff lea rax, [0x12451] - RAX is dead -12479: 48 83 c4 08 add rsp, 8 - sp-40 is dead -1247d: c3 ret - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Id: 52 -StartAddress: 0x0001247E -Size: 17 bytes -UnwindRVA: 0x000109E8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1247e: 50 push rax -1247f: 48 8d 7d e0 lea rdi, [rbp - 32] -12483: ff 15 07 2f 02 00 call qword ptr [0x35390] // void System.Runtime.CompilerServices.ExecutionAndSyncBlockStore.Pop() (METHOD_ENTRY_REF_TOKEN) -12489: 90 nop -1248a: 48 83 c4 08 add rsp, 8 -1248e: c3 ret - -_______________________________________________ - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) -Handle: 0x06000019 -Rid: 25 -EntryPointRuntimeFunctionId: 53 -Number of RuntimeFunctions: 1 - -System.Threading.Tasks.Task`1 InlineThunks.CrossModuleCallAsync(int) -Id: 53 -StartAddress: 0x00012490 -Size: 13 bytes -UnwindRVA: 0x0001097C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -Debug Info - Bounds: -00000000: 23 01 42 CA 32 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x7, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -12490: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -12491: ff 15 61 2f 02 00 call qword ptr [0x353f8] // System.Threading.Tasks.Task`1 CrossModuleHelper.SmallCrossModuleAsync(int) (METHOD_ENTRY_REF_TOKEN) -12497: 90 nop -12498: 48 83 c4 08 add rsp, 8 -1249c: c3 ret - -_______________________________________________ - -int InlineThunks.CrossModuleSyncCaller(int) -Handle: 0x0600001A -Rid: 26 -EntryPointRuntimeFunctionId: 54 -Number of RuntimeFunctions: 1 -Number of fixups: 1 - TableIndex 0, Offset 0003: int CrossModuleHelper.SmallCrossModuleSync(int) (CHECK_IL_BODY) - -int InlineThunks.CrossModuleSyncCaller(int) -Id: 54 -StartAddress: 0x000124A0 -Size: 4 bytes -UnwindRVA: 0x00010B18 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 13 01 22 B1 06 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x3, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -124a0: 8d 04 7f lea eax, [rdi + 2*rdi] -124a3: c3 ret - -_______________________________________________ - -void InlineThunks..ctor() -Handle: 0x0600001B -Rid: 27 -EntryPointRuntimeFunctionId: 55 -Number of RuntimeFunctions: 1 - -void InlineThunks..ctor() -Id: 55 -StartAddress: 0x000124B0 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 02 00 52 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -124b0: c3 ret - -_______________________________________________ - -void System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute..ctor(bool) -Handle: 0x0600001C -Rid: 28 -EntryPointRuntimeFunctionId: 56 -Number of RuntimeFunctions: 1 -Number of fixups: 1 - TableIndex 5, Offset 000D: System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) - -void System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute..ctor(bool) -Id: 56 -StartAddress: 0x000124C0 -Size: 24 bytes -UnwindRVA: 0x00010B30 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -Debug Info - Bounds: -00000000: 35 04 82 A0 18 5A 25 8B 02 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xC, IL Offset: 0x0007, Source Types: StackEmpty - Native Offset: 0x12, IL Offset: 0x000e, Source Types: StackEmpty - Native Offset: 0x12, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0xC - Loc Type: VLT_REG - Register: RDI - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x8 - Loc Type: VLT_REG - Register: RSI - -124c0: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -124c1: 48 8b 05 78 31 02 00 mov rax, qword ptr [0x35640] // System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) -124c8: 40 88 34 07 mov byte ptr [rdi + rax], sil -124cc: ff 15 a6 2e 02 00 call qword ptr [0x35378] // void System.Attribute..ctor() (METHOD_ENTRY_REF_TOKEN) -124d2: 90 nop -124d3: 48 83 c4 08 add rsp, 8 -124d7: c3 ret - -_______________________________________________ - -bool System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute.get_RuntimeAsync() -Handle: 0x0600001D -Rid: 29 -EntryPointRuntimeFunctionId: 57 -Number of RuntimeFunctions: 1 -Number of fixups: 1 - TableIndex 5, Offset 000D: System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) - -bool System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute.get_RuntimeAsync() -Id: 57 -StartAddress: 0x000124E0 -Size: 12 bytes -UnwindRVA: 0x00010B40 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 33 01 82 04 6B 01 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xB, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x7 - Loc Type: VLT_REG - Register: RDI - -124e0: 48 8b 05 59 31 02 00 mov rax, qword ptr [0x35640] // System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute (FIELD_BASE_OFFSET) -124e7: 0f b6 04 07 movzx eax, byte ptr [rdi + rax] -124eb: c3 ret - -_______________________________________________ - -void InlineThunks+<>c..cctor() -Handle: 0x0600001E -Rid: 30 -EntryPointRuntimeFunctionId: 58 -Number of RuntimeFunctions: 1 -Number of fixups: 1 - TableIndex 5, Offset 0005: InlineThunks+<>c (TYPE_HANDLE) - -void InlineThunks+<>c..cctor() -Id: 58 -StartAddress: 0x000124F0 -Size: 31 bytes -UnwindRVA: 0x00010B4C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) - -Debug Info - Bounds: -00000000: 45 03 02 A1 30 48 28 D9 02 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x1, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xA, IL Offset: 0x0005, Source Types: SourceTypeInvalid - Native Offset: 0x1C, IL Offset: 0x000a, Source Types: StackEmpty - Native Offset: 0x1C, Epilog, Source Types: StackEmpty - -124f0: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -124f1: ff 15 49 2e 02 00 call qword ptr [0x35340] // InlineThunks+<>c (NEW_OBJECT) -124f7: 48 8b d8 mov rbx, rax -124fa: ff 15 30 2e 02 00 call qword ptr [0x35330] // InlineThunks+<>c (STATIC_BASE_GC) -12500: 48 8b f8 mov rdi, rax -12503: 48 8b f3 mov rsi, rbx -12506: ff 15 f4 2d 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -1250c: 90 nop -1250d: 5b pop rbx -1250e: c3 ret - -_______________________________________________ - -void InlineThunks+<>c..ctor() -Handle: 0x0600001F -Rid: 31 -EntryPointRuntimeFunctionId: 59 -Number of RuntimeFunctions: 1 - -void InlineThunks+<>c..ctor() -Id: 59 -StartAddress: 0x00012510 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 02 00 52 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -12510: c3 ret - -_______________________________________________ - -void InlineThunks+<>c.
b__3_0() -Handle: 0x06000020 -Rid: 32 -EntryPointRuntimeFunctionId: 60 -Number of RuntimeFunctions: 1 -Number of fixups: 2 - TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) - TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -void InlineThunks+<>c.
b__3_0() -Id: 60 -StartAddress: 0x00012520 -Size: 58 bytes -UnwindRVA: 0x00010B60 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 - -Debug Info - Bounds: -00000000: 45 04 02 41 70 28 3B 29 2B 00 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty - Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty - Native Offset: 0x33, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x10 - Loc Type: VLT_REG - Register: RDI - -12520: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12521: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12525: 48 8d 6c 24 10 lea rbp, [rsp + 16] -1252a: 33 c0 xor eax, eax -1252c: 48 89 45 f8 mov qword ptr [rbp - 8], rax -12530: ff 15 92 2f 02 00 call qword ptr [0x354c8] // System.Threading.Tasks.Task InlineThunks.CallAsyncVoid() (METHOD_ENTRY_DEF_TOKEN) -12536: 48 8b f8 mov rdi, rax -12539: 4c 8d 1d 80 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) -12540: 39 3f cmp dword ptr [rdi], edi -12542: 41 ff 13 call qword ptr [r11] -12545: 48 89 45 f8 mov qword ptr [rbp - 8], rax -12549: 48 8d 7d f8 lea rdi, [rbp - 8] -1254d: ff 15 9d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) -12553: 90 nop -12554: 48 83 c4 10 add rsp, 16 -12558: 5d pop rbp -12559: c3 ret - -_______________________________________________ - -void InlineThunks+<>c.
b__3_1() -Handle: 0x06000021 -Rid: 33 -EntryPointRuntimeFunctionId: 61 -Number of RuntimeFunctions: 1 -Number of fixups: 2 - TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) - TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -void InlineThunks+<>c.
b__3_1() -Id: 61 -StartAddress: 0x00012560 -Size: 58 bytes -UnwindRVA: 0x00010B60 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 - -Debug Info - Bounds: -00000000: 45 04 02 41 70 28 3B 29 2B 00 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty - Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty - Native Offset: 0x33, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x10 - Loc Type: VLT_REG - Register: RDI - -12560: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12561: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12565: 48 8d 6c 24 10 lea rbp, [rsp + 16] -1256a: 33 c0 xor eax, eax -1256c: 48 89 45 f8 mov qword ptr [rbp - 8], rax -12570: ff 15 6a 2f 02 00 call qword ptr [0x354e0] // System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() (METHOD_ENTRY_DEF_TOKEN) -12576: 48 8b f8 mov rdi, rax -12579: 4c 8d 1d 40 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) -12580: 39 3f cmp dword ptr [rdi], edi -12582: 41 ff 13 call qword ptr [r11] -12585: 48 89 45 f8 mov qword ptr [rbp - 8], rax -12589: 48 8d 7d f8 lea rdi, [rbp - 8] -1258d: ff 15 5d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) -12593: 90 nop -12594: 48 83 c4 10 add rsp, 16 -12598: 5d pop rbp -12599: c3 ret - -_______________________________________________ - -void InlineThunks+<>c.
b__3_2() -Handle: 0x06000022 -Rid: 34 -EntryPointRuntimeFunctionId: 62 -Number of RuntimeFunctions: 1 -Number of fixups: 2 - TableIndex 5, Offset 0004: System.Runtime.CompilerServices.TaskAwaiter (TYPE_HANDLE) - TableIndex 5, Offset 0010: System.Runtime.CompilerServices.TaskAwaiter Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - -void InlineThunks+<>c.
b__3_2() -Id: 62 -StartAddress: 0x000125A0 -Size: 58 bytes -UnwindRVA: 0x00010B60 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 16 - -Debug Info - Bounds: -00000000: 45 04 02 41 70 28 3B 29 2B 00 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x10, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x29, IL Offset: 0x000b, Source Types: StackEmpty - Native Offset: 0x33, IL Offset: 0x0013, Source Types: StackEmpty - Native Offset: 0x33, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x10 - Loc Type: VLT_REG - Register: RDI - -125a0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -125a1: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -125a5: 48 8d 6c 24 10 lea rbp, [rsp + 16] -125aa: 33 c0 xor eax, eax -125ac: 48 89 45 f8 mov qword ptr [rbp - 8], rax -125b0: ff 15 7a 2f 02 00 call qword ptr [0x35530] // System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() (METHOD_ENTRY_DEF_TOKEN) -125b6: 48 8b f8 mov rdi, rax -125b9: 4c 8d 1d 00 2d 02 00 lea r11, [0x352c0] // System.Runtime.CompilerServices.TaskAwaiter System.Threading.Tasks.Task.GetAwaiter() (VIRTUAL_ENTRY) -125c0: 39 3f cmp dword ptr [rdi], edi -125c2: 41 ff 13 call qword ptr [r11] -125c5: 48 89 45 f8 mov qword ptr [rbp - 8], rax -125c9: 48 8d 7d f8 lea rdi, [rbp - 8] -125cd: ff 15 1d 2e 02 00 call qword ptr [0x353f0] // void System.Runtime.CompilerServices.TaskAwaiter.GetResult() (METHOD_ENTRY_REF_TOKEN) -125d3: 90 nop -125d4: 48 83 c4 10 add rsp, 16 -125d8: 5d pop rbp -125d9: c3 ret - -_______________________________________________ - -void InlineThunks+d__20..ctor() -Handle: 0x06000023 -Rid: 35 -EntryPointRuntimeFunctionId: 63 -Number of RuntimeFunctions: 1 - -void InlineThunks+d__20..ctor() -Id: 63 -StartAddress: 0x000125E0 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 02 00 52 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -125e0: c3 ret - -_______________________________________________ - -void InlineThunks+d__20.MoveNext() -Handle: 0x06000024 -Rid: 36 -EntryPointRuntimeFunctionId: 64 -Number of RuntimeFunctions: 2 -Number of fixups: 4 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) - -void InlineThunks+d__20.MoveNext() -Id: 64 -StartAddress: 0x000125F0 -Size: 62 bytes -UnwindRVA: 0x00010B74 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0003 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op 8 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13318, #clauses = 1 -Flags 00 TryOff 0016 (RVA 12606) TryEnd 0022 (RVA 12612) HndOff 003E (RVA 1262E) HndEnd 006D (RVA 1265D) ClsFlt 100000C CATCH: System.Exception - -Debug Info - Bounds: -00000000: 49 64 02 01 B1 81 94 42 AC A5 53 53 13 0A 00 84 -00000010: 02 08 15 0D 8B A4 47 14 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0xC, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x16, IL Offset: 0x0007, Source Types: StackEmpty - Native Offset: 0x22, IL Offset: 0x002a, Source Types: StackEmpty - Native Offset: 0x29, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x36, IL Offset: 0x003f, Source Types: StackEmpty - Native Offset: 0x36, Epilog, Source Types: StackEmpty - Native Offset: 0x3E, Prolog, Source Types: StackEmpty - Native Offset: 0x3F, IL Offset: 0x0012, Source Types: SourceTypeInvalid - Native Offset: 0x42, IL Offset: 0x0013, Source Types: StackEmpty - Native Offset: 0x54, IL Offset: 0x001b, Source Types: StackEmpty - Native Offset: 0x68, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x29 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x3E - End Offset: 0x4D - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -16 - - Variable Number: 0 - Start Offset: 0x4D - End Offset: 0x54 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 2 - Start Offset: 0x22 - End Offset: 0x30 - Loc Type: VLT_REG - Register: RSI - -125f0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -125f1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -125f2: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -125f3: 48 8d 6c 24 10 lea rbp, [rsp + 16] -125f8: 48 89 7d f0 mov qword ptr [rbp - 16], rdi -125fc: 40 38 3f cmp byte ptr [rdi], dil -125ff: 48 8b 1d 8a 30 02 00 mov rbx, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) -12606: 48 8b 35 93 30 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) -1260d: 8b 34 37 mov esi, dword ptr [rdi + rsi] -12610: 03 f6 add esi, esi -12612: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 -12619: 48 03 3d 78 30 02 00 add rdi, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - RDI is live - RDI is live - sp-16 is live -12620: ff 15 f2 2d 02 00 call qword ptr [0x35418] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetResult(!0) (METHOD_ENTRY) - RDI is dead -12626: 90 nop -12627: 48 83 c4 08 add rsp, 8 - RDI is dead - sp-16 is dead -1262b: 5b pop rbx -1262c: 5d pop rbp -1262d: c3 ret - -void InlineThunks+d__20.MoveNext() -Id: 65 -StartAddress: 0x0001262E -Size: 47 bytes -UnwindRVA: 0x00010BA4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1262e: 50 push rax -1262f: 48 8b f7 mov rsi, rdi - RSI is live -12632: 48 8b 1d 57 30 02 00 mov rbx, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) -12639: 48 8b 7d f0 mov rdi, qword ptr [rbp - 16] -1263d: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 -12644: 48 03 3d 4d 30 02 00 add rdi, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - RDI is live - RDI is dead - sp-16 is dead -1264b: ff 15 cf 2d 02 00 call qword ptr [0x35420] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(System.Exception) (METHOD_ENTRY) - RDI is dead - RSI is dead -12651: 48 8d 05 ce ff ff ff lea rax, [0x12626] -12658: 48 83 c4 08 add rsp, 8 -1265c: c3 ret - -_______________________________________________ - -void InlineThunks+d__20.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -Handle: 0x06000025 -Rid: 37 -EntryPointRuntimeFunctionId: 66 -Number of RuntimeFunctions: 1 - -void InlineThunks+d__20.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -Id: 66 -StartAddress: 0x00012660 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 03 01 92 2C 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RSI - -12660: c3 ret - -_______________________________________________ - -void InlineThunks+d__21..ctor() -Handle: 0x06000026 -Rid: 38 -EntryPointRuntimeFunctionId: 67 -Number of RuntimeFunctions: 1 - -void InlineThunks+d__21..ctor() -Id: 67 -StartAddress: 0x00012670 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 02 00 52 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - -12670: c3 ret - -_______________________________________________ - -void InlineThunks+d__21.MoveNext() -Handle: 0x06000027 -Rid: 39 -EntryPointRuntimeFunctionId: 68 -Number of RuntimeFunctions: 2 -Number of fixups: 4 - TableIndex 5, Offset 0002: System.Exception (TYPE_HANDLE) - TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) - -void InlineThunks+d__21.MoveNext() -Id: 68 -StartAddress: 0x00012680 -Size: 62 bytes -UnwindRVA: 0x00010B74 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0003 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op 8 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13330, #clauses = 1 -Flags 00 TryOff 0016 (RVA 12696) TryEnd 0022 (RVA 126A2) HndOff 003E (RVA 126BE) HndEnd 006D (RVA 126ED) ClsFlt 100000C CATCH: System.Exception - -Debug Info - Bounds: -00000000: 49 64 02 01 B1 81 94 42 AC A5 53 53 13 0A 00 84 -00000010: 02 08 15 0D 8B A4 47 14 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0xC, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x16, IL Offset: 0x0007, Source Types: StackEmpty - Native Offset: 0x22, IL Offset: 0x002a, Source Types: StackEmpty - Native Offset: 0x29, IL Offset: 0x0032, Source Types: StackEmpty - Native Offset: 0x36, IL Offset: 0x003f, Source Types: StackEmpty - Native Offset: 0x36, Epilog, Source Types: StackEmpty - Native Offset: 0x3E, Prolog, Source Types: StackEmpty - Native Offset: 0x3F, IL Offset: 0x0012, Source Types: SourceTypeInvalid - Native Offset: 0x42, IL Offset: 0x0013, Source Types: StackEmpty - Native Offset: 0x54, IL Offset: 0x001b, Source Types: StackEmpty - Native Offset: 0x68, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x29 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 0 - Start Offset: 0x3E - End Offset: 0x4D - Loc Type: VLT_STK - Base Register: RBP - Stack Offset: -16 - - Variable Number: 0 - Start Offset: 0x4D - End Offset: 0x54 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 2 - Start Offset: 0x22 - End Offset: 0x30 - Loc Type: VLT_REG - Register: RSI - -12680: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12681: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12682: 50 push rax - UWOP_ALLOC_SMALL 8 0 - -12683: 48 8d 6c 24 10 lea rbp, [rsp + 16] -12688: 48 89 7d f0 mov qword ptr [rbp - 16], rdi -1268c: 40 38 3f cmp byte ptr [rdi], dil -1268f: 48 8b 1d 12 30 02 00 mov rbx, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) -12696: 48 8b 35 1b 30 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) -1269d: 8b 34 37 mov esi, dword ptr [rdi + rsi] -126a0: 03 f6 add esi, esi -126a2: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 -126a9: 48 03 3d 00 30 02 00 add rdi, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - RDI is live - RDI is live - sp-16 is live -126b0: ff 15 7a 2d 02 00 call qword ptr [0x35430] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(!0) (METHOD_ENTRY) - RDI is dead -126b6: 90 nop -126b7: 48 83 c4 08 add rsp, 8 - RDI is dead - sp-16 is dead -126bb: 5b pop rbx -126bc: 5d pop rbp -126bd: c3 ret - -void InlineThunks+d__21.MoveNext() -Id: 69 -StartAddress: 0x000126BE -Size: 47 bytes -UnwindRVA: 0x00010BA4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -126be: 50 push rax -126bf: 48 8b f7 mov rsi, rdi - RSI is live -126c2: 48 8b 1d df 2f 02 00 mov rbx, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) -126c9: 48 8b 7d f0 mov rdi, qword ptr [rbp - 16] -126cd: c7 04 1f fe ff ff ff mov dword ptr [rdi + rbx], 4294967294 -126d4: 48 03 3d d5 2f 02 00 add rdi, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - RDI is live - RDI is dead - sp-16 is dead -126db: ff 15 57 2d 02 00 call qword ptr [0x35438] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception) (METHOD_ENTRY) - RDI is dead - RSI is dead -126e1: 48 8d 05 ce ff ff ff lea rax, [0x126b6] -126e8: 48 83 c4 08 add rsp, 8 -126ec: c3 ret - -_______________________________________________ - -void InlineThunks+d__21.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -Handle: 0x06000028 -Rid: 40 -EntryPointRuntimeFunctionId: 70 -Number of RuntimeFunctions: 1 - -void InlineThunks+d__21.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -Id: 70 -StartAddress: 0x000126F0 -Size: 1 bytes -UnwindRVA: 0x00010B24 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0000 -CountOfUnwindCodes: 0 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 - -Debug Info - Bounds: -00000000: 03 01 92 2C 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x0, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: StackEmpty - Native Offset: 0x0, Epilog, Source Types: SourceTypeInvalid - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x1 - Loc Type: VLT_REG - Register: RSI - -126f0: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Handle: 0x0600000F -Rid: 15 -EntryPointRuntimeFunctionId: 84 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForThunk() -Id: 84 -StartAddress: 0x00012CD0 -Size: 72 bytes -UnwindRVA: 0x00010D74 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 24 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 62 00 02 54 10 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x41, Epilog, Source Types: StackEmpty - -12cd0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12cd1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12cd2: 48 83 ec 18 sub rsp, 24 - UWOP_ALLOC_SMALL 24 0 - -12cd6: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12cdb: 33 c0 xor eax, eax -12cdd: 48 89 45 f0 mov qword ptr [rbp - 16], rax -12ce1: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12ce5: 48 8b df mov rbx, rdi -12ce8: 48 8d 7d f0 lea rdi, [rbp - 16] -12cec: 48 8d 75 e8 lea rsi, [rbp - 24] -12cf0: ff 15 c2 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12cf6: 48 85 db test rbx, rbx -12cf9: 40 0f 95 c7 setne dil -12cfd: 40 0f b6 ff movzx edi, dil -12d01: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] -12d05: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] -12d09: ff 15 b1 26 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12d0f: 33 c9 xor ecx, ecx -12d11: 48 83 c4 18 add rsp, 24 -12d15: 5b pop rbx -12d16: 5d pop rbp -12d17: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Handle: 0x06000007 -Rid: 7 -EntryPointRuntimeFunctionId: 73 -Number of RuntimeFunctions: 2 - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Id: 73 -StartAddress: 0x00012740 -Size: 123 bytes -UnwindRVA: 0x00010BC4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13348, #clauses = 1 -Flags 04 TryOff 0034 (RVA 12774) TryEnd 0055 (RVA 12795) HndOff 007B (RVA 127BB) HndEnd 009D (RVA 127DD) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 66 01 02 24 E1 9A A8 0F 3A A4 0E - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x55, NoMapping, Source Types: StackEmpty - Native Offset: 0x74, Epilog, Source Types: StackEmpty - Native Offset: 0x7B, Prolog, Source Types: StackEmpty - Native Offset: 0x98, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x25 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x25 - End Offset: 0x42 - Loc Type: VLT_REG - Register: RBX - -12740: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12741: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12742: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -12746: 48 8d 6c 24 30 lea rbp, [rsp + 48] -1274b: 33 c0 xor eax, eax -1274d: 48 89 45 d8 mov qword ptr [rbp - 40], rax -12751: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12756: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -1275b: 48 89 45 f0 mov qword ptr [rbp - 16], rax -1275f: 48 89 7d d0 mov qword ptr [rbp - 48], rdi -12763: 8b de mov ebx, esi -12765: 48 8d 7d f0 lea rdi, [rbp - 16] -12769: 48 8d 75 e8 lea rsi, [rbp - 24] -1276d: ff 15 45 2c 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12773: 90 nop -12774: 48 8d 7d e0 lea rdi, [rbp - 32] -12778: 48 8d 75 d8 lea rsi, [rbp - 40] -1277c: ff 15 36 2c 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12782: 03 db add ebx, ebx -12784: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live -12788: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -1278c: 33 ff xor edi, edi -1278e: ff 15 2c 2c 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12794: 90 nop -12795: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -1279a: 40 0f 95 c7 setne dil -1279e: 40 0f b6 ff movzx edi, dil -127a2: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -127a6: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -127aa: ff 15 10 2c 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -127b0: 8b c3 mov eax, ebx -127b2: 33 c9 xor ecx, ecx -127b4: 48 83 c4 28 add rsp, 40 - sp-48 is live -127b8: 5b pop rbx -127b9: 5d pop rbp -127ba: c3 ret - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallAsync(int) -Id: 74 -StartAddress: 0x000127BB -Size: 34 bytes -UnwindRVA: 0x00010BF8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -127bb: 50 push rax -127bc: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -127c1: 40 0f 95 c7 setne dil -127c5: 40 0f b6 ff movzx edi, dil -127c9: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -127cd: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -127d1: ff 15 e9 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -127d7: 90 nop -127d8: 48 83 c4 08 add rsp, 8 -127dc: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Handle: 0x06000012 -Rid: 18 -EntryPointRuntimeFunctionId: 87 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.Task InlineThunks.SmallAsyncVoidForVariant() -Id: 87 -StartAddress: 0x00012DE0 -Size: 72 bytes -UnwindRVA: 0x00010D74 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 24 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -Debug Info - Bounds: -00000000: 62 00 02 54 10 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x41, Epilog, Source Types: StackEmpty - -12de0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12de1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12de2: 48 83 ec 18 sub rsp, 24 - UWOP_ALLOC_SMALL 24 0 - -12de6: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12deb: 33 c0 xor eax, eax -12ded: 48 89 45 f0 mov qword ptr [rbp - 16], rax -12df1: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12df5: 48 8b df mov rbx, rdi -12df8: 48 8d 7d f0 lea rdi, [rbp - 16] -12dfc: 48 8d 75 e8 lea rsi, [rbp - 24] -12e00: ff 15 b2 25 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12e06: 48 85 db test rbx, rbx -12e09: 40 0f 95 c7 setne dil -12e0d: 40 0f b6 ff movzx edi, dil -12e11: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] -12e15: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] -12e19: ff 15 a1 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12e1f: 33 c9 xor ecx, ecx -12e21: 48 83 c4 18 add rsp, 24 -12e25: 5b pop rbx -12e26: 5d pop rbp -12e27: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Handle: 0x0600000D -Rid: 13 -EntryPointRuntimeFunctionId: 81 -Number of RuntimeFunctions: 2 -Number of fixups: 11 - TableIndex 5, Offset 0001: [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) - TableIndex 5, Offset 0007: InlineThunks+d__21 (TYPE_HANDLE) - TableIndex 5, Offset 0008: System.Threading.Tasks.ValueTask`1 (TYPE_HANDLE) - TableIndex 5, Offset 000A: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0011: System.Threading.Tasks.ValueTask`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0013: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0016: System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) - TableIndex 5, Offset 001A: int InlineThunks+d__21.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 001B: System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 001C: int InlineThunks+d__21.x (FIELD_OFFSET) - TableIndex 5, Offset 001E: (RESUMPTION_STUB RVA[0x12720]) - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 81 -StartAddress: 0x00012AB0 -Size: 406 bytes -UnwindRVA: 0x00010CC8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000A -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 72 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 133A8, #clauses = 1 -Flags 04 TryOff 0045 (RVA 12AF5) TryEnd 00F0 (RVA 12BA0) HndOff 0196 (RVA 12C46) HndEnd 01B8 (RVA 12C68) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 19 37 02 08 15 8D 56 45 1F C0 85 D4 15 70 21 A5 -00000010: 11 EA 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x45, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xF0, NoMapping, Source Types: StackEmpty - Native Offset: 0x10F, Epilog, Source Types: StackEmpty - Native Offset: 0x11A, IL Offset: 0x0006, Source Types: Async - Native Offset: 0x171, Epilog, Source Types: StackEmpty - Native Offset: 0x17C, IL Offset: 0x0006, Source Types: Async - Native Offset: 0x196, Prolog, Source Types: StackEmpty - Native Offset: 0x1B3, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x2D - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x2D - End Offset: 0x83 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0xEB - End Offset: 0x10B - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x191 - End Offset: 0x196 - Loc Type: VLT_REG - Register: RBX - -12ab0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12ab1: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12ab3: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -12ab5: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12ab6: 48 83 ec 48 sub rsp, 72 - UWOP_ALLOC_SMALL 72 0 - -12aba: 48 8d 6c 24 60 lea rbp, [rsp + 96] -12abf: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12ac4: c5 7e 7f 45 b0 vmovdqu ymmword ptr [rbp - 80], ymm8 -12ac9: c5 79 7f 45 d0 vmovdqa xmmword ptr [rbp - 48], xmm8 -12ace: 33 c0 xor eax, eax -12ad0: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12ad4: 48 89 7d a8 mov qword ptr [rbp - 88], rdi -12ad8: 48 8b d7 mov rdx, rdi -12adb: 8b de mov ebx, esi -12add: 48 85 d2 test rdx, rdx -12ae0: 0f 85 46 01 00 00 jne 0x12c2c -12ae6: 48 8d 7d e0 lea rdi, [rbp - 32] -12aea: 48 8d 75 d8 lea rsi, [rbp - 40] -12aee: ff 15 c4 28 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is live -12af4: 90 nop -12af5: ff 15 55 28 02 00 call qword ptr [0x35350] // InlineThunks+d__21 (NEW_OBJECT) - RAX is live -12afb: 48 89 45 c0 mov qword ptr [rbp - 64], rax -12aff: 4c 8b 7d c0 mov r15, qword ptr [rbp - 64] - R15 is live -12b03: ff 15 1f 29 02 00 call qword ptr [0x35428] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create() (METHOD_ENTRY) -12b09: 48 89 45 b0 mov qword ptr [rbp - 80], rax -12b0d: 48 89 55 b8 mov qword ptr [rbp - 72], rdx -12b11: 4c 8b 35 98 2b 02 00 mov r14, qword ptr [0x356b0] // System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 InlineThunks+d__21.<>t__builder (FIELD_OFFSET) -12b18: 4b 8d 3c 37 lea rdi, [r15 + r14] - RDI is live -12b1c: 48 8d 75 b0 lea rsi, [rbp - 80] - RSI is live -12b20: ff 15 e2 27 02 00 call qword ptr [0x35308] // BYREF_WRITE_BARRIER (HELPER) - RAX is dead - R15 is dead -12b26: 48 a5 movsq qword ptr es:[rdi], qword ptr [rsi] -12b28: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] - RDI is dead - RDI is live -12b2c: 48 8b 35 85 2b 02 00 mov rsi, qword ptr [0x356b8] // int InlineThunks+d__21.x (FIELD_OFFSET) - RSI is dead -12b33: 89 1c 37 mov dword ptr [rdi + rsi], ebx -12b36: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] -12b3a: 48 8b 35 67 2b 02 00 mov rsi, qword ptr [0x356a8] // int InlineThunks+d__21.<>1__state (FIELD_OFFSET) -12b41: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -12b48: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] -12b4c: 40 38 3f cmp byte ptr [rdi], dil -12b4f: 49 8b fe mov rdi, r14 - RDI is dead -12b52: 48 03 7d c0 add rdi, qword ptr [rbp - 64] - RDI is live -12b56: 48 8b 35 83 2a 02 00 mov rsi, qword ptr [0x355e0] // [INST] void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)d__21> (METHOD_DICTIONARY) -12b5d: 48 8d 55 c0 lea rdx, [rbp - 64] -12b61: ff 15 41 29 02 00 call qword ptr [0x354a8] // void System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) - RDI is dead -12b67: 48 8b 7d c0 mov rdi, qword ptr [rbp - 64] - RDI is live -12b6b: 40 38 3f cmp byte ptr [rdi], dil -12b6e: 49 8b fe mov rdi, r14 - RDI is dead -12b71: 48 03 7d c0 add rdi, qword ptr [rbp - 64] - RDI is live -12b75: ff 15 c5 28 02 00 call qword ptr [0x35440] // System.Threading.Tasks.ValueTask`1 System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) - RDI is dead - RAX is live -12b7b: 48 89 45 c8 mov qword ptr [rbp - 56], rax -12b7f: 48 89 55 d0 mov qword ptr [rbp - 48], rdx -12b83: 33 f6 xor esi, esi - RSI is live -12b85: 48 89 75 c0 mov qword ptr [rbp - 64], rsi -12b89: 48 8b 75 c8 mov rsi, qword ptr [rbp - 56] -12b8d: 48 8b 55 d0 mov rdx, qword ptr [rbp - 48] -12b91: 33 ff xor edi, edi - RDI is live -12b93: ff 15 f7 28 02 00 call qword ptr [0x35490] // !!0 System.Runtime.CompilerServices.AsyncHelpers.Await(System.Threading.Tasks.ValueTask`1) (METHOD_ENTRY) - RAX is dead - RCX is live - RSI is dead - RDI is dead -12b99: 8b d8 mov ebx, eax -12b9b: 48 85 c9 test rcx, rcx -12b9e: 75 2a jne 0x12bca - RCX is dead -12ba0: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 -12ba5: 40 0f 95 c7 setne dil -12ba9: 40 0f b6 ff movzx edi, dil -12bad: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12bb1: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live - sp-88 is dead -12bb5: ff 15 05 28 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12bbb: 8b c3 mov eax, ebx -12bbd: 33 c9 xor ecx, ecx -12bbf: 48 83 c4 48 add rsp, 72 - RCX is live - sp-88 is live -12bc3: 5b pop rbx -12bc4: 41 5e pop r14 -12bc6: 41 5f pop r15 -12bc8: 5d pop rbp -12bc9: c3 ret -12bca: 48 8b 35 b7 2a 02 00 mov rsi, qword ptr [0x35688] // System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) -12bd1: 48 8b f9 mov rdi, rcx - RDI is live -12bd4: ff 15 46 27 02 00 call qword ptr [0x35320] // ALLOC_CONTINUATION (HELPER) - RCX is dead - RAX is live - RDI is dead -12bda: 48 8b d8 mov rbx, rax - RBX is live -12bdd: 48 8d 05 0c 33 02 00 lea rax, [0x35ef0] -12be4: 48 89 43 10 mov qword ptr [rbx + 16], rax -12be8: 48 c7 43 18 80 00 00 00 mov qword ptr [rbx + 24], 128 -12bf0: ff 15 b2 27 02 00 call qword ptr [0x353a8] // System.Threading.ExecutionContext System.Runtime.CompilerServices.AsyncHelpers.CaptureExecutionContext() (METHOD_ENTRY_REF_TOKEN) - RAX is dead -12bf6: 48 8d 7b 28 lea rdi, [rbx + 40] - RDI is live -12bfa: 48 8b f0 mov rsi, rax - RSI is live -12bfd: ff 15 fd 26 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) - RAX is live - RSI is dead - RDI is dead -12c03: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 -12c08: 40 0f 95 c7 setne dil -12c0c: 40 0f b6 ff movzx edi, dil -12c10: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12c14: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live - sp-88 is dead -12c18: ff 15 aa 27 02 00 call qword ptr [0x353c8] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContextsOnSuspension(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12c1e: 48 8b cb mov rcx, rbx - RCX is live -12c21: 48 83 c4 48 add rsp, 72 - sp-88 is live - RCX is dead - RBX is dead -12c25: 5b pop rbx -12c26: 41 5e pop r14 -12c28: 41 5f pop r15 -12c2a: 5d pop rbp -12c2b: c3 ret -12c2c: 48 8b 55 a8 mov rdx, qword ptr [rbp - 88] - RDX is live -12c30: 48 8b 7a 28 mov rdi, qword ptr [rdx + 40] - RDI is live -12c34: ff 15 76 27 02 00 call qword ptr [0x353b0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreExecutionContext(System.Threading.ExecutionContext) (METHOD_ENTRY_REF_TOKEN) - RDI is dead - RDX is dead -12c3a: 48 8b 55 a8 mov rdx, qword ptr [rbp - 88] - RDX is live -12c3e: 8b 5a 20 mov ebx, dword ptr [rdx + 32] -12c41: e9 5a ff ff ff jmp 0x12ba0 - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 82 -StartAddress: 0x00012C46 -Size: 34 bytes -UnwindRVA: 0x00010D4C -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - - RDX is dead -12c46: 50 push rax -12c47: 48 83 7d a8 00 cmp qword ptr [rbp - 88], 0 -12c4c: 40 0f 95 c7 setne dil -12c50: 40 0f b6 ff movzx edi, dil -12c54: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12c58: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live - sp-88 is dead -12c5c: ff 15 5e 27 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RSI is dead - RDX is dead -12c62: 90 nop -12c63: 48 83 c4 08 add rsp, 8 -12c67: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Handle: 0x06000013 -Rid: 19 -EntryPointRuntimeFunctionId: 88 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForVariant(int) -Id: 88 -StartAddress: 0x00012E30 -Size: 85 bytes -UnwindRVA: 0x00010D58 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0008 -CountOfUnwindCodes: 4 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 -UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) - -Debug Info - Bounds: -00000000: 62 00 02 14 13 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4C, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x2B - Loc Type: VLT_REG - Register: R15 - -12e30: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12e31: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12e33: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12e34: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12e38: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12e3d: 33 c0 xor eax, eax -12e3f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12e43: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12e47: 48 8b df mov rbx, rdi -12e4a: 44 8b fe mov r15d, esi -12e4d: 48 8d 7d e8 lea rdi, [rbp - 24] -12e51: 48 8d 75 e0 lea rsi, [rbp - 32] -12e55: ff 15 5d 25 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12e5b: 45 03 ff add r15d, r15d -12e5e: 48 85 db test rbx, rbx -12e61: 40 0f 95 c7 setne dil -12e65: 40 0f b6 ff movzx edi, dil -12e69: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] -12e6d: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] -12e71: ff 15 49 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12e77: 41 8b c7 mov eax, r15d -12e7a: 33 c9 xor ecx, ecx -12e7c: 48 83 c4 10 add rsp, 16 -12e80: 5b pop rbx -12e81: 41 5f pop r15 -12e83: 5d pop rbp -12e84: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Handle: 0x06000017 -Rid: 23 -EntryPointRuntimeFunctionId: 91 -Number of RuntimeFunctions: 2 -Number of fixups: 1 - TableIndex 0, Offset 0001: System.Threading.Tasks.Task CrossModuleHelper.SmallCrossModuleAsyncVoid() (CHECK_IL_BODY) - -[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Id: 91 -StartAddress: 0x00012F30 -Size: 105 bytes -UnwindRVA: 0x00010C04 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 48 - -EH info @ 133D8, #clauses = 1 -Flags 04 TryOff 0027 (RVA 12F57) TryEnd 0046 (RVA 12F76) HndOff 0069 (RVA 12F99) HndEnd 008B (RVA 12FBB) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 65 01 02 24 A3 EA 20 43 EA 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x46, NoMapping, Source Types: StackEmpty - Native Offset: 0x63, Epilog, Source Types: StackEmpty - Native Offset: 0x69, Prolog, Source Types: StackEmpty - Native Offset: 0x86, Epilog, Source Types: StackEmpty - -12f30: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12f31: 48 83 ec 30 sub rsp, 48 - UWOP_ALLOC_SMALL 48 0 - -12f35: 48 8d 6c 24 30 lea rbp, [rsp + 48] -12f3a: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12f3f: c5 7e 7f 45 e0 vmovdqu ymmword ptr [rbp - 32], ymm8 -12f44: 48 89 7d d8 mov qword ptr [rbp - 40], rdi -12f48: 48 8d 7d f8 lea rdi, [rbp - 8] -12f4c: 48 8d 75 f0 lea rsi, [rbp - 16] -12f50: ff 15 62 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12f56: 90 nop -12f57: 48 8d 7d e8 lea rdi, [rbp - 24] -12f5b: 48 8d 75 e0 lea rsi, [rbp - 32] -12f5f: ff 15 53 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12f65: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] - RDX is live -12f69: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] - RSI is live -12f6d: 33 ff xor edi, edi -12f6f: ff 15 4b 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12f75: 90 nop -12f76: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 -12f7b: 40 0f 95 c7 setne dil -12f7f: 40 0f b6 ff movzx edi, dil -12f83: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] - RSI is live -12f87: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] - RDX is live - sp-40 is dead -12f8b: ff 15 2f 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12f91: 33 c9 xor ecx, ecx -12f93: 48 83 c4 30 add rsp, 48 - sp-40 is live -12f97: 5d pop rbp -12f98: c3 ret - -[ASYNC] System.Threading.Tasks.Task InlineThunks.CrossModuleAsyncCallerVoid() -Id: 92 -StartAddress: 0x00012F99 -Size: 34 bytes -UnwindRVA: 0x00010C34 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12f99: 50 push rax -12f9a: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 -12f9f: 40 0f 95 c7 setne dil -12fa3: 40 0f b6 ff movzx edi, dil -12fa7: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] - RSI is live -12fab: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] - RDX is live - sp-40 is dead -12faf: ff 15 0b 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12fb5: 90 nop -12fb6: 48 83 c4 08 add rsp, 8 -12fba: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Handle: 0x06000011 -Rid: 17 -EntryPointRuntimeFunctionId: 86 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForVariant(int) -Id: 86 -StartAddress: 0x00012D80 -Size: 85 bytes -UnwindRVA: 0x00010D58 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0008 -CountOfUnwindCodes: 4 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 -UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) - -Debug Info - Bounds: -00000000: 62 00 02 14 13 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4C, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x2B - Loc Type: VLT_REG - Register: R15 - -12d80: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12d81: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12d83: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12d84: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12d88: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12d8d: 33 c0 xor eax, eax -12d8f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12d93: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12d97: 48 8b df mov rbx, rdi -12d9a: 44 8b fe mov r15d, esi -12d9d: 48 8d 7d e8 lea rdi, [rbp - 24] -12da1: 48 8d 75 e0 lea rsi, [rbp - 32] -12da5: ff 15 0d 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12dab: 45 03 ff add r15d, r15d -12dae: 48 85 db test rbx, rbx -12db1: 40 0f 95 c7 setne dil -12db5: 40 0f b6 ff movzx edi, dil -12db9: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] -12dbd: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] -12dc1: ff 15 f9 25 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12dc7: 41 8b c7 mov eax, r15d -12dca: 33 c9 xor ecx, ecx -12dcc: 48 83 c4 10 add rsp, 16 -12dd0: 5b pop rbx -12dd1: 41 5f pop r15 -12dd3: 5d pop rbp -12dd4: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Handle: 0x0600000E -Rid: 14 -EntryPointRuntimeFunctionId: 83 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.SmallAsyncForThunk(int) -Id: 83 -StartAddress: 0x00012C70 -Size: 85 bytes -UnwindRVA: 0x00010D58 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0008 -CountOfUnwindCodes: 4 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 -UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) - -Debug Info - Bounds: -00000000: 62 00 02 14 13 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4C, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x2B - Loc Type: VLT_REG - Register: R15 - -12c70: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12c71: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12c73: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12c74: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12c78: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12c7d: 33 c0 xor eax, eax -12c7f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12c83: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12c87: 48 8b df mov rbx, rdi -12c8a: 44 8b fe mov r15d, esi -12c8d: 48 8d 7d e8 lea rdi, [rbp - 24] -12c91: 48 8d 75 e0 lea rsi, [rbp - 32] -12c95: ff 15 1d 27 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12c9b: 45 03 ff add r15d, r15d -12c9e: 48 85 db test rbx, rbx -12ca1: 40 0f 95 c7 setne dil -12ca5: 40 0f b6 ff movzx edi, dil -12ca9: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] -12cad: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] -12cb1: ff 15 09 27 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12cb7: 41 8b c7 mov eax, r15d -12cba: 33 c9 xor ecx, ecx -12cbc: 48 83 c4 10 add rsp, 16 -12cc0: 5b pop rbx -12cc1: 41 5f pop r15 -12cc3: 5d pop rbp -12cc4: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Handle: 0x06000010 -Rid: 16 -EntryPointRuntimeFunctionId: 85 -Number of RuntimeFunctions: 1 - -[ASYNC] System.Threading.Tasks.ValueTask`1 InlineThunks.SmallValueTaskAsyncForThunk(int) -Id: 85 -StartAddress: 0x00012D20 -Size: 85 bytes -UnwindRVA: 0x00010D58 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0008 -CountOfUnwindCodes: 4 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0008 FrameOffset 0x0000 NextOffset 0x0 Op 16 -UnwindCode[2]: CodeOffset 0x0003 FrameOffset 0x0000 NextOffset 0x0 Op R15(15) - -Debug Info - Bounds: -00000000: 62 00 02 14 13 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4C, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x1D - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x1D - End Offset: 0x2B - Loc Type: VLT_REG - Register: R15 - -12d20: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12d21: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12d23: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12d24: 48 83 ec 10 sub rsp, 16 - UWOP_ALLOC_SMALL 16 0 - -12d28: 48 8d 6c 24 20 lea rbp, [rsp + 32] -12d2d: 33 c0 xor eax, eax -12d2f: 48 89 45 e8 mov qword ptr [rbp - 24], rax -12d33: 48 89 45 e0 mov qword ptr [rbp - 32], rax -12d37: 48 8b df mov rbx, rdi -12d3a: 44 8b fe mov r15d, esi -12d3d: 48 8d 7d e8 lea rdi, [rbp - 24] -12d41: 48 8d 75 e0 lea rsi, [rbp - 32] -12d45: ff 15 6d 26 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12d4b: 45 03 ff add r15d, r15d -12d4e: 48 85 db test rbx, rbx -12d51: 40 0f 95 c7 setne dil -12d55: 40 0f b6 ff movzx edi, dil -12d59: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] -12d5d: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] -12d61: ff 15 59 26 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12d67: 41 8b c7 mov eax, r15d -12d6a: 33 c9 xor ecx, ecx -12d6c: 48 83 c4 10 add rsp, 16 -12d70: 5b pop rbx -12d71: 41 5f pop r15 -12d73: 5d pop rbp -12d74: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Handle: 0x0600000B -Rid: 11 -EntryPointRuntimeFunctionId: 79 -Number of RuntimeFunctions: 2 -Number of fixups: 9 - TableIndex 5, Offset 0000: [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) - TableIndex 5, Offset 0006: InlineThunks+d__20 (TYPE_HANDLE) - TableIndex 5, Offset 0009: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 (TYPE_HANDLE) - TableIndex 5, Offset 0012: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 8 Align native GCLayout 0x1 (CHECK_TYPE_LAYOUT) - TableIndex 5, Offset 0016: System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) - TableIndex 5, Offset 0017: int InlineThunks+d__20.<>1__state (FIELD_OFFSET) - TableIndex 5, Offset 0018: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) - TableIndex 5, Offset 0019: int InlineThunks+d__20.x (FIELD_OFFSET) - TableIndex 5, Offset 001D: (RESUMPTION_STUB RVA[0x12700]) - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 79 -StartAddress: 0x00012910 -Size: 372 bytes -UnwindRVA: 0x00010C40 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x000A -CountOfUnwindCodes: 5 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x000A FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op R14(14) -UnwindCode[4]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13390, #clauses = 1 -Flags 04 TryOff 003D (RVA 1294D) TryEnd 00CE (RVA 129DE) HndOff 0174 (RVA 12A84) HndEnd 0196 (RVA 12AA6) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 19 37 02 08 F5 8C 22 45 1F C0 85 D4 15 70 21 A5 -00000010: 11 EA 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x3D, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0xCE, NoMapping, Source Types: StackEmpty - Native Offset: 0xED, Epilog, Source Types: StackEmpty - Native Offset: 0xF8, IL Offset: 0x0006, Source Types: Async - Native Offset: 0x14F, Epilog, Source Types: StackEmpty - Native Offset: 0x15A, IL Offset: 0x0006, Source Types: Async - Native Offset: 0x174, Prolog, Source Types: StackEmpty - Native Offset: 0x191, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x25 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x25 - End Offset: 0x70 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0xC9 - End Offset: 0xE9 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 1 - Start Offset: 0x16F - End Offset: 0x174 - Loc Type: VLT_REG - Register: RBX - -12910: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12911: 41 57 push r15 - UWOP_PUSH_NONVOL R15(15) 0 - -12913: 41 56 push r14 - UWOP_PUSH_NONVOL R14(14) 0 - -12915: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12916: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -1291a: 48 8d 6c 24 40 lea rbp, [rsp + 64] -1291f: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12924: c5 79 7f 45 d0 vmovdqa xmmword ptr [rbp - 48], xmm8 -12929: 33 c0 xor eax, eax -1292b: 48 89 45 e0 mov qword ptr [rbp - 32], rax -1292f: 48 89 7d c8 mov qword ptr [rbp - 56], rdi -12933: 8b de mov ebx, esi -12935: 48 85 ff test rdi, rdi -12938: 0f 85 2c 01 00 00 jne 0x12a6a -1293e: 48 8d 7d e0 lea rdi, [rbp - 32] - RDI is live -12942: 48 8d 75 d8 lea rsi, [rbp - 40] -12946: ff 15 6c 2a 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -1294c: 90 nop -1294d: ff 15 f5 29 02 00 call qword ptr [0x35348] // InlineThunks+d__20 (NEW_OBJECT) - RAX is live -12953: 48 89 45 d0 mov qword ptr [rbp - 48], rax -12957: 4c 8b 7d d0 mov r15, qword ptr [rbp - 48] - R15 is live -1295b: ff 15 a7 2a 02 00 call qword ptr [0x35408] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create() (METHOD_ENTRY) -12961: 4c 8b 35 30 2d 02 00 mov r14, qword ptr [0x35698] // System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 InlineThunks+d__20.<>t__builder (FIELD_OFFSET) -12968: 4b 8d 3c 37 lea rdi, [r15 + r14] - RDI is live -1296c: 48 8b f0 mov rsi, rax - RSI is live -1296f: ff 15 8b 29 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) -12975: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] - RDI is live -12979: 48 8b 35 20 2d 02 00 mov rsi, qword ptr [0x356a0] // int InlineThunks+d__20.x (FIELD_OFFSET) -12980: 89 1c 37 mov dword ptr [rdi + rsi], ebx -12983: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -12987: 48 8b 35 02 2d 02 00 mov rsi, qword ptr [0x35690] // int InlineThunks+d__20.<>1__state (FIELD_OFFSET) -1298e: c7 04 37 ff ff ff ff mov dword ptr [rdi + rsi], 4294967295 -12995: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] -12999: 40 38 3f cmp byte ptr [rdi], dil -1299c: 49 8b fe mov rdi, r14 - RDI is dead -1299f: 48 03 7d d0 add rdi, qword ptr [rbp - 48] - RDI is dead -129a3: 48 8b 35 2e 2c 02 00 mov rsi, qword ptr [0x355d8] // [INST] void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)d__20> (METHOD_DICTIONARY) -129aa: 48 8d 55 d0 lea rdx, [rbp - 48] -129ae: ff 15 ec 2a 02 00 call qword ptr [0x354a0] // void System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start(ref !!0)<__Canon> (METHOD_ENTRY) - RDI is live -129b4: 48 8b 7d d0 mov rdi, qword ptr [rbp - 48] - RDI is live -129b8: 40 38 3f cmp byte ptr [rdi], dil -129bb: 49 8b fe mov rdi, r14 - RDI is dead -129be: 48 03 7d d0 add rdi, qword ptr [rbp - 48] - RDI is live -129c2: ff 15 48 2a 02 00 call qword ptr [0x35410] // System.Threading.Tasks.Task`1 System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task() (METHOD_ENTRY) - RDI is dead - RAX is live -129c8: 48 8b f0 mov rsi, rax - RSI is live -129cb: 33 ff xor edi, edi - RDI is live -129cd: 48 89 7d d0 mov qword ptr [rbp - 48], rdi - RAX is dead - RDI is dead -129d1: ff 15 b1 2a 02 00 call qword ptr [0x35488] // !!0 System.Runtime.CompilerServices.AsyncHelpers.Await(System.Threading.Tasks.Task`1) (METHOD_ENTRY) - RCX is live - RSI is dead -129d7: 8b d8 mov ebx, eax -129d9: 48 85 c9 test rcx, rcx -129dc: 75 2a jne 0x12a08 - RCX is dead -129de: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 -129e3: 40 0f 95 c7 setne dil -129e7: 40 0f b6 ff movzx edi, dil -129eb: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -129ef: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live - sp-56 is dead -129f3: ff 15 c7 29 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RSI is dead - RDX is dead -129f9: 8b c3 mov eax, ebx -129fb: 33 c9 xor ecx, ecx -129fd: 48 83 c4 28 add rsp, 40 - sp-56 is live - RCX is live -12a01: 5b pop rbx -12a02: 41 5e pop r14 -12a04: 41 5f pop r15 -12a06: 5d pop rbp -12a07: c3 ret -12a08: 48 8b 35 79 2c 02 00 mov rsi, qword ptr [0x35688] // System.Runtime.CompilerServices.Continuation Flags READYTORUN_LAYOUT_Alignment, READYTORUN_LAYOUT_Alignment_Native, READYTORUN_LAYOUT_GCLayout Size 16 Align native GCLayout 0x2 (CONTINUATION_LAYOUT) -12a0f: 48 8b f9 mov rdi, rcx - RDI is live -12a12: ff 15 08 29 02 00 call qword ptr [0x35320] // ALLOC_CONTINUATION (HELPER) - RCX is dead - RAX is live - RDI is dead -12a18: 48 8b d8 mov rbx, rax - RBX is live -12a1b: 48 8d 05 be 34 02 00 lea rax, [0x35ee0] - RAX is dead -12a22: 48 89 43 10 mov qword ptr [rbx + 16], rax -12a26: 48 c7 43 18 80 00 00 00 mov qword ptr [rbx + 24], 128 -12a2e: ff 15 74 29 02 00 call qword ptr [0x353a8] // System.Threading.ExecutionContext System.Runtime.CompilerServices.AsyncHelpers.CaptureExecutionContext() (METHOD_ENTRY_REF_TOKEN) - RAX is live -12a34: 48 8d 7b 28 lea rdi, [rbx + 40] - RDI is live -12a38: 48 8b f0 mov rsi, rax - RSI is live -12a3b: ff 15 bf 28 02 00 call qword ptr [0x35300] // WRITE_BARRIER (HELPER) - RAX is dead - RSI is dead - RDI is dead -12a41: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 -12a46: 40 0f 95 c7 setne dil -12a4a: 40 0f b6 ff movzx edi, dil -12a4e: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12a52: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - sp-56 is dead - RDX is live -12a56: ff 15 6c 29 02 00 call qword ptr [0x353c8] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContextsOnSuspension(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RSI is dead - RDX is dead -12a5c: 48 8b cb mov rcx, rbx - RCX is live -12a5f: 48 83 c4 28 add rsp, 40 - RCX is dead - RBX is dead - sp-56 is live -12a63: 5b pop rbx -12a64: 41 5e pop r14 -12a66: 41 5f pop r15 -12a68: 5d pop rbp -12a69: c3 ret -12a6a: 48 8b 7d c8 mov rdi, qword ptr [rbp - 56] - RDI is live -12a6e: 48 8b 7f 28 mov rdi, qword ptr [rdi + 40] -12a72: ff 15 38 29 02 00 call qword ptr [0x353b0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreExecutionContext(System.Threading.ExecutionContext) (METHOD_ENTRY_REF_TOKEN) - RDI is dead -12a78: 48 8b 7d c8 mov rdi, qword ptr [rbp - 56] - RDI is live -12a7c: 8b 5f 20 mov ebx, dword ptr [rdi + 32] -12a7f: e9 5a ff ff ff jmp 0x129de - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 80 -StartAddress: 0x00012A84 -Size: 34 bytes -UnwindRVA: 0x00010CBC -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - - RDI is dead -12a84: 50 push rax -12a85: 48 83 7d c8 00 cmp qword ptr [rbp - 56], 0 -12a8a: 40 0f 95 c7 setne dil -12a8e: 40 0f b6 ff movzx edi, dil -12a92: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12a96: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live - sp-56 is dead -12a9a: ff 15 20 29 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12aa0: 90 nop -12aa1: 48 83 c4 08 add rsp, 8 -12aa5: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Handle: 0x06000009 -Rid: 9 -EntryPointRuntimeFunctionId: 77 -Number of RuntimeFunctions: 2 - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Id: 77 -StartAddress: 0x00012870 -Size: 123 bytes -UnwindRVA: 0x00010BC4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 13378, #clauses = 1 -Flags 04 TryOff 0034 (RVA 128A4) TryEnd 0055 (RVA 128C5) HndOff 007B (RVA 128EB) HndEnd 009D (RVA 1290D) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 66 01 02 24 E1 9A A8 0F 3A A4 0E - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x55, NoMapping, Source Types: StackEmpty - Native Offset: 0x74, Epilog, Source Types: StackEmpty - Native Offset: 0x7B, Prolog, Source Types: StackEmpty - Native Offset: 0x98, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x25 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x25 - End Offset: 0x42 - Loc Type: VLT_REG - Register: RBX - -12870: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12871: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12872: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -12876: 48 8d 6c 24 30 lea rbp, [rsp + 48] -1287b: 33 c0 xor eax, eax -1287d: 48 89 45 d8 mov qword ptr [rbp - 40], rax -12881: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12886: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -1288b: 48 89 45 f0 mov qword ptr [rbp - 16], rax -1288f: 48 89 7d d0 mov qword ptr [rbp - 48], rdi -12893: 8b de mov ebx, esi -12895: 48 8d 7d f0 lea rdi, [rbp - 16] -12899: 48 8d 75 e8 lea rsi, [rbp - 24] -1289d: ff 15 15 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -128a3: 90 nop -128a4: 48 8d 7d e0 lea rdi, [rbp - 32] -128a8: 48 8d 75 d8 lea rsi, [rbp - 40] -128ac: ff 15 06 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -128b2: 03 db add ebx, ebx -128b4: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live -128b8: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -128bc: 33 ff xor edi, edi -128be: ff 15 fc 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -128c4: 90 nop -128c5: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -128ca: 40 0f 95 c7 setne dil -128ce: 40 0f b6 ff movzx edi, dil -128d2: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -128d6: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -128da: ff 15 e0 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -128e0: 8b c3 mov eax, ebx -128e2: 33 c9 xor ecx, ecx -128e4: 48 83 c4 28 add rsp, 40 - sp-48 is live -128e8: 5b pop rbx -128e9: 5d pop rbp -128ea: c3 ret - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.AsyncCallerOfSmallValueTaskAsync(int) -Id: 78 -StartAddress: 0x000128EB -Size: 34 bytes -UnwindRVA: 0x00010BF8 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -128eb: 50 push rax -128ec: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -128f1: 40 0f 95 c7 setne dil -128f5: 40 0f b6 ff movzx edi, dil -128f9: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -128fd: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -12901: ff 15 b9 2a 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12907: 90 nop -12908: 48 83 c4 08 add rsp, 8 -1290c: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Handle: 0x06000018 -Rid: 24 -EntryPointRuntimeFunctionId: 93 -Number of RuntimeFunctions: 2 -Number of fixups: 1 - TableIndex 0, Offset 0002: System.Threading.Tasks.ValueTask`1 CrossModuleHelper.SmallCrossModuleValueTaskAsync(int) (CHECK_IL_BODY) - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Id: 93 -StartAddress: 0x00012FC0 -Size: 124 bytes -UnwindRVA: 0x00010D90 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 133F0, #clauses = 1 -Flags 04 TryOff 0034 (RVA 12FF4) TryEnd 0056 (RVA 13016) HndOff 007C (RVA 1303C) HndEnd 009E (RVA 1305E) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 66 01 02 24 E1 A2 A8 0F 3A A4 0E - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x56, NoMapping, Source Types: StackEmpty - Native Offset: 0x75, Epilog, Source Types: StackEmpty - Native Offset: 0x7C, Prolog, Source Types: StackEmpty - Native Offset: 0x99, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x25 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x25 - End Offset: 0x42 - Loc Type: VLT_REG - Register: RBX - -12fc0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12fc1: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12fc2: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -12fc6: 48 8d 6c 24 30 lea rbp, [rsp + 48] -12fcb: 33 c0 xor eax, eax -12fcd: 48 89 45 d8 mov qword ptr [rbp - 40], rax -12fd1: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12fd6: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -12fdb: 48 89 45 f0 mov qword ptr [rbp - 16], rax -12fdf: 48 89 7d d0 mov qword ptr [rbp - 48], rdi -12fe3: 8b de mov ebx, esi -12fe5: 48 8d 7d f0 lea rdi, [rbp - 16] -12fe9: 48 8d 75 e8 lea rsi, [rbp - 24] -12fed: ff 15 c5 23 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12ff3: 90 nop -12ff4: 48 8d 7d e0 lea rdi, [rbp - 32] -12ff8: 48 8d 75 d8 lea rsi, [rbp - 40] -12ffc: ff 15 b6 23 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -13002: 8d 1c 5b lea ebx, [rbx + 2*rbx] -13005: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live -13009: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -1300d: 33 ff xor edi, edi -1300f: ff 15 ab 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -13015: 90 nop -13016: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -1301b: 40 0f 95 c7 setne dil -1301f: 40 0f b6 ff movzx edi, dil -13023: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -13027: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -1302b: ff 15 8f 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -13031: 8b c3 mov eax, ebx -13033: 33 c9 xor ecx, ecx -13035: 48 83 c4 28 add rsp, 40 - sp-48 is live -13039: 5b pop rbx -1303a: 5d pop rbp -1303b: c3 ret - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCallerValueTask(int) -Id: 94 -StartAddress: 0x0001303C -Size: 34 bytes -UnwindRVA: 0x00010DC4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -1303c: 50 push rax -1303d: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -13042: 40 0f 95 c7 setne dil -13046: 40 0f b6 ff movzx edi, dil -1304a: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -1304e: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -13052: ff 15 68 23 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -13058: 90 nop -13059: 48 83 c4 08 add rsp, 8 -1305d: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Handle: 0x06000016 -Rid: 22 -EntryPointRuntimeFunctionId: 89 -Number of RuntimeFunctions: 2 -Number of fixups: 1 - TableIndex 0, Offset 0000: System.Threading.Tasks.Task`1 CrossModuleHelper.SmallCrossModuleAsync(int) (CHECK_IL_BODY) - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Id: 89 -StartAddress: 0x00012E90 -Size: 124 bytes -UnwindRVA: 0x00010D90 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0006 -CountOfUnwindCodes: 3 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0006 FrameOffset 0x0000 NextOffset 0x0 Op 40 -UnwindCode[2]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBP(5) - -EH info @ 133C0, #clauses = 1 -Flags 04 TryOff 0034 (RVA 12EC4) TryEnd 0056 (RVA 12EE6) HndOff 007C (RVA 12F0C) HndEnd 009E (RVA 12F2E) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 66 01 02 24 E1 A2 A8 0F 3A A4 0E - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x42, IL Offset: 0x0000, Source Types: StackEmpty - Native Offset: 0x56, NoMapping, Source Types: StackEmpty - Native Offset: 0x75, Epilog, Source Types: StackEmpty - Native Offset: 0x7C, Prolog, Source Types: StackEmpty - Native Offset: 0x99, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x25 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 0 - Start Offset: 0x25 - End Offset: 0x42 - Loc Type: VLT_REG - Register: RBX - -12e90: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -12e91: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12e92: 48 83 ec 28 sub rsp, 40 - UWOP_ALLOC_SMALL 40 0 - -12e96: 48 8d 6c 24 30 lea rbp, [rsp + 48] -12e9b: 33 c0 xor eax, eax -12e9d: 48 89 45 d8 mov qword ptr [rbp - 40], rax -12ea1: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -12ea6: c5 79 7f 45 e0 vmovdqa xmmword ptr [rbp - 32], xmm8 -12eab: 48 89 45 f0 mov qword ptr [rbp - 16], rax -12eaf: 48 89 7d d0 mov qword ptr [rbp - 48], rdi -12eb3: 8b de mov ebx, esi -12eb5: 48 8d 7d f0 lea rdi, [rbp - 16] -12eb9: 48 8d 75 e8 lea rsi, [rbp - 24] -12ebd: ff 15 f5 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12ec3: 90 nop -12ec4: 48 8d 7d e0 lea rdi, [rbp - 32] -12ec8: 48 8d 75 d8 lea rsi, [rbp - 40] -12ecc: ff 15 e6 24 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12ed2: 8d 1c 5b lea ebx, [rbx + 2*rbx] -12ed5: 48 8b 55 d8 mov rdx, qword ptr [rbp - 40] - RDX is live -12ed9: 48 8b 75 e0 mov rsi, qword ptr [rbp - 32] - RSI is live -12edd: 33 ff xor edi, edi -12edf: ff 15 db 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12ee5: 90 nop -12ee6: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -12eeb: 40 0f 95 c7 setne dil -12eef: 40 0f b6 ff movzx edi, dil -12ef3: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -12ef7: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -12efb: ff 15 bf 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12f01: 8b c3 mov eax, ebx -12f03: 33 c9 xor ecx, ecx -12f05: 48 83 c4 28 add rsp, 40 - sp-48 is live -12f09: 5b pop rbx -12f0a: 5d pop rbp -12f0b: c3 ret - -[ASYNC] System.Threading.Tasks.Task`1 InlineThunks.CrossModuleAsyncCaller(int) -Id: 90 -StartAddress: 0x00012F0C -Size: 34 bytes -UnwindRVA: 0x00010DC4 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12f0c: 50 push rax -12f0d: 48 83 7d d0 00 cmp qword ptr [rbp - 48], 0 -12f12: 40 0f 95 c7 setne dil -12f16: 40 0f b6 ff movzx edi, dil -12f1a: 48 8b 75 f0 mov rsi, qword ptr [rbp - 16] - RSI is live -12f1e: 48 8b 55 e8 mov rdx, qword ptr [rbp - 24] - RDX is live - sp-48 is dead -12f22: ff 15 98 24 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12f28: 90 nop -12f29: 48 83 c4 08 add rsp, 8 -12f2d: c3 ret - -_______________________________________________ - -[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Handle: 0x06000008 -Rid: 8 -EntryPointRuntimeFunctionId: 75 -Number of RuntimeFunctions: 2 - -[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Id: 75 -StartAddress: 0x000127E0 -Size: 105 bytes -UnwindRVA: 0x00010C04 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0005 -CountOfUnwindCodes: 2 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0005 FrameOffset 0x0000 NextOffset 0x0 Op 48 - -EH info @ 13360, #clauses = 1 -Flags 04 TryOff 0027 (RVA 12807) TryEnd 0046 (RVA 12826) HndOff 0069 (RVA 12849) HndEnd 008B (RVA 1286B) ClsFlt 0000 FAULT - -Debug Info - Bounds: -00000000: 65 01 02 24 A3 EA 20 43 EA 00 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x46, NoMapping, Source Types: StackEmpty - Native Offset: 0x63, Epilog, Source Types: StackEmpty - Native Offset: 0x69, Prolog, Source Types: StackEmpty - Native Offset: 0x86, Epilog, Source Types: StackEmpty - -127e0: 55 push rbp - UWOP_PUSH_NONVOL RBP(5) 0 - -127e1: 48 83 ec 30 sub rsp, 48 - UWOP_ALLOC_SMALL 48 0 - -127e5: 48 8d 6c 24 30 lea rbp, [rsp + 48] -127ea: c4 41 38 57 c0 vxorps xmm8, xmm8, xmm8 -127ef: c5 7e 7f 45 e0 vmovdqu ymmword ptr [rbp - 32], ymm8 -127f4: 48 89 7d d8 mov qword ptr [rbp - 40], rdi -127f8: 48 8d 7d f8 lea rdi, [rbp - 8] -127fc: 48 8d 75 f0 lea rsi, [rbp - 16] -12800: ff 15 b2 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12806: 90 nop -12807: 48 8d 7d e8 lea rdi, [rbp - 24] -1280b: 48 8d 75 e0 lea rsi, [rbp - 32] -1280f: ff 15 a3 2b 02 00 call qword ptr [0x353b8] // void System.Runtime.CompilerServices.AsyncHelpers.CaptureContexts(ref System.Threading.ExecutionContext, ref System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) -12815: 48 8b 55 e0 mov rdx, qword ptr [rbp - 32] - RDX is live -12819: 48 8b 75 e8 mov rsi, qword ptr [rbp - 24] - RSI is live -1281d: 33 ff xor edi, edi -1281f: ff 15 9b 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12825: 90 nop -12826: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 -1282b: 40 0f 95 c7 setne dil -1282f: 40 0f b6 ff movzx edi, dil -12833: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] - RSI is live -12837: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] - RDX is live - sp-40 is dead -1283b: ff 15 7f 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12841: 33 c9 xor ecx, ecx -12843: 48 83 c4 30 add rsp, 48 - sp-40 is live -12847: 5d pop rbp -12848: c3 ret - -[ASYNC] System.Threading.Tasks.Task InlineThunks.AsyncCallerOfSmallAsyncVoid() -Id: 76 -StartAddress: 0x00012849 -Size: 34 bytes -UnwindRVA: 0x00010C34 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op 8 - -12849: 50 push rax -1284a: 48 83 7d d8 00 cmp qword ptr [rbp - 40], 0 -1284f: 40 0f 95 c7 setne dil -12853: 40 0f b6 ff movzx edi, dil -12857: 48 8b 75 f8 mov rsi, qword ptr [rbp - 8] - RSI is live -1285b: 48 8b 55 f0 mov rdx, qword ptr [rbp - 16] - RDX is live - sp-40 is dead -1285f: ff 15 5b 2b 02 00 call qword ptr [0x353c0] // void System.Runtime.CompilerServices.AsyncHelpers.RestoreContexts(bool, System.Threading.ExecutionContext, System.Threading.SynchronizationContext) (METHOD_ENTRY_REF_TOKEN) - RDX is dead - RSI is dead -12865: 90 nop -12866: 48 83 c4 08 add rsp, 8 -1286a: c3 ret - -_______________________________________________ - -[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Handle: 0x0600000D -Rid: 13 -EntryPointRuntimeFunctionId: 72 -Number of RuntimeFunctions: 1 - -[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeValueTaskAsync(int) -Id: 72 -StartAddress: 0x00012720 -Size: 23 bytes -UnwindRVA: 0x00010BB0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) - -Debug Info - Bounds: -00000000: 26 05 42 20 46 BA A7 92 D2 AA 01 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4, IL Offset: 0x000e, Source Types: StackEmpty - Native Offset: 0xB, IL Offset: 0x001b, Source Types: StackEmpty - Native Offset: 0x10, IL Offset: 0x0021, Source Types: StackEmpty - Native Offset: 0x12, IL Offset: 0x0028, Source Types: StackEmpty - Native Offset: 0x15, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x4 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x4 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 1 - Start Offset: 0x4 - End Offset: 0x10 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 3 - Start Offset: 0xB - End Offset: 0x10 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 4 - Start Offset: 0xB - End Offset: 0x12 - Loc Type: VLT_REG - Register: RCX - -12720: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12721: 48 8b de mov rbx, rsi -12724: 33 f6 xor esi, esi -12726: e8 85 03 00 00 call 0x12ab0 -1272b: 48 85 c9 test rcx, rcx -1272e: 75 02 jne 0x12732 -12730: 89 03 mov dword ptr [rbx], eax -12732: 48 8b c1 mov rax, rcx -12735: 5b pop rbx -12736: c3 ret - -_______________________________________________ - -[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Handle: 0x0600000B -Rid: 11 -EntryPointRuntimeFunctionId: 71 -Number of RuntimeFunctions: 1 - -[RESUME] System.Threading.Tasks.Task`1 InlineThunks.AwaitNonRuntimeAsync(int) -Id: 71 -StartAddress: 0x00012700 -Size: 23 bytes -UnwindRVA: 0x00010BB0 -Version: 1 -Flags: 0x03 EHANDLER UHANDLER -SizeOfProlog: 0x0001 -CountOfUnwindCodes: 1 -FrameRegister: None -FrameOffset: 0x0 -PersonalityRVA: 0x13408 -UnwindCode[0]: CodeOffset 0x0001 FrameOffset 0x0000 NextOffset 0x0 Op RBX(3) - -Debug Info - Bounds: -00000000: 26 05 42 20 46 BA A7 92 D2 AA 01 - Native Offset: 0x0, Prolog, Source Types: StackEmpty - Native Offset: 0x4, IL Offset: 0x000e, Source Types: StackEmpty - Native Offset: 0xB, IL Offset: 0x001b, Source Types: StackEmpty - Native Offset: 0x10, IL Offset: 0x0021, Source Types: StackEmpty - Native Offset: 0x12, IL Offset: 0x0028, Source Types: StackEmpty - Native Offset: 0x15, Epilog, Source Types: StackEmpty - - Variable Locations: - Variable Number: 0 - Start Offset: 0x0 - End Offset: 0x4 - Loc Type: VLT_REG - Register: RDI - - Variable Number: 1 - Start Offset: 0x0 - End Offset: 0x4 - Loc Type: VLT_REG - Register: RSI - - Variable Number: 1 - Start Offset: 0x4 - End Offset: 0x10 - Loc Type: VLT_REG - Register: RBX - - Variable Number: 3 - Start Offset: 0xB - End Offset: 0x10 - Loc Type: VLT_REG - Register: RAX - - Variable Number: 4 - Start Offset: 0xB - End Offset: 0x12 - Loc Type: VLT_REG - Register: RCX - -12700: 53 push rbx - UWOP_PUSH_NONVOL RBX(3) 0 - -12701: 48 8b de mov rbx, rsi -12704: 33 f6 xor esi, esi -12706: e8 05 02 00 00 call 0x12910 -1270b: 48 85 c9 test rcx, rcx -1270e: 75 02 jne 0x12712 -12710: 89 03 mov dword ptr [rbx], eax -12712: 48 8b c1 mov rax, rcx -12715: 5b pop rbx -12716: c3 ret - -=========== Eager fixup counts across all methods =========== - - Fixup | Count - TypeHandle | 43 - Check_TypeLayout | 34 - FieldOffset | 24 - StringHandle | 23 - MethodDictionary | 6 - Check_IL_Body | 4 - FieldBaseOffset | 2 - ContinuationLayout | 2 -ResumptionStubEntryPoint | 2 --------------------------------- - Total | 140 - -============================================================= - From 3d2c7d6723a8f10c01779d934c8a132d79c611f4 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Fri, 27 Mar 2026 12:29:43 -0700 Subject: [PATCH 12/18] Fix MayHaveILHeader assert for async IL body fixups When crossgen2 emits CHECK_IL_BODY fixups for cross-module inlined async methods (miAsync), the runtime crashes with a MayHaveILHeader() precondition failure. This happens because the runtime marks the original MethodDesc as an async thunk, and MayHaveILHeader() returns false for thunks. However, the IL bytes are still present at the method's RVA in the PE. Runtime fix: Add GetILHeaderForStandaloneMetadata() helper that bypasses MayHaveILHeader() for async thunk methods by accessing the IL directly via Module::GetIL(GetRVA()). Crossgen2 fix: Separate ILBodyFixupSignature into _ilMethod (EcmaMethod for IL body hash computation) and _signatureMethod (MethodDesc for method identity encoding), making the different roles explicit. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ReadyToRun/ILBodyFixupSignature.cs | 37 ++++++++++++------- .../vm/readytorunstandalonemethodmetadata.cpp | 17 ++++++++- 2 files changed, 40 insertions(+), 14 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 8ac6d562fcad72..8caa8896701b52 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -17,18 +17,29 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun { /// /// This fixup instructs the runtime to validate that the IL found at runtime matches the hash of the IL computed at compile time. - /// This will use the method IL in metadata for the EcmaMethod, not what is provided by the ILProvider. Notably, this is different for Async methods, - /// for which the ILProvider used during JIT compilation will return the Task-returning thunk for a runtime-async EcmaMethod. + /// The ilMethod provides the IL body from metadata for computing the standalone metadata hash. + /// The signatureMethod is the method identity encoded in the fixup signature that the runtime will decode + /// back to a MethodDesc. These are the same for most methods, but differ for runtime-async methods where the inlinee + /// is an AsyncMethodVariant: the IL comes from the target EcmaMethod, while the signature must identify the same method + /// so the runtime can locate the IL at the method's RVA. /// public class ILBodyFixupSignature : Signature, IEquatable { private readonly ReadyToRunFixupKind _fixupKind; - private readonly EcmaMethod _method; + private readonly EcmaMethod _ilMethod; + private readonly MethodDesc _signatureMethod; - public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ecmaMethod) + public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ilMethod, MethodDesc signatureMethod) { + Debug.Assert(signatureMethod.IsMethodDefinition); _fixupKind = fixupKind; - _method = ecmaMethod; + _ilMethod = ilMethod; + _signatureMethod = signatureMethod; + } + + public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ecmaMethod) + : this(fixupKind, ecmaMethod, ecmaMethod) + { } public override int ClassCode => 308579267; @@ -49,10 +60,10 @@ public static void NotifyComplete(NodeFactory factory, List object.ReferenceEquals(other, this); diff --git a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp index 30802a7076915a..d2edbe7edd91af 100644 --- a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp +++ b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp @@ -20,10 +20,25 @@ class ReadyToRunStandaloneMethodMetadataHelper Module* pModule; IMDInternalImport* pMDImport; + static COR_ILMETHOD* GetILHeaderForStandaloneMetadata(MethodDesc *pMD) + { + // For runtime-async methods with miAsync in metadata, the runtime marks the original + // MethodDesc as a thunk (IsAsyncThunkMethod() == true, MayHaveILHeader() == false). + // However, the IL body check fixup needs to validate the original IL from metadata, + // which is still present at the method's RVA. Bypass MayHaveILHeader() for this case. + if (!pMD->MayHaveILHeader()) + { + _ASSERTE(pMD->IsAsyncThunkMethod()); + _ASSERTE(pMD->GetRVA() != 0); + return PTR_COR_ILMETHOD(pMD->GetModule()->GetIL(pMD->GetRVA())); + } + return pMD->GetILHeader(); + } + public: ReadyToRunStandaloneMethodMetadataHelper(MethodDesc *pMD, SArray *pTypeRefTokenStreamInput) : - header(pMD->GetILHeader(), pMD->GetMDImport(), NULL), + header(GetILHeaderForStandaloneMetadata(pMD), pMD->GetMDImport(), NULL), currentILStreamIterator(0), pTypeRefTokenStream(pTypeRefTokenStreamInput), pModule(pMD->GetModule()), From 86e95ccbb9603c90cba5abb0fc477b7210dade3e Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Fri, 27 Mar 2026 13:11:50 -0700 Subject: [PATCH 13/18] Use signatureMethod for EmitMethodSignature in ILBodyFixupSignature Split GetModuleToken into GetILModuleToken (for IL hash and fixup module context) and GetSignatureModuleToken (for method identity encoding). Use _signatureMethod.GetTypicalMethodDefinition() for EmitMethodSignature so the correct method identity is encoded when IL source and signature method differ (e.g. runtime-async inlinees). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ReadyToRun/ILBodyFixupSignature.cs | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 8caa8896701b52..3790bd99362d88 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -54,11 +54,12 @@ public static void NotifyComplete(NodeFactory factory, List Date: Fri, 27 Mar 2026 13:16:06 -0700 Subject: [PATCH 14/18] Add comments explaining IL/signature method split for async fixups Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ReadyToRun/ILBodyFixupSignature.cs | 25 +++++++++++++++---- .../vm/readytorunstandalonemethodmetadata.cpp | 11 ++++++-- 2 files changed, 29 insertions(+), 7 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 3790bd99362d88..f8cce6cb930c2c 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -17,16 +17,31 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun { /// /// This fixup instructs the runtime to validate that the IL found at runtime matches the hash of the IL computed at compile time. - /// The ilMethod provides the IL body from metadata for computing the standalone metadata hash. - /// The signatureMethod is the method identity encoded in the fixup signature that the runtime will decode - /// back to a MethodDesc. These are the same for most methods, but differ for runtime-async methods where the inlinee - /// is an AsyncMethodVariant: the IL comes from the target EcmaMethod, while the signature must identify the same method - /// so the runtime can locate the IL at the method's RVA. /// + /// + /// The fixup encodes two distinct pieces of information that may come from different methods: + /// + /// _ilMethod (EcmaMethod): The source of the IL body from metadata, used to compute the standalone + /// metadata hash that the runtime will validate against. + /// _signatureMethod (MethodDesc): The method identity encoded in the fixup signature. The runtime + /// decodes this back to a MethodDesc via ZapSig::DecodeMethod and then reads the IL at that method's RVA + /// to compare against the hash. + /// + /// For most methods these are the same EcmaMethod. They differ for runtime-async methods: the JIT inlines an + /// AsyncMethodVariant (which is a MethodDelegator, not an EcmaMethod), but the IL body lives on the + /// underlying EcmaMethod. Since AsyncMethodVariant cannot be encoded as a MethodDef token, both + /// _ilMethod and _signatureMethod point to the same EcmaMethod, and the runtime side + /// (see GetILHeaderForStandaloneMetadata in readytorunstandalonemethodmetadata.cpp) handles the fact that + /// the decoded MethodDesc is marked as an async thunk whose MayHaveILHeader() returns false. + /// public class ILBodyFixupSignature : Signature, IEquatable { private readonly ReadyToRunFixupKind _fixupKind; + + /// The EcmaMethod whose IL body from metadata is hashed for the fixup validation. private readonly EcmaMethod _ilMethod; + + /// The method identity encoded in the fixup signature that the runtime decodes to locate the IL at its RVA. private readonly MethodDesc _signatureMethod; public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ilMethod, MethodDesc signatureMethod) diff --git a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp index d2edbe7edd91af..ef66cb0e986482 100644 --- a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp +++ b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp @@ -24,8 +24,15 @@ class ReadyToRunStandaloneMethodMetadataHelper { // For runtime-async methods with miAsync in metadata, the runtime marks the original // MethodDesc as a thunk (IsAsyncThunkMethod() == true, MayHaveILHeader() == false). - // However, the IL body check fixup needs to validate the original IL from metadata, - // which is still present at the method's RVA. Bypass MayHaveILHeader() for this case. + // However, the IL body is still present at the method's RVA in the PE — the "thunk" + // designation controls execution flow, not metadata layout. + // + // This method is called when the runtime resolves a CHECK_IL_BODY / VERIFY_IL_BODY + // fixup emitted by crossgen2's ILBodyFixupSignature. On the crossgen2 side, the fixup + // encodes the EcmaMethod (which has the IL) as the signatureMethod. At runtime, + // ZapSig::DecodeMethod resolves the MethodDef token back to the original MethodDesc, + // which is the async thunk. We need to read the IL from its RVA despite + // MayHaveILHeader() returning false. if (!pMD->MayHaveILHeader()) { _ASSERTE(pMD->IsAsyncThunkMethod()); From b6982ba26ec41ae624e35f37d0f8993cfe83f628 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Fri, 27 Mar 2026 13:43:31 -0700 Subject: [PATCH 15/18] Simplify: single GetModuleToken, add GetPrimaryMethodDesc assert The IL and signature methods always resolve to the same module token, so a single GetModuleToken suffices. Add Debug.Assert that signatureMethod.GetPrimaryMethodDesc() == ilMethod to enforce the invariant that both refer to the same underlying EcmaMethod. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ReadyToRun/ILBodyFixupSignature.cs | 22 ++++++------------- 1 file changed, 7 insertions(+), 15 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index f8cce6cb930c2c..223eee9a8e266a 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -13,6 +13,8 @@ using Internal.CorConstants; using Internal.JitInterface; +using ILCompiler.ReadyToRun.TypeSystem; + namespace ILCompiler.DependencyAnalysis.ReadyToRun { /// @@ -47,6 +49,7 @@ public class ILBodyFixupSignature : Signature, IEquatable public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ilMethod, MethodDesc signatureMethod) { Debug.Assert(signatureMethod.IsMethodDefinition); + Debug.Assert(signatureMethod.GetPrimaryMethodDesc() == ilMethod); _fixupKind = fixupKind; _ilMethod = ilMethod; _signatureMethod = signatureMethod; @@ -69,12 +72,11 @@ public static void NotifyComplete(NodeFactory factory, List Date: Fri, 27 Mar 2026 14:06:34 -0700 Subject: [PATCH 16/18] Undo changes to runtime --- .../vm/readytorunstandalonemethodmetadata.cpp | 24 +------------------ 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp index ef66cb0e986482..30802a7076915a 100644 --- a/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp +++ b/src/coreclr/vm/readytorunstandalonemethodmetadata.cpp @@ -20,32 +20,10 @@ class ReadyToRunStandaloneMethodMetadataHelper Module* pModule; IMDInternalImport* pMDImport; - static COR_ILMETHOD* GetILHeaderForStandaloneMetadata(MethodDesc *pMD) - { - // For runtime-async methods with miAsync in metadata, the runtime marks the original - // MethodDesc as a thunk (IsAsyncThunkMethod() == true, MayHaveILHeader() == false). - // However, the IL body is still present at the method's RVA in the PE — the "thunk" - // designation controls execution flow, not metadata layout. - // - // This method is called when the runtime resolves a CHECK_IL_BODY / VERIFY_IL_BODY - // fixup emitted by crossgen2's ILBodyFixupSignature. On the crossgen2 side, the fixup - // encodes the EcmaMethod (which has the IL) as the signatureMethod. At runtime, - // ZapSig::DecodeMethod resolves the MethodDef token back to the original MethodDesc, - // which is the async thunk. We need to read the IL from its RVA despite - // MayHaveILHeader() returning false. - if (!pMD->MayHaveILHeader()) - { - _ASSERTE(pMD->IsAsyncThunkMethod()); - _ASSERTE(pMD->GetRVA() != 0); - return PTR_COR_ILMETHOD(pMD->GetModule()->GetIL(pMD->GetRVA())); - } - return pMD->GetILHeader(); - } - public: ReadyToRunStandaloneMethodMetadataHelper(MethodDesc *pMD, SArray *pTypeRefTokenStreamInput) : - header(GetILHeaderForStandaloneMetadata(pMD), pMD->GetMDImport(), NULL), + header(pMD->GetILHeader(), pMD->GetMDImport(), NULL), currentILStreamIterator(0), pTypeRefTokenStream(pTypeRefTokenStreamInput), pModule(pMD->GetModule()), From 00578a28ba8a975743e5b161f7dcdc5543dabbf6 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Fri, 27 Mar 2026 14:07:12 -0700 Subject: [PATCH 17/18] Add SignatureMethod to ILBodyFixupSignature to control what method signature is created --- .../ReadyToRun/ILBodyFixupSignature.cs | 55 +++++++++---------- 1 file changed, 25 insertions(+), 30 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 223eee9a8e266a..45d3c2e0ecc7e9 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -21,18 +21,18 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun /// This fixup instructs the runtime to validate that the IL found at runtime matches the hash of the IL computed at compile time. /// /// - /// The fixup encodes two distinct pieces of information that may come from different methods: + /// The fixup encodes two distinct pieces of information: /// - /// _ilMethod (EcmaMethod): The source of the IL body from metadata, used to compute the standalone - /// metadata hash that the runtime will validate against. - /// _signatureMethod (MethodDesc): The method identity encoded in the fixup signature. The runtime - /// decodes this back to a MethodDesc via ZapSig::DecodeMethod and then reads the IL at that method's RVA - /// to compare against the hash. + /// The IL body hash, computed from the (the underlying EcmaMethod whose metadata + /// contains the IL). This is derived from _signatureMethod via GetPrimaryMethodDesc(). + /// The method identity (_signatureMethod), encoded in the fixup signature. The runtime decodes this + /// back to a MethodDesc via ZapSig::DecodeMethod and reads the IL at that method's RVA to compare against + /// the hash. /// - /// For most methods these are the same EcmaMethod. They differ for runtime-async methods: the JIT inlines an - /// AsyncMethodVariant (which is a MethodDelegator, not an EcmaMethod), but the IL body lives on the - /// underlying EcmaMethod. Since AsyncMethodVariant cannot be encoded as a MethodDef token, both - /// _ilMethod and _signatureMethod point to the same EcmaMethod, and the runtime side + /// For most methods, _signatureMethod is already the EcmaMethod. For runtime-async methods, the JIT inlines + /// an AsyncMethodVariant (a MethodDelegator, not an EcmaMethod), but the IL body lives on the + /// underlying EcmaMethod. Since AsyncMethodVariant cannot be encoded as a MethodDef token, + /// _signatureMethod is the EcmaMethod itself, and the runtime side /// (see GetILHeaderForStandaloneMetadata in readytorunstandalonemethodmetadata.cpp) handles the fact that /// the decoded MethodDesc is marked as an async thunk whose MayHaveILHeader() returns false. /// @@ -40,26 +40,20 @@ public class ILBodyFixupSignature : Signature, IEquatable { private readonly ReadyToRunFixupKind _fixupKind; - /// The EcmaMethod whose IL body from metadata is hashed for the fixup validation. - private readonly EcmaMethod _ilMethod; - /// The method identity encoded in the fixup signature that the runtime decodes to locate the IL at its RVA. private readonly MethodDesc _signatureMethod; - public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ilMethod, MethodDesc signatureMethod) + /// The underlying EcmaMethod whose IL body from metadata is hashed for the fixup validation. + private EcmaMethod ILMethod => (EcmaMethod)_signatureMethod.GetPrimaryMethodDesc(); + + public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, MethodDesc signatureMethod) { - Debug.Assert(signatureMethod.IsMethodDefinition); - Debug.Assert(signatureMethod.GetPrimaryMethodDesc() == ilMethod); + Debug.Assert(signatureMethod.IsTypicalMethodDefinition); + Debug.Assert(signatureMethod.GetPrimaryMethodDesc() is EcmaMethod); _fixupKind = fixupKind; - _ilMethod = ilMethod; _signatureMethod = signatureMethod; } - public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod ecmaMethod) - : this(fixupKind, ecmaMethod, ecmaMethod) - { - } - public override int ClassCode => 308579267; protected override void OnMarked(NodeFactory context) @@ -78,10 +72,11 @@ public static void NotifyComplete(NodeFactory factory, List object.ReferenceEquals(other, this); From 1ea7bc46ceb77a2b4d2512d517ada52e8fa37b21 Mon Sep 17 00:00:00 2001 From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:34:26 -0700 Subject: [PATCH 18/18] Allow CheckILBody fixup to encode non-Ecma method signatures In order to resolve the async method (which has a non-thunk IL body) from the CheckILBody fixup, separate out the signature MethodDesc from the IL providing MethodDesc inf ILBodyFixupSignature. The IL is retrieved for the EcmaMethod resolved from the _signatureMethod.GetPrimaryMethodDesc(), which is always an EcmaMethod for the TypicalMethodDefinitions allowed. At runtime, the correct method is resolved and the IL body is properly validated. --- .../ReadyToRun/ILBodyFixupSignature.cs | 19 ++++----- .../ReadyToRun/InliningInfoNode.cs | 40 +++++++++++-------- .../ReadyToRunCodegenNodeFactory.cs | 7 ++-- .../ReadyToRunSymbolNodeFactory.cs | 4 +- .../JitInterface/CorInfoImpl.ReadyToRun.cs | 12 +++--- 5 files changed, 45 insertions(+), 37 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs index 45d3c2e0ecc7e9..c6e8281e0d3613 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ILBodyFixupSignature.cs @@ -24,17 +24,13 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun /// The fixup encodes two distinct pieces of information: /// /// The IL body hash, computed from the (the underlying EcmaMethod whose metadata - /// contains the IL). This is derived from _signatureMethod via GetPrimaryMethodDesc(). - /// The method identity (_signatureMethod), encoded in the fixup signature. The runtime decodes this - /// back to a MethodDesc via ZapSig::DecodeMethod and reads the IL at that method's RVA to compare against + /// contains the IL). This is derived from _signatureMethod via GetPrimaryMethodDesc(). + /// The method identity (_signatureMethod), encoded in the fixup signature. The runtime decodes this + /// back to a MethodDesc via ZapSig::DecodeMethod and reads the IL at that method's RVA to compare against /// the hash. /// - /// For most methods, _signatureMethod is already the EcmaMethod. For runtime-async methods, the JIT inlines - /// an AsyncMethodVariant (a MethodDelegator, not an EcmaMethod), but the IL body lives on the - /// underlying EcmaMethod. Since AsyncMethodVariant cannot be encoded as a MethodDef token, - /// _signatureMethod is the EcmaMethod itself, and the runtime side - /// (see GetILHeaderForStandaloneMetadata in readytorunstandalonemethodmetadata.cpp) handles the fact that - /// the decoded MethodDesc is marked as an async thunk whose MayHaveILHeader() returns false. + /// For most methods, _signatureMethod is already the EcmaMethod. For runtime-async methods, the JIT inlines + /// an AsyncMethodVariant. The EcmaMethod for AsyncMethodVariant can be retrieved with GetPrimaryMethodDesc(). /// public class ILBodyFixupSignature : Signature, IEquatable { @@ -49,6 +45,7 @@ public class ILBodyFixupSignature : Signature, IEquatable public ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, MethodDesc signatureMethod) { Debug.Assert(signatureMethod.IsTypicalMethodDefinition); + Debug.Assert(!signatureMethod.IsCompilerGeneratedILBodyForAsync()); Debug.Assert(signatureMethod.GetPrimaryMethodDesc() is EcmaMethod); _fixupKind = fixupKind; _signatureMethod = signatureMethod; @@ -127,12 +124,12 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - return comparer.Compare(ILMethod, otherNode.ILMethod); + return comparer.Compare(_signatureMethod, otherNode._signatureMethod); } public override string ToString() { - return $"ILBodyFixupSignature {_fixupKind} {ILMethod}"; + return $"ILBodyFixupSignature {_fixupKind} {_signatureMethod}"; } public bool Equals(ILBodyFixupSignature other) => object.ReferenceEquals(other, this); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs index e9a76a74d8a8dc..ab07c61ce11c58 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs @@ -60,7 +60,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) if (relocsOnly) return new ObjectData(Array.Empty(), Array.Empty(), 1, new ISymbolDefinitionNode[] { this }); - Dictionary> inlineeToInliners = new Dictionary>(); + Dictionary> inlineeToInliners = new Dictionary>(); // Build a map from inlinee to the list of inliners // We are only interested in the generic definitions of these. @@ -88,7 +88,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) foreach (MethodDesc inlinee in inlinees) { MethodDesc inlineeDefinition = inlinee.GetTypicalMethodDefinition(); - if (!(inlineeDefinition is EcmaMethod ecmaInlineeDefinition)) + if (!(inlineeDefinition is EcmaMethod or AsyncMethodVariant)) { // We don't record non-ECMA methods because they don't have tokens that // diagnostic tools could reason about anyway. @@ -109,7 +109,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { if (!inlinerReportAllVersionsWithInlinee) { - // We'll won't report this method + // We won't report this method continue; } } @@ -118,17 +118,17 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) Debug.Assert(factory.CompilationModuleGroup.CrossModuleInlineable(inlineeDefinition)); if (_inlineInfoType != InfoType.CrossModuleInliningForCrossModuleDataOnly) { - // We'll won't report this method + // We won't report this method continue; } } - if (!inlineeToInliners.TryGetValue(ecmaInlineeDefinition, out HashSet inliners)) + if (!inlineeToInliners.TryGetValue(inlineeDefinition, out HashSet inliners)) { - inliners = new HashSet(); - inlineeToInliners.Add(ecmaInlineeDefinition, inliners); + inliners = new HashSet(); + inlineeToInliners.Add(inlineeDefinition, inliners); } - inliners.Add((EcmaMethod)inlinerDefinition); + inliners.Add(inlinerDefinition); } } @@ -141,8 +141,9 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) foreach (var inlineeWithInliners in inlineeToInliners) { - EcmaMethod inlinee = inlineeWithInliners.Key; - int inlineeRid = MetadataTokens.GetRowNumber(inlinee.Handle); + MethodDesc inlinee = inlineeWithInliners.Key; + EcmaMethod ecmaInlinee = (EcmaMethod)inlinee.GetPrimaryMethodDesc(); + int inlineeRid = MetadataTokens.GetRowNumber(ecmaInlinee.Handle); int hashCode; if (AllowCrossModuleInlines) @@ -153,7 +154,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) else { // InliningInfo2 format - hashCode = VersionResilientHashCode.ModuleNameHashCode(inlinee.Module); + hashCode = VersionResilientHashCode.ModuleNameHashCode(ecmaInlinee.Module); hashCode ^= inlineeRid; } @@ -168,14 +169,19 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) // Followed by inliner RIDs deltas with flag in the lowest bit // - if flag is set, followed by module ID Debug.Assert(_module != null); - bool isForeignInlinee = inlinee.Module != _module; + bool isForeignInlinee = ecmaInlinee.Module != _module; sig.Append(new UnsignedConstant((uint)(inlineeRid << 1 | (isForeignInlinee ? 1 : 0)))); if (isForeignInlinee) { - sig.Append(new UnsignedConstant((uint)factory.ManifestMetadataTable.ModuleToIndex(inlinee.Module))); + sig.Append(new UnsignedConstant((uint)factory.ManifestMetadataTable.ModuleToIndex(ecmaInlinee.Module))); } - List sortedInliners = new List(inlineeWithInliners.Value); + // We're only concerned with metadata here, so we can convert all to EcmaMethod and lose info about AsyncVariant vs Task-Returning + List sortedInliners = new List(inlineeWithInliners.Value.Count); + foreach (var inliner in inlineeWithInliners.Value) + { + sortedInliners.Add((EcmaMethod)inliner.GetPrimaryMethodDesc()); + } sortedInliners.MergeSort((a, b) => { if (a == b) @@ -297,7 +303,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) } else { - indexOfInlinee = (uint)MetadataTokens.GetRowNumber(inlinee.Handle); + indexOfInlinee = (uint)MetadataTokens.GetRowNumber(ecmaInlinee.Handle); } encodedInlinee = indexOfInlinee << (int)ReadyToRunCrossModuleInlineFlags.CrossModuleInlinerIndexShift; @@ -310,7 +316,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) sig.Append(new UnsignedConstant(encodedInlinee)); if (crossModuleMultiModuleFormat && !isCrossModuleInlinee) - sig.Append(new UnsignedConstant((uint)factory.ManifestMetadataTable.ModuleToIndex(inlinee.Module))); + sig.Append(new UnsignedConstant((uint)factory.ManifestMetadataTable.ModuleToIndex(ecmaInlinee.Module))); int inlinerIndex = 0; if (crossModuleInlinerCount > 0) @@ -334,7 +340,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) uint inlinerRid = (uint)MetadataTokens.GetRowNumber(inliner.Handle); uint ridDelta = inlinerRid - baseRid; baseRid = inlinerRid; - bool isForeignInliner = inliner.Module != inlinee.Module; + bool isForeignInliner = inliner.Module != ecmaInlinee.Module; Debug.Assert(!isForeignInliner || crossModuleMultiModuleFormat); if (crossModuleMultiModuleFormat) diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs index 88278fc10f707f..6e0d6535e341c5 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs @@ -644,11 +644,12 @@ public VirtualResolutionFixupSignature VirtualResolutionFixupSignature(ReadyToRu private struct ILBodyFixupSignatureFixupKey : IEquatable { public readonly ReadyToRunFixupKind FixupKind; - public readonly EcmaMethod Method; + public readonly MethodDesc Method; - public ILBodyFixupSignatureFixupKey(ReadyToRunFixupKind fixupKind, EcmaMethod method) + public ILBodyFixupSignatureFixupKey(ReadyToRunFixupKind fixupKind, MethodDesc method) { FixupKind = fixupKind; + Debug.Assert(method.IsTypicalMethodDefinition); Method = method; } public bool Equals(ILBodyFixupSignatureFixupKey other) => FixupKind == other.FixupKind && Method.Equals(other.Method); @@ -660,7 +661,7 @@ public ILBodyFixupSignatureFixupKey(ReadyToRunFixupKind fixupKind, EcmaMethod me private NodeCache _ilBodySignatures = new NodeCache((key) => new ILBodyFixupSignature(key.FixupKind, key.Method)); - public ILBodyFixupSignature ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, EcmaMethod method) + public ILBodyFixupSignature ILBodyFixupSignature(ReadyToRunFixupKind fixupKind, MethodDesc method) { return _ilBodySignatures.GetOrAdd(new ILBodyFixupSignatureFixupKey(fixupKind, method)); } diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs index 4cf1f416a2a2ce..56afd326b88b95 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs @@ -9,6 +9,7 @@ using Internal.TypeSystem.Ecma; using Internal.ReadyToRunConstants; using Internal.Text; +using System.Diagnostics; namespace ILCompiler.DependencyAnalysis { @@ -507,8 +508,9 @@ public Import CheckVirtualFunctionOverride(MethodWithToken declMethod, TypeDesc } private NodeCache _ilBodyFixupsCache; - public Import CheckILBodyFixupSignature(EcmaMethod method) + public Import CheckILBodyFixupSignature(MethodDesc method) { + Debug.Assert(method.IsTypicalMethodDefinition); return _ilBodyFixupsCache.GetOrAdd(_codegenNodeFactory.ILBodyFixupSignature( _verifyTypeAndFieldLayout ? ReadyToRunFixupKind.Verify_IL_Body : ReadyToRunFixupKind.Check_IL_Body, method)); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 3cae5a603ebf6e..0be908211636f7 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -816,13 +816,15 @@ public void CompileMethod(MethodWithGCInfo methodCodeNodeNeedingCode, Logger log return; } - if (MethodBeingCompiled.GetTypicalMethodDefinition() is EcmaMethod ecmaMethod) + var typicalDef = MethodBeingCompiled.GetTypicalMethodDefinition(); + if (typicalDef is EcmaMethod or AsyncMethodVariant) { - if ((methodIL.GetMethodILScopeDefinition() is IEcmaMethodIL && _compilation.SymbolNodeFactory.VerifyTypeAndFieldLayout && ecmaMethod.Module == ecmaMethod.Context.SystemModule) || + var ecmaMethod = (EcmaMethod)typicalDef.GetPrimaryMethodDesc(); + if ((methodIL.GetMethodILScopeDefinition() is IEcmaMethodIL && _compilation.SymbolNodeFactory.VerifyTypeAndFieldLayout && ecmaMethod.Module == typicalDef.Context.SystemModule) || (!_compilation.NodeFactory.CompilationModuleGroup.VersionsWithMethodBody(MethodBeingCompiled) && _compilation.NodeFactory.CompilationModuleGroup.CrossModuleInlineable(MethodBeingCompiled))) { - ISymbolNode ilBodyNode = _compilation.SymbolNodeFactory.CheckILBodyFixupSignature((EcmaMethod)MethodBeingCompiled.GetTypicalMethodDefinition()); + ISymbolNode ilBodyNode = _compilation.SymbolNodeFactory.CheckILBodyFixupSignature(typicalDef); AddPrecodeFixup(ilBodyNode); } @@ -846,7 +848,7 @@ public void CompileMethod(MethodWithGCInfo methodCodeNodeNeedingCode, Logger log else { _ilBodiesNeeded = _ilBodiesNeeded ?? new List(); - _ilBodiesNeeded.Add(ecmaMethod); + _ilBodiesNeeded.Add(typicalDef); } } } @@ -3355,7 +3357,7 @@ private void reportInliningDecision(CORINFO_METHOD_STRUCT_* inlinerHnd, CORINFO_ // or if we are working with a full cross module inline // The CheckILBodyFixupSignature will use the exact IL in metadata, not what is used by the ReadyToRunILProvider, // which can be different for runtime-async methods (the ILProvider returns the Task-returning thunk for runtime-async EcmaMethods). - ISymbolNode ilBodyNode = _compilation.SymbolNodeFactory.CheckILBodyFixupSignature(ecmaMethod); + ISymbolNode ilBodyNode = _compilation.SymbolNodeFactory.CheckILBodyFixupSignature(typicalMethod); AddPrecodeFixup(ilBodyNode); }