Mono.Debugging.Win32 Do not pass direct handle to because it may be invalidated after func-eval. Pass initial reference instead, adapter will automatically extract array value

Find IL offset of `await` instruction in `IAsyncStateMachine.MoveNext` method corresponding particular state of state machine

current state stepping info for method IL code of method

Raised when debugger has registered itself for debugging and process id is available: When attach Process Id available right away for .NET(including .NET Core) and .NET Framework When running under debugger on .NetFramework the process id is available once the process is created and its main thread is created (no user's (.NET and native) code hasn't been yet executed) .NET(including .NET Core) the process id is available once the runtime is loaded into the process

Assigns the newly-created , without even Initialize called.

Similar code exists in CorInterpreterContext::CopyValueFromMemory(long address, IMetadataType substitutedType)

Says JIT to recompiled(if the function is already compiled)/compile(if it's not) with disabled optimisations on the next function call

If we stay in a function the function won't recompiled right after this method is called, it will be recompiled on the next the function call

Unwrap real type in the case when the type is REF or PTR

Don't just use , because we must find a CorLib that is not a facade assembly.

True, if assembly is a CorLib assembly and it is not a facade assembly

Use for any calls to ICorDebug Manages of evaluation start, abort, handles cross thread dependency notifications

Make any runtime call using

finds generic substitutions if owner contains generic parameters

Get a stepper for thread with JustMyCode = false as a default

Explicit, if set; from executable command, if possible; TEMP otherwise. Never NULL/empty.

Provides intervals when target process is stopped and debugger does it's processing

Provides intervals when target process is stopped and debugger does it's processing

Provides intervals of evaluation

Provides intervals of evaluation

Collects all referenced assemblies walking by type members

When we recompile class for dfa, we have to replace new types/methods/properties/fields/events, etc. in new instructions with original ones. Because in the recompiled assembly methods that are called from method we stay in have been stripped out and have "throw null" body, so can't be interpreted without replacement. These utils provide ability to determine which new members we should replace with original ones. It also covers compiler-generated methods replacement

Next delta version

For DFA we have to handle variables original and recompiled variables mismatch It matches original and recompiled variables indexes and raise an exception when the interpreter needs a variable (extra variable) which doesn't exist on original frame and hasn't been written yet

Holder for

Do not add runtime executable to the command line, assume it's already there.

false -- only result the frontend suspend context true -- also terminate paused context and cancel all ongoing operations

Debugger can send a lot of different stop events (managed symbol breakpoint, managed data breakpoint, managed exception thrown, managed step completion, etc.) this method is called for every stop event that is going to be sent to IDEA.

false - if we haven't set a breakpoint at the address

We need this call to ensure that the continue events we received which were not requested by Idea weren't mistakenly sent to Idea when it requests the last continue event By this method call originating from ContinueDebugEventLLDBCommand::Execute we ensure that `SendSessionContinue` will wait for the last continue event

We need it only to create an exception event on an unmanaged thread (unmanaged threads are not represented as ICorDebugThread) For managed threads we use a function above(which takes ICorDebugThread instead of a thread id)

When CLR is stopped by EXCEPTION_CALLBACK it doesn't return a correct thread context of the top frame It should be a context of the dotnet frame where the exception was thrown. Instead, stack walker returns a context of WaitForSingleObject call (from a real windows frame) We fix it by skipping such frames until we walk to the dotnet frame where the exception was thrown

This method step restores an original instruction instead of `int3`, moves the instruction pointer `int3` size back and clears the exception breakpoint. So we can say it masks the breakpoint as if it has never been hit

LLDB sends either or depending on the debuggee architecture.

LLDB can walk native frames, but has troubles when walking managed jitted frames We use the same approach as in VS debugger, refer to ICorDebug for dotnet frames

LLDB can walk native frames, but has troubles when walking managed jitted frames We use the same approach as in VS debugger, refer to ICorDebug for dotnet frames

If the event was sent to lldb

Native threads may start to call managed code and from that moment will be trackable by ICorDebug, so we have to refresh our list of native threads Additionally, we just need to remove created by dotnet threads since we save handles of all threads

Encapsulates all state and situations when we have to suspend/resume native threads via Windows API

Encapsulates all state and situations when we have to suspend/resume native threads via Windows API

Suspends all threads except myThreadsToKeepResumed NOTE: Threads listed in myThreadsToResume will not be resumed via `ResumeThread` API. We rely on the fact that ICorDebug will resume them from ICorDebugProcess::Continue call

Return absolute path or null

Receives events from runtime and delegates them to on the main thread

x64

x64

Use the method only if you are not able to determine a method address in the target memory, if you are able to use please