internal void ChildExecd(SingleSteppingEngine engine, Inferior inferior)
{
is_execed = true;
if (!is_forked) {
if (mono_language != null)
mono_language.Dispose();
if (native_language != null)
native_language.Dispose ();
if (os != null)
os.Dispose ();
if (symtab_manager != null)
symtab_manager.Dispose ();
}
if (breakpoint_manager != null)
breakpoint_manager.Dispose ();
session.OnProcessExecd (this);
breakpoint_manager = new BreakpointManager ();
exception_handlers = new Dictionary<int,ExceptionCatchPoint> ();
symtab_manager = new SymbolTableManager (session);
os = Inferior.CreateOperatingSystemBackend (this);
native_language = new NativeLanguage (this, os, target_info);
Inferior new_inferior = Inferior.CreateInferior (manager, this, start);
try {
new_inferior.InitializeAfterExec (inferior.PID);
} catch (Exception ex) {
if ((ex is TargetException) && (((TargetException) ex).Type == TargetError.PermissionDenied)) {
Report.Error ("Permission denied when trying to debug exec()ed child {0}, detaching!",
inferior.PID);
} else {
Report.Error ("InitializeAfterExec() failed on pid {0}: {1}", inferior.PID, ex);
}
new_inferior.DetachAfterFork ();
return;
}
SingleSteppingEngine new_thread = new SingleSteppingEngine (
manager, this, new_inferior, inferior.PID);
ThreadServant[] threads;
lock (thread_hash.SyncRoot) {
threads = new ThreadServant [thread_hash.Count];
thread_hash.Values.CopyTo (threads, 0);
}
for (int i = 0; i < threads.Length; i++) {
if (threads [i].PID != inferior.PID)
threads [i].Kill ();
}
thread_hash [inferior.PID] = new_thread;
inferior.Dispose ();
inferior = null;
manager.Debugger.OnProcessExecdEvent (this);
manager.Debugger.OnThreadCreatedEvent (new_thread.Thread);
initialized = is_forked = false;
main_thread = new_thread;
if ((engine.Thread.ThreadFlags & Thread.Flags.StopOnExit) != 0)
new_thread.Thread.ThreadFlags |= Thread.Flags.StopOnExit;
CommandResult result = engine.OnExecd (new_thread);
new_thread.StartExecedChild (result);
}
internal void OnManagedThreadExitedEvent(ThreadServant thread)
{
thread_hash.Remove (thread.PID);
}
void OnThreadCreatedEvent(ThreadServant thread)
{
thread_hash.Add (thread.PID, thread);
manager.Debugger.OnThreadCreatedEvent (thread.Client);
}
public Thread[] GetThreads()
{
lock (thread_hash.SyncRoot) {
int count = thread_hash.Count;
Thread[] threads = new Thread [count];
ThreadServant[] servants = new ThreadServant [count];
thread_hash.Values.CopyTo (servants, 0);
for (int i = 0; i < count; i++)
threads [i] = servants [i].Client;
return threads;
}
}
internal override StackFrame GetLMF(ThreadServant thread, TargetMemoryAccess memory, ref TargetAddress lmf_address)
{
TargetAddress lmf = lmf_address;
TargetBinaryReader reader = memory.ReadMemory (lmf_address, 88).GetReader ();
lmf_address = reader.ReadTargetAddress (); // prev
reader.ReadTargetAddress ();
reader.ReadTargetAddress (); // method
TargetAddress rip = reader.ReadTargetAddress ();
if (lmf_address.IsNull)
return null;
TargetAddress rbx = reader.ReadTargetAddress ();
TargetAddress rbp = reader.ReadTargetAddress ();
TargetAddress rsp = reader.ReadTargetAddress ();
TargetAddress r12 = reader.ReadTargetAddress ();
TargetAddress r13 = reader.ReadTargetAddress ();
TargetAddress r14 = reader.ReadTargetAddress ();
TargetAddress r15 = reader.ReadTargetAddress ();
Registers regs = new Registers (this);
if ((lmf_address.Address & 1) == 0) {
rip = memory.ReadAddress (rsp - 8);
regs [(int) X86_Register.RIP].SetValue (rsp - 8, rip);
regs [(int) X86_Register.RBP].SetValue (lmf + 40, rbp);
} else {
TargetAddress new_rbp = memory.ReadAddress (rbp);
regs [(int) X86_Register.RIP].SetValue (lmf + 24, rip);
regs [(int) X86_Register.RBP].SetValue (rbp, new_rbp);
rbp = new_rbp;
lmf_address--;
}
regs [(int) X86_Register.RBX].SetValue (lmf + 32, rbx);
regs [(int) X86_Register.RSP].SetValue (lmf + 48, rsp);
regs [(int) X86_Register.R12].SetValue (lmf + 56, r12);
regs [(int) X86_Register.R13].SetValue (lmf + 64, r13);
regs [(int) X86_Register.R14].SetValue (lmf + 72, r14);
regs [(int) X86_Register.R15].SetValue (lmf + 80, r15);
return CreateFrame (thread.Client, FrameType.LMF, memory, rip, rsp, rbp, regs);
}
internal abstract StackFrame GetLMF(ThreadServant thread, TargetMemoryAccess target,
ref TargetAddress lmf_address);
void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (disposed)
return;
disposed = true;
// If this is a call to Dispose, dispose all managed resources.
if (disposing) {
if (servant != null) {
servant.Dispose ();
servant = null;
}
}
}
internal override StackFrame GetLMF(ThreadServant thread, TargetMemoryAccess memory,
ref TargetAddress lmf_address)
{
TargetAddress lmf = lmf_address;
TargetBinaryReader reader = memory.ReadMemory (lmf, 36).GetReader ();
lmf_address = reader.ReadTargetAddress (); // prev
reader.Position = 16;
TargetAddress ebx = reader.ReadTargetAddress ();
TargetAddress edi = reader.ReadTargetAddress ();
TargetAddress esi = reader.ReadTargetAddress ();
TargetAddress ebp = reader.ReadTargetAddress ();
TargetAddress eip = reader.ReadTargetAddress ();
Registers regs = new Registers (this);
regs [(int) X86_Register.RBX].SetValue (lmf + 16, ebx);
regs [(int) X86_Register.RDI].SetValue (lmf + 20, edi);
regs [(int) X86_Register.RSI].SetValue (lmf + 24, esi);
regs [(int) X86_Register.RBP].SetValue (lmf + 28, ebp);
regs [(int) X86_Register.RIP].SetValue (lmf + 32, eip);
TargetAddress new_ebp = memory.ReadAddress (ebp);
regs [(int) X86_Register.RBP].SetValue (ebp, new_ebp);
TargetAddress new_esp = ebp + 8;
regs [(int) X86_Register.RSP].SetValue (ebp, new_esp);
return CreateFrame (thread.Client, FrameType.LMF, memory, eip, new_esp, new_ebp, regs);
}
private StackFrame TryLMF(ThreadServant thread, TargetMemoryAccess memory)
{
try {
if (lmf_address.IsNull)
return null;
StackFrame new_frame = thread.Architecture.GetLMF (thread, memory, ref lmf_address);
if (new_frame == null)
return null;
// Sanity check; don't loop.
if (new_frame.StackPointer <= last_frame.StackPointer)
return null;
return new_frame;
} catch (TargetException) {
return null;
}
}
internal Thread(ThreadServant servant, int id)
{
this.id = id;
this.servant = servant;
this.flags = Flags.AutoRun;
}
private bool TryCallback(ThreadServant thread, TargetMemoryAccess memory,
ref StackFrame frame, bool exact_match)
{
try {
if (frame == null)
return false;
Inferior.CallbackFrame callback = thread.GetCallbackFrame (
frame.StackPointer, exact_match);
if (callback == null)
return false;
frame = thread.Architecture.CreateFrame (
thread.Client, FrameType.Normal, memory, callback.Registers);
FrameType callback_type;
string frame_name = "<method called from mdb>";
if (callback.IsRuntimeInvokeFrame) {
callback_type = FrameType.RuntimeInvoke;
TargetFunctionType func = thread.GetRuntimeInvokedFunction (callback.ID);
if (func != null)
frame_name = String.Format ("<Invocation of: {0}>", func.FullName);
} else {
callback_type = FrameType.Callback;
}
AddFrame (new StackFrame (
thread.Client, callback_type, callback.CallAddress, callback.StackPointer,
TargetAddress.Null, callback.Registers, thread.NativeLanguage,
new Symbol (frame_name, callback.CallAddress, 0)));
return true;
} catch (TargetException) {
return false;
}
}
internal bool TryUnwind(ThreadServant thread, TargetMemoryAccess memory,
Mode mode, TargetAddress until)
{
StackFrame new_frame = null;
try {
new_frame = last_frame.UnwindStack (memory);
} catch (TargetException) {
}
if (!TryCallback (thread, memory, ref new_frame, true)) {
if ((new_frame == null) || !IsFrameOkForMode (new_frame, mode)) {
if (!tried_lmf) {
tried_lmf = true;
if (thread.LMFAddress.IsNull)
return false;
lmf_address = memory.ReadAddress (thread.LMFAddress);
}
if (!lmf_address.IsNull)
new_frame = TryLMF (thread, memory);
else
return false;
}
}
if (new_frame == null)
return false;
// Sanity check; don't loop.
if (new_frame.StackPointer <= last_frame.StackPointer)
return false;
if (!until.IsNull && (new_frame.StackPointer >= until))
return false;
AddFrame (new_frame);
return true;
}
internal void GetBacktrace(ThreadServant thread, TargetMemoryAccess memory,
Mode mode, TargetAddress until, int max_frames)
{
while (TryUnwind (thread, memory, mode, until)) {
if ((max_frames != -1) && (frames.Count > max_frames))
break;
}
// Ugly hack: in Mode == Mode.Default, we accept wrappers but not as the
// last frame.
if ((mode == Mode.Default) && (frames.Count > 1)) {
StackFrame last = this [frames.Count - 1];
if (!IsFrameOkForMode (last, Mode.Managed))
frames.Remove (last);
}
}
internal void OnThreadExitedEvent(ThreadServant thread)
{
thread_hash.Remove (thread.PID);
thread.ThreadGroup.RemoveThread (thread.ID);
session.DeleteThreadGroup (thread.ThreadGroup.Name);
manager.Debugger.OnThreadExitedEvent (thread.Client);
if (thread_hash.Count == 0)
OnProcessExitedEvent ();
}
internal abstract StackFrame GetLMF(ThreadServant thread, TargetMemoryAccess target, ref TargetAddress lmf_address);
internal CommandResult StartApplication()
{
SingleSteppingEngine engine = new SingleSteppingEngine (manager, this, start);
initialized = true;
this.main_thread = engine;
engine.Thread.ThreadFlags |= Thread.Flags.StopOnExit;
if (thread_hash.Contains (engine.PID))
thread_hash [engine.PID] = engine;
else
thread_hash.Add (engine.PID, engine);
session.MainThreadGroup.AddThread (engine.Thread.ID);
session.OnMainProcessCreated (this);
manager.Debugger.OnMainProcessCreatedEvent (this);
CommandResult result = Debugger.StartOperation (start.Session.Config.ThreadingModel, engine);
return engine.StartApplication (result);
}
internal Thread CreateThread(ThreadServant servant, int id)
{
return new Thread (servant, id);
}