• 홈
• Mono
• Debugger
• Backend
• SingleSteppingEngine

C# 클래스 Mono.Debugger.Backend.SingleSteppingEngine

파일 보기 프로젝트 열기: baulig/debugger 1 사용 예제들

보호된 프로퍼티들

프로퍼티	타입	설명
current_backtrace	Backtrace
current_frame	System.Diagnostics.StackFrame
current_method	Method
registers	Registers

Private Properties

프로퍼티	타입	설명
AbortInvocation	void
AbortRuntimeInvoke	OperationRuntimeInvoke
AcquireThreadLock	void
ActivatePendingBreakpoints	bool
CreateStepFrame	StepFrame
CreateStepFrame	StepFrame
DetachThread	void
DoTargetAccess	object
GetCallbackFrame	Inferior.CallbackFrame
GetRuntimeInvokedFunction	Mono.Debugger.Languages.TargetFunctionType
InitializeBreakpoints	bool
InsertBreakpoint	void
Invoke	object
Old_Step	ThreadCommandResult
OnExecd	CommandResult
OnManagedCallback	bool
OnManagedThreadCreated	void
OnManagedThreadExited	void
OnModuleLoaded	bool
OnThreadExited	void
ProcessOperation	CommandResult
ReleaseThreadLock	void
ReleaseThreadLock	void
RemoveBreakpoint	void
ResumeUserThread	void
SendCommand	object
SetMainReturnAddress	void
SetManagedThreadData	void
SetTID	void
StartOperation	CommandResult
SuspendUserThread	void
check_method_operation	System.Operation
check_runtime_version	bool
child_breakpoint	bool
compute_frame	System.Diagnostics.StackFrame
frame_changed	System.Operation
handle_exception	bool
is_in_step_frame	bool
is_managed_frame	bool
lookup_breakpoint	Breakpoint
save_stack	StackData
step_over_breakpoint	bool
throw_exception	ExceptionAction

공개 메소드들

메소드	설명
CallMethod ( TargetAddress method, TargetAddress method_arg, TargetObject object_arg ) : CommandResult
CallMethod ( TargetAddress method, long arg1, long arg2 ) : CommandResult
CallMethod ( TargetAddress method, long arg1, long arg2, long arg3, string string_argument ) : CommandResult
Detach ( ) : void
DisassembleInstruction ( Method method, TargetAddress address ) : AssemblerLine
DisassembleMethod ( Method method ) : AssemblerMethod
GetBacktrace ( Backtrace mode, int max_frames ) : Backtrace
GetInstructionSize ( TargetAddress address ) : int
GetMemoryMaps ( ) : TargetMemoryArea[]
GetRegisters ( ) : Registers
Kill ( ) : void
Lookup ( TargetAddress address ) : Method
ManagedCallback ( ManagedCallbackFunction func, CommandResult result ) : bool
PrintObject ( Style style, TargetObject obj, DisplayFormat format ) : string
PrintType ( Style style, TargetType type ) : string
ProcessEvent ( Inferior cevent ) : bool
ProcessEvent ( int status ) : void	This is called from the SingleSteppingEngine's main event loop to give us the next event - `status' has no meaning to us, it's just meant to be passed to inferior.ProcessEvent() to get the actual event. Actually, `status' is the waitpid() status code. In Linux 2.6.x, you can call waitpid() from any thread in the debugger, but we need to get the target's registers to find out whether it's a breakpoint etc. That's done in inferior.ProcessEvent() - which must always be called from the engine's thread.
ReadAddress ( TargetAddress address ) : TargetAddress
ReadBuffer ( TargetAddress address, int size ) : byte[]
ReadByte ( TargetAddress address ) : byte
ReadInteger ( TargetAddress address ) : int
ReadLongInteger ( TargetAddress address ) : long
ReadMemory ( TargetAddress address, int size ) : TargetBlob
ReadString ( TargetAddress address ) : string
Return ( ReturnMode mode ) : CommandResult
RuntimeInvoke ( TargetFunctionType function, TargetStructObject object_argument, TargetObject param_objects, RuntimeInvokeFlags flags, RuntimeInvokeResult result ) : void
SetKilledFlag ( ) : void
SetRegisters ( Registers registers ) : void
SimpleLookup ( TargetAddress address, bool exact_match ) : Symbol
SingleSteppingEngine ( ThreadManager manager, Process process, Inferior inferior, int pid ) : System
SingleSteppingEngine ( ThreadManager manager, Process process, ProcessStart start ) : System
StartApplication ( CommandResult result ) : CommandResult
StartExecedChild ( CommandResult result ) : CommandResult
StartForkedChild ( CommandResult result ) : CommandResult
StartSuspended ( ) : void
StartThread ( CommandResult result ) : CommandResult
Step ( ThreadingModel model, StepMode mode, StepFrame frame ) : CommandResult
Stop ( ) : void
ToString ( ) : string
WriteAddress ( TargetAddress address, TargetAddress value ) : void
WriteBuffer ( TargetAddress address, byte buffer ) : void
WriteByte ( TargetAddress address, byte value ) : void
WriteInteger ( TargetAddress address, int value ) : void
WriteLongInteger ( TargetAddress address, long value ) : void

보호된 메소드들

메소드	설명
CheckTrampoline ( Instruction instruction, TrampolineHandler handler ) : bool
DoAbortInvocation ( long rti_id ) : void
DoDetach ( ) : void
DoDispose ( ) : void
DoProcessEvent ( Inferior cevent ) : void
ExecuteOperation ( System.Operation operation ) : void
MethodHasSource ( Method method ) : bool
OperationCompleted ( TargetEventArgs args ) : void
OperationCompleted ( TargetEventArgs args, bool suspended ) : void
OperationInterrupted ( ) : void
ProcessOperationEvent ( Inferior cevent ) : void
PushOperation ( System.Operation operation ) : void
PushOperationNoExec ( System.Operation operation ) : void
SingleSteppingEngine ( ThreadManager manager, Process process ) : System
StartOperation ( ) : void	Start a new stepping operation. All stepping operations are done asynchronously. The inferior basically just knows two kinds of stepping operations: there is do_continue() to continue execution (until a breakpoint is hit or the target receives a signal or exits) and there is do_step_native() to single-step one machine instruction. There's also a version of do_continue() which takes an address - it inserts a temporary breakpoint on that address and calls do_continue(). Let's call these "atomic operations" while a "stepping operation" is something like stepping until the next source line. We normally need to do several atomic operations for each stepping operation. We start a new stepping operation here, but what we actually do is starting an atomic operation on the target. Note that we just start it, but don't wait until is completed. Once the target is running, we go back to the main event loop and wait for it (or another thread) to stop (or to get another command from the user).
check_inferior ( ) : void
disable_extended_notification ( NotificationType type ) : void
do_continue ( ) : void	Resume the target.
do_continue ( TargetAddress until ) : void
do_next ( ) : void	Step over the next machine instruction.
do_step ( ) : void
do_step_native ( ) : void
enable_extended_notification ( NotificationType type ) : void
enforce_managed_context ( ) : void
frames_invalid ( ) : void
insert_lmf_breakpoint ( TargetAddress lmf_address ) : void
insert_temporary_breakpoint ( TargetAddress address ) : void
remove_lmf_breakpoint ( ) : void
remove_temporary_breakpoint ( ) : void
request_managed_callback ( ManagedCallbackData data ) : void
restore_stack ( StackData stack ) : void
set_registers ( Registers registers ) : void
update_current_frame ( StackFrame new_frame ) : void

비공개 메소드들

메소드	설명
AbortInvocation ( long rti_id ) : void
AbortRuntimeInvoke ( long rti_id ) : OperationRuntimeInvoke
AcquireThreadLock ( ) : void	Interrupt any currently running stepping operation, but don't send any notifications to the caller. The currently running operation is automatically resumed when ReleaseThreadLock() is called.
ActivatePendingBreakpoints ( Module module ) : bool
CreateStepFrame ( ) : StepFrame	Create a step frame to step until the next source line.
CreateStepFrame ( StepMode mode ) : StepFrame	Create a step frame for a native stepping operation.
DetachThread ( ) : void
DoTargetAccess ( TargetAccessHandler func ) : object
GetCallbackFrame ( TargetAddress stack_pointer, bool exact_match ) : Inferior.CallbackFrame
GetRuntimeInvokedFunction ( long ID ) : TargetFunctionType
InitializeBreakpoints ( ) : bool
InsertBreakpoint ( BreakpointHandle handle, TargetAddress address, int domain ) : void
Invoke ( TargetAccessDelegate func, object data ) : object
Old_Step ( StepMode mode, StepFrame frame ) : ThreadCommandResult
OnExecd ( SingleSteppingEngine new_engine ) : CommandResult
OnManagedCallback ( Queue callbacks ) : bool
OnManagedThreadCreated ( TargetAddress end_stack_address ) : void
OnManagedThreadExited ( ) : void
OnModuleLoaded ( Module module ) : bool
OnThreadExited ( Inferior cevent ) : void
ProcessOperation ( System.Operation operation ) : CommandResult
ReleaseThreadLock ( ) : void
ReleaseThreadLock ( Inferior cevent ) : void
RemoveBreakpoint ( BreakpointHandle handle ) : void
ResumeUserThread ( CommandResult result ) : void
SendCommand ( TargetAccessDelegate target ) : object
SetMainReturnAddress ( TargetAddress main_ret ) : void
SetManagedThreadData ( TargetAddress lmf_address, TargetAddress extended_notifications_addr ) : void
SetTID ( long tid ) : void
StartOperation ( System.Operation operation ) : CommandResult
SuspendUserThread ( ) : void
check_method_operation ( TargetAddress address, Method method, SourceAddress source, System.Operation operation ) : System.Operation	Checks whether to do a "method operation". This is only used while doing a source stepping operation and ensures that we don't stop somewhere inside a method's prologue code or between two source lines.
check_runtime_version ( int major, int minor ) : bool
child_breakpoint ( Inferior cevent, int index, Breakpoint &bpt ) : bool	A breakpoint has been hit; now the sse needs to find out what do do: either ignore the breakpoint and continue or keep the target stopped and send out the notification. If @index is zero, we hit an "unknown" breakpoint - ie. a breakpoint which we did not create. Normally, this means that there is a breakpoint instruction (such as G_BREAKPOINT ()) in the code. Such unknown breakpoints are handled by the Debugger; one of the language backends may recognize the breakpoint's address, for instance if this is the JIT's breakpoint trampoline. Returns true if the target should remain stopped and false to continue stepping. If we can't find a handler for the breakpoint, the default is to stop the target and let the user decide what to do.
compute_frame ( TargetAddress address ) : StackFrame
frame_changed ( TargetAddress address, System.Operation operation ) : System.Operation	This is called when a stepping operation is completed or something unexpected happened (received signal etc.). Normally, we just compute the new StackFrame here, but we may also discover that we need to do one more stepping operation, see check_method_operation().
handle_exception ( TargetAddress stack, TargetAddress exc, TargetAddress ip ) : bool
is_in_step_frame ( StepFrame frame, TargetAddress address ) : bool	Check whether @address is inside @frame.
is_managed_frame ( ) : bool
lookup_breakpoint ( int index ) : Breakpoint
save_stack ( long id ) : StackData
step_over_breakpoint ( bool singlestep, TargetAddress until ) : bool
throw_exception ( TargetAddress stack, TargetAddress exc, TargetAddress ip ) : ExceptionAction

메소드 상세

프로퍼티 상세