internal StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess memory) { if (!IsLoaded) { return(null); } try { StackFrame new_frame = Module.UnwindStack(frame, memory); if (new_frame != null) { return(new_frame); } } catch { } int prologue_size; if (HasMethodBounds) { prologue_size = (int)(MethodStartAddress - StartAddress); } else { prologue_size = (int)(EndAddress - StartAddress); } int offset = (int)(frame.TargetAddress - StartAddress); byte[] prologue = memory.ReadBuffer(StartAddress, prologue_size); return(frame.Thread.Architecture.UnwindStack(frame, memory, prologue, offset)); }
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 void UpdateSymbolTable(TargetMemoryAccess target) { if (mono_language != null) { mono_language.Update(target); } }
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); }
public override bool GetTrampoline(TargetMemoryAccess memory, TargetAddress address, out TargetAddress trampoline, out bool is_start) { foreach (Bfd bfd in bfd_hash.Values) { if (bfd.GetTrampoline (memory, address, out trampoline, out is_start)) return true; } is_start = false; trampoline = TargetAddress.Null; return false; }
internal bool CheckException(MonoLanguageBackend mono, TargetMemoryAccess target, TargetAddress address) { TargetClassObject exc = mono.CreateObject (target, address) as TargetClassObject; if (exc == null) return false; // OOOPS if (exception == null) exception = mono.LookupType (Name); if (exception == null) return false; return IsSubclassOf (target, exc.Type, exception); }
internal void WriteRegister(TargetMemoryAccess target, long value) { this.value = value; if (addr_on_stack.IsNull) { target.SetRegisters(registers); } else if (Size == target.TargetMemoryInfo.TargetIntegerSize) { target.WriteInteger(addr_on_stack, (int)value); } else { target.WriteLongInteger(addr_on_stack, value); } }
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 CheckException(MonoLanguageBackend mono, TargetMemoryAccess target, TargetAddress address) { TargetClassObject exc = mono.CreateObject(target, address) as TargetClassObject; if (exc == null) { return(false); // OOOPS } if (exception == null) { exception = mono.LookupType(Name); } if (exception == null) { return(false); } return(IsSubclassOf(target, exc.Type, exception)); }
bool IsSubclassOf(TargetMemoryAccess target, TargetClassType type, TargetType parent) { while (type != null) { if (type == parent) { return(true); } if (!type.HasParent) { return(false); } type = type.GetParentType(target); } return(false); }
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); } } }
public override AssemblerLine DisassembleInstruction(TargetMemoryAccess memory, Method method, TargetAddress address) { lock (this) { memory_exception = null; sb = new StringBuilder (); address = new TargetAddress (memory.AddressDomain, address.Address); string insn; int insn_size; try { this.memory = memory; current_method = method; insn_size = bfd_glue_disassemble_insn (handle, address.Address); if (memory_exception != null) return null; insn = sb.ToString (); } finally { sb = null; this.memory = null; memory_exception = null; current_method = null; } Symbol label = null; if (process != null) label = process.SymbolTableManager.SimpleLookup (address, true); string label_name = null; if (label != null) label_name = label.ToString (); return new AssemblerLine ( label_name, address, (byte) insn_size, insn); } }
internal StackFrame UnwindStack(TargetMemoryAccess memory) { if (parent_frame != null) { return(parent_frame); } StackFrame new_frame = null; if (method != null) { try { new_frame = method.UnwindStack(this, memory); } catch (TargetException) { } if (new_frame != null) { return(new_frame); } } foreach (Module module in thread.Process.Modules) { try { new_frame = module.UnwindStack(this, memory); } catch { continue; } if (new_frame != null) { return(new_frame); } } return(thread.Architecture.UnwindStack(this, memory, null, 0)); }
// <summary> // Get the size of the current instruction. // </summary> public abstract int GetInstructionSize(TargetMemoryAccess memory, TargetAddress address);
public override AssemblerMethod DisassembleMethod(TargetMemoryAccess memory, Method method) { lock (this) { ArrayList list = new ArrayList (); TargetAddress current = method.StartAddress; while (current < method.EndAddress) { AssemblerLine line = DisassembleInstruction ( memory, method, current); if (line == null) break; current += line.InstructionSize; list.Add (line); } AssemblerLine[] lines = new AssemblerLine [list.Count]; list.CopyTo (lines, 0); return new AssemblerMethod (method, lines); } }
internal Method ReadRangeEntry(TargetMemoryAccess memory, TargetReader reader, byte[] contents) { RangeEntry range = RangeEntry.Create (this, memory, reader, contents); if (!range_hash.Contains (range.Hash)) { range_hash.Add (range.Hash, range); ranges.Add (range); } return range.GetMethod (); }
bool IsSubclassOf(TargetMemoryAccess target, TargetClassType type, TargetType parent) { while (type != null) { if (type == parent) return true; if (!type.HasParent) return false; type = type.GetParentType (target); } return false; }
internal StackFrame UnwindStack(StackFrame last_frame, TargetMemoryAccess memory) { return SymbolFile.UnwindStack (last_frame, memory); }
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; } }
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 MonoClassInfo ReadClassInfo(MonoLanguageBackend mono, TargetMemoryAccess target) { if (info == null) info = mono.ReadClassInfo (target, KlassAddress); return info; }
internal override StackFrame UnwindStack(StackFrame last_frame, TargetMemoryAccess memory) { return null; }
internal override MethodSource GetTrampoline(TargetMemoryAccess memory, TargetAddress address) { return File.MonoLanguage.GetTrampoline (memory, address); }
internal virtual Block LookupBlock(TargetMemoryAccess memory, TargetAddress address) { return(null); }
public static RangeEntry Create(MonoSymbolFile file, TargetMemoryAccess memory, TargetReader reader, byte[] contents) { int domain = reader.BinaryReader.ReadInt32 (); int index = reader.BinaryReader.ReadInt32 (); TargetAddress wrapper_data = reader.ReadAddress (); TargetAddress method = reader.ReadAddress (); reader.ReadAddress (); /* address_list */ TargetAddress code_start = reader.ReadAddress (); TargetAddress wrapper_addr = reader.ReadAddress (); int code_size = reader.BinaryReader.ReadInt32 (); WrapperEntry wrapper = null; if (!wrapper_data.IsNull) { int wrapper_size = 4 + 3 * memory.TargetMemoryInfo.TargetAddressSize; TargetReader wrapper_reader = new TargetReader ( memory.ReadMemory (wrapper_data, wrapper_size)); TargetAddress name_address = wrapper_reader.ReadAddress (); TargetAddress cil_address = wrapper_reader.ReadAddress (); int wrapper_type = wrapper_reader.BinaryReader.ReadInt32 (); string name = "<" + memory.ReadString (name_address) + ">"; string cil_code = memory.ReadString (cil_address); wrapper = new WrapperEntry ( wrapper_addr, (WrapperType) wrapper_type, name, cil_code); } return new RangeEntry ( file, domain, index, wrapper, method, code_start, code_start + code_size, contents); }
internal abstract MethodSource GetTrampoline(TargetMemoryAccess memory, TargetAddress address);
internal StackFrame UnwindStack(StackFrame last_frame, TargetMemoryAccess memory) { return(SymbolFile.UnwindStack(last_frame, memory)); }
internal abstract StackFrame UnwindStack(StackFrame last_frame, TargetMemoryAccess memory);
protected MonoDebuggerInfo(TargetMemoryAccess memory, TargetReader reader) { reader.Offset = 8; MajorVersion = reader.ReadInteger (); MinorVersion = reader.ReadInteger (); RuntimeFlags = reader.ReadInteger (); reader.Offset = 24; SymbolTableSize = reader.ReadInteger (); MonoTrampolineNum = reader.ReadInteger (); MonoTrampolineCode = reader.ReadAddress (); NotificationAddress = reader.ReadAddress (); SymbolTable = reader.ReadAddress (); MonoMetadataInfo = reader.ReadAddress (); DebuggerVersion = reader.ReadAddress (); CompileMethod = reader.ReadAddress (); GetVirtualMethod = reader.ReadAddress (); GetBoxedObjectMethod = reader.ReadAddress (); RuntimeInvoke = reader.ReadAddress (); ClassGetStaticFieldData = reader.ReadAddress (); RunFinally = reader.ReadAddress (); Initialize = reader.ReadAddress (); CreateString = reader.ReadAddress (); LookupClass = reader.ReadAddress (); InsertMethodBreakpoint = reader.ReadAddress (); InsertSourceBreakpoint = reader.ReadAddress (); RemoveBreakpoint = reader.ReadAddress (); RegisterClassInitCallback = reader.ReadAddress (); RemoveClassInitCallback = reader.ReadAddress (); ThreadTable = reader.ReadAddress (); ExecutableCodeBuffer = reader.ReadAddress (); BreakpointInfo = reader.ReadAddress (); BreakpointInfoIndex = reader.ReadAddress (); ExecutableCodeBufferSize = reader.ReadInteger (); BreakpointArraySize = reader.ReadInteger (); GetMethodSignature = reader.ReadAddress (); InitCodeBuffer = reader.ReadAddress (); ThreadVTablePtr = reader.ReadAddress (); ThreadVTable = reader.ReadAddress (); EventHandlerPtr = reader.ReadAddress (); EventHandler = reader.ReadAddress (); UsingMonoDebugger = reader.ReadAddress (); InterruptionRequest = reader.ReadAddress (); if (HasAbortRuntimeInvoke) AbortRuntimeInvoke = reader.ReadAddress (); if (HasThreadAbortSignal) ThreadAbortSignal = reader.ReadAddress (); Report.Debug (DebugFlags.JitSymtab, this); }
internal void WriteRegister(TargetMemoryAccess target, long value) { this.value = value; if (addr_on_stack.IsNull) target.SetRegisters (registers); else if (Size == target.TargetMemoryInfo.TargetIntegerSize) target.WriteInteger (addr_on_stack, (int) value); else target.WriteLongInteger (addr_on_stack, value); }
internal MonoClassInfo LookupClassInfo(TargetMemoryAccess target, int token) { ClassEntry entry = (ClassEntry) class_entry_by_token [token]; if (entry == null) { MonoLanguage.Update (target); entry = (ClassEntry) class_entry_by_token [token]; if (entry == null) return null; } return entry.ReadClassInfo (MonoLanguage, target); }
internal StackFrame UnwindStack(TargetMemoryAccess memory) { if (parent_frame != null) return parent_frame; StackFrame new_frame = null; if (method != null) { try { new_frame = method.UnwindStack (this, memory); } catch (TargetException) { } if (new_frame != null) return new_frame; } foreach (Module module in thread.Process.Modules) { try { new_frame = module.UnwindStack (this, memory); } catch { continue; } if (new_frame != null) return new_frame; } return thread.Architecture.UnwindStack (this, memory, null, 0); }
public static MonoDebuggerInfo Create(TargetMemoryAccess memory, TargetAddress info) { TargetBinaryReader header = memory.ReadMemory (info, 24).GetReader (); long magic = header.ReadInt64 (); if (magic != DynamicMagic) { Report.Error ("`MONO_DEBUGGER__debugger_info' at {0} has unknown magic {1:x}.", info, magic); return null; } int version = header.ReadInt32 (); if (version < MinDynamicVersion) { Report.Error ("`MONO_DEBUGGER__debugger_info' has version {0}, " + "but expected at least {1}.", version, MonoDebuggerInfo.MinDynamicVersion); return null; } if (version > MaxDynamicVersion) { Report.Error ("`MONO_DEBUGGER__debugger_info' has version {0}, " + "but expected at most {1}.", version, MonoDebuggerInfo.MaxDynamicVersion); return null; } header.ReadInt32 (); // minor version header.ReadInt32 (); int size = header.ReadInt32 (); TargetReader reader = new TargetReader (memory.ReadMemory (info, size)); return new MonoDebuggerInfo (memory, reader); }
internal void UpdateSymbolTable(TargetMemoryAccess target) { if (mono_language != null) mono_language.Update (target); }
// <summary> // Disassemble one method. // </summary> public abstract AssemblerMethod DisassembleMethod(TargetMemoryAccess memory, Method method);
public override int GetInstructionSize(TargetMemoryAccess memory, TargetAddress address) { memory_exception = null; try { this.memory = memory; int count = bfd_glue_disassemble_insn (handle, address.Address); if (memory_exception != null) throw memory_exception; return count; } finally { this.memory = null; memory_exception = null; } }
internal StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess memory) { if (!IsLoaded) return null; try { StackFrame new_frame = Module.UnwindStack (frame, memory); if (new_frame != null) return new_frame; } catch { } int prologue_size; if (HasMethodBounds) prologue_size = (int) (MethodStartAddress - StartAddress); else prologue_size = (int) (EndAddress - StartAddress); int offset = (int) (frame.TargetAddress - StartAddress); byte[] prologue = memory.ReadBuffer (StartAddress, prologue_size); return frame.Thread.Architecture.UnwindStack (frame, memory, prologue, offset); }
public abstract bool GetTrampoline(TargetMemoryAccess memory, TargetAddress address, out TargetAddress trampoline, out bool is_start);
// <summary> // Disassemble one instruction. // If @imethod is non-null, it specifies the current method which will // be used to lookup function names from trampoline calls. // </summary> public abstract AssemblerLine DisassembleInstruction(TargetMemoryAccess memory, Method method, TargetAddress address);
internal virtual Block LookupBlock(TargetMemoryAccess memory, TargetAddress address) { return null; }