protected void TwoByteOpcode(TargetReader reader)
{
byte opcode = reader.ReadByte();
if (TwoByte_Has_ModRM [opcode] != 0)
{
DecodeModRM(reader);
}
if ((opcode >= 0x80) && (opcode <= 0x8f))
{
if ((RexPrefix & X86_REX_Prefix.REX_W) != 0)
{
long offset = reader.BinaryReader.ReadInt32();
long long_target = Address.Address + offset + 5;
CallTarget = new TargetAddress(
Address.Domain, long_target);
}
else if ((Prefix & X86_Prefix.ADDR) != 0)
{
short offset = reader.BinaryReader.ReadInt16();
int short_target = (short)Address.Address + offset + 3;
CallTarget = new TargetAddress(
Address.Domain, short_target);
}
else
{
int offset = reader.BinaryReader.ReadInt32();
CallTarget = Address + offset + 5;
}
type = Type.ConditionalJump;
}
}
internal void InitializeThreads(Inferior inferior)
{
TargetAddress ptr = inferior.ReadAddress(MonoDebuggerInfo.ThreadTable);
while (!ptr.IsNull)
{
int size;
if (MonoDebuggerInfo.CheckRuntimeVersion(81, 3))
{
size = 60 + inferior.TargetMemoryInfo.TargetAddressSize;
}
else
{
size = 32 + inferior.TargetMemoryInfo.TargetAddressSize;
}
TargetReader reader = new TargetReader(inferior.ReadMemory(ptr, size));
long tid = reader.ReadLongInteger();
TargetAddress lmf_addr = reader.ReadAddress();
TargetAddress end_stack = reader.ReadAddress();
TargetAddress extended_notifications_addr = ptr + 24;
if (inferior.TargetMemoryInfo.TargetAddressSize == 4)
{
tid &= 0x00000000ffffffffL;
}
reader.Offset += 8;
ptr = reader.ReadAddress();
ThreadFlags flags = ThreadFlags.None;
if (MonoDebuggerInfo.CheckRuntimeVersion(81, 3))
{
reader.Offset = 56 + inferior.TargetAddressSize;
flags = (ThreadFlags)reader.ReadInteger();
}
bool found = false;
foreach (SingleSteppingEngine engine in process.Engines)
{
if (engine.TID != tid)
{
continue;
}
engine.SetManagedThreadData(lmf_addr, extended_notifications_addr);
engine.OnManagedThreadCreated(end_stack);
check_thread_flags(engine, flags);
found = true;
break;
}
if (!found)
{
Report.Error("Cannot find thread {0:x} in {1}",
tid, process.ProcessStart.CommandLine);
}
}
}
public MonoMethodSignature GetMethodSignature(MonoLanguageBackend mono,
TargetMemoryAccess memory,
TargetAddress signature)
{
int count = memory.ReadInteger(signature + 4) & 0x0000ffff;
int offset = memory.TargetAddressSize == 8 ? 16 : 12;
TargetAddress ret = memory.ReadAddress(signature + offset);
TargetType ret_type = mono.ReadType(memory, ret);
if (count == 0)
{
return(new MonoMethodSignature(ret_type, new TargetType [0]));
}
offset += memory.TargetAddressSize;
TargetReader reader = new TargetReader(
memory.ReadMemory(signature + offset, count * memory.TargetAddressSize));
TargetType[] param_types = new TargetType [count];
for (int i = 0; i < count; i++)
{
param_types [i] = mono.ReadType(memory, reader.ReadAddress());
}
return(new MonoMethodSignature(ret_type, param_types));
}
public GenericParamInfo GetGenericParameter(TargetMemoryAccess memory,
TargetAddress address)
{
int addr_size = memory.TargetMemoryInfo.TargetAddressSize;
TargetReader reader = new TargetReader(
memory.ReadMemory(address, 4 * addr_size + 4));
TargetAddress container = reader.ReadAddress();
TargetAddress klass = reader.ReadAddress();
TargetAddress name_addr = reader.ReadAddress();
reader.BinaryReader.ReadInt16(); /* flags */
int pos = reader.BinaryReader.ReadInt16();
string name;
if (!name_addr.IsNull)
{
name = memory.ReadString(name_addr);
}
else
{
name = String.Format("!{0}", pos);
}
return(new GenericParamInfo(container, klass, name, pos));
}
public AppDomainInfo GetAppDomainInfo(MonoLanguageBackend mono, TargetMemoryAccess memory,
TargetAddress address)
{
int addr_size = memory.TargetMemoryInfo.TargetAddressSize;
TargetReader reader = new TargetReader(memory.ReadMemory(address, 12 * addr_size));
return(new AppDomainInfo(mono, memory, reader));
}
protected void DecodeModRM(TargetReader reader)
{
ModRM = new X86_ModRM(this, reader.ReadByte());
if (Is64BitMode && (ModRM.Mod == 0) && ((ModRM.R_M & 0x07) == 0x05))
{
is_ip_relative = true;
}
}
//
// The following API is new in `terrania'.
//
public GenericClassInfo GetGenericClass(TargetMemoryAccess memory,
TargetAddress address)
{
int addr_size = memory.TargetMemoryInfo.TargetAddressSize;
TargetReader reader = new TargetReader(memory.ReadMemory(address, 5 * addr_size));
TargetAddress container = reader.ReadAddress();
TargetAddress class_inst = reader.ReadAddress();
reader.ReadAddress(); /* method_inst */
reader.ReadAddress();
TargetAddress cached_class = reader.ReadAddress();
int inst_id = memory.ReadInteger(class_inst);
int inst_data = memory.ReadInteger(class_inst + 4);
TargetAddress inst_argv;
if (MonoDebuggerInfo.MajorVersion == 80)
{
inst_argv = memory.ReadAddress(class_inst + 8);
}
else
{
inst_argv = class_inst + 8;
}
int type_argc = inst_data & 0x3fffff;
TargetReader argv_reader = new TargetReader(
memory.ReadMemory(inst_argv, type_argc * addr_size));
TargetAddress[] type_args = new TargetAddress [type_argc];
for (int i = 0; i < type_argc; i++)
{
type_args [i] = argv_reader.ReadAddress();
}
TargetAddress cached_class_ptr = address + 4 * addr_size;
return(new GenericClassInfo(container, type_args, cached_class_ptr,
cached_class));
}
protected void DoDecodeInstruction(TargetMemoryAccess memory,
TargetAddress address)
{
TargetReader reader = new TargetReader(
memory.ReadMemory(address, MaxInstructionLength));
while (CheckPrefix(reader))
{
reader.Offset++;
}
byte opcode = reader.ReadByte();
if (opcode == 0x0f)
{
TwoByteOpcode(reader);
}
else
{
OneByteOpcode(reader, opcode);
}
if (InstructionType != Type.Unknown)
{
insn_size = (int)reader.Offset;
has_insn_size = true;
}
else
{
insn_size = Opcodes.Disassembler.GetInstructionSize(memory, address);
has_insn_size = true;
}
if (has_insn_size)
{
code = new byte [insn_size];
Array.Copy(reader.Contents, 0, code, 0, insn_size);
}
}
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));
}
protected void OneByteOpcode(TargetReader reader, byte opcode)
{
if (OneByte_Has_ModRM [opcode] != 0)
{
DecodeModRM(reader);
}
if ((opcode >= 0x70) && (opcode <= 0x7f))
{
CallTarget = Address + reader.BinaryReader.ReadSByte() + 2;
type = Type.ConditionalJump;
}
else if ((opcode >= 0xe0) && (opcode <= 0xe3))
{
CallTarget = Address + reader.BinaryReader.ReadSByte() + 2;
type = Type.ConditionalJump;
}
else if ((opcode == 0xe8) || (opcode == 0xe9))
{
if ((RexPrefix & X86_REX_Prefix.REX_W) != 0)
{
long offset = reader.BinaryReader.ReadInt32();
long long_target = Address.Address + offset + 5;
CallTarget = new TargetAddress(
Address.Domain, long_target);
}
else if ((Prefix & X86_Prefix.ADDR) != 0)
{
short offset = reader.BinaryReader.ReadInt16();
int short_target = (short)Address.Address + offset + 3;
CallTarget = new TargetAddress(
Address.Domain, short_target);
}
else
{
int offset = reader.BinaryReader.ReadInt32();
CallTarget = Address + offset + 5;
}
type = (opcode == 0xe8) ? Type.Call : Type.Jump;
}
else if (opcode == 0xeb)
{
CallTarget = Address + reader.BinaryReader.ReadSByte() + 2;
type = Type.Jump;
}
else if (opcode == 0xc3)
{
type = Type.Ret;
}
else if (opcode == 0x55) /* push %rbp */
{
type = Type.Interpretable;
}
else if (opcode == 0xc2)
{
Displacement = reader.BinaryReader.ReadInt16();
type = Type.Ret;
}
else if (opcode == 0xff)
{
DecodeGroup5(reader);
}
else if (opcode == 0x90)
{
type = Type.Interpretable;
}
}
bool CheckPrefix(TargetReader reader)
{
byte opcode = reader.PeekByte();
if ((opcode >= 0x40) && (opcode <= 0x4f))
{
if (!Is64BitMode)
{
return(false);
}
if ((opcode & 0x01) != 0)
{
RexPrefix |= X86_REX_Prefix.REX_B;
}
if ((opcode & 0x02) != 0)
{
RexPrefix |= X86_REX_Prefix.REX_X;
}
if ((opcode & 0x04) != 0)
{
RexPrefix |= X86_REX_Prefix.REX_R;
}
if ((opcode & 0x08) != 0)
{
RexPrefix |= X86_REX_Prefix.REX_W;
}
return(true);
}
else if (opcode == 0x26)
{
Prefix |= X86_Prefix.ES;
return(true);
}
else if (opcode == 0x2e)
{
Prefix |= X86_Prefix.CS;
return(true);
}
else if (opcode == 0x36)
{
Prefix |= X86_Prefix.SS;
return(true);
}
else if (opcode == 0x3e)
{
Prefix |= X86_Prefix.DS;
return(true);
}
else if (opcode == 0x64)
{
Prefix |= X86_Prefix.FS;
return(true);
}
else if (opcode == 0x65)
{
Prefix |= X86_Prefix.GS;
return(true);
}
else if (opcode == 0x66)
{
Prefix |= X86_Prefix.DATA;
return(true);
}
else if (opcode == 0x67)
{
Prefix |= X86_Prefix.ADDR;
return(true);
}
else if (opcode == 0xf0)
{
Prefix |= X86_Prefix.LOCK;
return(true);
}
else if (opcode == 0xf2)
{
Prefix |= X86_Prefix.REPNZ;
return(true);
}
else if (opcode == 0xf3)
{
Prefix |= X86_Prefix.REPZ;
return(true);
}
return(false);
}
internal void InitializeThreads(Inferior inferior)
{
TargetAddress ptr = inferior.ReadAddress (MonoDebuggerInfo.ThreadTable);
while (!ptr.IsNull) {
int size;
if (MonoDebuggerInfo.CheckRuntimeVersion (81, 3))
size = 60 + inferior.TargetMemoryInfo.TargetAddressSize;
else
size = 32 + inferior.TargetMemoryInfo.TargetAddressSize;
TargetReader reader = new TargetReader (inferior.ReadMemory (ptr, size));
long tid = reader.ReadLongInteger ();
TargetAddress lmf_addr = reader.ReadAddress ();
TargetAddress end_stack = reader.ReadAddress ();
TargetAddress extended_notifications_addr = ptr + 24;
if (inferior.TargetMemoryInfo.TargetAddressSize == 4)
tid &= 0x00000000ffffffffL;
reader.Offset += 8;
ptr = reader.ReadAddress ();
ThreadFlags flags = ThreadFlags.None;
if (MonoDebuggerInfo.CheckRuntimeVersion (81, 3)) {
reader.Offset = 56 + inferior.TargetAddressSize;
flags = (ThreadFlags) reader.ReadInteger ();
}
bool found = false;
foreach (SingleSteppingEngine engine in process.Engines) {
if (engine.TID != tid)
continue;
engine.SetManagedThreadData (lmf_addr, extended_notifications_addr);
engine.OnManagedThreadCreated (end_stack);
check_thread_flags (engine, flags);
found = true;
break;
}
if (!found)
Report.Error ("Cannot find thread {0:x} in {1}",
tid, process.ProcessStart.CommandLine);
}
}
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);
}
public AppDomainInfo(MonoLanguageBackend mono, TargetMemoryAccess memory, TargetReader reader)
{
int addr_size = memory.TargetMemoryInfo.TargetAddressSize;
reader.Offset = 2 * addr_size;
ApplicationBase = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
ApplicationName = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
CachePath = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
ConfigFile = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
DynamicBase = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
reader.Offset += 3 * addr_size;
ShadowCopyDirectories = MonoStringObject.ReadString(mono, memory, reader.ReadAddress());
ShadowCopyFiles = MonoStringObject.ReadString(mono, memory, reader.ReadAddress()) == "true";
}
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);
}
protected void DecodeGroup5(TargetReader reader)
{
if ((ModRM.Reg == 2) || (ModRM.Reg == 3))
{
type = Type.IndirectCall;
}
else if ((ModRM.Reg == 4) || (ModRM.Reg == 5))
{
type = Type.IndirectJump;
}
else
{
return;
}
int displacement = 0;
bool dereference_addr;
int register;
int index_register = -1;
if ((ModRM.R_M == 5) || (ModRM.R_M == 13))
{
/* Special meaning in mod == 00 */
if (ModRM.Mod == 0)
{
if (Is64BitMode)
{
displacement = reader.BinaryReader.ReadInt32();
register = -1;
is_ip_relative = true;
}
else
{
CallTarget = reader.ReadAddress();
return;
}
}
else
{
register = DecodeRegister(ModRM.R_M);
}
}
else if ((ModRM.R_M == 4) || (ModRM.R_M == 12))
{
/* Activate SIB byte if mod != 11 */
if (ModRM.Mod != 3)
{
SIB = new X86_SIB(this, reader.ReadByte());
if ((ModRM.Mod == 0) &&
((SIB.Base == 5) || (SIB.Base == 13)))
{
displacement = reader.BinaryReader.ReadInt32();
CallTarget = new TargetAddress(
reader.AddressDomain, displacement);
return;
}
if (SIB.Index != 4)
{
index_register = DecodeRegister(SIB.Index);
}
register = DecodeRegister(SIB.Base);
}
else
{
register = DecodeRegister(ModRM.R_M);
}
}
else
{
register = DecodeRegister(ModRM.R_M);
}
if (ModRM.Mod == 0)
{
dereference_addr = true;
}
else if (ModRM.Mod == 1)
{
displacement = reader.BinaryReader.ReadSByte();
dereference_addr = true;
}
else if (ModRM.Mod == 2)
{
displacement = reader.BinaryReader.ReadInt32();
dereference_addr = true;
}
else if (ModRM.Mod == 3)
{
displacement = 0;
dereference_addr = false;
}
else
{
// Can never happen
throw new InvalidOperationException();
}
Register = register;
IndexRegister = index_register;
Displacement = displacement;
DereferenceAddress = dereference_addr;
}
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);
}
public PlayerTarget(TargetReader targetReader, TargetOfTarget targetOfTarget)
{
Reader = targetReader;
Target = targetOfTarget;
}
