/// <summary> /// Function tries to bind a breakpoint to the specified module. /// </summary> /// <param name="managedModule">A module the breakpoint should be bound to.</param> /// <returns>true if breakpoint was successfully bound or false if it failed or was already bound.</returns> /// <remarks> /// This function is called by breakpoint manager for every brekapoint whenever a new module /// gets loaded into the debugged process or whenever a dynamic module loads a new class /// or new symbols. This adds any missing bindings, but will not duplicate any that already exist. /// </remarks> public sealed override bool BindToModule(MDbgModule managedModule) { List <MDbgFunction> funcs; int ILoffset; // If we already bound a breakpoint in this module then nothing to do if (m_breakpoints != null && m_breakpoints.ContainsKey(managedModule)) { return(false); } // If we can't resolve the location in this module then there is nothing to do if (!m_location.ResolveLocation(this, managedModule, out funcs, out ILoffset)) { return(false); } // Use the resolved information to get a raw CorBreakpoint object. CorFunctionBreakpoint breakpoint = null; try { if (ILoffset == 0) { foreach (var func in funcs) { breakpoint = func.CorFunction.CreateBreakpoint(); SetupBreakpoint(breakpoint, managedModule); } } else { foreach (var func in funcs) { // we need to set a breakpoint on code rather than directly on function CorCode code = func.CorFunction.ILCode; if (code == null) { throw new MDbgException(String.Format(CultureInfo.InvariantCulture, "IL Code for function {0} is null", new Object[] { func.FullName })); } breakpoint = code.CreateBreakpoint(ILoffset); SetupBreakpoint(breakpoint, managedModule); } } } catch (NotImplementedException) { return(false); } catch (COMException) { return(false); } return(true); }
static void ProcessCommand(CorProcess process) { Task.Run(() => { while (true) { Console.Write("> "); String command = Console.ReadLine(); if (command.StartsWith("set-break", StringComparison.Ordinal)) { // setting breakpoint command = command.Remove(0, "set-break".Length).Trim(); // try module!type.method location (simple regex used) Match match = methodBreakpointRegex.Match(command); if (match.Groups["method"].Length > 0) { Console.Write("Setting method breakpoint... "); CorFunction func = process.ResolveFunctionName(match.Groups["module"].Value, match.Groups["class"].Value, match.Groups["method"].Value); func.CreateBreakpoint().Activate(true); Console.WriteLine("done."); continue; } // try file code:line location match = codeBreakpointRegex.Match(command); if (match.Groups["filepath"].Length > 0) { Console.Write("Setting code breakpoint..."); int offset; CorCode code = process.ResolveCodeLocation(match.Groups["filepath"].Value, Int32.Parse(match.Groups["linenum"].Value), out offset); code.CreateBreakpoint(offset).Activate(true); Console.WriteLine("done."); continue; } } else if (command.StartsWith("go", StringComparison.Ordinal)) { process.Continue(false); ProcessCommand(process); break; } } }); }
/// <summary> /// Function tries to bind a breakpoint to the specified module. /// </summary> /// <param name="managedModule">A module the breakpoint should be bound to.</param> /// <returns>true if breakpoint was successfully bound or false if it failed or was already bound.</returns> /// <remarks> /// This function is called by breakpoint manager for every brekapoint whenever a new module /// gets loaded into the debugged process or whenever a dynamic module loads a new class /// or new symbols. This adds any missing bindings, but will not duplicate any that already exist. /// </remarks> public sealed override bool BindToModule(MDbgModule managedModule) { MDbgFunction func; int ILoffset; // If we already bound a breakpoint in this module then nothing to do if (m_breakpoints != null && m_breakpoints.ContainsKey(managedModule)) { return(false); } // If we can't resolve the location in this module then there is nothing to do if (!m_location.ResolveLocation(this, managedModule, out func, out ILoffset)) { return(false); } // Use the resolved information to get a raw CorBreakpoint object. CorFunctionBreakpoint breakpoint = null; try { if (ILoffset == 0) { breakpoint = func.CorFunction.CreateBreakpoint(); } else { // we need to set a breakpoint on code rather than directly on function CorCode code = func.CorFunction.ILCode; if (code == null) { throw new MDbgException(String.Format(CultureInfo.InvariantCulture, "IL Code for function {0} is null", new Object[] { func.FullName })); } breakpoint = code.CreateBreakpoint(ILoffset); } } catch (NotImplementedException) { return(false); } catch (COMException) { return(false); } // Add the new CorBreakpoint object to our internal list and register a handler for it. Debug.Assert(breakpoint != null); breakpoint.Activate(true); if (m_breakpoints == null) { m_breakpoints = new Dictionary <MDbgModule, CorFunctionBreakpoint>(); } m_breakpoints.Add(managedModule, breakpoint); MDbgProcess p = managedModule.Process; CustomBreakpointEventHandler handler = new CustomBreakpointEventHandler(this.InternalOnHitHandler); p.RegisterCustomBreakpoint(breakpoint, handler); return(true); }
/// <summary> /// Function tries to bind a breakpoint to the specified module. /// </summary> /// <param name="managedModule">A module the breakpoint should be bound to.</param> /// <returns>true if breakpoint was successfully bound or false if it failed or was already bound.</returns> /// <remarks> /// This function is called by breakpoint manager for every brekapoint whenever a new module /// gets loaded into the debugged process or whenever a dynamic module loads a new class /// or new symbols. This adds any missing bindings, but will not duplicate any that already exist. /// </remarks> public sealed override bool BindToModule(MDbgModule managedModule) { MDbgFunction func; int ILoffset; // Note that in some cases (eg. source/line breakpoints) we may actually // want to bind to multiple locations in this module instead of just one. if (!m_location.ResolveLocation(this, managedModule, out func, out ILoffset)) { return(false); } if (m_breakpoints != null) { // Assume all breakpoints are CorFunctionBreakpoints. // If this ever becomes invalid, we'll need a new check here to avoid // duplicating that type of breakpoint. foreach (CorFunctionBreakpoint cb in m_breakpoints) { // If we find a CorBreakpoint that already matches this location // don't add a new one, or the debugger will stop twice when it's hit. // Note that CorFunction instances are 1:1 with a specific function in a // specific module and AppDomain (but represents all generic instantiations). if (cb.Function == func.CorFunction && cb.Offset == ILoffset) { return(false); } } } // Use the resolved information to get a raw CorBreakpoint object. CorBreakpoint breakpoint = null; try { if (ILoffset == 0) { breakpoint = func.CorFunction.CreateBreakpoint(); } else { // we need to set a breakpoint on code rather than directly on function CorCode code = func.CorFunction.ILCode; if (code == null) { throw new MDbgException(String.Format(CultureInfo.InvariantCulture, "IL Code for function {0} is null", new Object[] { func.FullName })); } breakpoint = code.CreateBreakpoint(ILoffset); } } catch (COMException) { return(false); } // Add the new CorBreakpoint object to our internal list and register a handler for it. Debug.Assert(breakpoint != null); breakpoint.Activate(true); if (m_breakpoints == null) { m_breakpoints = new ArrayList(); } m_breakpoints.Add(breakpoint); MDbgProcess p = managedModule.Process; CustomBreakpointEventHandler handler = new CustomBreakpointEventHandler(this.InternalOnHitHandler); p.RegisterCustomBreakpoint(breakpoint, handler); return(true); }