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 abstract StackFrame UnwindStack(StackFrame last_frame,
TargetMemoryAccess memory);
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);
// <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);
// <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 abstract MethodSource GetTrampoline(TargetMemoryAccess memory, TargetAddress address);
// <summary>
// Get the size of the current instruction.
// </summary>
public abstract int GetInstructionSize(TargetMemoryAccess memory,
TargetAddress address);
internal virtual Block LookupBlock(TargetMemoryAccess memory,
TargetAddress address)
{
return null;
}