internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) { return(handle); } if (frame.Thread.Process.IsManaged) { MonoLanguageBackend mono = frame.Thread.Process.MonoLanguage; MonoFunctionType main = mono.MainMethod; if (main == null) { return(null); } handle = main.GetBreakpointHandle(this, -1, -1); } else { OperatingSystemBackend os = frame.Thread.Process.OperatingSystem; TargetAddress main = os.LookupSymbol("main"); if (main.IsNull) { return(null); } handle = new AddressBreakpointHandle(this, main); } return(handle); }
public override TargetMethodSignature GetSignature(Thread thread) { if (signature != null) { return(signature); } if (!ContainsGenericParameters) { return(new MonoMethodSignature(return_type, parameter_types)); } if (!thread.CurrentFrame.Language.IsManaged) { throw new TargetException(TargetError.InvalidContext); } TargetAddress addr = (TargetAddress)thread.ThreadServant.DoTargetAccess( delegate(TargetMemoryAccess target) { MonoClassInfo class_info = ResolveClass(target, true); return(class_info.GetMethodAddress(target, token)); }); MonoLanguageBackend mono = klass.File.MonoLanguage; TargetAddress sig = thread.CallMethod( mono.MonoDebuggerInfo.GetMethodSignature, addr, 0); signature = (MonoMethodSignature)thread.ThreadServant.DoTargetAccess( delegate(TargetMemoryAccess target) { return(mono.MetadataHelper.GetMethodSignature(mono, target, sig)); }); return(signature); }
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 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)); }
void DoDispose() { if (!is_forked) { if (architecture != null) { architecture.Dispose(); architecture = null; } if (mono_language != null) { mono_language.Dispose(); mono_language = null; } if (native_language != null) { native_language.Dispose(); native_language = null; } if (os != null) { os.Dispose(); os = null; } if (symtab_manager != null) { symtab_manager.Dispose(); symtab_manager = null; } } if (breakpoint_manager != null) { breakpoint_manager.Dispose(); breakpoint_manager = null; } if (thread_db != null) { thread_db.Dispose(); thread_db = null; } if (thread_lock_mutex != null) { thread_lock_mutex.Dispose(); thread_lock_mutex = null; } exception_handlers = null; manager.RemoveProcess(this); }
protected FunctionBreakpointHandle (Breakpoint bpt, TargetFunctionType function, int line, int column) : base (bpt) { this.function = function; this.line = line; this.column = column; this.Index = MonoLanguageBackend.GetUniqueID (); }
internal static string ReadString(MonoLanguageBackend mono, TargetMemoryAccess target, TargetAddress address) { if (address.IsNull) { return(null); } TargetLocation location = new AbsoluteTargetLocation(address); MonoStringObject so = new MonoStringObject(mono.BuiltinTypes.StringType, location); return((string)so.DoGetObject(target)); }
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"; }
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 MonoGenericParameterType(MonoLanguageBackend mono, string name) : base(mono) { this.name = name; }
public static MonoClassInfo ReadClassInfo(MonoLanguageBackend mono, TargetMemoryAccess target, TargetAddress klass) { TargetAddress image = mono.MetadataHelper.MonoClassGetMonoImage(target, klass); MonoSymbolFile file = mono.GetImage(image); if (file == null) { throw new InternalError(); } int token = mono.MetadataHelper.MonoClassGetToken(target, klass); if ((token & 0xff000000) != 0x02000000) { throw new InternalError(); } Cecil.TypeDefinition typedef; typedef = (Cecil.TypeDefinition)file.ModuleDefinition.LookupToken( new Cecil.MetadataToken(Cecil.TokenType.TypeDef, token & 0x00ffffff)); if (typedef == null) { throw new InternalError(); } MonoClassInfo info = new MonoClassInfo(file, typedef, target, klass); if ((file == mono.BuiltinTypes.Corlib) && (typedef.FullName == "System.Decimal")) { MonoFundamentalType ftype = mono.BuiltinTypes.DecimalType; if (ftype.ClassType == null) { MonoClassType ctype = new MonoClassType(file, typedef, info); ((IMonoStructType)ctype).ClassInfo = info; ftype.SetClass(ctype); } info.struct_type = (IMonoStructType)ftype.ClassType; info.type = ftype; } else if (info.IsGenericClass) { info.struct_type = (IMonoStructType) file.MonoLanguage.ReadGenericClass( target, info.GenericClass, false); info.type = info.struct_type.Type; } else { info.type = file.LookupMonoType(typedef); if (info.type is TargetClassType) { info.struct_type = (IMonoStructType)info.type; } else { info.struct_type = (IMonoStructType)info.type.ClassType; } } info.struct_type.ClassInfo = info; return(info); }
internal MonoLanguageBackend CreateMonoLanguage(MonoDebuggerInfo info) { mono_language = new MonoLanguageBackend(this, info); return(mono_language); }
internal bool HandleChildEvent(SingleSteppingEngine engine, Inferior inferior, ref Inferior.ChildEvent cevent, out bool resume_target) { if (cevent.Type == Inferior.ChildEventType.CHILD_NOTIFICATION) { NotificationType type = (NotificationType)cevent.Argument; Report.Debug(DebugFlags.EventLoop, "{0} received notification {1}: {2}", engine, type, cevent); switch (type) { case NotificationType.AcquireGlobalThreadLock: Report.Debug(DebugFlags.Threads, "{0} received notification {1}", engine, type); engine.Process.AcquireGlobalThreadLock(engine); break; case NotificationType.ReleaseGlobalThreadLock: Report.Debug(DebugFlags.Threads, "{0} received notification {1}", engine, type); engine.Process.ReleaseGlobalThreadLock(engine); break; case NotificationType.ThreadCreated: { TargetAddress data = new TargetAddress( inferior.AddressDomain, cevent.Data2); TargetAddress lmf = inferior.ReadAddress(data + 8); engine.SetManagedThreadData(lmf, data + 24); if (MonoDebuggerInfo.CheckRuntimeVersion(81, 3)) { int flags_offset = 56 + inferior.TargetAddressSize; ThreadFlags flags = (ThreadFlags)inferior.ReadInteger(data + flags_offset); check_thread_flags(engine, flags); } Report.Debug(DebugFlags.Threads, "{0} managed thread created: {1:x} {2} {3} - {4}", engine, cevent.Data1, data, lmf, engine.LMFAddress); break; } case NotificationType.ThreadCleanup: { TargetAddress data = new TargetAddress( inferior.AddressDomain, cevent.Data1); Report.Debug(DebugFlags.Threads, "{0} managed thread cleanup: {1:x} {2}", engine, cevent.Data2, data); break; } case NotificationType.GcThreadCreated: { TargetAddress data = new TargetAddress( inferior.AddressDomain, cevent.Data1); long tid = cevent.Data2; Report.Debug(DebugFlags.Threads, "{0} created gc thread: {1:x} {2}", engine, tid, data); engine = engine.Process.GetEngineByTID(inferior, tid); if (engine == null) { throw new InternalError(); } engine.OnManagedThreadCreated(data); break; } case NotificationType.GcThreadExited: Report.Debug(DebugFlags.Threads, "{0} gc thread exited", engine); engine.OnManagedThreadExited(); try { inferior.Continue(); } catch { // Ignore errors; for some reason, the thread may have died // already by the time get this notification. } resume_target = false; return(true); case NotificationType.InitializeThreadManager: csharp_language = inferior.Process.CreateMonoLanguage( debugger_info); if (engine.Process.IsAttached) { csharp_language.InitializeAttach(inferior); } else { csharp_language.Initialize(inferior); } break; case NotificationType.ReachedMain: { Inferior.StackFrame iframe = inferior.GetCurrentFrame(false); engine.SetMainReturnAddress(iframe.StackPointer); engine.Process.OnProcessReachedMainEvent(); resume_target = !engine.InitializeBreakpoints(); return(true); } case NotificationType.WrapperMain: break; case NotificationType.MainExited: engine.SetMainReturnAddress(TargetAddress.Null); break; case NotificationType.UnhandledException: cevent = new Inferior.ChildEvent( Inferior.ChildEventType.UNHANDLED_EXCEPTION, 0, cevent.Data1, cevent.Data2); resume_target = false; return(false); case NotificationType.HandleException: cevent = new Inferior.ChildEvent( Inferior.ChildEventType.HANDLE_EXCEPTION, 0, cevent.Data1, cevent.Data2); resume_target = false; return(false); case NotificationType.ThrowException: cevent = new Inferior.ChildEvent( Inferior.ChildEventType.THROW_EXCEPTION, 0, cevent.Data1, cevent.Data2); resume_target = false; return(false); case NotificationType.FinalizeManagedCode: mono_debugger_server_finalize_mono_runtime(mono_runtime_info); mono_runtime_info = IntPtr.Zero; csharp_language = null; break; case NotificationType.OldTrampoline: case NotificationType.Trampoline: resume_target = false; return(false); case NotificationType.ClassInitialized: break; case NotificationType.InterruptionRequest: inferior.WriteInteger(MonoDebuggerInfo.InterruptionRequest, 0); var callbacks = managed_callbacks; managed_callbacks = new Queue <ManagedCallbackData> (); resume_target = !engine.OnManagedCallback(callbacks); return(true); default: { TargetAddress data = new TargetAddress( inferior.AddressDomain, cevent.Data1); resume_target = csharp_language.Notification( engine, inferior, type, data, cevent.Data2); return(true); } } resume_target = true; return(true); } if ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument == thread_abort_signal)) { resume_target = true; return(true); } if ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument != 0) && ! engine.Process.Session.Config.StopOnManagedSignals) { if (inferior.IsManagedSignal((int)cevent.Argument)) { resume_target = true; return(true); } } resume_target = false; return(false); }